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.Get();
  value |= buf.Get() << 8;
}

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

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


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


template <typename Integer>
void
LeastSignificantFirst::Reverse(Integer& value)
{
  char* p = reinterpret_cast<char*>(&value);
  std::reverse(p, p + 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.Get() << 8;
  value |= buf.Get();
}

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

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


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


template <typename Integer>
void
MostSignificantFirst::Reverse(Integer& value)
{
  char* p = reinterpret_cast<char*>(&value);
  std::reverse(p, p + 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);
}