data_io.cpp

Go to the documentation of this file.

/*
 * Copyright (C) Sergey P. Derevyago, 2008.
 *
 * Permission to copy, use, modify, sell and distribute this software is granted
 * provided this copyright notice appears in all copies.
 * This software is provided "as is" without express or implied warranty, and
 * with no claim as to its suitability for any purpose.
 *
 */

#include <ders/data_io.hpp>
#include <stdexcept>

namespace {

using namespace ders;
using namespace std;

class cb_dio : public data_io {
      sh_cycl_buf cb;

      bool read(void* ptr, int n, bool noeof);
      void write(const void* ptr, int n) { cb->put(ptr, n); }

      template<class T>
      bool read(T& val) { return read(&val, sizeof(T), false); }
      template<class T>
      void write(T val) { write(&val, sizeof(T)); }

 public:
      cb_dio(sh_cycl_buf c) : cb(c) {}

      virtual void destroy(mem_pool& mp2) { destroy_this(this, mp2); }

      virtual bool read_bool(bool& val);
      virtual bool read_char(char& val);
      virtual bool read_schar(signed char& val);
      virtual bool read_uchar(unsigned char& val);
      virtual bool read_wchar(wchar_t& val);
      virtual bool read_short(short& val);
      virtual bool read_ushort(unsigned short& val);
      virtual bool read_int(int& val);
      virtual bool read_uint(unsigned int& val);
      virtual bool read_long(long& val);
      virtual bool read_ulong(unsigned long& val);
      virtual bool read_float(float& val);
      virtual bool read_double(double& val);
      virtual bool read_ldouble(long double& val);
      virtual bool read_ptr(void*& val);
      virtual bool read_text(sh_text& val);

      virtual void write_bool(bool val);
      virtual void write_char(char val);
      virtual void write_schar(signed char val);
      virtual void write_uchar(unsigned char val);
      virtual void write_wchar(wchar_t val);
      virtual void write_short(short val);
      virtual void write_ushort(unsigned short val);
      virtual void write_int(int val);
      virtual void write_uint(unsigned int val);
      virtual void write_long(long val);
      virtual void write_ulong(unsigned long val);
      virtual void write_float(float val);
      virtual void write_double(double val);
      virtual void write_ldouble(long double val);
      virtual void write_ptr(void* val);
      virtual void write_text(const ch_rng& val);
};

bool cb_dio::read(void* ptr, int n, bool noeof)
{
 if (cb->size()<n) {
    if (cb->size()==0 && !noeof) return false;

    // no thread-safe mem_pool object to throw shException at this point
    throw runtime_error("Not enough bytes in data_io");
 }

 cb->get(ptr, n);
 return true;
}

bool cb_dio::read_bool(bool& val)
{
 return read(val);
}

bool cb_dio::read_char(char& val)
{
 return read(val);
}

bool cb_dio::read_schar(signed char& val)
{
 return read(val);
}

bool cb_dio::read_uchar(unsigned char& val)
{
 return read(val);
}

bool cb_dio::read_wchar(wchar_t& val)
{
 return read(val);
}

bool cb_dio::read_short(short& val)
{
 return read(val);
}

bool cb_dio::read_ushort(unsigned short& val)
{
 return read(val);
}

bool cb_dio::read_int(int& val)
{
 return read(val);
}

bool cb_dio::read_uint(unsigned int& val)
{
 return read(val);
}

bool cb_dio::read_long(long& val)
{
 return read(val);
}

bool cb_dio::read_ulong(unsigned long& val)
{
 return read(val);
}

bool cb_dio::read_float(float& val)
{
 return read(val);
}

bool cb_dio::read_double(double& val)
{
 return read(val);
}

bool cb_dio::read_ldouble(long double& val)
{
 return read(val);
}

bool cb_dio::read_ptr(void*& val)
{
 return read(val);
}

bool cb_dio::read_text(sh_text& val)
{
 int sz;
 if (!read(sz)) return false;

 val->uninitialized_resize(sz);
 read(val->begin(), sz, true);

 return true;
}

void cb_dio::write_bool(bool val)
{
 write(val);
}

void cb_dio::write_char(char val)
{
 write(val);
}

void cb_dio::write_schar(signed char val)
{
 write(val);
}

void cb_dio::write_uchar(unsigned char val)
{
 write(val);
}

void cb_dio::write_wchar(wchar_t val)
{
 write(val);
}

void cb_dio::write_short(short val)
{
 write(val);
}

void cb_dio::write_ushort(unsigned short val)
{
 write(val);
}

void cb_dio::write_int(int val)
{
 write(val);
}

void cb_dio::write_uint(unsigned int val)
{
 write(val);
}

void cb_dio::write_long(long val)
{
 write(val);
}

void cb_dio::write_ulong(unsigned long val)
{
 write(val);
}

void cb_dio::write_float(float val)
{
 write(val);
}

void cb_dio::write_double(double val)
{
 write(val);
}

void cb_dio::write_ldouble(long double val)
{
 write(val);
}

void cb_dio::write_ptr(void* val)
{
 write(val);
}

void cb_dio::write_text(const ch_rng& val)
{
 int sz=val.size();
 write(sz);
 write(val.beg, sz);
}

}  // unnamed

namespace ders {  // ::ders

sh_data_io new_data_io(sh_cycl_buf cb)
{
 mp_newbuf<cb_dio> buf(cb.pool());
 return sh_data_io(buf.pool(), buf.rls(::new(buf.get()) cb_dio(cb)));
}

}  // namespace ::ders

---