/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/sg/mf

Go to the documentation of this file.

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

#ifndef inlib_sg_mf
#define inlib_sg_mf

// mf for multiple field.

#include "field"

#include "../cstr"
#include "../vdata"

namespace inlib {
namespace sg {

template <class T>
class bmf : public field {
  // bmf is intended to have no implementation of :
  //   virtual bool write(io::iwbuf&)  
  //   virtual bool read(io::irbuf&)  
public:
  bmf(){}
  //bmf(const T& a_value){m_values.push_back(a_value);}
  virtual ~bmf(){m_values.clear();}
public:
  bmf(const bmf& a_from):field(a_from),m_values(a_from.m_values){}
  bmf& operator=(const bmf& a_from){
    field::operator=(a_from);
    if(a_from.m_values!=m_values) m_touched = true;
    m_values = a_from.m_values;
    return *this;
  }
public:
  bmf& operator=(const std::vector<T>& a_from){
    if(a_from!=m_values) m_touched = true;
    m_values = a_from;
    return *this;
  }
  bool operator==(const bmf& a_from) const {
    return m_values==a_from.m_values;
  }
  bool operator!=(const bmf& a_from) const { 
    return !operator==(a_from);
  }
  const T& operator[](unsigned int a_index) const {
    //WARNING : no check is done on a_index.
    return m_values[a_index];    
  }
  T& operator[](unsigned int a_index) {
    //WARNING : no check is done on a_index.
    return m_values[a_index];    
  }
public:
  //unsigned int number() const {return m_values.size();}
  unsigned int size() const {return m_values.size();}
  bool empty() const {return m_values.empty();}
  const std::vector<T>& values() const {return m_values;}
  std::vector<T>& values() {return m_values;}
  void add(const T& a_value) {
    m_values.push_back(a_value);
    m_touched = true;
  }
  typedef typename std::vector<T>::iterator it_t;
  void insert(const it_t& a_it,const T& a_value) {
    m_values.insert(a_it,a_value);
    m_touched = true;
  }
  bool set_value(unsigned int a_index,const T& a_value) {
    if(a_index>=m_values.size()) return false;
    if(m_values[a_index]!=a_value) m_touched = true;
    m_values[a_index] = a_value;
    return true;
  }
  bool get_value(unsigned int a_index,T& a_value) {
    if(a_index>=m_values.size()) {a_value=T();return false;}
    a_value = m_values[a_index];
    return true;
  }
  void clear() {
    if(m_values.size()) m_touched = true;
    m_values.clear();
  }
  //void set(const std::vector<T>& a_values) {
  //  if(a_values!=m_values) m_touched = true;
  //  m_values = a_values;
  //}
protected:
  std::vector<T> m_values;
};

}}

#include "../io/iwbuf"
#include "../io/irbuf"

namespace inlib {
namespace sg {

template <class T>
class mf : public bmf<T> {
public:
  virtual bool write(io::iwbuf& a_buffer) {
    const std::vector<T>& vec = bmf<T>::m_values;
    return a_buffer.write_vec(vec.size(),vec_data(vec));
  }
  virtual bool read(io::irbuf& a_buffer) {
    std::vector<T>& vec = bmf<T>::m_values;
    return a_buffer.read_std_vec(vec);
  }
  virtual bool dump(std::ostream& a_out) {
    const std::vector<T>& vec = bmf<T>::m_values;
    a_out << "size : " << vec.size() << std::endl;
    typedef typename std::vector<T>::const_iterator cit_t;
    for(cit_t it=vec.begin();it!=vec.end();++it) {
      a_out << "  " << (*it) << std::endl;
    }
    return true;
  }
public:
  mf(){}
public:
  mf(const mf& a_from)
  : bmf<T>(a_from)
  {}
  mf& operator=(const mf& a_from){
    //typedef typename bmf<T>::iterator bmf_t;
    bmf<T>::operator=(a_from);
    return *this;
  }
public:
  mf& operator=(const std::vector<T>& a_from){
    bmf<T>::operator=(a_from);
    return *this;
  }
};

class mf_string : public bmf<std::string> {
public:
  virtual bool write(io::iwbuf& a_buffer) {
    return a_buffer.write_vec(m_values);
  }
  virtual bool read(io::irbuf& a_buffer) {
    std::vector<std::string>& vec = bmf<std::string>::m_values;
    return a_buffer.read_vec(vec);
  }
  virtual bool dump(std::ostream& a_out) {
    const std::vector<std::string>& vec = bmf<std::string>::m_values;
    a_out << "size : " << vec.size() << std::endl;
    std::vector<std::string>::const_iterator it;
    for(it=vec.begin();it!=vec.end();++it) {
      a_out << "  \"" << (*it) << "\"" << std::endl;
    }
    return true;
  }
public:
  mf_string(): bmf<std::string>(){}
  virtual ~mf_string(){}
public:
  mf_string(const mf_string& a_from)
  : bmf<std::string>(a_from){}
  mf_string& operator=(const mf_string& a_from){
    bmf<std::string>::operator=(a_from);
    return *this;
  }
public:
  mf_string& operator=(const std::vector<std::string>& a_value){
    bmf<std::string>::operator=(a_value);
    return *this;
  }
};

//exa exlib::sg::entries.mf_vec<entry_type>

template <class T>
class mf_enum : public bmf<T> {
public:
  virtual bool write(io::iwbuf& a_buffer) {
    const std::vector<T>& vec = bmf<T>::m_values;
    std::vector<int> v; //an enum can be negative.
    typedef typename std::vector<T>::const_iterator cit_t;
    for(cit_t it=vec.begin();it!=vec.end();++it) v.push_back(*it);
    return a_buffer.write_vec(v.size(),vec_data(v));
  }
  virtual bool read(io::irbuf& a_buffer) {
    std::vector<int> v; //an enum can be negative.
    if(!a_buffer.read_std_vec(v)) return false;
    std::vector<T>& vec = bmf<T>::m_values;
    vec.clear();
    std::vector<int>::const_iterator it;
    for(it=v.begin();it!=v.end();++it) vec.push_back((T)(*it));
    return true;
  }
  virtual bool dump(std::ostream& a_out) {
    const std::vector<T>& vec = bmf<T>::m_values;
    a_out << "size : " << vec.size() << std::endl;
    typedef typename std::vector<T>::const_iterator cit_t;
    for(cit_t it=vec.begin();it!=vec.end();++it) {
      a_out << "  " << (*it) << std::endl;
    }
    return true;
  }
public:
  mf_enum(): bmf<T>(){}
  virtual ~mf_enum(){}
public:
  mf_enum(const mf_enum& a_from)
  : bmf<T>(a_from){}
  mf_enum& operator=(const mf_enum& a_from){
    bmf<T>::operator=(a_from);
    return *this;
  }
};

//exa mf_vec<colorf,float>
//exa mf_vec<inlib::vecs,std::string>

template <class T,class TT> 
class mf_vec : public bmf<T> {
public:
  virtual bool write(io::iwbuf& a_buffer) {
    const std::vector<T>& vec = bmf<T>::m_values;
    typedef typename std::vector<TT> vec_t;
    std::vector<vec_t> vec_vec;
    typedef typename std::vector<T>::const_iterator cit_t;
    for(cit_t it=vec.begin();it!=vec.end();++it) {
      vec_vec.push_back((*it).vector());
    }
    return a_buffer.write_std_vec_vec(vec_vec);
  }
  virtual bool read(io::irbuf& a_buffer) {
    std::vector<T>& vec = bmf<T>::m_values;
    vec.clear();
    typedef typename std::vector<TT> vec_t;
    std::vector<vec_t> vec_vec;
    if(!a_buffer.read_std_vec_vec(vec_vec)) return false;
    typedef typename std::vector<vec_t>::iterator it_t;
    for(it_t it=vec_vec.begin();it!=vec_vec.end();++it) {
      T x;
      if(!x.fill(*it)) {vec.clear();return false;}
      vec.push_back(x);
    }
    return true;
  }
  virtual bool dump(std::ostream& a_out) {
    const std::vector<T>& vec = bmf<T>::m_values;
    a_out << "size : " << vec.size() << std::endl;
    typedef typename std::vector<T>::const_iterator cit_t;
    for(cit_t it=vec.begin();it!=vec.end();++it) {
      a_out << "  " << (*it) << std::endl;
    }
    return true;
  }
public:
  mf_vec(): bmf<T>(){}
  virtual ~mf_vec(){}
public:
  mf_vec(const mf_vec& a_from)
  : bmf<T>(a_from){}
  mf_vec& operator=(const mf_vec& a_from){
    bmf<T>::operator=(a_from);
    return *this;
  }
};

template <class T>
class mf_std_vec : public bmf< std::vector<T> > {
public:
  virtual bool write(io::iwbuf& a_buffer) {
    //used in exlib/sg/text_freetype::unitext
    const std::vector< std::vector<T> >& vec = bmf< std::vector<T> >::m_values;
    return a_buffer.write_std_vec_vec(vec);
  }
  virtual bool read(io::irbuf& a_buffer) {
    std::vector< std::vector<T> >& vec = bmf< std::vector<T> >::m_values;
    return a_buffer.read_std_vec_vec(vec);
  }
  virtual bool dump(std::ostream& a_out) {
    const std::vector< std::vector<T> >& vec = bmf< std::vector<T> >::m_values;
    a_out << "size : " << vec.size() << std::endl;
    typedef typename std::vector< std::vector<T> >::const_iterator cit_t;
    for(cit_t it=vec.begin();it!=vec.end();++it) {
      //a_out << "  " << (*it) << std::endl;
    }
    return true;
  }
public:
  mf_std_vec(): bmf< std::vector<T> >(){}
  virtual ~mf_std_vec(){}
public:
  mf_std_vec(const mf_std_vec& a_from)
  : bmf< std::vector<T> >(a_from){}
  mf_std_vec& operator=(const mf_std_vec& a_from){
    bmf< std::vector<T> >::operator=(a_from);
    return *this;
  }
};

}}

#endif