kome::core::Base64 Class Reference

base64 conversion class More...

#include <Base64.h>

Static Public Member Functions
static int	encode (void *src, const unsigned int srcLength, char *dest, const unsigned int destLength)
	encodes source buffer into the destination buffer More...
static int	decode (char *src, const unsigned int srcLength, void *dest, const unsigned int destLength)
	decodes source buffer into the destination buffer More...

Protected Member Functions
	Base64 ()
	constructor
virtual	~Base64 ()
	destructor
void	createMap ()
	creates encode and decode map

Static Protected Member Functions
static Base64 &	getInstance ()
	gets base64 object More...

Protected Attributes
char	m_encodeMap [64]
int	m_decodeMap [256]

Detailed Description

base64 conversion class

Definition at line 23 of file Base64.h.

Member Function Documentation

static int kome::core::Base64::decode ( char *  src, const unsigned int  srcLength, void *  dest, const unsigned int  destLength  )

static

decodes source buffer into the destination buffer

Parameters

[in]	src	source buffer
[in]	srcLength	byte length of the source buffer
[out]	dest	destination buffer
[in]	destLength	byte length of the destination buffer

Returns

If negative value, destination buffer size is to small, otherwise returns the size of decoded data

Definition at line 128 of file Base64.cpp.

  {
    // get instance
    Base64& base64 = getInstance();

    // cast 
    char* cDest = (char*)dest;

    // buffers
    char dataBuff[ 3 ];
    unsigned char base64Buff[ 4 ];

    // read
    unsigned int srcPos = 0;
    unsigned int destPos = 0;
    unsigned int length = 0;

    while( srcPos < srcLength ) {
        // get base64 data
        unsigned char c = (unsigned char)src[ srcPos++ ];
        if( base64.m_decodeMap[ c ] >= 0 ) {
            base64Buff[ length++ ] = base64.m_decodeMap[ c ];
        }

        // decode
        if( length == 4 || c == '=' ) {
            switch( length ) {
            case 4:
                dataBuff[ 2 ] = ( base64Buff[ 2 ] << 6 ) | ( base64Buff[ 3 ] );
            case 3:
                dataBuff[ 1 ] = ( base64Buff[ 1 ] << 4 ) | ( base64Buff[ 2 ] >> 2 );
            case 2:
                dataBuff[ 0 ] = ( base64Buff[ 0 ] << 2 ) | ( base64Buff[ 1 ] >> 4 );
            default:
                break;              
            }           

            // store
            if( length > 1 ) {
                length--;
                for( unsigned int i = 0; i < length; i++ ) {
                    if( destPos >= destLength ) {
                        return -1;
                    }
                    cDest[ destPos++ ] = dataBuff[ i ];
                }
            }

            length = 0;

            if( c == '=' ) {
                srcPos = srcLength;
            }
        }
    }

    return destPos;
}

Here is the call graph for this function:

static unsigned int kome::core::Base64::encode ( void *  src, const unsigned int  srcLength, char *  dest, const unsigned int  destLength  )

static

encodes source buffer into the destination buffer

Parameters

[in]	src	source buffer
[in]	srcLength	byte length of the source buffer
[out]	dest	destination buffer
[in]	destLength	byte length of the destination buffer

Returns

If negative value, destination buffer size is too small, otherwise returns the size of encoded data

Definition at line 66 of file Base64.cpp.

  {
    // get instance
    Base64& base64 = getInstance();

    // cast
    char* cSrc = (char*)src;

    // buffers
    unsigned char dataBuff[ 3 ];
    unsigned char base64Buff[ 4 ];

    // read
    unsigned int srcPos = 0;
    unsigned int destPos = 0;
    unsigned int encodeSize = 0;
    while( srcPos < srcLength ) {
        // fill zero
        fillzero( dataBuff, sizeof( dataBuff ) );

        // get 3 bytes
        unsigned int count = 0;
        for( unsigned int i = 0; i < 3; i++ ) {
            if( srcPos < srcLength ) {
                dataBuff[ i ] = cSrc[ srcPos++ ];
                count++;
            }
        }

        // get encode data
        base64Buff[ 0 ] = base64.m_encodeMap[ ( dataBuff[ 0 ] >> 2 ) & 0x3f ];
        base64Buff[ 1 ] = base64.m_encodeMap[ ( ( dataBuff[ 0 ] << 4 ) | ( dataBuff[ 1 ] >> 4 ) ) & 0x3f ];
        base64Buff[ 2 ] = base64.m_encodeMap[ ( ( dataBuff[ 1 ] << 2 ) | ( dataBuff[ 2 ] >> 6 ) ) & 0x3f ];
        base64Buff[ 3 ] = base64.m_encodeMap[ ( dataBuff[ 2 ] ) & 0x3f ];

        // store
        for( unsigned int i = 0; i < 4; i++ ) {
            // check the buffer size
            if( destPos >= destLength ) {
                return -1;
            }

            // character
            if( i > count ) {
                dest[ destPos++ ] = '=';
            }
            else {
                dest[ destPos++ ] = base64Buff[ i ];
            }

            encodeSize++;
        }
    }

    return (int)destPos;
}

Here is the call graph for this function:

static Base64 & kome::core::Base64::getInstance ( )

staticprotected

gets base64 object

Returns

base64 object (This is the only object.)

Definition at line 192 of file Base64.cpp.

                            {
    // create object (This is the only object)
    static Base64 base64;

    return base64;
}

Member Data Documentation

int kome::core::Base64::m_decodeMap[256]

protected

decode map

Definition at line 42 of file Base64.h.

char kome::core::Base64::m_encodeMap[64]

protected

encode map

Definition at line 39 of file Base64.h.

---

The documentation for this class was generated from the following files:

• CoreToolkits/Base64.h
• CoreToolkits/Base64.cpp