Public Member Functions
	wbuf (std::ostream &a_out, bool a_byte_swap, const char a_eob, char &a_pos)
virtual	~wbuf ()
void	set_eob (const char *a_eob)
bool	write (unsigned char a_x)
bool	write (unsigned short a_x)
bool	write (unsigned int a_x)
bool	write (uint64 a_x)
bool	write (float a_x)
bool	write (double a_x)
bool	write (char a_x)
bool	write (short a_x)
bool	write (int a_x)
bool	write (int64 a_x)
bool	write (const std::string &a_x)
template<class T >
bool	write (const T *a_a, uint32 a_n)
Protected Member Functions
	wbuf (const wbuf &a_from)
wbuf &	operator= (const wbuf &)
template<class T >
bool	check_eob ()
bool	check_eob (size_t a_n, const char *a_cmt)
Protected Attributes
std::ostream &	m_out
bool	m_byte_swap
const char *	m_eob
char *&	m_pos
w_2_func	m_w_2_func
w_4_func	m_w_4_func
w_8_func	m_w_8_func

Detailed Description

Definition at line 20 of file wbuf.

Constructor & Destructor Documentation

inlib::wroot::wbuf::wbuf	(	std::ostream &	a_out,
		bool	a_byte_swap,
		const char *	a_eob,
		char *&	a_pos
	)		`[inline]`

Definition at line 78 of file wbuf.

  :m_out(a_out)
  ,m_byte_swap(a_byte_swap)
  ,m_eob(a_eob)
  ,m_pos(a_pos)

  ,m_w_2_func(0)
  ,m_w_4_func(0)
  ,m_w_8_func(0)
  {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    if(m_byte_swap) {
      m_w_2_func = write_swap_2;
      m_w_4_func = write_swap_4;
      m_w_8_func = write_swap_8;
    } else {
      m_w_2_func = write_nswp_2;
      m_w_4_func = write_nswp_4;
      m_w_8_func = write_nswp_8;
    }
  }

virtual inlib::wroot::wbuf::~wbuf ( ) [inline, virtual]

Definition at line 102 of file wbuf.

                 {
#ifdef INLIB_MEM
    mem::decrement(s_class().c_str());
#endif
  }

inlib::wroot::wbuf::wbuf ( const wbuf & a_from ) [inline, protected]

Definition at line 108 of file wbuf.

  :m_out(a_from.m_out),m_eob(a_from.m_eob),m_pos(a_from.m_pos){
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
  }

Member Function Documentation

template<class T >

bool inlib::wroot::wbuf::check_eob ( ) [inline, protected]

Definition at line 203 of file wbuf.

                  {
    if((m_pos+sizeof(T))>m_eob) {
      m_out << s_class() << " : " << stype(T()) << " : "
           << " try to access out of buffer " << long2s(sizeof(T)) << " bytes"
           << " (pos=" << char_p2s(m_pos)
           << ", eob=" << char_p2s(m_eob) << ")." << std::endl;
      return false;
    }
    return true;
  }

bool inlib::wroot::wbuf::check_eob	(	size_t	a_n,
		const char *	a_cmt
	)		`[inline, protected]`

Definition at line 213 of file wbuf.

                                              {
    if((m_pos+a_n)>m_eob) {
      m_out << s_class() << " : " << a_cmt << " : "
           << " try to access out of buffer " << long2s(a_n) << " bytes"
           << " (pos=" << char_p2s(m_pos)
           << ", eob=" << char_p2s(m_eob) << ")." << std::endl;
      return false;
    }
    return true;
  }

wbuf& inlib::wroot::wbuf::operator= ( const wbuf & ) [inline, protected]

Definition at line 114 of file wbuf.

{return *this;}

void inlib::wroot::wbuf::set_eob ( const char * a_eob ) [inline]

Definition at line 116 of file wbuf.

{m_eob = a_eob;}

bool inlib::wroot::wbuf::write ( unsigned char a_x ) [inline]

Definition at line 119 of file wbuf.

                                {
    if(!check_eob<unsigned char>()) return false;
    *m_pos++ = a_x;
    return true;
  }

bool inlib::wroot::wbuf::write ( unsigned short a_x ) [inline]

Definition at line 125 of file wbuf.

                                 {
    if(!check_eob<unsigned short>()) return false;
    m_w_2_func(m_pos,(char*)&a_x);
    m_pos += sizeof(unsigned short);
    return true;
  }

bool inlib::wroot::wbuf::write ( unsigned int a_x ) [inline]

Definition at line 132 of file wbuf.

                               {
    if(!check_eob<unsigned int>()) return false;
    m_w_4_func(m_pos,(char*)&a_x);
    m_pos += sizeof(unsigned int);
    return true;
  }

bool inlib::wroot::wbuf::write ( uint64 a_x ) [inline]

Definition at line 139 of file wbuf.

                        {
    if(!check_eob<uint64>()) return false;
    m_w_8_func(m_pos,(char*)&a_x);
    m_pos += 8;
    return true;
  }

bool inlib::wroot::wbuf::write ( float a_x ) [inline]

Definition at line 146 of file wbuf.

                        {
    if(!check_eob<float>()) return false;
    m_w_4_func(m_pos,(char*)&a_x);
    m_pos += sizeof(float);
    return true;
  }

bool inlib::wroot::wbuf::write ( double a_x ) [inline]

Definition at line 153 of file wbuf.

                         {
    if(!check_eob<double>()) return false;
    m_w_8_func(m_pos,(char*)&a_x);
    m_pos += sizeof(double);
    return true;
  }

bool inlib::wroot::wbuf::write ( char a_x ) [inline]

Definition at line 160 of file wbuf.

{return write((unsigned char)a_x);}

bool inlib::wroot::wbuf::write ( short a_x ) [inline]

Definition at line 161 of file wbuf.

{return write((unsigned short)a_x);}

bool inlib::wroot::wbuf::write ( int a_x ) [inline]

Definition at line 162 of file wbuf.

{return write((unsigned int)a_x);}

bool inlib::wroot::wbuf::write ( int64 a_x ) [inline]

Definition at line 163 of file wbuf.

{return write((uint64)a_x);}

bool inlib::wroot::wbuf::write ( const std::string & a_x ) [inline]

Definition at line 165 of file wbuf.

                                   {
    unsigned char nwh;
    unsigned int nchars = a_x.size();
    if(nchars>254) {
      if(!check_eob(1+4,"std::string")) return false;
      nwh = 255;
      if(!write(nwh)) return false;
      if(!write(nchars)) return false;
    } else {
      if(!check_eob(1,"std::string")) return false;
      nwh = (unsigned char)nchars;
      if(!write(nwh)) return false;
    }
    if(!check_eob(nchars,"std::string")) return false;
    for (unsigned int i = 0; i < nchars; i++) m_pos[i] = a_x[i];
    m_pos += nchars;
    return true;
  }

template<class T >

bool inlib::wroot::wbuf::write	(	const T *	a_a,
		uint32	a_n
	)		`[inline]`

Definition at line 186 of file wbuf.

                                      {
    if(!a_n) return true;
    uint32 l = a_n * sizeof(T);
    if(!check_eob(l,"array")) return false;
    if(m_byte_swap) {
      for(uint32 i=0;i<a_n;i++) {
        if(!write(a_a[i])) return false;
      }
    } else {
      ::memcpy(m_pos,a_a,l);
      m_pos += l;
    }
    return true;
  }