#ifndef cmw_Formatting_hh
#define cmw_Formatting_hh

#include <stdint.h>

class SameFormat
{
public:
  template <template<typename> class B, typename U>
  void Read (B<SameFormat>& buf, U& data);

  template <template<typename> class B, typename U>
  void ReadBlock (B<SameFormat>& buf, U* data, unsigned int elements);
};


class LeastSignificantFirst
{
public:
  template <template<typename> class B>
  void Read (B<LeastSignificantFirst>& buf, uint16_t&);

  template <template<typename> class B>
  void Read (B<LeastSignificantFirst>& buf, uint32_t&);

  template <template<typename> class B>
  void Read (B<LeastSignificantFirst>& buf, uint64_t&);

  template <template<typename> class B>
  void Read (B<LeastSignificantFirst>& buf, float&);

  template <template<typename> class B>
  void Read (B<LeastSignificantFirst>& buf, double&);

  template <template<typename> class B, typename U>
  void ReadBlock (B<LeastSignificantFirst>& buf 
                  , U* data
                  , unsigned int elements
                 );

  template <template<typename> class B>
  void ReadBlock (B<LeastSignificantFirst>& buf 
                  , uint8_t* data
                  , unsigned int elements
                 );

  template <template<typename> class B>
  void ReadBlock (B<LeastSignificantFirst>& buf
                  , int8_t* data
                  , unsigned int elements
                 );
};


class MostSignificantFirst
{
public:
  template <template<typename> class B>
  void Read (B<MostSignificantFirst>& buf, uint16_t&);

  template <template<typename> class B>
  void Read (B<MostSignificantFirst>& buf, uint32_t&);

  template <template<typename> class B>
  void Read (B<MostSignificantFirst>& buf, uint64_t&);

  template <template<typename> class B>
  void Read (B<MostSignificantFirst>& buf, float&);

  template <template<typename> class B>
  void Read (B<MostSignificantFirst>& buf, double&);

  template <template<typename> class B, typename U>
  void ReadBlock (B<MostSignificantFirst>& buf
                  , U* data
                  , unsigned int elements
                 );

  template <template<typename> class B>
  void ReadBlock (B<MostSignificantFirst>& buf
                  , uint8_t* data
                  , unsigned int elements
                 );

  template <template<typename> class B>
  void ReadBlock (B<MostSignificantFirst>& buf
                  , int8_t* data
                  , unsigned int elements
                 );
};

uint8_t const least_significant_first = 0;
uint8_t const most_significant_first = 1;

 
#include <cstring>   // memcpy

template <template<typename> class B, typename U>
void
SameFormat::Read (B<SameFormat>& buf, U& data)
{
  buf.Give(&data, sizeof data);
}


template <template<typename> class B, typename U>
void
SameFormat::ReadBlock (B<SameFormat>& buf
                       , U* data
                       , unsigned int elements
                      )
{
  buf.Give(data, elements * sizeof(U));
}


// ----------------------------------------------------


template <template<typename> class B>
void
LeastSignificantFirst::Read (B<LeastSignificantFirst>& buf
                             , uint16_t& value
                            )
{
  value = buf.Give();
  value |= buf.Give() << 8;
}

template <template<typename> class B>
void
LeastSignificantFirst::Read (B<LeastSignificantFirst>& buf
                             , uint32_t& value
                            )
{
  value = buf.Give();
  value |= buf.Give() << 8;
  value |= buf.Give() << 16;
  value |= buf.Give() << 24;
}

template <template<typename> class B>
void
LeastSignificantFirst::Read (B<LeastSignificantFirst>& buf
                             , uint64_t& value
                            )
{
  value = buf.Give();
  value |= buf.Give() << 8;
  value |= buf.Give() << 16;
  value |= buf.Give() << 24;
  value |= (uint64_t)buf.Give() << 32;
  value |= (uint64_t)buf.Give() << 40;
  value |= (uint64_t)buf.Give() << 48;
  value |= (uint64_t)buf.Give() << 56;
}


template <template<typename> class B>
void
LeastSignificantFirst::Read (B<LeastSignificantFirst>& buf
                             , float& value
                            )
{
  uint32_t tmp;
  this->Read(buf, tmp);
  ::std::memcpy(&value, &tmp, sizeof(value));
}


template <template<typename> class B>
void
LeastSignificantFirst::Read (B<LeastSignificantFirst>& buf
                             , double& value
                            )
{
  uint64_t tmp;
  this->Read(buf, tmp);
  ::std::memcpy(&value, &tmp, sizeof(value));
}


template <template<typename> class B, typename U>
void
LeastSignificantFirst::ReadBlock (B<LeastSignificantFirst>& buf
                                  , U* data
                                  , unsigned int elements
                                 )
{
  for (unsigned int ii = 0; ii < elements; ++ii) {
    buf.Give(*(data + ii));
  }
}


/* Overloads for when U is uint8_t or int8_t */
template <template<typename> class B>
void
LeastSignificantFirst::ReadBlock (B<LeastSignificantFirst>& buf
                                  , uint8_t* data
                                  , unsigned int elements
                                 )
{
  buf.Give(data, elements);
}

template <template<typename> class B>
void
LeastSignificantFirst::ReadBlock (B<LeastSignificantFirst>& buf
                                  , int8_t* data
                                  , unsigned int elements
                                 )
{
  buf.Give(data, elements);
}

// ----------------------------------------------------

template <template<typename> class B>
void
MostSignificantFirst::Read (B<MostSignificantFirst>& buf
                            , uint16_t& value
                           )
{
  value = buf.Give() << 8;
  value |= buf.Give();
}

template <template<typename> class B>
void
MostSignificantFirst::Read (B<MostSignificantFirst>& buf
                            , uint32_t& value
                           )
{
  value = buf.Give() << 24;
  value |= buf.Give() << 16;
  value |= buf.Give() << 8;
  value |= buf.Give();
}

template <template<typename> class B>
void
MostSignificantFirst::Read (B<MostSignificantFirst>& buf 
                            , uint64_t& value
                           )
{
  value = (uint64_t)buf.Give() << 56;
  value |= (uint64_t)buf.Give() << 48;
  value |= (uint64_t)buf.Give() << 40;
  value |= (uint64_t)buf.Give() << 32;
  value |= buf.Give() << 24;
  value |= buf.Give() << 16;
  value |= buf.Give() << 8;
  value |= buf.Give();
}


template <template<typename> class B>
void
MostSignificantFirst::Read (B<MostSignificantFirst>& buf
                            , float& value
                           )
{
  uint32_t tmp;
  this->Read(buf, tmp);
  ::std::memcpy(&value, &tmp, sizeof(value));
}


template <template<typename> class B>
void
MostSignificantFirst::Read (B<MostSignificantFirst>& buf
                            , double& value
                           )
{
  uint64_t tmp;
  this->Read(buf, tmp);
  ::std::memcpy(&value, &tmp, sizeof(value));
}


template <template<typename> class B, typename U>
void
MostSignificantFirst::ReadBlock (B<MostSignificantFirst>& buf
                                 , U* data
                                 , unsigned int elements
                                )
{
  for (unsigned int ii = 0; ii < elements; ++ii) {
    buf.Give(*(data + ii));
  }
}

template <template<typename> class B>
void
MostSignificantFirst::ReadBlock (B<MostSignificantFirst>& buf
                                 , uint8_t* data
                                 , unsigned int elements
                                )
{
  buf.Give(data, elements);
}

template <template<typename> class B>
void
MostSignificantFirst::ReadBlock (B<MostSignificantFirst>& buf
                                 , int8_t* data
                                 , unsigned int elements
                                )
{
  buf.Give(data, elements);
}

#endif