/** * @file include/ActivMiddleware/Misc/Base64.h * * @brief Header file for base64 functions. */ #if (!defined ACTIV_MISC_BASE64_H) #define ACTIV_MISC_BASE64_H #include "ActivMiddleware/ActivMiddleware.h" #include ACTIV_BOOST_INCLUDE(mpl/integral_c.hpp) #include ACTIV_BOOST_INCLUDE(mpl/if.hpp) #include ACTIV_BOOST_INCLUDE(mpl/equal_to.hpp) #include ACTIV_BOOST_INCLUDE(type_traits/is_base_of.hpp) #include //! Activ namespace. namespace Activ { /** * @brief Empty base for Base64SingleBufferIterator to ease template code. */ class Base64SingleBufferIteratorBase { }; // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- // Forward reference. template class Base64SingleBufferIteratorHelper; // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- /** * @brief Base64 constants. */ class Base64Constants { public: static const byte_t undefinedBits = Boost::integer_traits::const_max; }; // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- /** * @brief Base64 codec class. * * @param UTF7 whether to use UTF7 ("modified base64") encoding. Non-UTF7 encoded data is always a multiple of 4 bytes, padded * by PAD. * @param SIXTY_TWO the character to use for the binary value 62. * @param SIXTY_THREE the character to use for the binary value 63. * @param PAD the character to use for padding in the output of non-UTF7 format. */ template class Base64 { public: /** * @brief Stateful base64 decoder class. */ class Validator { public: /** * @brief Constructor. * * @param pData pointer to the base64-encoded character stream. * @param dataLength length of data pointed to by @a pData. */ Validator(const void * const pData, const size_t dataLength); /** * @brief Decode some of the base64-encoded stream. * * @param pOutput pointer to a buffer to receive the decoded binary. * @param outputLength on input, the length of the buffer pointed to by @a pOutput. On output, the number of bytes written * to @a pOutput. * * @retval STATUS_CODE_SUCCESS * @retval STATUS_CODE_INVALID_FORMAT * @retval STATUS_CODE_BUFFER_UNDERRUN pOutput has had outputLength bytes written to it but there are more input bytes * left to process. Call operator() again to continue decoding. * @retval STATUS_CODE_WRONG_STATE internal error. */ StatusCode operator()(void * const pOutput, size_t &outputLength); /** * @brief Decode some of the base64-encoded stream into multiple buffers. * * ITERATOR_HELPER is a class that should provide static members size_t GetLength(iterator &) and * void *GetData(iterator &) in order to access the length and data pointer from a buffer iterator. * * @param begin iterator to the first buffer. * @param end iterator to passed the last buffer. * @param outputLength on output, the number of bytes written across the buffers provided. * * @retval STATUS_CODE_SUCCESS * @retval STATUS_CODE_INVALID_FORMAT * @retval STATUS_CODE_BUFFER_UNDERRUN output buffers have been filled. There are more input bytes * left to process. Call operator() again to continue decoding. * @retval STATUS_CODE_WRONG_STATE internal error. */ template StatusCode operator()(ITERATOR begin, ITERATOR end, size_t &outputLength) { // Quick hack to avoid multiple buffer range checking for a single buffer invocation. // Compiler should make this all disappear at compile-time. const bool isMultipleBuffer = !Boost::is_base_of::value; ITERATOR currentIter = begin; byte_t *pNextOutput = reinterpret_cast(ITERATOR_HELPER::GetData(currentIter)); size_t outputBytesLeft = ITERATOR_HELPER::GetLength(currentIter); char inputChar; bool isDone = false; outputLength = 0; while (!isDone) { switch (m_state) { case STATE_1: // First byte. if (ACTIV_UNLIKELY(0 == m_inputBytesLeft)) { isDone = true; } else { if (UTF7) { if (ACTIV_UNLIKELY(m_inputBytesLeft < 2)) return STATUS_CODE_INVALID_FORMAT; } else { if (ACTIV_UNLIKELY(m_inputBytesLeft < 4)) return STATUS_CODE_INVALID_FORMAT; } inputChar = *m_pInput++; --m_inputBytesLeft; m_decodedByte = GetBinaryFromEncoded(inputChar); if (ACTIV_UNLIKELY(Base64Constants::undefinedBits == m_decodedByte)) return STATUS_CODE_INVALID_FORMAT; m_outputByte = (m_decodedByte & Binary::value) << 2; m_state = STATE_2; } break; case STATE_2: inputChar = *m_pInput++; --m_inputBytesLeft; m_decodedByte = GetBinaryFromEncoded(inputChar); if (ACTIV_UNLIKELY(Base64Constants::undefinedBits == m_decodedByte)) return STATUS_CODE_INVALID_FORMAT; m_outputByte |= (m_decodedByte >> 4) & Binary::value; m_state = STATE_ASSIGN_1; break; case STATE_ASSIGN_1: if (!isMultipleBuffer) { if (0 == outputBytesLeft) return STATUS_CODE_BUFFER_UNDERRUN; } else { if ((0 == outputBytesLeft) && !AdvanceIterator(currentIter, outputBytesLeft, pNextOutput, end)) { return STATUS_CODE_BUFFER_UNDERRUN; } } *pNextOutput++ = m_outputByte; --outputBytesLeft; ++outputLength; m_outputByte = (m_decodedByte & Binary::value) << 4; m_state = STATE_3; break; case STATE_3: // Third byte. if (UTF7) { // End of input terminates with UTF7. if (ACTIV_UNLIKELY(0 == m_inputBytesLeft)) { isDone = true; break; } } inputChar = *m_pInput++; --m_inputBytesLeft; if (ACTIV_LIKELY(undefinedChar != inputChar)) { m_decodedByte = GetBinaryFromEncoded(inputChar); if (ACTIV_UNLIKELY(Base64Constants::undefinedBits == m_decodedByte)) return STATUS_CODE_INVALID_FORMAT; m_outputByte |= (m_decodedByte >> 2) & Binary::value; m_state = STATE_ASSIGN_2; } else { if (UTF7) return STATUS_CODE_INVALID_FORMAT; if (ACTIV_UNLIKELY(0 != m_outputByte)) return STATUS_CODE_INVALID_FORMAT; // Fourth byte must also be PAD if third was and we must be at the end. inputChar = *m_pInput++; --m_inputBytesLeft; if (ACTIV_UNLIKELY(undefinedChar != inputChar) || ACTIV_UNLIKELY(0 != m_inputBytesLeft)) return STATUS_CODE_INVALID_FORMAT; isDone = true; } break; case STATE_ASSIGN_2: if (!isMultipleBuffer) { if (0 == outputBytesLeft) return STATUS_CODE_BUFFER_UNDERRUN; } else { if ((0 == outputBytesLeft) && !AdvanceIterator(currentIter, outputBytesLeft, pNextOutput, end)) { return STATUS_CODE_BUFFER_UNDERRUN; } } *pNextOutput++ = m_outputByte; --outputBytesLeft; ++outputLength; m_outputByte = (m_decodedByte & Binary::value) << 6; m_state = STATE_4; break; case STATE_4: // Fourth byte. if (UTF7) { // End of input terminates with UTF7. if (ACTIV_UNLIKELY(0 == m_inputBytesLeft)) { isDone = true; break; } } inputChar = *m_pInput++; --m_inputBytesLeft; if (ACTIV_LIKELY(undefinedChar != inputChar)) { m_decodedByte = GetBinaryFromEncoded(inputChar); if (ACTIV_UNLIKELY(Base64Constants::undefinedBits == m_decodedByte)) return STATUS_CODE_INVALID_FORMAT; m_outputByte |= m_decodedByte & Binary::value; m_state = STATE_ASSIGN_3; } else { if (UTF7) return STATUS_CODE_INVALID_FORMAT; if (ACTIV_UNLIKELY(0 != m_outputByte)) return STATUS_CODE_INVALID_FORMAT; if (ACTIV_UNLIKELY(0 != m_inputBytesLeft)) return STATUS_CODE_INVALID_FORMAT; isDone = true; } break; case STATE_ASSIGN_3: if (!isMultipleBuffer) { if (0 == outputBytesLeft) return STATUS_CODE_BUFFER_UNDERRUN; } else { if ((0 == outputBytesLeft) && !AdvanceIterator(currentIter, outputBytesLeft, pNextOutput, end)) { return STATUS_CODE_BUFFER_UNDERRUN; } } *pNextOutput++ = m_outputByte; --outputBytesLeft; ++outputLength; m_state = STATE_1; break; default: assert(false); return STATUS_CODE_WRONG_STATE; } } return STATUS_CODE_SUCCESS; } private: /** * @brief Decoding states. */ enum State { STATE_1, STATE_2, STATE_ASSIGN_1, STATE_3, STATE_ASSIGN_2, STATE_4, STATE_ASSIGN_3 }; State m_state; ///< Current state. const char *m_pInput; ///< Next input byte to process. size_t m_inputBytesLeft; ///< Number of input bytes left to process. byte_t m_decodedByte; ///< Decoded value of current input byte. byte_t m_outputByte; ///< Current output byte being generated. }; /** * @brief Encode a byte stream into base64. * * @param pData pointer to the data to encode. * @param dataLength length of data pointed to by @a pData. * @param pOutput pointer to buffer to store the base64-encoded data. * @param outputLength on input, the size of the buffer pointed to by @a pOutput. On successful completion, the * encoded length of the output. * * @retval STATUS_CODE_SUCCESS * @retval STATUS_CODE_BUFFER_OVERFLOW @a outputLength is not sufficient to hold the base64 encoded data. */ static StatusCode Encode(const void * const pData, const size_t dataLength, char * const pOutput, size_t &outputLength); /** * @brief Encode a byte stream into base64. * * ITERATOR_HELPER is a class that should provide static members size_t GetLength(iterator &) and * void *GetData(iterator &) in order to access the length and data pointer from a buffer iterator. * * @param begin iterator to the first buffer. * @param end iterator to passed the last buffer. * @param offset offset within the buffer range begin,end at which to start encoding. * @param dataLength the amount of data starting at offset @a offset within the buffer range to encode. * @param pOutput pointer to buffer to store the base64-encoded data. * @param outputLength on input, the size of the buffer pointed to by @a pOutput. On successful completion, the * encoded length of the output. * * @retval STATUS_CODE_SUCCESS * @retval STATUS_CODE_BUFFER_OVERFLOW @a outputLength is not sufficient to hold the base64 encoded data. * @retval STATUS_CODE_BUFFER_UNDERRUN the iterator range begin,end starting at offset @a offset does not hold @a dataLength * bytes. */ template static StatusCode Encode(const ITERATOR begin, const ITERATOR end, const size_t offset, const size_t dataLength, char * const pOutput, size_t &outputLength) { // Quick hack to avoid multiple buffer range checking for a single buffer invocation. // Compiler should make this all disappear at compile-time. const bool isMultipleBuffer = !Boost::is_base_of::value; if (ACTIV_UNLIKELY(0 == dataLength)) return STATUS_CODE_SUCCESS; if (ACTIV_UNLIKELY(outputLength < GetMaximumEncodedLength(dataLength))) return STATUS_CODE_INVALID_PARAMETER; // Find the iterator and offset into it for the provided offset. ITERATOR currentIter = begin; size_t initialOffset = offset; while (initialOffset > 0) { const size_t iteratorLength = ITERATOR_HELPER::GetLength(currentIter); if (initialOffset < iteratorLength) break; ++currentIter; if (currentIter == end) return STATUS_CODE_INVALID_PARAMETER; initialOffset -= iteratorLength; } char * const pInitialOutput = pOutput; char *pNextOutput = pOutput; size_t inputBytesLeft = dataLength; const byte_t *pInput = reinterpret_cast(ITERATOR_HELPER::GetData(currentIter)) + initialOffset; size_t currentIterBytesLeft = ITERATOR_HELPER::GetLength(currentIter) - initialOffset; while (inputBytesLeft > 0) { byte_t inputByte; if (ACTIV_UNLIKELY(isMultipleBuffer) && ACTIV_UNLIKELY(0 == currentIterBytesLeft)) { // Move to next buffer in chain. if (!AdvanceIterator(currentIter, currentIterBytesLeft, pInput, end)) return STATUS_CODE_BUFFER_UNDERRUN; } inputByte = *pInput++; --inputBytesLeft; --currentIterBytesLeft; const byte_t first6Bits = (inputByte >> 2) & Binary::value; byte_t second6Bits = (inputByte & Binary::value) << 4; byte_t third6Bits = Base64Constants::undefinedBits; byte_t fourth6Bits = Base64Constants::undefinedBits; if (ACTIV_LIKELY(inputBytesLeft > 0)) { if (ACTIV_UNLIKELY(isMultipleBuffer) && ACTIV_UNLIKELY(0 == currentIterBytesLeft)) { // Move to next buffer in chain. if (!AdvanceIterator(currentIter, currentIterBytesLeft, pInput, end)) return STATUS_CODE_BUFFER_UNDERRUN; } inputByte = *pInput++; --inputBytesLeft; --currentIterBytesLeft; second6Bits |= (inputByte >> 4) & Binary::value; third6Bits = (inputByte & Binary::value) << 2; if (ACTIV_LIKELY(inputBytesLeft > 0)) { if (ACTIV_UNLIKELY(isMultipleBuffer) && ACTIV_UNLIKELY(0 == currentIterBytesLeft)) { // Move to next buffer in chain. if (!AdvanceIterator(currentIter, currentIterBytesLeft, pInput, end)) return STATUS_CODE_BUFFER_UNDERRUN; } inputByte = *pInput++; --inputBytesLeft; --currentIterBytesLeft; third6Bits |= (inputByte >> 6) & Binary::value; fourth6Bits = inputByte & Binary::value; } } *pNextOutput++ = GetEncodedFromBinary(first6Bits); *pNextOutput++ = GetEncodedFromBinary(second6Bits); // For UTF7 format, we just stop if we have undefined bits. Otherwise we append PAD. if (ACTIV_LIKELY(Base64Constants::undefinedBits != third6Bits)) { *pNextOutput++ = GetEncodedFromBinary(third6Bits); } else { if (UTF7) break; else *pNextOutput++ = undefinedChar; } if (ACTIV_LIKELY(Base64Constants::undefinedBits != fourth6Bits)) { *pNextOutput++ = GetEncodedFromBinary(fourth6Bits); } else { if (UTF7) break; else *pNextOutput++ = undefinedChar; } } outputLength = pNextOutput - pInitialOutput; return STATUS_CODE_SUCCESS; } /** * @brief Encode a byte stream into base64. * * @param pData pointer to the data to encode. * @param dataLength length of data pointed to by @a pData. * @param output string to have the base64-encoded data appended to (string is *not* cleared). */ static void Encode(const void * const pData, const size_t dataLength, String &output); /** * @brief Decode a base64-encoded character stream into binary. * * @param pData pointer to the base64-encoded character stream. * @param dataLength length of data pointed to by @a pData. * @param pOutput pointer to a buffer to receive the decoded binary. * @param outputLength on input, the length of the buffer pointed to by @a pOutput. On output, the number of bytes written * to @a pOutput. * * @retval STATUS_CODE_SUCCESS * @retval STATUS_CODE_INVALID_FORMAT * @retval STATUS_CODE_BUFFER_UNDERRUN @a outputLength insufficient to hold decoded data. */ static StatusCode Decode(const char * const pData, const size_t dataLength, void * const pOutput, size_t &outputLength); /** * @brief Calculate the maximum base64-encoded length for a given input length. * * @param inputLength length of the source data. * * @return The maximum possible encoded length given the input length. */ static size_t GetMaximumEncodedLength(const size_t inputLength); /** * @brief Calculate the maximum decoded length for a given base64 encoded length. * * Useful for reserving sufficient buffer space before calling Decode(). * * @param inputLength length of the base64-encoded data. * * @return The maximum possible decoded length given the input length. */ static size_t GetMaximumDecodedLength(const size_t inputLength); /** * @brief Get encoded byte from binary. * * @param binaryByte the binary byte. * * @return The encoded byte. */ static char GetEncodedFromBinary(const byte_t binaryByte); /** * @brief Get binary from encoded byte. * * @param encodedByte the encoded byte. * * @return The binary byte. */ static byte_t GetBinaryFromEncoded(const char encodedByte); private: /** * @brief Move along an iterator chain to the next non-empty buffer. * * @param currentIter the iterator to advance. * @param currentIterByteLeft to receive the length of the new buffer. * @param pData to receive the new buffer's data pointer. * @param end passed the last iterator in the chain. * * @return false if we get to the end of the chain. */ template static bool AdvanceIterator(ITERATOR ¤tIter, size_t ¤tIterBytesLeft, POINTER &pData, const ITERATOR end) { assert(0 == currentIterBytesLeft); do { ++currentIter; if (currentIter != end) { pData = reinterpret_cast(ITERATOR_HELPER::GetData(currentIter)); currentIterBytesLeft = ITERATOR_HELPER::GetLength(currentIter); } else { return false; } } while (0 == currentIterBytesLeft); return true; } static const char undefinedChar = PAD; static const char binaryToBase64Table[64]; static const byte_t base64ToBinaryTable[256]; }; // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- /** * @brief Helper class to map from base64 character to binary value. */ template class Base64Lookup { private: typedef Boost::mpl::integral_c SixtyTwoChar; typedef Boost::mpl::integral_c SixtyThreeChar; typedef Boost::mpl::integral_c ThisChar; typedef Boost::mpl::integral_c Undefined; public: // Really wanted to specialize for SIXTY_TWO and SIXTY_THREE something like this: // template // class Base64Lookup { static const byte_t value = 62; }; // But that doesn't work with GCC (OK with VC++). // So some boost mpl, effectively: // if (ASCII_VALUE == SIXTY_TWO) // value = 62; // else if (ASCII_VALUE == SIXTY_THREE) // value = 63; // else // value = Base64Constants::undefinedBits; static const byte_t value = Boost::mpl::if_ < Boost::mpl::equal_to, Boost::mpl::integral_c, typename Boost::mpl::if_ < Boost::mpl::equal_to, Boost::mpl::integral_c, Undefined >::type >::type::value; }; // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- /** * @brief Class to act like an iterator to a single ptr,length buffer. */ template class Base64SingleBufferIterator : public Base64SingleBufferIteratorBase { public: Base64SingleBufferIterator() : m_pData(0), m_dataLength(0) { } Base64SingleBufferIterator(POINTER pData, const size_t dataLength) : m_pData(pData), m_dataLength(dataLength) { } Base64SingleBufferIterator &operator++() { m_pData = 0; m_dataLength = 0; return *this; } bool operator==(const Base64SingleBufferIterator &rhs) const { return (m_pData == rhs.m_pData); } bool operator!=(const Base64SingleBufferIterator &rhs) const { return !operator==(rhs); } private: POINTER m_pData; size_t m_dataLength; friend class Base64SingleBufferIteratorHelper; }; // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- /** * @brief Helper class to get ptr,length from a Base64SingleBufferIterator. */ template class Base64SingleBufferIteratorHelper { public: static POINTER GetData(Base64SingleBufferIterator &iterator) { return iterator.m_pData; } static size_t GetLength(const Base64SingleBufferIterator &iterator) { return iterator.m_dataLength; } }; // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- template inline StatusCode Base64::Encode(const void * const pData, const size_t dataLength, char * const pOutput, size_t &outputLength) { return Encode, Base64SingleBufferIterator >( Base64SingleBufferIterator(pData, dataLength), Base64SingleBufferIterator(), 0, dataLength, pOutput, outputLength); } // --------------------------------------------------------------------------------------------------------------------------------- template inline void Base64::Encode(const void * const pData, const size_t dataLength, String &output) { if (ACTIV_UNLIKELY(0 == dataLength)) return; // String::append() is slow. push_back() is far worse, even with a pre-allocated correct buffer size. // So cache a ptr to the string internal and just write to it. Slightly nasty... const size_t initialOutputLength = output.length(); output.resize(initialOutputLength + GetMaximumEncodedLength(dataLength)); size_t outputLength = output.length() - initialOutputLength; (void) Encode(pData, dataLength, &output[initialOutputLength], outputLength); output.resize(initialOutputLength + outputLength); } // --------------------------------------------------------------------------------------------------------------------------------- template StatusCode Base64::Decode(const char * const pData, const size_t dataLength, void * const pOutput, size_t &outputLength) { const char *pInput = pData; size_t inputBytesLeft = dataLength; byte_t *pNextOutput = reinterpret_cast(pOutput); size_t outputBytesLeft = outputLength; while (inputBytesLeft > 0) { if (UTF7) { if (ACTIV_UNLIKELY(inputBytesLeft < 2)) return STATUS_CODE_INVALID_FORMAT; } else { if (ACTIV_UNLIKELY(inputBytesLeft < 4)) return STATUS_CODE_INVALID_FORMAT; } char inputChar; byte_t decodedByte, outputByte; // First byte. inputChar = *pInput++; --inputBytesLeft; decodedByte = GetBinaryFromEncoded(inputChar); if (ACTIV_UNLIKELY(Base64Constants::undefinedBits == decodedByte)) return STATUS_CODE_INVALID_FORMAT; outputByte = (decodedByte & Binary::value) << 2; // Second byte. inputChar = *pInput++; --inputBytesLeft; decodedByte = GetBinaryFromEncoded(inputChar); if (ACTIV_UNLIKELY(Base64Constants::undefinedBits == decodedByte)) return STATUS_CODE_INVALID_FORMAT; outputByte |= (decodedByte >> 4) & Binary::value; if (ACTIV_UNLIKELY(0 == outputBytesLeft)) return STATUS_CODE_BUFFER_UNDERRUN; *pNextOutput++ = outputByte; --outputBytesLeft; outputByte = (decodedByte & Binary::value) << 4; // Third byte. if (UTF7) { // End of input terminates with UTF7. if (ACTIV_UNLIKELY(0 == inputBytesLeft)) break; } inputChar = *pInput++; --inputBytesLeft; if (ACTIV_LIKELY(undefinedChar != inputChar)) { decodedByte = GetBinaryFromEncoded(inputChar); if (ACTIV_UNLIKELY(Base64Constants::undefinedBits == decodedByte)) return STATUS_CODE_INVALID_FORMAT; outputByte |= (decodedByte >> 2) & Binary::value; if (ACTIV_UNLIKELY(0 == outputBytesLeft)) return STATUS_CODE_BUFFER_UNDERRUN; *pNextOutput++ = outputByte; --outputBytesLeft; outputByte = (decodedByte & Binary::value) << 6; // Fourth byte. if (UTF7) { // End of input terminates with UTF7. if (ACTIV_UNLIKELY(0 == inputBytesLeft)) break; } inputChar = *pInput++; --inputBytesLeft; if (ACTIV_LIKELY(undefinedChar != inputChar)) { decodedByte = GetBinaryFromEncoded(inputChar); if (ACTIV_UNLIKELY(Base64Constants::undefinedBits == decodedByte)) return STATUS_CODE_INVALID_FORMAT; outputByte |= decodedByte & Binary::value; if (ACTIV_UNLIKELY(0 == outputBytesLeft)) return STATUS_CODE_BUFFER_UNDERRUN; *pNextOutput++ = outputByte; --outputBytesLeft; } else { if (UTF7) return STATUS_CODE_INVALID_FORMAT; if (ACTIV_UNLIKELY(0 != outputByte)) return STATUS_CODE_INVALID_FORMAT; if (ACTIV_UNLIKELY(0 != inputBytesLeft)) return STATUS_CODE_INVALID_FORMAT; } } else { if (UTF7) return STATUS_CODE_INVALID_FORMAT; if (ACTIV_UNLIKELY(0 != outputByte)) return STATUS_CODE_INVALID_FORMAT; // Fourth byte must also be PAD if third was and we must be at the end. inputChar = *pInput++; --inputBytesLeft; if (ACTIV_UNLIKELY(undefinedChar != inputChar) || ACTIV_UNLIKELY(0 != inputBytesLeft)) return STATUS_CODE_INVALID_FORMAT; } } outputLength -= outputBytesLeft; return STATUS_CODE_SUCCESS; } // --------------------------------------------------------------------------------------------------------------------------------- template inline size_t Base64::GetMaximumEncodedLength(const size_t inputLength) { return 4 * ((inputLength + 2) / 3); } // --------------------------------------------------------------------------------------------------------------------------------- template inline size_t Base64::GetMaximumDecodedLength(const size_t inputLength) { return 3 * ((inputLength + 3) / 4); } // --------------------------------------------------------------------------------------------------------------------------------- template inline char Base64::GetEncodedFromBinary(const byte_t binaryByte) { return binaryToBase64Table[binaryByte]; } // --------------------------------------------------------------------------------------------------------------------------------- template inline byte_t Base64::GetBinaryFromEncoded(const char encodedByte) { return base64ToBinaryTable[static_cast(encodedByte)]; } // --------------------------------------------------------------------------------------------------------------------------------- template const char Base64::binaryToBase64Table[64] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', SIXTY_TWO, SIXTY_THREE }; // --------------------------------------------------------------------------------------------------------------------------------- template const byte_t Base64::base64ToBinaryTable[256] = { Base64Lookup<0, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<1, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<2, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<3, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<4, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<5, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<6, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<7, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<8, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<9, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<10, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<11, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<12, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<13, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<14, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<15, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<16, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<17, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<18, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<19, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<20, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<21, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<22, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<23, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<24, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<25, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<26, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<27, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<28, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<29, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<30, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<31, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<32, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<33, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<34, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<35, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<36, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<37, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<38, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<39, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<40, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<41, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<42, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<43, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<44, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<45, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<46, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<47, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<48, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<49, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<50, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<51, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<52, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<53, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<54, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<55, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<56, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<57, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<58, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<59, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<60, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<61, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<62, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<63, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<64, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<65, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<66, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<67, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<68, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<69, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<70, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<71, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<72, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<73, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<74, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<75, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<76, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<77, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<78, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<79, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<80, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<81, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<82, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<83, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<84, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<85, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<86, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<87, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<88, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<89, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<90, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<91, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<92, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<93, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<94, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<95, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<96, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<97, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<98, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<99, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<100, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<101, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<102, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<103, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<104, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<105, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<106, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<107, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<108, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<109, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<110, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<111, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<112, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<113, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<114, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<115, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<116, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<117, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<118, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<119, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<120, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<121, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<122, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<123, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<124, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<125, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<126, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<127, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<128, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<129, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<130, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<131, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<132, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<133, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<134, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<135, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<136, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<137, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<138, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<139, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<140, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<141, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<142, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<143, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<144, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<145, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<146, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<147, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<148, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<149, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<150, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<151, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<152, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<153, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<154, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<155, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<156, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<157, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<158, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<159, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<160, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<161, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<162, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<163, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<164, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<165, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<166, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<167, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<168, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<169, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<170, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<171, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<172, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<173, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<174, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<175, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<176, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<177, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<178, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<179, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<180, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<181, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<182, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<183, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<184, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<185, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<186, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<187, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<188, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<189, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<190, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<191, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<192, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<193, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<194, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<195, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<196, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<197, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<198, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<199, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<200, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<201, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<202, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<203, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<204, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<205, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<206, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<207, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<208, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<209, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<210, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<211, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<212, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<213, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<214, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<215, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<216, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<217, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<218, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<219, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<220, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<221, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<222, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<223, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<224, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<225, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<226, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<227, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<228, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<229, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<230, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<231, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<232, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<233, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<234, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<235, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<236, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<237, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<238, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<239, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<240, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<241, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<242, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<243, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<244, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<245, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<246, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<247, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<248, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<249, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<250, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<251, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<252, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<253, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<254, SIXTY_TWO, SIXTY_THREE>::value, Base64Lookup<255, SIXTY_TWO, SIXTY_THREE>::value, }; // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- // Upper-case base64 char -> binary mappings. template class Base64Lookup<'A', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 0; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'B', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 1; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'C', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 2; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'D', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 3; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'E', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 4; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'F', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 5; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'G', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 6; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'H', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 7; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'I', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 8; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'J', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 9; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'K', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 10; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'L', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 11; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'M', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 12; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'N', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 13; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'O', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 14; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'P', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 15; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'Q', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 16; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'R', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 17; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'S', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 18; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'T', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 19; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'U', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 20; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'V', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 21; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'W', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 22; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'X', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 23; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'Y', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 24; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'Z', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 25; }; // --------------------------------------------------------------------------------------------------------------------------------- // Lower-case base64 char -> binary mappings. template class Base64Lookup<'a', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 26; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'b', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 27; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'c', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 28; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'d', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 29; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'e', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 30; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'f', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 31; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'g', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 32; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'h', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 33; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'i', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 34; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'j', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 35; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'k', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 36; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'l', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 37; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'m', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 38; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'n', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 39; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'o', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 40; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'p', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 41; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'q', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 42; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'r', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 43; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'s', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 44; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'t', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 45; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'u', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 46; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'v', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 47; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'w', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 48; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'x', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 49; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'y', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 50; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'z', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 51; }; // --------------------------------------------------------------------------------------------------------------------------------- // Numerical base64 char -> binary mappings. template class Base64Lookup<'0', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 52; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'1', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 53; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'2', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 54; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'3', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 55; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'4', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 56; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'5', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 57; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'6', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 58; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'7', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 59; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'8', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 60; }; // --------------------------------------------------------------------------------------------------------------------------------- template class Base64Lookup<'9', SIXTY_TWO, SIXTY_THREE> { public: static const byte_t value = 61; }; // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- template inline Base64::Validator::Validator(const void * const pData, const size_t dataLength) : m_state(STATE_1), m_pInput(reinterpret_cast(pData)), m_inputBytesLeft(dataLength) { } // --------------------------------------------------------------------------------------------------------------------------------- template inline StatusCode Base64::Validator::operator()(void * const pOutput, size_t &outputLength) { return operator() >(Base64SingleBufferIterator(pOutput, outputLength), Base64SingleBufferIterator(), outputLength); } } // namespace Activ #endif // (!defined ACTIV_MISC_BASE64_H)