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

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_xwbuf
#define inlib_io_xwbuf

// used to produce exsg XML files.

#include "iwbuf"

#include "../realloc"

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

#include <ostream>

#include "../mnmx"

namespace inlib {
namespace io {

class xwbuf : public virtual iwbuf {
#ifdef INLIB_MEM
  static const std::string& s_class() {
    static const std::string s_v("inlib::io::xwbuf");
    return s_v;
  }
#endif
public: //iwbuf
  virtual bool write(uchar a_x) {
    if(!_write_cstr("<uchar v=\"")) return false;
    if(!_write<uchar>(a_x,write_format(a_x).c_str())) return false;
    if(!_write_cstr("\"/>")) return false;
    return true;
  }
  virtual bool write(char a_x) {
    if(!_write_cstr("<char v=\"")) return false;
    if(!_write<char>(a_x,write_format(a_x).c_str())) return false;
    if(!_write_cstr("\"/>")) return false;
    return true;
  }
  virtual bool write(uint16 a_x) {
    if(!_write_cstr("<uint16 v=\"")) return false;
    if(!_write<uint16>(a_x,write_format(a_x).c_str())) return false;
    if(!_write_cstr("\"/>")) return false;
    return true;
  }
  virtual bool write(int16 a_x) {
    if(!_write_cstr("<int16 v=\"")) return false;
    if(!_write<int16>(a_x,write_format(a_x).c_str())) return false;
    if(!_write_cstr("\"/>")) return false;
    return true;
  }
  virtual bool write(uint32 a_x) {
    if(!_write_cstr("<uint32 v=\"")) return false;
    if(!_write<uint32>(a_x,write_format(a_x).c_str())) return false;
    if(!_write_cstr("\"/>")) return false;
    return true;
  }
  virtual bool write(int32 a_x) {
    if(!_write_cstr("<int32 v=\"")) return false;
    if(!_write<int32>(a_x,write_format(a_x).c_str())) return false;
    if(!_write_cstr("\"/>")) return false;
    return true;
  }
  virtual bool write(uint64 a_x) {
    if(!_write_cstr("<uint64 v=\"")) return false;
    if(!_write<uint64>(a_x,write_format(a_x).c_str())) return false;
    if(!_write_cstr("\"/>")) return false;
    return true;
  }
  virtual bool write(int64 a_x) {
    if(!_write_cstr("<int64 v=\"")) return false;
    if(!_write<int64>(a_x,write_format(a_x).c_str())) return false;
    if(!_write_cstr("\"/>")) return false;
    return true;
  }
  virtual bool write(float a_x) {
    if(!_write_cstr("<float v=\"")) return false;
    if(!_write<float>(a_x,write_format(a_x).c_str())) return false;
    if(!_write_cstr("\"/>")) return false;
    return true;
  }
  virtual bool write(double a_x) {
    if(!_write_cstr("<double v=\"")) return false;
    if(!_write<double>(a_x,write_format(a_x).c_str())) return false;
    if(!_write_cstr("\"/>")) return false;
    return true;
  }

  virtual bool write(bool a_v) {
    if(!_write_cstr("<bool v=\"")) return false;
    if((m_pos+MAX_SPRINTF_SIZE())>m_max) {
      if(!expand(inlib::mx<uint32>(2*m_size,m_size+MAX_SPRINTF_SIZE()))) 
        return false;
    }
    if(!m_buffer) return false;
    //NOTE : the below writes an ending null char.
#ifdef WIN32
    int sz = _snprintf(m_pos,MAX_SPRINTF_SIZE(),"%u",a_v?1:0);
#else
    int sz = ::snprintf(m_pos,MAX_SPRINTF_SIZE(),"%u",a_v?1:0);
#endif
    if(sz>(MAX_SPRINTF_SIZE()-1)) return false;
    m_pos += sz;
    if(!_write_cstr("\"/>")) return false;
    return true;
  }

  virtual bool write_cstr(const char* a_cstr) {
    if(!_write_cstr("<string v=\"")) return false;
    if(!_write_xml_cstr(a_cstr)) return false;
    if(!_write_cstr("\"/>")) return false;
    return true;
  }

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

  virtual bool write_vec(const std::vector<std::string>& a_v){
    // <string>\n<string>\n<string>
    if(!_write_cstr("<array>")) return false;
    std::vector<std::string>::const_iterator it;    
    for(it=a_v.begin();it!=a_v.end();++it) {
      if(it!=a_v.begin()) {if(!_write_cstr("\\n")) return false;}
      if(!_write_xml_cstr((*it).c_str())) return false;
    }
    if(!_write_cstr("</array>")) return false;
    return true;
  }

  virtual bool write_std_vec_vec(const std_vec_vec_uint_t& a_vv) {
    return _write_std_vec_vec<unsigned int>(a_vv);
  }
  virtual bool write_std_vec_vec(const std_vec_vec_float_t& a_vv) {
    return _write_std_vec_vec<float>(a_vv);
  }
  virtual bool write_std_vec_vec(const std_vec_vec_string_t& a_vv) {
    if(!_write_cstr("<array>")) return false;

    typedef std::vector<std::string> vec_t;

    std::vector<vec_t>::const_iterator it;
    for(it=a_vv.begin();it!=a_vv.end();++it) {
      if(it!=a_vv.begin()) {if(!_write_cstr("\\t")) return false;}
      
      std::vector<std::string>::const_iterator it2;
      for(it2=(*it).begin();it2!=(*it).end();++it2) {
        if(it2!=(*it).begin()) {if(!_write_cstr("\\n")) return false;}
        if(!_write_xml_cstr((*it2).c_str())) return false;
      }

    }

    if(!_write_cstr("</array>")) return false;

    return true;
  }
public:
  virtual const char* buf() const {return m_buffer;}
  virtual uint32 length() const {return m_pos-m_buffer;}
public:
  xwbuf(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 ~xwbuf(){
    delete [] m_buffer;
#ifdef INLIB_MEM
    mem::decrement(s_class().c_str());
#endif
  }
protected:
  xwbuf(const xwbuf& a_from)
  : iwbuf(a_from)
  ,m_out(a_from.m_out){
#ifdef INLIB_MEM
    mem::decrement(s_class().c_str());
#endif
  }
  xwbuf& operator=(const xwbuf&){return *this;}
public:
  bool write_verbatim(const char* a_cstr) {
    if(!_write_cstr(a_cstr)) return false;
    return true;
  }
  void reset_pos() {m_pos = m_buffer;}
protected:

  bool _write_cstr(const char* a_cstr) {
    size_t sz = ::strlen(a_cstr);
    if((m_pos+sz)>m_max)
      if(!expand(inlib::mx<uint32>(2*m_size,m_size+sz))) return false;
    if(!m_buffer) return false;
    ::memcpy(m_pos,a_cstr,sz);
    m_pos += sz;
    return true;
  }

  bool _write_xml_cstr(const char* a_cstr) {
    size_t sz = ::strlen(a_cstr);
    if((m_pos+sz)>m_max)
      if(!expand(inlib::mx<uint32>(2*m_size,m_size+sz))) return false;
    if(!m_buffer) return false;

    char* pos = (char*)a_cstr;
    while(true){
      char c = *pos;pos++;
      if(c=='\0') {
        break;
      } else if(c=='<') {
        *m_pos = '&';m_pos++;
        *m_pos = 'l';m_pos++;
        *m_pos = 't';m_pos++;
        *m_pos = ';';m_pos++;
      } else if(c=='>') {
        *m_pos = '&';m_pos++;
        *m_pos = 'g';m_pos++;
        *m_pos = 't';m_pos++;
        *m_pos = ';';m_pos++;
      } else if(c=='&') {
        *m_pos = '&';m_pos++;
        *m_pos = 'a';m_pos++;
        *m_pos = 'm';m_pos++;
        *m_pos = 'p';m_pos++;
        *m_pos = ';';m_pos++;
      } else if(c=='"') {
        *m_pos = '&';m_pos++;
        *m_pos = 'q';m_pos++;
        *m_pos = 'u';m_pos++;
        *m_pos = 'o';m_pos++;
        *m_pos = 't';m_pos++;
        *m_pos = ';';m_pos++;
      } else if(c=='\'') {
        *m_pos = '&';m_pos++;
        *m_pos = 'a';m_pos++;
        *m_pos = 'p';m_pos++;
        *m_pos = 'o';m_pos++;
        *m_pos = 's';m_pos++;
        *m_pos = ';';m_pos++;
      } else {
        *m_pos = c;m_pos++;
      }
    }

    return true;
  }

  static int MAX_SPRINTF_SIZE() {return 256;}

  template <class ta_type>
  bool _write(ta_type a_v,const char* a_format) {
    if((m_pos+MAX_SPRINTF_SIZE())>m_max) {
      if(!expand(inlib::mx<uint32>(2*m_size,m_size+MAX_SPRINTF_SIZE())))
        return false;
    }
    if(!m_buffer) return false;
#ifdef WIN32
    int sz = _snprintf(m_pos,MAX_SPRINTF_SIZE(),a_format,a_v);
#else
    int sz = ::snprintf(m_pos,MAX_SPRINTF_SIZE(),a_format,a_v);
#endif
    if(sz>(MAX_SPRINTF_SIZE()-1)) return false;
    m_pos += sz;
    return true;
  }

  template <class ta_type>
  bool _write_array(uint32 a_n,const ta_type* a_a) {
    if(!_write_cstr("<array>")) return false;

    for(uint32 i=0;i<a_n;i++) {
      if(i) {if(!_write_cstr(" ")) return false;}
      if(!_write<ta_type>(a_a[i],write_format(a_a[i]).c_str())) return false;
    }

    if(!_write_cstr("</array>")) return false;
    return true;
  }

  template <class T>
  bool _write_std_vec_vec(const std::vector< std::vector<T> >& a_vv) {
    // <num> <num> <num>\n<num> <num> <num>\n...\n<num> <num>
    if(!_write_cstr("<array>")) return false;

    typedef typename std::vector<T> vec_t;

    typedef typename std::vector<vec_t>::const_iterator cit_t;
    for(cit_t it=a_vv.begin();it!=a_vv.end();++it) {
      if(it!=a_vv.begin()) {if(!_write_cstr("\\n")) return false;}
      
      typedef typename std::vector<T>::const_iterator cit2_t;
      for(cit2_t it2=(*it).begin();it2!=(*it).end();++it2) {
        if(it2!=(*it).begin()) {if(!_write_cstr(" ")) return false;}
        if(!_write<T>(*it2,write_format(*it2).c_str())) return false;
      }

    }

    if(!_write_cstr("</array>")) return false;

    return true;
  }
protected:
  static const std::string& write_format(uchar) {
    static const std::string s_v("%u");
    return s_v;    
  }
  static const std::string& write_format(char) {
    static const std::string s_v("%d");
    return s_v;    
  }
  static const std::string& write_format(uint16) {
    static const std::string s_v("%u");
    return s_v;    
  }
  static const std::string& write_format(int16) {
    static const std::string s_v("%d");
    return s_v;    
  }
  static const std::string& write_format(uint32) {
    static const std::string s_v("%u");
    return s_v;    
  }
  static const std::string& write_format(int32) {
    static const std::string s_v("%d");
    return s_v;    
  }
  static const std::string& write_format(uint64) {
    static const std::string s_v(uint64_format());
    return s_v;   
  }
  static const std::string& write_format(int64) {
    static const std::string s_v(int64_format());
    return s_v;   
  }
  static const std::string& write_format(float) {
    static const std::string s_v("%g");
    return s_v;    
  }
  static const std::string& write_format(double) {
    static const std::string s_v("%g");
    return s_v;    
  }

  bool expand(uint32 a_new_size) {
    unsigned long len = m_pos-m_buffer;
    if(!realloc<char>(m_buffer,a_new_size,m_size)) {
      m_out << "inlib::io::xwbuf::expand :"
            << " can't realloc " << a_new_size << " bytes."
            << std::endl;
      m_size = 0;
      m_max = 0;
      m_pos = 0;
      return false;
    }
    m_size = a_new_size;
    m_max = m_buffer + m_size;
    m_pos = m_buffer + len;
    return true;
  }
protected:
  std::ostream& m_out;
  uint32 m_size;
  char* m_buffer;
  char* m_max;
  char* m_pos;
};

}}

#endif