to_byte_array.hpp

Go to the documentation of this file.

/*****************************************************************************
** Ifdefs
*****************************************************************************/

#ifndef ECL_CONVERTERS_TO_BYTE_ARRAY_HPP_
#define ECL_CONVERTERS_TO_BYTE_ARRAY_HPP_

/*****************************************************************************
** Includes
*****************************************************************************/

#include <vector>
#include <ecl/concepts/containers.hpp>
#include <ecl/errors/compile_time_assert.hpp>
#include <ecl/exceptions/standard_exception.hpp>
#include <ecl/exceptions/macros.hpp>
#include <ecl/type_traits/fundamental_types.hpp>
#include <ecl/type_traits/numeric_limits.hpp>
#include "converter.hpp"

/*****************************************************************************
** Namespaces
*****************************************************************************/

namespace ecl {

namespace converters {

/*****************************************************************************
** Interface
*****************************************************************************/

template <typename ByteArray, typename Integral>
class IntegralToByteArray : public ConverterBase {
public:
        const ByteArray& operator()( ByteArray &byte_array, const Integral &input ) ecl_debug_throw_decl(ecl::StandardException)  {
        /*********************
                ** Checks
                **********************/
        ecl_compile_time_concept_check(ecl::ContainerConcept<ByteArray>);
        ecl_compile_time_concept_check(ecl::ByteContainerConcept<ByteArray>);
        ecl_compile_time_assert(is_integral<Integral>::value);
        /*********************
                ** Configuration
                **********************/
        if ( byte_array.size() != ecl::numeric_limits<Integral>::bytes ) {
                ecl_debug_throw(StandardException(LOC,ConversionError,"The specified byte array size does not match the byte size of the integral type."));
                error_handler = ConversionError;
        }

        /*********************
                ** Method
                **********************/
        for (unsigned int i = 0; i < ecl::numeric_limits<Integral>::bytes; ++i ) {
            byte_array[i] = static_cast<typename ByteArray::value_type>( input >> 8*i);
        }
        return byte_array;
    }
};

} // namespace converters
/*****************************************************************************
** Integral to Byte Array Converters
*****************************************************************************/
template <>
class Converter< std::vector<char>, int > : public converters::IntegralToByteArray< std::vector<char>, int > {};

template <>
class Converter< std::vector<unsigned char>, int > : public converters::IntegralToByteArray< std::vector<unsigned char>, int > {};

template <>
class Converter< std::vector<signed char>, int > : public converters::IntegralToByteArray< std::vector<signed char>, int > {};

template <>
class Converter< std::vector<char>, unsigned int > : public converters::IntegralToByteArray< std::vector<char>, unsigned int > {};

template <>
class Converter< std::vector<unsigned char>, unsigned int > : public converters::IntegralToByteArray< std::vector<unsigned char>, unsigned int > {};

template <>
class Converter< std::vector<signed char>, unsigned int > : public converters::IntegralToByteArray< std::vector<signed char>, unsigned int > {};

template <>
class Converter< std::vector<char>, long > : public converters::IntegralToByteArray< std::vector<char>, long > {};

template <>
class Converter< std::vector<unsigned char>, long > : public converters::IntegralToByteArray< std::vector<unsigned char>, long > {};

template <>
class Converter< std::vector<signed char>, long > : public converters::IntegralToByteArray< std::vector<signed char>, long > {};

template <>
class Converter< std::vector<char>, unsigned long > : public converters::IntegralToByteArray< std::vector<char>, unsigned long > {};

template <>
class Converter< std::vector<unsigned char>, unsigned long > : public converters::IntegralToByteArray< std::vector<unsigned char>, unsigned long > {};

template <>
class Converter< std::vector<signed char>, unsigned long > : public converters::IntegralToByteArray< std::vector<signed char>, unsigned long > {};


/*****************************************************************************
** Byte Converter Interface
*****************************************************************************/
template <>
class Converter< std::vector<char>, char*> : public converters::ConverterBase {
public:
        std::vector<char> operator ()(const char* input) ecl_debug_throw_decl(StandardException) {

                std::vector<char> bytes;
                state = waiting_zero;

                while ( *input != '\0') {
                        switch (state) {
                                case (waiting_zero) : {
                                        if ( *input == '0' ) {
                                                state = waiting_x;
                                        } else if ( *input == ' ' ) {
                                                // ignore whitespace
                                        } else {
                                                ecl_debug_throw(StandardException(LOC,ConversionError));
                                                error_handler = ConversionError;
                                                bytes.clear();
                                                return bytes;
                                        }
                                        break;
                                }
                                case (waiting_x) : {
                                        if ( *input == 'x' ) {
                                                state = waiting_first_digit;
                                        } else {
                                                ecl_debug_throw(StandardException(LOC,ConversionError));
                                                error_handler = ConversionError;
                                                bytes.clear();
                                                return bytes;
                                        }
                                        break;
                                }
                                case (waiting_first_digit) : {
                                        if ( (*input >= '0' ) && (*input <= '9' ) ) {
                                                byte = ( *input - '0' ) << 4;
                                                state = waiting_second_digit;
                                        } else if ( (*input >= 'a' ) && (*input <= 'f' ) ) {
                                                byte = ( ( *input - 'a' ) + 0x0A ) << 4;
                                                state = waiting_second_digit;
                                        } else if ( (*input >= 'A' ) && (*input <= 'F' ) ) {
                                                byte = ( ( *input - 'A' ) + 0x0A ) << 4;
                                                state = waiting_second_digit;
                                        } else {
                                                ecl_debug_throw(StandardException(LOC,ConversionError));
                                                error_handler = ConversionError;
                                                bytes.clear();
                                                return bytes;
                                        }
                                        break;
                                }
                                case (waiting_second_digit) : {
                                        if ( (*input >= '0' ) && (*input <= '9' ) ) {
                                                byte += *input - '0';
                                                bytes.push_back(byte);
                                        } else if ( (*input >= 'a' ) && (*input <= 'f' ) ) {
                                                byte += ( *input - 'a' ) + 0x0A;
                                                bytes.push_back(byte);
                                        } else if ( (*input >= 'A' ) && (*input <= 'F' ) ) {
                                                byte += ( *input - 'A' ) + 0x0A;
                                                bytes.push_back(byte);
                                        } else {
                                                ecl_debug_throw(StandardException(LOC,ConversionError));
                                                error_handler = ConversionError;
                                                bytes.clear();
                                                return bytes;
                                        }
                                        state = waiting_zero;
                                        break;
                                }
                                default : {
                                        state = waiting_zero;
                                        break;
                                }
                        }
                        ++input;
                }
                return bytes;
        };
    virtual ~Converter() {}

private:
    unsigned int state;
    char byte;
    static const unsigned int waiting_zero = 0;
    static const unsigned int waiting_x = 1;
    static const unsigned int waiting_first_digit = 2;
    static const unsigned int waiting_second_digit = 3;
};

/*****************************************************************************
 * Byte Array Converter Family
 ****************************************************************************/
template <>
class Converter< std::vector<char>,void>  :
    public Converter< std::vector<char>, char* >,
    public Converter< std::vector<char>, int >,
    public Converter< std::vector<char>, unsigned int >,
    public Converter< std::vector<char>, long >,
    public Converter< std::vector<char>, unsigned long >
{
public:
        virtual ~Converter() {}

    using Converter< std::vector<char>, char* >::operator();
    using Converter< std::vector<char>, int >::operator();
    using Converter< std::vector<char>, unsigned int >::operator();
    using Converter< std::vector<char>, long >::operator();
    using Converter< std::vector<char>, unsigned long >::operator();
};

template <>
class Converter< std::vector<unsigned char>,void>  :
    public Converter< std::vector<unsigned char>, int >,
    public Converter< std::vector<unsigned char>, unsigned int >,
    public Converter< std::vector<unsigned char>, long >,
    public Converter< std::vector<unsigned char>, unsigned long >
{
public:
        virtual ~Converter() {}

    using Converter< std::vector<unsigned char>, int >::operator();
    using Converter< std::vector<unsigned char>, unsigned int >::operator();
    using Converter< std::vector<unsigned char>, long >::operator();
    using Converter< std::vector<unsigned char>, unsigned long >::operator();
};

template <>
class Converter< std::vector<signed char>,void>  :
    public Converter< std::vector<signed char>, int >,
    public Converter< std::vector<signed char>, unsigned int >,
    public Converter< std::vector<signed char>, long >,
    public Converter< std::vector<signed char>, unsigned long >
{
public:
        virtual ~Converter() {}

        using Converter< std::vector<signed char>, int >::operator();
    using Converter< std::vector<signed char>, unsigned int >::operator();
    using Converter< std::vector<signed char>, long >::operator();
    using Converter< std::vector<signed char>, unsigned long >::operator();
};

} // namespace ecl

#endif /* ECL_CONVERTERS_TO_BYTE_ARRAY_HPP_ */