// © Copyright 2006-2010, Terry Golubiewski, all rights reserved.
#ifndef BOOST_INTERFACE_ENDIAN_H
#define BOOST_INTERFACE_ENDIAN_H
#pragma once

#include <boost/detail/endian.hpp>
#include <boost/cstdint.hpp>

#include <cassert>
#include <memory>
#include <cstddef>
#include <algorithm>

namespace boost { namespace interface {

struct uninitialized_t { };
static const uninitialized_t uninitialized;

/// Endian type enumeration.
enum endian_t { little, big };

#ifdef BOOST_BIG_ENDIAN
static const endian_t native = big;
#else
static const endian_t native = little;
#endif

namespace detail {

#ifndef NDEBUG

// Check (at runtime) that BOOST_BIG_ENDIAN and "native" are set correctly.

namespace {

const unsigned short Dummy = 1;

const endian_t ActualEndian =
    bool(*reinterpret_cast<const char*>(&Dummy)) ? little : big;

int InitDummy2() {
  assert(ActualEndian == native);
  return 0;
} // InitDummy2()

const int Dummy2 = InitDummy2();

} // static

#endif

template<std::size_t L> inline
void unrolled_reverse_copy(char* dst, const char* src) {
  *dst = *src;
  unrolled_reverse_copy<L-1>(dst+1, src-1);
} // unrolled_reverse_copy

template<> inline void unrolled_reverse_copy<1>(char* dst, const char* src)
  { *dst = *src; }

template<> inline void unrolled_reverse_copy<0>(char*, const char*) { }

template<std::size_t L, bool>
struct reverse_copy_helper {
  static void copy(char* dst, const char* src)
    { std::reverse_copy(src, src+L, dst); }
};

template<std::size_t L>
struct reverse_copy_helper<L, true> {
  static void copy(char* dst, const char* src)
    { unrolled_reverse_copy<L>(dst, src+(L-1)); }
};

template<std::size_t L> inline
void reverse_copy(void* dst, const void* src) {
  reverse_copy_helper< L, (L<=16) >::copy(static_cast<char*>(dst),
                                          static_cast<const char*>(src));
}

} // detail

#pragma pack(push, 1)

template<endian_t E, class T>
class endian {
public:
  static const endian_t endian_type = E;
  typedef T value_type;

private:
  char m_storage[sizeof(value_type)];

  void store(const value_type& v)
    { detail::reverse_copy<sizeof(value_type)>(m_storage, &v); }

  void retrieve(value_type* result) const
    { detail::reverse_copy<sizeof(value_type)>(result, m_storage); }

public:
  endian() { store(value_type()); }
  endian(uninitialized_t) { }
  endian(const value_type& x) { store(x); }
  value_type value() const { value_type rval; retrieve(&rval); return rval; }
  operator value_type() const { return value(); }
  endian& operator=(const value_type& rhs) { store(rhs); return *this; }
}; // endian

// Specialize for native endian.
template<class T>
class endian<native, T> {
public:
  static const endian_t endian_type = native;
  typedef T value_type;

private:
  value_type m_value;

public:
  endian() : m_value() { }
  endian(uninitialized_t) { }
  endian(const value_type& x) : m_value(x) { }
  const value_type& value() const { return m_value; }
  operator value_type() const { return value(); }
  endian& operator=(const value_type& rhs) { m_value = rhs; return *this; }
}; // endian

#pragma pack(pop)

template<endian_t E1, class T, endian_t E2> inline
endian<E2, T>* copy(const endian<E1, T>* first_, const endian<E1, T>* last_,
                    endian<E2, T>* dest_)
{
  if ((void*) first_ == (void*) dest_) {
    if (E1 == E2)
      return dest_ + (last_ - first_);
    if (E2 != native) {
      while (first_ != last_) {
        T tmp = *first_++;
        *dest_++ = tmp;
      }
      return dest_;
    }
  }
  while (first_ != last_)
    *dest_++ = *first_++;
  return dest_;
} // copy

template<endian_t E, class T> inline
endian<E, T>* copy(const T* first_, const T* last_, endian<E, T>* dest_) {
  if ((void*) first_ == (void*) dest_) {
    if (E == native)
      return dest_ + (last_ - first_);
    while (first_ != last_) {
      T tmp = *first_++;
      *dest_++ = tmp;
    }
  }
  else {
    while (first_ != last_)
      *dest_++ = *first_++;
  }
  return dest_;
} // copy

template<endian_t E, class T> inline
T* copy(const endian<E, T>* first_, const endian<E, T>* last_, T* dest_) {
  if (E == native && (void*) first_ == (void*) dest_)
    return dest_ + (last_ - first_);
  while (first_ != last_)
    *dest_++ = *first_++;
  return dest_;
} // copy

/// @name Convenient Typedefs
/// Use these convenient typedefs to save typing.
//@{

typedef endian<little, int8_t > little_int8_t;
typedef endian<little, int16_t> little_int16_t;
typedef endian<little, int32_t> little_int32_t;
typedef endian<little, int64_t> little_int64_t;

typedef endian<little, uint8_t > little_uint8_t;
typedef endian<little, uint16_t> little_uint16_t;
typedef endian<little, uint32_t> little_uint32_t;
typedef endian<little, uint64_t> little_uint64_t;

typedef endian<big, int8_t > big_int8_t;
typedef endian<big, int16_t> big_int16_t;
typedef endian<big, int32_t> big_int32_t;
typedef endian<big, int64_t> big_int64_t;

typedef endian<big, uint8_t > big_uint8_t;
typedef endian<big, uint16_t> big_uint16_t;
typedef endian<big, uint32_t> big_uint32_t;
typedef endian<big, uint64_t> big_uint64_t;

typedef endian<native, int8_t > native_int8_t;
typedef endian<native, int16_t> native_int16_t;
typedef endian<native, int32_t> native_int32_t;
typedef endian<native, int64_t> native_int64_t;

typedef endian<native, uint8_t > native_uint8_t;
typedef endian<native, uint16_t> native_uint16_t;
typedef endian<native, uint32_t> native_uint32_t;
typedef endian<native, uint64_t> native_uint64_t;

typedef endian<little, float > little_float;
typedef endian<big,    float > big_float;
typedef endian<native, float>  native_float;
typedef endian<little, double> little_double;
typedef endian<big,    double> big_double;
typedef endian<native, double> native_double;

//@}

} } // boost::interface

#endif