props.hxx

Go to the documentation of this file.

#ifndef __PROPS_HXX
#define __PROPS_HXX

#ifndef PROPS_STANDALONE
#define PROPS_STANDALONE 0
#endif

#include <vector>

#if PROPS_STANDALONE

#include <string>
#include <iostream>

using std::string;
using std::vector;
using std::istream;
using std::ostream;

#else

#include <simgear/compiler.h>
#include <simgear/debug/logstream.hxx>
#include STL_STRING
#include STL_IOSTREAM
SG_USING_STD(string);
SG_USING_STD(vector);
SG_USING_STD(istream);
SG_USING_STD(ostream);

#endif

#include <simgear/structure/SGReferenced.hxx>
#include <simgear/structure/SGSharedPtr.hxx>


#ifdef NONE
#pragma warn A sloppy coder has defined NONE as a macro!
#undef NONE
#endif

#ifdef ALIAS
#pragma warn A sloppy coder has defined ALIAS as a macro!
#undef ALIAS
#endif

#ifdef UNSPECIFIED
#pragma warn A sloppy coder has defined UNSPECIFIED as a macro!
#undef UNSPECIFIED
#endif

#ifdef BOOL
#pragma warn A sloppy coder has defined BOOL as a macro!
#undef BOOL
#endif

#ifdef INT
#pragma warn A sloppy coder has defined INT as a macro!
#undef INT
#endif

#ifdef LONG
#pragma warn A sloppy coder has defined LONG as a macro!
#undef LONG
#endif

#ifdef FLOAT
#pragma warn A sloppy coder has defined FLOAT as a macro!
#undef FLOAT
#endif

#ifdef DOUBLE
#pragma warn A sloppy coder has defined DOUBLE as a macro!
#undef DOUBLE
#endif

#ifdef STRING
#pragma warn A sloppy coder has defined STRING as a macro!
#undef STRING
#endif



// A raw value.
//
// This is the mechanism that information-providing routines can
// use to link their own values to the property manager.  Any
// SGValue can be tied to a raw value and then untied again.
//
// Note: we are forced to use inlined methods here to ensure
// that the templates will be instantiated.  We're probably taking
// a small performance hit for that.


template <class T>
class SGRawValue
{
public:

  static const T DefaultValue;  // Default for this kind of raw value.


  SGRawValue () {}


  virtual ~SGRawValue () {}


  virtual T getValue () const = 0;


  virtual bool setValue (T value) = 0;


  virtual SGRawValue * clone () const = 0;
};


template <class T>
class SGRawValuePointer : public SGRawValue<T>
{
public:

  SGRawValuePointer (T * ptr) : _ptr(ptr) {}

  virtual ~SGRawValuePointer () {}

  virtual T getValue () const { return *_ptr; }

  virtual bool setValue (T value) { *_ptr = value; return true; }

  virtual SGRawValue<T> * clone () const {
    return new SGRawValuePointer<T>(_ptr);
  }

private:
  T * _ptr;
};


template <class T>
class SGRawValueFunctions : public SGRawValue<T>
{
public:

  typedef T (*getter_t)();

  typedef void (*setter_t)(T);

  SGRawValueFunctions (getter_t getter = 0, setter_t setter = 0)
    : _getter(getter), _setter(setter) {}

  virtual ~SGRawValueFunctions () {}

  virtual T getValue () const {
    if (_getter) return (*_getter)();
    else return SGRawValue<T>::DefaultValue;
  }

  virtual bool setValue (T value) {
    if (_setter) { (*_setter)(value); return true; }
    else return false;
  }

  virtual SGRawValue<T> * clone () const {
    return new SGRawValueFunctions<T>(_getter,_setter);
  }

private:
  getter_t _getter;
  setter_t _setter;
};


template <class T>
class SGRawValueFunctionsIndexed : public SGRawValue<T>
{
public:
  typedef T (*getter_t)(int);
  typedef void (*setter_t)(int,T);
  SGRawValueFunctionsIndexed (int index, getter_t getter = 0, setter_t setter = 0)
    : _index(index), _getter(getter), _setter(setter) {}
  virtual ~SGRawValueFunctionsIndexed () {}
  virtual T getValue () const {
    if (_getter) return (*_getter)(_index);
    else return SGRawValue<T>::DefaultValue;
  }
  virtual bool setValue (T value) {
    if (_setter) { (*_setter)(_index, value); return true; }
    else return false;
  }
  virtual SGRawValue<T> * clone () const {
    return new SGRawValueFunctionsIndexed<T>(_index, _getter, _setter);
  }
private:
  int _index;
  getter_t _getter;
  setter_t _setter;
};


template <class C, class T>
class SGRawValueMethods : public SGRawValue<T>
{
public:
  typedef T (C::*getter_t)() const;
  typedef void (C::*setter_t)(T);
  SGRawValueMethods (C &obj, getter_t getter = 0, setter_t setter = 0)
    : _obj(obj), _getter(getter), _setter(setter) {}
  virtual ~SGRawValueMethods () {}
  virtual T getValue () const {
    if (_getter) { return (_obj.*_getter)(); }
    else { return SGRawValue<T>::DefaultValue; }
  }
  virtual bool setValue (T value) {
    if (_setter) { (_obj.*_setter)(value); return true; }
    else return false;
  }
  virtual SGRawValue<T> * clone () const {
    return new SGRawValueMethods<C,T>(_obj, _getter, _setter);
  }
private:
  C &_obj;
  getter_t _getter;
  setter_t _setter;
};


template <class C, class T>
class SGRawValueMethodsIndexed : public SGRawValue<T>
{
public:
  typedef T (C::*getter_t)(int) const;
  typedef void (C::*setter_t)(int, T);
  SGRawValueMethodsIndexed (C &obj, int index,
                     getter_t getter = 0, setter_t setter = 0)
    : _obj(obj), _index(index), _getter(getter), _setter(setter) {}
  virtual ~SGRawValueMethodsIndexed () {}
  virtual T getValue () const {
    if (_getter) { return (_obj.*_getter)(_index); }
    else { return SGRawValue<T>::DefaultValue; }
  }
  virtual bool setValue (T value) {
    if (_setter) { (_obj.*_setter)(_index, value); return true; }
    else return false;
  }
  virtual SGRawValue<T> * clone () const {
    return new SGRawValueMethodsIndexed<C,T>(_obj, _index, _getter, _setter);
  }
private:
  C &_obj;
  int _index;
  getter_t _getter;
  setter_t _setter;
};


class SGPropertyNode;
typedef SGSharedPtr<SGPropertyNode> SGPropertyNode_ptr;
typedef SGSharedPtr<const SGPropertyNode> SGConstPropertyNode_ptr;


class SGPropertyChangeListener
{
public:
  virtual ~SGPropertyChangeListener ();
  virtual void valueChanged (SGPropertyNode * node);
  virtual void childAdded (SGPropertyNode * parent, SGPropertyNode * child);
  virtual void childRemoved (SGPropertyNode * parent, SGPropertyNode * child);

protected:
  friend class SGPropertyNode;
  virtual void register_property (SGPropertyNode * node);
  virtual void unregister_property (SGPropertyNode * node);

private:
  vector<SGPropertyNode *> _properties;
};



class SGPropertyNode : public SGReferenced
{
public:

  enum {
    MAX_STRING_LEN = 1024
  };

  enum Type {
    NONE = 0,
    ALIAS,
    BOOL,
    INT,
    LONG,
    FLOAT,
    DOUBLE,
    STRING,
    UNSPECIFIED
  };


  enum Attribute {
    READ = 1,
    WRITE = 2,
    ARCHIVE = 4,
    REMOVED = 8,
    TRACE_READ = 16,
    TRACE_WRITE = 32,
    USERARCHIVE = 64
  };


  static const int LAST_USED_ATTRIBUTE;


  SGPropertyNode ();


  SGPropertyNode (const SGPropertyNode &node);


  virtual ~SGPropertyNode ();



  //
  // Basic properties.
  //

  bool hasValue () const { return (_type != NONE); }


  const char * getName () const { return _name.c_str(); }


  const char * getDisplayName (bool simplify = false) const;


  int getIndex () const { return _index; }


  SGPropertyNode * getParent () { return _parent; }


  const SGPropertyNode * getParent () const { return _parent; }


  //
  // Children.
  //


  int nChildren () const { return _children.size(); }


  SGPropertyNode * getChild (int position);


  const SGPropertyNode * getChild (int position) const;


  bool hasChild (const char * name, int index = 0) const
  {
    return (getChild(name, index) != 0);
  }


  SGPropertyNode * getChild (const char * name, int index = 0,
                             bool create = false);


  const SGPropertyNode * getChild (const char * name, int index = 0) const;


  vector<SGPropertyNode_ptr> getChildren (const char * name) const;


  SGPropertyNode_ptr removeChild (int pos, bool keep = true);


  SGPropertyNode_ptr removeChild (const char * name, int index = 0,
                                  bool keep = true);

  vector<SGPropertyNode_ptr> removeChildren (const char * name,
                                             bool keep = true);


  //
  // Alias support.
  //


  bool alias (SGPropertyNode * target);


  bool alias (const char * path);


  bool unalias ();


  bool isAlias () const { return (_type == ALIAS); }


  SGPropertyNode * getAliasTarget ();


  const SGPropertyNode * getAliasTarget () const;


  //
  // Path information.
  //


  const char * getPath (bool simplify = false) const;


  SGPropertyNode * getRootNode ();


  const SGPropertyNode * getRootNode () const;


  SGPropertyNode * getNode (const char * relative_path, bool create = false);


  SGPropertyNode * getNode (const char * relative_path, int index,
                            bool create = false);


  const SGPropertyNode * getNode (const char * relative_path) const;


  const SGPropertyNode * getNode (const char * relative_path,
                                  int index) const;


  //
  // Access Mode.
  //

  bool getAttribute (Attribute attr) const { return ((_attr & attr) != 0); }


  void setAttribute (Attribute attr, bool state) {
    (state ? _attr |= attr : _attr &= ~attr);
  }


  int getAttributes () const { return _attr; }


  void setAttributes (int attr) { _attr = attr; }
  

  //
  // Leaf Value (primitive).
  //


  Type getType () const;


  bool getBoolValue () const;


  int getIntValue () const;


  long getLongValue () const;


  float getFloatValue () const;


  double getDoubleValue () const;


  const char * getStringValue () const;



  bool setBoolValue (bool value);


  bool setIntValue (int value);


  bool setLongValue (long value);


  bool setFloatValue (float value);


  bool setDoubleValue (double value);


  bool setStringValue (const char * value);


  bool setUnspecifiedValue (const char * value);


  //
  // Data binding.
  //


  bool isTied () const { return _tied; }


  bool tie (const SGRawValue<bool> &rawValue, bool useDefault = true);


  bool tie (const SGRawValue<int> &rawValue, bool useDefault = true);


  bool tie (const SGRawValue<long> &rawValue, bool useDefault = true);


  bool tie (const SGRawValue<float> &rawValue, bool useDefault = true);


  bool tie (const SGRawValue<double> &rawValue, bool useDefault = true);


  bool tie (const SGRawValue<const char *> &rawValue, bool useDefault = true);


  bool untie ();


  //
  // Convenience methods using paths.
  // TODO: add attribute methods
  //


  Type getType (const char * relative_path) const;


  bool hasValue (const char * relative_path) const;


  bool getBoolValue (const char * relative_path,
                     bool defaultValue = false) const;


  int getIntValue (const char * relative_path,
                   int defaultValue = 0) const;


  long getLongValue (const char * relative_path,
                     long defaultValue = 0L) const;


  float getFloatValue (const char * relative_path,
                       float defaultValue = 0.0) const;


  double getDoubleValue (const char * relative_path,
                         double defaultValue = 0.0L) const;


  const char * getStringValue (const char * relative_path,
                               const char * defaultValue = "") const;


  bool setBoolValue (const char * relative_path, bool value);


  bool setIntValue (const char * relative_path, int value);


  bool setLongValue (const char * relative_path, long value);


  bool setFloatValue (const char * relative_path, float value);


  bool setDoubleValue (const char * relative_path, double value);


  bool setStringValue (const char * relative_path, const char * value);


  bool setUnspecifiedValue (const char * relative_path, const char * value);


  bool isTied (const char * relative_path) const;


  bool tie (const char * relative_path, const SGRawValue<bool> &rawValue,
            bool useDefault = true);


  bool tie (const char * relative_path, const SGRawValue<int> &rawValue,
            bool useDefault = true);


  bool tie (const char * relative_path, const SGRawValue<long> &rawValue,
            bool useDefault = true);


  bool tie (const char * relative_path, const SGRawValue<float> &rawValue,
            bool useDefault = true);


  bool tie (const char * relative_path, const SGRawValue<double> &rawValue,
            bool useDefault = true);


  bool tie (const char * relative_path, const SGRawValue<const char *> &rawValue,
            bool useDefault = true);


  bool untie (const char * relative_path);


  void addChangeListener (SGPropertyChangeListener * listener,
                          bool initial = false);


  void removeChangeListener (SGPropertyChangeListener * listener);


  int nListeners () const { return _listeners ? _listeners->size() : 0; }


  void fireValueChanged ();


  void fireChildAdded (SGPropertyNode * child);


  void fireChildRemoved (SGPropertyNode * child);


  void clearValue ();


protected:

  void fireValueChanged (SGPropertyNode * node);
  void fireChildAdded (SGPropertyNode * parent, SGPropertyNode * child);
  void fireChildRemoved (SGPropertyNode * parent, SGPropertyNode * child);

  SGPropertyNode (const char * name, int index, SGPropertyNode * parent);


private:

                                // Get the raw value
  bool get_bool () const;
  int get_int () const;
  long get_long () const;
  float get_float () const;
  double get_double () const;
  const char * get_string () const;

                                // Set the raw value
  bool set_bool (bool value);
  bool set_int (int value);
  bool set_long (long value);
  bool set_float (float value);
  bool set_double (double value);
  bool set_string (const char * value);


  const char * make_string () const;


  void trace_read () const;


  void trace_write () const;


  void remove_from_path_caches();


  class hash_table;

  int _index;
  string _name;
  mutable string _display_name;
  SGPropertyNode * _parent;
  vector<SGPropertyNode_ptr> _children;
  vector<SGPropertyNode_ptr> _removedChildren;
  vector<hash_table *> _linkedNodes;
  mutable string _path;
  mutable string _buffer;
  hash_table * _path_cache;
  Type _type;
  bool _tied;
  int _attr;

                                // The right kind of pointer...
  union {
    SGPropertyNode * alias;
    SGRawValue<bool> * bool_val;
    SGRawValue<int> * int_val;
    SGRawValue<long> * long_val;
    SGRawValue<float> * float_val;
    SGRawValue<double> * double_val;
    SGRawValue<const char *> * string_val;
  } _value;

  union {
    bool bool_val;
    int int_val;
    long long_val;
    float float_val;
    double double_val;
    char * string_val;
  } _local_val;

  vector <SGPropertyChangeListener *> * _listeners;


  void add_linked_node (hash_table * node) { _linkedNodes.push_back(node); }
  bool remove_linked_node (hash_table * node);



  class hash_table {
  public:

    class entry {
    public:
      entry ();
      ~entry ();
      const char * get_key () { return _key.c_str(); }
      void set_key (const char * key);
      SGPropertyNode * get_value () { return _value; }
      void set_value (SGPropertyNode * value);
    private:
      string _key;
      SGSharedPtr<SGPropertyNode> _value;
    };


    class bucket {
    public:
      bucket ();
      ~bucket ();
      entry * get_entry (const char * key, bool create = false);
      bool erase (SGPropertyNode * node);
      void clear (hash_table * owner);
    private:
      int _length;
      entry ** _entries;
    };

    friend class bucket;

    hash_table ();
    ~hash_table ();
    SGPropertyNode * get (const char * key);
    void put (const char * key, SGPropertyNode * value);
    bool erase (SGPropertyNode * node);

  private:
    unsigned int hashcode (const char * key);
    unsigned int _data_length;
    bucket ** _data;
  };

};

#endif // __PROPS_HXX

// end of props.hxx

---