/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/io/xrbuf

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_io_xrbuf
#define inlib_io_xrbuf

#include "irbuf"

#ifdef INLIB_MEM
#include "../mem"
#endif

#include <ostream>

#include "../realloc"
#include "../s2int64"
#include "../cstr"

namespace inlib {
namespace io {

class xrbuf : public virtual irbuf {
#ifdef INLIB_MEM
  static const std::string& s_class() {
    static const std::string s_v("inlib::io::xrbuf");
    return s_v;
  }
#endif
public: //irbuf
  virtual bool read(uchar& a_x){return _read_strtol<uchar>(a_x);}
  virtual bool read(char& a_x){return _read_strtol<char>(a_x);}
  virtual bool read(uint16& a_x){return _read_strtol<uint16>(a_x);}
  virtual bool read(int16& a_x){return _read_strtol<int16>(a_x);}
  virtual bool read(uint32& a_x){return _read_strtol<uint32>(a_x);}
  virtual bool read(int32& a_x){return _read_strtol<int32>(a_x);}

  virtual bool read(uint64& a_x){
    return _read<uint64,int64>(a_x,inlib::s2int64);
  }
  virtual bool read(int64& a_x){
    return _read<int64,int64>(a_x,inlib::s2int64);
  }

  virtual bool read(bool& a_v) {
    uchar v;
    bool status = read(v);
    a_v = (v==1?true:false);
    return status;
  }

  virtual bool read(float& a_v){
    char* end;
#ifdef WIN32
    double v = ::strtod(m_pos,&end);
    a_v = (float)v;
#else
    a_v = ::strtof(m_pos,&end);
#endif
    if(end==m_pos) return false;
    if((end+1)>m_max) return false;
    m_pos = end+1;
    return true;
  }
  virtual bool read(double& a_v){
    char* end;
    a_v = ::strtod(m_pos,&end);
    if(end==m_pos) return false;
    if((end+1)>m_max) return false;
    m_pos = end+1;
    return true;
  }

  virtual bool read_cstr(char*& a_cstr) {
    char* pos = m_pos;
    char* begin = m_pos;
    uint32 sz = _remaining();
    for(uint32 index=0;index<sz;index++,pos++) {
      if((*pos)=='\0') {
        diff_pointer_t l = pos-begin;
        a_cstr = str_new(l);
        ::memcpy(a_cstr,begin,l);
        begin = pos+1;
        m_pos = begin;
        return true; //stop at first string found.
      }
    }
    a_cstr = 0;
    return false;
  }

  virtual bool read_vec(uint32& a_n,uchar*& a_x){
    return _read_array<uchar>(a_n,a_x);
  }
  virtual bool read_vec(uint32& a_n,char*& a_x){
    return _read_array<char>(a_n,a_x);
  }
  virtual bool read_vec(uint32& a_n,uint16*& a_x){
    return _read_array<uint16>(a_n,a_x);
  }
  virtual bool read_vec(uint32& a_n,int16*& a_x){
    return _read_array<int16>(a_n,a_x);
  }
  virtual bool read_vec(uint32& a_n,uint32*& a_x){
    return _read_array<uint32>(a_n,a_x);
  }
  virtual bool read_vec(uint32& a_n,int32*& a_x){
    return _read_array<int32>(a_n,a_x);
  }
  virtual bool read_vec(uint32& a_n,uint64*& a_x){
    return _read_array<uint64>(a_n,a_x);
  }
  virtual bool read_vec(uint32& a_n,int64*& a_x){
    return _read_array<int64>(a_n,a_x);
  }
  virtual bool read_vec(uint32& a_n,float*& a_x){
    return _read_array<float>(a_n,a_x);
  }
  virtual bool read_vec(uint32& a_n,double*& a_x){
    return _read_array<double>(a_n,a_x);
  }
  virtual bool read_vec(uint32& a_n,bool*& a_x){
    return _read_array<bool>(a_n,a_x);
  }

  virtual bool read_vec(std::vector<std::string>& a_a){
    // <chars>\n<chars>\n<chars>0
    a_a.clear();
    typedef cstr_t ta_type;
    char* pos = m_pos;
    char* begin = m_pos;
    uint32 sz = _remaining();
    for(uint32 index=0;index<sz;index++,pos++) {
      if((*pos)=='\0') {
        m_pos = begin;
        ta_type v;
        if(!read_cstr(v)) { //v is allocated with str_new.
          a_a.clear();
          return false;
        }
        if(v) a_a.push_back(v);
        begin = pos+1;
        return true;

      } else if( ((*pos)=='\\') && 
                 ((pos+1)<=m_max) &&
                 ((*(pos+1))=='n') ){
        m_pos = begin;
        char old_char = *pos;
        *pos = '\0';
        ta_type v;
        if(!read_cstr(v)) { //v is allocated with str_new.
          *pos = old_char;       
          a_a.clear();
          return false;
        }
        *pos = old_char;       
        if(v) a_a.push_back(v);
        begin = pos+2;
      }
    }
    //FIXME : return false if not ending with null char.
    return true;
  }

  virtual bool read_std_vec_vec(std_vec_vec_uint_t& a_vv) {
    return _read_std_vec_vec<unsigned int>(a_vv);
  }
  virtual bool read_std_vec_vec(std_vec_vec_float_t& a_vv) {
    return _read_std_vec_vec<float>(a_vv);
  }
  virtual bool read_std_vec_vec(std_vec_vec_string_t& a_vv) {
    // <str>\n<str>\n<num>\t<str>\n<str>\n<str>\t...\t<str>\n<str>0
    a_vv.clear();
    char* pos = m_pos;
    char* begin = m_pos;
    uint32 sz = _remaining();
    for(uint32 index=0;index<sz;index++,pos++) {
      if((*pos)=='\0') {
        m_pos = begin;
        std::vector<std::string> v;
        if(!read_vec(v)) {
          a_vv.clear();
          return false;
        }
        a_vv.push_back(v);
        return true;

      } else if( ((*pos)=='\\') && 
                 ((pos+1)<=m_max) &&
                 ((*(pos+1))=='t') ){
        m_pos = begin;
        char old_char = *pos;
        *pos = '\0';

        std::vector<std::string> v;
        if(!read_vec(v)) {
          *pos = old_char;       
          a_vv.clear();
          return false;
        }
        *pos = old_char;       

        a_vv.push_back(v);

        begin = pos+2;
      }
    }

    return true;
  }
public:
  xrbuf(std::ostream& a_out,uint32 a_size = 1014)
  :m_out(a_out)
  ,m_size(0)
  ,m_buffer(0)
  ,m_max(0)
  ,m_pos(0)
  {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    m_size = a_size;
    m_buffer = new char[m_size];
    m_max = m_buffer+m_size;
    m_pos = m_buffer;
  }
  virtual ~xrbuf(){
    delete [] m_buffer;
#ifdef INLIB_MEM
    mem::decrement(s_class().c_str());
#endif
  }
protected:
  xrbuf(const xrbuf& a_from)
  : irbuf(a_from)
  ,m_out(a_from.m_out){
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
  }
  xrbuf& operator=(const xrbuf&){return *this;}
public:
  bool copy(uint32 a_size,const char* a_buffer) {
    delete [] m_buffer;
    m_buffer = new char[a_size];
    if(!m_buffer) {m_size = 0;m_max = 0;m_pos = 0;return false;}
    ::memcpy(m_buffer,a_buffer,a_size);
    m_size = a_size;
    m_max = m_buffer + m_size;
    m_pos = m_buffer;
    return true;
  }
protected:
  template <class ta_type>
  bool _read_strtol(ta_type& a_v) {
    //introduced to compile on Android.
    //we expect at m_pos a C string (null terminated).
    char* end;
    long v = ::strtol(m_pos,&end,10);
    if(end==m_pos) return false;
    if((end+1)>m_max) return false;
    m_pos = end+1;
    a_v = (ta_type)v;
    return true;
  }

  template <class ta_type,class ta_ret_type>
  bool _read(ta_type& a_v,inlib::s2int64_func a_func) {
    //we expect at m_pos a C string (null terminated).
    char* end;
    ta_ret_type v = a_func(m_pos,&end,10);
    if(end==m_pos) return false;
    if((end+1)>m_max) return false;
    m_pos = end+1;
    a_v = (ta_type)v;
    return true;
  }

  template <class ta_type>
  inline bool _read_array(uint32& a_n,ta_type*& a_a){
    // assume that the whole remaining buffer containes {xxx0}.
    // a_a is allocated by this method.
    a_n = 0;
    uint32 a_size = 100;
    a_a = new ta_type[a_size];
    if(!a_a) return false;
    char* pos = m_pos;
    char* begin = m_pos;
    uint32 sz = _remaining();
    if(sz==1) {a_n = 0;return true;}
    for(uint32 index=0;index<sz;index++,pos++) {
      if( ((*pos)==' ')  ||
          ((*pos)=='\0') ){
        m_pos = begin;
        ta_type v;
        if(!read(v)) {
          delete [] a_a;
          a_a = 0;
          a_n = 0;
          return false;
        }
        if((a_n+1)>a_size) {
          uint32 new_a_size = 2*a_size;
          if(!realloc<ta_type>(a_a,new_a_size,a_size)) {a_n=0;return false;}
          a_size = new_a_size;
        }
        a_a[a_n] = v;
        a_n++;
        begin = pos+1;

        if((*pos)=='\0') return true;
      }
    }
    //FIXME : return false if not ending with null char.
    return true;
  }

  template <class T>
  bool _read_std_vec_vec(std::vector< std::vector<T> >& a_vv) {
    // <num> <num> <num>\n<num> <num> <num>\n...\n<num> <num>0
    a_vv.clear();
    char* pos = m_pos;
    char* begin = m_pos;
    uint32 sz = _remaining();
    for(uint32 index=0;index<sz;index++,pos++) {
      if((*pos)=='\0') {
        m_pos = begin;

        uint32 n;
        T* v;
        if(!_read_array<T>(n,v)) { //v is allocated with new T[].
          a_vv.clear();
          return false;
        }
        if(n) {
          std::vector<T> sv(n);
          for(unsigned int i=0;i<n;i++) sv[i] = v[i];
          a_vv.push_back(sv);
        }

        delete [] v;

        return true;

      } else if( ((*pos)=='\\') && 
                 ((pos+1)<=m_max) &&
                 ((*(pos+1))=='n') ){
        m_pos = begin;
        char old_char = *pos;
        *pos = '\0';

        uint32 n;
        T* v;
        if(!_read_array<T>(n,v)) { //v is allocated with new T[].
          *pos = old_char;       
          a_vv.clear();
          return false;
        }
        *pos = old_char;       

        if(n) {
          std::vector<T> sv(n);
          for(unsigned int i=0;i<n;i++) sv[i] = v[i];
          a_vv.push_back(sv);
        }

        delete [] v;

        begin = pos+2;
      }
    }

    return true;
  }

  uint32 _remaining() const {return (uint32)(m_max - m_pos);}
protected:
  std::ostream& m_out;
  uint32 m_size;
  char* m_buffer;
  char* m_max;
  char* m_pos;
};

}}

#endif