base64< _E, _Tr > Class Template Reference

#include <base64.h>

Classes
struct	crlf
struct	crlfsp
struct	noline
struct	three2four

Public Types
typedef unsigned char	byte_t
typedef _E	char_type
typedef _Tr	traits_type

Public Member Functions
template<class _II, class _OI, class _State, class _Endline>
_II	put (_II _First, _II _Last, _OI _To, _State &_St, _Endline _Endl) const
template<class _II, class _OI, class _State>
_II	get (_II _First, _II _Last, _OI _To, _State &_St) const

Protected Member Functions
int	_getCharType (int _Ch) const

Detailed Description

template<class _E = char, class _Tr = std::char_traits<_E>>
class base64< _E, _Tr >

Definition at line 40 of file base64.h.

Member Typedef Documentation

byte_t

template<class _E = char, class _Tr = std::char_traits<_E>>

typedef unsigned char base64< _E, _Tr >::byte_t

Definition at line 42 of file base64.h.

char_type

template<class _E = char, class _Tr = std::char_traits<_E>>

typedef _E base64< _E, _Tr >::char_type

Definition at line 43 of file base64.h.

traits_type

template<class _E = char, class _Tr = std::char_traits<_E>>

typedef _Tr base64< _E, _Tr >::traits_type

Definition at line 44 of file base64.h.

Member Function Documentation

_getCharType()

template<class _E = char, class _Tr = std::char_traits<_E>>

int base64< _E, _Tr >::_getCharType ( int _Ch ) const

inlineprotected

Definition at line 326 of file base64.h.

                                    {
    if ( _base64Chars[62] == _Ch ) return 62;
 
    if ( _base64Chars[63] == _Ch ) return 63;
 
    if ( ( _base64Chars[0] <= _Ch ) && ( _base64Chars[25] >= _Ch ) )
      return _Ch - _base64Chars[0];
 
    if ( ( _base64Chars[26] <= _Ch ) && ( _base64Chars[51] >= _Ch ) )
      return _Ch - _base64Chars[26] + 26;
 
    if ( ( _base64Chars[52] <= _Ch ) && ( _base64Chars[61] >= _Ch ) )
      return _Ch - _base64Chars[52] + 52;
 
    if ( _Ch == _Tr::to_int_type( '=' ) ) return _EQUAL_CHAR;
 
    return _UNKNOWN_CHAR;
  }

Referenced by get().

get()

template<class _E = char, class _Tr = std::char_traits<_E>>

template<class _II, class _OI, class _State>

_II base64< _E, _Tr >::get ( _II _First, _II _Last, _OI _To, _State & _St ) const

inline

Definition at line 198 of file base64.h.

                                                               {
    three2four _3to4;
    int        _Char;
 
    while ( _First != _Last )
    {
 
      // Take octet
      _3to4.zero();
 
      // -- 0 --
      // Search next valid char...
      while ( ( _Char = _getCharType( *_First ) ) < 0 && _Char == _UNKNOWN_CHAR )
      {
        if ( ++_First == _Last )
        {
          _St |= _IOS_FAILBIT | _IOS_EOFBIT;
          return _First; // unexpected EOF
        }
      }
 
      if ( _Char == _EQUAL_CHAR )
      {
        // Error! First character in octet can't be '='
        _St |= _IOS_FAILBIT;
        return _First;
      }
      else _3to4.b64_0( _Char );
 
      // -- 1 --
      // Search next valid char...
      while ( ++_First != _Last )
        if ( ( _Char = _getCharType( *_First ) ) != _UNKNOWN_CHAR ) break;
 
      if ( _First == _Last )
      {
        _St |= _IOS_FAILBIT | _IOS_EOFBIT; // unexpected EOF
        return _First;
      }
 
      if ( _Char == _EQUAL_CHAR )
      {
        // Error! Second character in octet can't be '='
        _St |= _IOS_FAILBIT;
        return _First;
      }
      else _3to4.b64_1( _Char );
 
      // -- 2 --
      // Search next valid char...
      while ( ++_First != _Last )
        if ( ( _Char = _getCharType( *_First ) ) != _UNKNOWN_CHAR ) break;
 
      if ( _First == _Last )
      {
        // Error! Unexpected EOF. Must be '=' or base64 character
        _St |= _IOS_FAILBIT | _IOS_EOFBIT;
        return _First;
      }
 
      if ( _Char == _EQUAL_CHAR )
      {
        // OK!
        _3to4.b64_2( 0 );
        _3to4.b64_3( 0 );
 
        // chek for EOF
        if ( ++_First == _Last )
        {
          // Error! Unexpected EOF. Must be '='. Ignore it.
          //_St |= _IOS_BADBIT|_IOS_EOFBIT;
          _St |= _IOS_EOFBIT;
        }
        else if ( _getCharType( *_First ) != _EQUAL_CHAR )
        {
          // Error! Must be '='. Ignore it.
          //_St |= _IOS_BADBIT;
        }
        else ++_First; // Skip '='
 
        // write 1 byte to output
        *_To = (byte_t)_3to4.get_0();
        return _First;
      }
      else _3to4.b64_2( _Char );
 
      // -- 3 --
      // Search next valid char...
      while ( ++_First != _Last )
        if ( ( _Char = _getCharType( *_First ) ) != _UNKNOWN_CHAR ) break;
 
      if ( _First == _Last )
      {
        // Unexpected EOF. It's error. But ignore it.
        //_St |= _IOS_FAILBIT|_IOS_EOFBIT;
        _St |= _IOS_EOFBIT;
 
        return _First;
      }
 
      if ( _Char == _EQUAL_CHAR )
      {
        // OK!
        _3to4.b64_3( 0 );
 
        // write to output 2 bytes
        *_To = (byte_t)_3to4.get_0();
        *_To = (byte_t)_3to4.get_1();
 
        ++_First; // set position to next character
 
        return _First;
      }
      else _3to4.b64_3( _Char );
 
      // write to output 3 bytes
      *_To = (byte_t)_3to4.get_0();
      *_To = (byte_t)_3to4.get_1();
      *_To = (byte_t)_3to4.get_2();
 
      ++_First;
 
    } // while(_First != _Last)
 
    return ( _First );
  }

Referenced by XmlRpc::XmlRpcValue::binaryFromXml().

put()

template<class _E = char, class _Tr = std::char_traits<_E>>

template<class _II, class _OI, class _State, class _Endline>

_II base64< _E, _Tr >::put ( _II _First, _II _Last, _OI _To, _State & _St, _Endline _Endl ) const

inline

Definition at line 129 of file base64.h.

                                                                               {
    three2four _3to4;
    int        line_octets = 0;
 
    while ( _First != _Last )
    {
      _3to4.zero();
 
      // áåð¸ì ïî 3 ñèìâîëà
      _3to4.set_0( *_First );
      _First++;
 
      if ( _First == _Last )
      {
        *_To = _Tr::to_char_type( _base64Chars[_3to4.b64_0()] );
        ++_To;
        *_To = _Tr::to_char_type( _base64Chars[_3to4.b64_1()] );
        ++_To;
        *_To = _Tr::to_char_type( '=' );
        ++_To;
        *_To = _Tr::to_char_type( '=' );
        ++_To;
        goto __end;
      }
 
      _3to4.set_1( *_First );
      _First++;
 
      if ( _First == _Last )
      {
        *_To = _Tr::to_char_type( _base64Chars[_3to4.b64_0()] );
        ++_To;
        *_To = _Tr::to_char_type( _base64Chars[_3to4.b64_1()] );
        ++_To;
        *_To = _Tr::to_char_type( _base64Chars[_3to4.b64_2()] );
        ++_To;
        *_To = _Tr::to_char_type( '=' );
        ++_To;
        goto __end;
      }
 
      _3to4.set_2( *_First );
      _First++;
 
      *_To = _Tr::to_char_type( _base64Chars[_3to4.b64_0()] );
      ++_To;
      *_To = _Tr::to_char_type( _base64Chars[_3to4.b64_1()] );
      ++_To;
      *_To = _Tr::to_char_type( _base64Chars[_3to4.b64_2()] );
      ++_To;
      *_To = _Tr::to_char_type( _base64Chars[_3to4.b64_3()] );
      ++_To;
 
      if ( line_octets == 17 ) // base64 ïîçâîëÿåò äëèíó ñòðîêè íå áîëåå 72 ñèìâîëîâ
      {
        //_To = _Endl(_To);
        *_To = '\n';
        ++_To;
        line_octets = 0;
      }
      else ++line_octets;
    }
 
  __end:;
 
    return ( _First );
  }

Referenced by XmlRpc::XmlRpcValue::binaryToXml(), and XmlRpc::XmlRpcValue::write().

---

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

• base64.h