from_byte_array.hpp

Go to the documentation of this file.

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

#ifndef ECL_CONVERTERS_CONVERTERS_FROM_BYTE_ARRAY_HPP_
#define ECL_CONVERTERS_CONVERTERS_FROM_BYTE_ARRAY_HPP_

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

#include <vector>
#include <ecl/config/macros.hpp>
#include <ecl/concepts/containers.hpp>
#include <ecl/errors/compile_time_assert.hpp>
#include <ecl/exceptions/standard_exception.hpp>
#include <ecl/mpl/converters.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 Integral, typename ByteArray>
class ECL_PUBLIC FromByteArray : public ConverterBase
{
public:
  Integral operator()(const ByteArray &byte_array)
  {
    /*********************
     ** Checks
     **********************/
    ecl_compile_time_concept_check(ByteContainerConcept<ByteArray>);
    ecl_compile_time_assert(is_integral<Integral>::value);
    if (byte_array.size() > ecl::numeric_limits<Integral>::bytes)
    {
      ecl_debug_throw(
          StandardException(LOC,ConversionError,"The byte array is too long for the integral type specified."));
      error_handler = ConversionError;
    }
    /*********************
     ** Method
     **********************/
    typename ecl::Unsigned<Integral>::type unsigned_value = 0;
    for (unsigned int i = 0; i < byte_array.size(); ++i)
    {
      unsigned_value |= static_cast<unsigned char>(byte_array[i]) << 8 * i;
    }
    if (ecl::is_signed<Integral>::value)
    {
      Integral value = static_cast<Integral>(unsigned_value);
      return value;
    }
    else
    {
      return unsigned_value;
    }
  }
  virtual ~FromByteArray() {}
};

} // namespace converters

template<typename Integral>
class ECL_PUBLIC Converter<Integral, std::vector<char> > :
    public converters::FromByteArray<Integral, std::vector<char> >
{
};
template<typename Integral>
class ECL_PUBLIC Converter<Integral, std::vector<unsigned char> > : public converters::FromByteArray<Integral,
    std::vector<unsigned char> >
{
};
template<typename Integral>
class ECL_PUBLIC Converter<Integral, std::vector<signed char> > : public converters::FromByteArray<Integral,
    std::vector<signed char> >
{
};

} // namespace ecl

#endif /* ECL_CONVERTERS_CONVERTERS_FROM_BYTE_ARRAY_HPP_ */