fields.h

Go to the documentation of this file.

//
// Copyright (c) 2000-2004 California Institute of Technology
// Copyright (c) 2004-2007 University of Southern California
// Rob Peters <rjpeters at usc dot edu>
//
// created: Sat Nov 11 15:25:00 2000
// commit: $Id: fields.h 10065 2007-04-12 05:54:56Z rjpeters $
// $HeadURL: file:///lab/rjpeters/svnrepo/code/trunk/groovx/src/io/fields.h $
//
// --------------------------------------------------------------------
//
// This file is part of GroovX.
//   [http://ilab.usc.edu/rjpeters/groovx/]
//
// GroovX is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// GroovX is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with GroovX; if not, write to the Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//

#ifndef GROOVX_IO_FIELDS_H_UTC20051109000918_DEFINED
#define GROOVX_IO_FIELDS_H_UTC20051109000918_DEFINED

#include "io/reader.h"
#include "io/writer.h"

#include "nub/object.h"

#include "rutz/algo.h"
#include "rutz/fileposition.h"
#include "rutz/fstring.h"
#include "rutz/shared_ptr.h"
#include "rutz/stderror.h"
#include "rutz/traits.h"
#include "rutz/value.h"

#include <limits>

namespace rutz
{
  template <class T> class fwd_iter;
}

namespace io
{
  class reader;
  class writer;
}

namespace nub
{
  class signal0;
}

class FieldContainer;

namespace FieldAux
{

  template <class C, class F>
  inline C& cast(F& p);

  void throwNotAllowed(const char* what, const rutz::file_pos& pos);
}




class FieldImpl
{
public:
  virtual ~FieldImpl();

  virtual void readValueFrom(FieldContainer* obj,
                             io::reader& reader,
                             const rutz::fstring& name) const = 0;
  virtual void writeValueTo(const FieldContainer* obj,
                            io::writer& writer,
                            const rutz::fstring& name) const = 0;
};

namespace
{
  template <class C, class T>
  struct MatchConst
  {
    typedef T Type;
  };

  template <class C, class T>
  struct MatchConst<const C, T>
  {
    typedef const T Type;
  };

  template <class C, class T>
  struct Deref
  {
    typedef typename MatchConst<C,T>::Type Type;

    static Type& get(C& obj, T C::* mptr) { return (obj.*mptr); }
  };

  template <class C, class T>
  struct Deref<C, T*>
  {
    typedef typename MatchConst<C,T>::Type Type;

    static Type& get(C& obj, T* C::* mptr) { return *(obj.*mptr); }
  };

  template <class C, class T>
  typename Deref<C,T>::Type&
  dereference(C& obj, T C::* mptr)
  {
    return Deref<C,T>::get(obj, mptr);
  }

  template <class C, class T>
  typename Deref<const C,T>::Type&
  const_dereference(const C& obj, T C::* mptr)
  {
    return Deref<const C,T>::get(obj, mptr);
  }

  template <class PM>
  struct PmTraits;

  template <class C, class T>
  struct PmTraits<T C::*>
  {
    typedef C ClassType;
    typedef T MemType;
  };
}



template <class PM>
class DataMemberFieldImpl : public FieldImpl
{
public:
  // PM is a pointer-to-member-type of the form "T C::*"
  typedef typename PmTraits<PM>::ClassType C;
  typedef typename PmTraits<PM>::MemType T;

  typedef typename rutz::type_traits<T>::deref_t deref_t;

  DataMemberFieldImpl(T C::* memptr) : itsDataMember(memptr) {}

  static rutz::shared_ptr<FieldImpl>
  make(T C::* memptr)
  {
    return rutz::shared_ptr<FieldImpl> (new DataMemberFieldImpl(memptr));
  }

  virtual void readValueFrom(FieldContainer* obj,
                             io::reader& reader,
                             const rutz::fstring& name) const
  {
    C& cobj = FieldAux::cast<C>(*obj);

    reader.read_value(name, dereference(cobj, itsDataMember));
  }

  virtual void writeValueTo(const FieldContainer* obj,
                            io::writer& writer,
                            const rutz::fstring& name) const
  {
    const C& cobj = FieldAux::cast<const C>(*obj);

    writer.write_value(name.c_str(), const_dereference(cobj, itsDataMember));
  }

private:
  DataMemberFieldImpl& operator=(const DataMemberFieldImpl&);
  DataMemberFieldImpl(const DataMemberFieldImpl&);

  T C::* itsDataMember;
};

template <class PM>
class CheckedDataMemberFieldImpl : public FieldImpl
{
public:
  // PM is a pointer-to-member-type of the form "T C::*"
  typedef typename PmTraits<PM>::ClassType C;
  typedef typename PmTraits<PM>::MemType T;

  typedef typename rutz::type_traits<T>::deref_t deref_t;

  CheckedDataMemberFieldImpl(T C::* memptr,
                             const deref_t& min,
                             const deref_t& max) :
    itsDataMember(memptr),
    itsMin(min),
    itsMax(max)
  {}

  static rutz::shared_ptr<FieldImpl>
  make(T C::* memptr, const deref_t& min, const deref_t& max)
  {
    return rutz::shared_ptr<FieldImpl>
      (new CheckedDataMemberFieldImpl(memptr, min, max));
  }

  virtual void readValueFrom(FieldContainer* obj,
                             io::reader& reader,
                             const rutz::fstring& name) const
  {
    C& cobj = FieldAux::cast<C>(*obj);

    deref_t temp;

    reader.read_value(name, temp);

    dereference(cobj, itsDataMember) = this->limit(temp);
  }

  virtual void writeValueTo(const FieldContainer* obj,
                            io::writer& writer,
                            const rutz::fstring& name) const
  {
    const C& cobj = FieldAux::cast<const C>(*obj);

    writer.write_value(name.c_str(), const_dereference(cobj, itsDataMember));
  }

private:
  CheckedDataMemberFieldImpl(const CheckedDataMemberFieldImpl&);
  CheckedDataMemberFieldImpl& operator=(const CheckedDataMemberFieldImpl&);

  deref_t limit(const deref_t& raw) const
  {
    return rutz::clamp(raw, itsMin, itsMax);
  }

  T C::* itsDataMember;
  const deref_t itsMin;
  const deref_t itsMax;
};

template <class C, class V>
class ValueFieldImpl : public FieldImpl
{
public:
  ValueFieldImpl(V C::* memptr) : itsValueMember(memptr) {}

  virtual void readValueFrom(FieldContainer* obj,
                             io::reader& reader,
                             const rutz::fstring& name) const
  {
    C& cobj = FieldAux::cast<C>(*obj);

    reader.read_value_obj(name, dereference(cobj, itsValueMember));
  }

  virtual void writeValueTo(const FieldContainer* obj,
                            io::writer& writer,
                            const rutz::fstring& name) const
  {
    const C& cobj = FieldAux::cast<const C>(*obj);

    writer.write_value_obj(name.c_str(), const_dereference(cobj, itsValueMember));
  }

private:
  ValueFieldImpl& operator=(const ValueFieldImpl&);
  ValueFieldImpl(const ValueFieldImpl&);

  V C::* itsValueMember;
};

template <class C, class T>
class FuncMemberFieldImpl : public FieldImpl
{
  typedef T (C::* Getter)() const;
  typedef void (C::* Setter)(T);

  Getter itsGetter;
  Setter itsSetter;

  FuncMemberFieldImpl& operator=(const FuncMemberFieldImpl&);
  FuncMemberFieldImpl(const FuncMemberFieldImpl&);

public:
  FuncMemberFieldImpl(Getter g, Setter s) : itsGetter(g), itsSetter(s) {}

  virtual void readValueFrom(FieldContainer* obj,
                             io::reader& reader,
                             const rutz::fstring& name) const
  {
    if (itsSetter == 0) FieldAux::throwNotAllowed("read", SRC_POS);

    C& cobj = FieldAux::cast<C>(*obj);

    typedef typename rutz::type_traits<T>::stack_t stack_t;

    stack_t temp;
    reader.read_value(name, temp);
    (cobj.*itsSetter)(temp);
  }

  virtual void writeValueTo(const FieldContainer* obj,
                            io::writer& writer,
                            const rutz::fstring& name) const
  {
    if (itsGetter == 0) FieldAux::throwNotAllowed("write", SRC_POS);

    const C& cobj = FieldAux::cast<const C>(*obj);

    writer.write_value(name.c_str(), (cobj.*itsGetter)());
  }
};




class Field
{
private:
  const rutz::fstring               itsName;
  const rutz::shared_ptr<FieldImpl> itsFieldImpl;
  const rutz::fstring               itsDefaultValue;
  const rutz::fstring               itsMin;
  const rutz::fstring               itsMax;
  const rutz::fstring               itsRes;
  const unsigned int                itsFlags;
  io::version_id                     itsMinVersion;
  io::version_id                     itsMaxVersion;

public:

  //
  // Attribute flags
  //

  static const unsigned int NEW_GROUP = 1 << 0; 
  static const unsigned int TRANSIENT = 1 << 1; 
  static const unsigned int STRING    = 1 << 2; 
  static const unsigned int MULTI     = 1 << 3; 
  static const unsigned int CHECKED   = 1 << 4; 
  static const unsigned int NO_GET    = 1 << 5; 
  static const unsigned int NO_SET    = 1 << 6; 
  static const unsigned int PRIVATE   = 1 << 7; 
  static const unsigned int BOOLEAN   = 1 << 8; 

  unsigned int flags()    const { return itsFlags; }

  bool startsNewGroup()   const { return   itsFlags & NEW_GROUP; }

  bool isTransient()      const { return   itsFlags & TRANSIENT ; }
  bool isPersistent()     const { return !(itsFlags & TRANSIENT); }

  bool isString()         const { return   itsFlags & STRING ; }
  bool isNumeric()        const { return !(itsFlags & STRING); }

  bool isMultiValued()    const { return   itsFlags & MULTI ; }
  bool isSingleValued()   const { return !(itsFlags & MULTI); }

  bool isChecked()        const { return   itsFlags & CHECKED ; }
  bool isUnchecked()      const { return !(itsFlags & CHECKED); }

  bool allowGet()         const { return !(itsFlags & NO_GET); }
  bool allowSet()         const { return !(itsFlags & NO_SET); }

  bool isPrivate()        const { return   itsFlags & PRIVATE ; }
  bool isPublic()         const { return !(itsFlags & PRIVATE); }

  bool isBoolean()        const { return   itsFlags & BOOLEAN; }

  struct ValueType {};

  template <class C, class V>
  Field(const rutz::fstring& name, ValueType, V C::* value_ptr,
        const rutz::fstring& def, const rutz::fstring& min,
        const rutz::fstring& max, const rutz::fstring& res,
        unsigned int flags=0) :
    itsName(name),
    itsFieldImpl(new ValueFieldImpl<C,V>(value_ptr)),
    itsDefaultValue(def),
    itsMin(min),
    itsMax(max),
    itsRes(res),
    itsFlags(flags),
    itsMinVersion(0),
    itsMaxVersion(std::numeric_limits<io::version_id>::max())
  {}

  template <class T, class PM>
  Field(const rutz::fstring& name, PM memptr,
        const T& def, const T& min, const T& max, const T& res,
        unsigned int flags=0) :
    itsName(name),
    itsFieldImpl((flags & CHECKED)
                 ? CheckedDataMemberFieldImpl<PM>::make(memptr, min, max)
                 : DataMemberFieldImpl<PM>::make(memptr)
                 ),
    itsDefaultValue(rutz::sconvert(def)),
    itsMin(rutz::sconvert(min)),
    itsMax(rutz::sconvert(max)),
    itsRes(rutz::sconvert(res)),
    itsFlags(flags),
    itsMinVersion(0),
    itsMaxVersion(std::numeric_limits<io::version_id>::max())
  {}

  template <class C, class T>
  Field(const rutz::fstring& name,
        T (C::* getter)() const,
        void (C::* setter)(T),
        const T& def, const T& min, const T& max, const T& res,
        unsigned int flags=0) :
    itsName(name),
    itsFieldImpl(new FuncMemberFieldImpl<C,T>(getter, setter)),
    itsDefaultValue(rutz::sconvert(def)),
    itsMin(rutz::sconvert(min)),
    itsMax(rutz::sconvert(max)),
    itsRes(rutz::sconvert(res)),
    itsFlags(flags),
    itsMinVersion(0),
    itsMaxVersion(std::numeric_limits<io::version_id>::max())
  {}

  Field& versions(io::version_id lo,
                  io::version_id hi
                  = std::numeric_limits<io::version_id>::max())
  {
    itsMinVersion = lo;
    itsMaxVersion = hi;
    return *this;
  }

  const rutz::fstring& name() const { return itsName; }
  const rutz::fstring& defaultValue() const { return itsDefaultValue; }

  const rutz::fstring& min() const { return itsMin; }
  const rutz::fstring& max() const { return itsMax; }
  const rutz::fstring& res() const { return itsRes; }

  io::version_id minVersion() const { return itsMinVersion; }
  io::version_id maxVersion() const { return itsMaxVersion; }

  bool shouldSerialize(io::version_id svid) const
  {
    return (svid >= itsMinVersion && svid <= itsMaxVersion);
  }

  void readValueFrom(FieldContainer* obj,
                     io::reader& reader) const
  {
    itsFieldImpl->readValueFrom(obj, reader, itsName);
  }

  void writeValueTo(const FieldContainer* obj,
                    io::writer& writer) const
  {
    itsFieldImpl->writeValueTo(obj, writer, itsName);
  }
};




class FieldMap
{
private:
  class Impl;
  Impl* rep;

  FieldMap(const FieldMap&);
  FieldMap& operator=(const FieldMap&);

  void init(const Field* begin, const Field* end,
            const FieldMap* parent);

public:
  FieldMap(const Field* begin, const Field* end,
           const FieldMap* parent=0) :
    rep(0)
  {
    init(begin, end, parent);
  }

  template<unsigned int N>
  FieldMap(Field const (&array)[N], const FieldMap* parent=0) :
    rep(0)
  {
    init(&array[0], &array[0]+N, parent);
  }

  ~FieldMap();

  static const FieldMap* emptyFieldMap();

  bool hasParent() const throw();

  const FieldMap* parent() const throw();


  const Field& field(const rutz::fstring& name) const;

  typedef rutz::fwd_iter<const Field> Iterator;

  Iterator alphaFields() const;


  Iterator ioFields() const;
};




class FieldContainer : public virtual nub::object
{
private:
  const FieldMap* itsFieldMap;
public:
  nub::signal0* itsSignal;
private:
  FieldContainer(const FieldContainer&);
  FieldContainer& operator=(const FieldContainer&);

public:
  FieldContainer(nub::signal0* sig);

  virtual ~FieldContainer() throw();

  void setFieldMap(const FieldMap& fields);


  const Field& field(const rutz::fstring& name) const;

  void touch() const;

  void readFieldsFrom(io::reader& reader, const FieldMap& fields);
  void writeFieldsTo(io::writer& writer, const FieldMap& fields,
                     io::version_id svid) const;

  const FieldMap& fields() const { return *itsFieldMap; }

  virtual FieldContainer* child() const;
};

template <class C, class F>
inline C& FieldAux::cast(F& p)
{
  C* result = dynamic_cast<C*>(&p);

  if (result == 0)
    {
      F* child = p.child();
      if (child != 0)
        result = &(FieldAux::cast<C>(*child));
      else
        rutz::throw_bad_cast(typeid(C), typeid(F), SRC_POS);
    }

  return *result;
}

static const char __attribute__((used)) vcid_groovx_io_fields_h_utc20051109000918[] = "$Id: fields.h 10065 2007-04-12 05:54:56Z rjpeters $ $HeadURL: file:
#endif // !GROOVX_IO_FIELDS_H_UTC20051109000918DEFINED

---

The software described here is Copyright (c) 1998-2005, Rob Peters.
This page was generated Wed Dec 3 06:49:39 2008 by Doxygen version 1.5.5.