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

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_sf
#define inlib_sg_sf

// sf for simple field.

#include "field"

//#include "../sto"

namespace inlib {
namespace sg {

template <class T>
class bsf : public field {
  // bsf is intended to have no implementation of :
  //   virtual bool write(io::iwbuf&)  
  //   virtual bool read(io::irbuf&)  
/*
public:
  static const std::string& s_class() {
    static const std::string s_v("inlib::sg::bsf");
    return s_v;
  }
  virtual void* cast(const std::string& a_class) const {
    if(void* p = inlib::cmp_cast<node>(this,a_class)) {return p;}
    else return 0;
  }
  virtual bool equal(const field& a_field) const {    
    bsf<T>* fld = inlib::cast<inlib::sg::field,bsf<T>>(a_field);
    if(!fld) return false;
    return operator==(*fld);    
  }
*/
protected:
  bsf(){}
public:
  bsf(const T& a_value):m_value(a_value){}
  virtual ~bsf(){}
public:
  bsf(const bsf& a_from)
  :field(a_from)
  ,m_value(a_from.m_value){}

  bsf& operator=(const bsf& a_from){
    field::operator=(a_from);
    if(a_from.m_value!=m_value) m_touched = true;
    m_value = a_from.m_value;
    return *this;
  }
public:
  bsf& operator=(const T& a_value){
    if(a_value!=m_value) m_touched = true;
    m_value = a_value;
    return *this;
  }
  bool operator==(const bsf& a_from) const {
    return m_value==a_from.m_value;
  }
  bool operator!=(const bsf& a_from) const {
    return !operator==(a_from);
  }

  bool operator==(const T& a_value) const {
    return m_value==a_value;
  }
  bool operator!=(const T& a_value) const { 
    return !operator==(a_value);
  }

  operator const T& () const {return m_value;}
  operator T() {return m_value;}

  bsf& operator+=(const T& a_value){
    m_value += a_value;
    m_touched = true;
    return *this;
  }
public:
  T& value() {return m_value;}
  const T& value() const {return m_value;}
  void value(const T& a_value) {
    if(a_value!=m_value) m_touched = true;
    m_value = a_value;
  }
  void value_no_cmp(const T& a_value) {
    //if(a_value!=m_value) m_touched = true;
    m_value = a_value;
  }
//public: //for style.
//  bool s2v(const std::string& a_s) {
//    T v;
//    if(!inlib::to<T>(a_s,v)) return false;
//    if(v!=m_value) m_touched = true;
//    m_value = v;
//    return true;
//  }  
protected:
  T m_value;
};

}}

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

namespace inlib {
namespace sg {

template <class T>
class sf : public bsf<T> {
public:
  virtual bool write(io::iwbuf& a_buffer) {
    return a_buffer.write(bsf<T>::m_value);
  }
  virtual bool read(io::irbuf& a_buffer) {
    return a_buffer.read(bsf<T>::m_value);
  }
  virtual bool dump(std::ostream& a_out) {
    a_out << bsf<T>::m_value << std::endl;
    return true;
  }
public:
  sf(){}
  sf(const T& a_value): bsf<T>(a_value){}
public:
  sf(const sf& a_from)
  : bsf<T>(a_from)
  {}
  sf& operator=(const sf& a_from){
    bsf<T>::operator=(a_from);
    return *this;
  }
public:
  sf& operator=(const T& a_value){
    bsf<T>::operator=(a_value);
    return *this;
  }
public:
};

}}

#endif