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"
#include <iostream>
/*****************************************************************************
 ** 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)
    {
      std::cout << "Failed size check" << std::endl;
      ecl_debug_throw(
          StandardException(LOC,ConversionError,"The specified byte array size does not match the byte size of the integral type."));
      error_handler = ConversionError;
      return byte_array;
    }

    /*********************
     ** 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);
//            Einstein was bit 'AND'ing a 0xff for dslam - is this useful?
//            byte_array[i] = static_cast<typename ByteArray::value_type>( input >> 8*i & 0xff);
    }
    return byte_array;
  }
  virtual ~IntegralToByteArray() {}
};

} // 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>
{
};

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

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

template<>
class Converter<std::vector<signed char>, long long> : public converters::IntegralToByteArray<std::vector<signed char>, long 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_ */