X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=simgear%2Fprops%2Fprops.hxx;h=8cf38e6da7954becd375207277a69e56381e837f;hb=708ae35068499af33329f9db91f55441f4956acb;hp=d25637e04a351fc793b521fa9ab34ce298f51017;hpb=2e65538fb5b9eb9a26d254a67d883f81eea1f73e;p=simgear.git diff --git a/simgear/props/props.hxx b/simgear/props/props.hxx index d25637e0..8cf38e6d 100644 --- a/simgear/props/props.hxx +++ b/simgear/props/props.hxx @@ -18,6 +18,10 @@ #include #include +#include +#include + +#include #if PROPS_STANDALONE #else @@ -26,10 +30,49 @@ #endif - +#include #include #include +// XXX This whole file should be in the simgear namespace, but I don't +// have the guts yet... + +namespace simgear +{ +template +std::istream& readFrom(std::istream& stream, T& result) +{ + stream >> result; + return stream; +} + +/** + * Parse a string as an object of a given type. + * XXX no error behavior yet. + * + * @tparam T the return type + * @param str the string + * @return the object. + */ +template +inline T parseString(const std::string& str) +{ + std::istringstream stream(str); + T result; + readFrom(stream, result); + return result; +} + +// Extended properties +template<> +std::istream& readFrom(std::istream& stream, SGVec3d& result); +template<> +std::istream& readFrom(std::istream& stream, SGVec4d& result); + + +/** + * Property value types. + */ #ifdef NONE #pragma warn A sloppy coder has defined NONE as a macro! @@ -76,6 +119,68 @@ #undef STRING #endif +namespace props +{ +/** + * The possible types of an SGPropertyNode. Types that appear after + * EXTENDED are not stored in the SGPropertyNode itself. + */ +enum Type { + NONE = 0, /**< The node hasn't been assigned a value yet. */ + ALIAS, /**< The node "points" to another node. */ + BOOL, + INT, + LONG, + FLOAT, + DOUBLE, + STRING, + UNSPECIFIED, + EXTENDED, /**< The node's value is not stored in the property; + * the actual value and type is retrieved from an + * SGRawValue node. This type is never returned by @see + * SGPropertyNode::getType. + */ + // Extended properties + VEC3D, + VEC4D +}; + +template struct PropertyTraits; + +#define DEFINTERNALPROP(TYPE, PROP) \ +template<> \ +struct PropertyTraits \ +{ \ + static const Type type_tag = PROP; \ + enum { Internal = 1 }; \ +} + +DEFINTERNALPROP(bool, BOOL); +DEFINTERNALPROP(int, INT); +DEFINTERNALPROP(long, LONG); +DEFINTERNALPROP(float, FLOAT); +DEFINTERNALPROP(double, DOUBLE); +DEFINTERNALPROP(const char *, STRING); +DEFINTERNALPROP(const char[], STRING); +#undef DEFINTERNALPROP + +template<> +struct PropertyTraits +{ + static const Type type_tag = VEC3D; + enum { Internal = 0 }; +}; + +template<> +struct PropertyTraits +{ + static const Type type_tag = VEC4D; + enum { Internal = 0 }; +}; +} +} + + //////////////////////////////////////////////////////////////////////// @@ -90,6 +195,74 @@ // a small performance hit for that. //////////////////////////////////////////////////////////////////////// +/** + * Base class for SGRawValue classes that holds no type + * information. This allows some generic manipulation of the + * SGRawValue object. + */ +class SGRaw +{ +public: + /** + * Get the type enumeration for the raw value. + * + * @return the type. + */ + virtual simgear::props::Type getType() const = 0; + virtual ~SGRaw() {} + + /** + * Create a new deep copy of this raw value. + * + * The copy will contain its own version of the underlying value + * as well, and will be the same type. + * + * @return A deep copy of the current object. + */ + virtual SGRaw* clone() const = 0; + +}; + +class SGRawExtended : public SGRaw +{ +public: + /** + * Make an SGRawValueContainer from the SGRawValue. + * + * This is a virtual function of SGRawExtended so that + * SGPropertyNode::untie doesn't need to know the type of an + * extended property. + */ + virtual SGRawExtended* makeContainer() const = 0; + /** + * Write value out to a stream + */ + virtual std::ostream& printOn(std::ostream& stream) const = 0; + /** + * Read value from a stream and store it. + */ + virtual std::istream& readFrom(std::istream& stream) = 0; +}; + +// Choose between different base classes based on whether the value is +// stored internal to the property node. This frees us from defining +// the virtual functions in the SGRawExtended interface where they +// don't make sense, e.g. readFrom for the const char* type. +template::Internal> +class SGRawBase; + +template +class SGRawBase : public SGRaw +{ +}; + +template +class SGRawBase : public SGRawExtended +{ + virtual SGRawExtended* makeContainer() const; + virtual std::ostream& printOn(std::ostream& stream) const; + virtual std::istream& readFrom(std::istream& stream); +}; /** * Abstract base class for a raw value. @@ -108,10 +281,7 @@ * set, and clone the underlying value. The SGRawValue may change * frequently during a session as a value is retyped or bound and * unbound to various data source, but the abstract SGPropertyNode - * layer insulates the application from those changes. The raw value - * contains no facilities for data binding or for type conversion: it - * is simply the abstraction of a primitive data type (or a compound - * data type, in the case of a string).

+ * layer insulates the application from those changes. * *

The SGPropertyNode class always keeps a *copy* of a raw value, * not the original one passed to it; if you override a derived class @@ -127,9 +297,10 @@ * @see SGRawValueFunctionsIndexed * @see SGRawValueMethods * @see SGRawValueMethodsIndexed + * @see SGRawValueContainer */ template -class SGRawValue +class SGRawValue : public SGRawBase { public: @@ -142,7 +313,10 @@ public: * may need different kinds of default values (such as epoch for a * date type). The default value is used when creating new values. */ - static const T DefaultValue; // Default for this kind of raw value. + static T DefaultValue() + { + return T(); + } /** @@ -184,17 +358,30 @@ public: /** - * Create a new deep copy of this raw value. - * - * The copy will contain its own version of the underlying value - * as well. - * - * @return A deep copy of the current object. + * Return the type tag for this raw value type. */ - virtual SGRawValue * clone () const = 0; + virtual simgear::props::Type getType() const + { + return simgear::props::PropertyTraits::type_tag; + } }; + +//////////////////////////////////////////////////////////////////////// +// Default values for every type. +//////////////////////////////////////////////////////////////////////// + +template<> inline bool SGRawValue::DefaultValue() +{ + return false; +} + +template<> inline const char * SGRawValue::DefaultValue() +{ + return ""; +} + /** * A raw value bound to a pointer. * @@ -247,8 +434,8 @@ public: * * The copy will use the same external pointer as the original. */ - virtual SGRawValue * clone () const { - return new SGRawValuePointer(_ptr); + virtual SGRaw* clone () const { + return new SGRawValuePointer(_ptr); } private: @@ -304,7 +491,7 @@ public: */ virtual T getValue () const { if (_getter) return (*_getter)(); - else return SGRawValue::DefaultValue; + else return SGRawValue::DefaultValue(); } /** @@ -322,8 +509,8 @@ public: /** * Create a copy of this raw value, bound to the same functions. */ - virtual SGRawValue * clone () const { - return new SGRawValueFunctions(_getter,_setter); + virtual SGRaw* clone () const { + return new SGRawValueFunctions(_getter,_setter); } private: @@ -353,14 +540,14 @@ public: virtual ~SGRawValueFunctionsIndexed () {} virtual T getValue () const { if (_getter) return (*_getter)(_index); - else return SGRawValue::DefaultValue; + else return SGRawValue::DefaultValue(); } virtual bool setValue (T value) { if (_setter) { (*_setter)(_index, value); return true; } else return false; } - virtual SGRawValue * clone () const { - return new SGRawValueFunctionsIndexed(_index, _getter, _setter); + virtual SGRaw* clone () const { + return new SGRawValueFunctionsIndexed(_index, _getter, _setter); } private: int _index; @@ -386,14 +573,14 @@ public: virtual ~SGRawValueMethods () {} virtual T getValue () const { if (_getter) { return (_obj.*_getter)(); } - else { return SGRawValue::DefaultValue; } + else { return SGRawValue::DefaultValue(); } } virtual bool setValue (T value) { if (_setter) { (_obj.*_setter)(value); return true; } else return false; } - virtual SGRawValue * clone () const { - return new SGRawValueMethods(_obj, _getter, _setter); + virtual SGRaw* clone () const { + return new SGRawValueMethods(_obj, _getter, _setter); } private: C &_obj; @@ -420,14 +607,14 @@ public: virtual ~SGRawValueMethodsIndexed () {} virtual T getValue () const { if (_getter) { return (_obj.*_getter)(_index); } - else { return SGRawValue::DefaultValue; } + else { return SGRawValue::DefaultValue(); } } virtual bool setValue (T value) { if (_setter) { (_obj.*_setter)(_index, value); return true; } else return false; } - virtual SGRawValue * clone () const { - return new SGRawValueMethodsIndexed(_obj, _index, _getter, _setter); + virtual SGRaw* clone () const { + return new SGRawValueMethodsIndexed(_obj, _index, _getter, _setter); } private: C &_obj; @@ -436,6 +623,77 @@ private: setter_t _setter; }; +/** + * A raw value that contains its value. This provides a way for + * property nodes to contain values that shouldn't be stored in the + * property node itself. + */ +template +class SGRawValueContainer : public SGRawValue +{ +public: + + /** + * Explicit constructor. + */ + SGRawValueContainer(const T& obj) : _obj(obj) {} + + /** + * Destructor. + */ + virtual ~SGRawValueContainer() {} + + /** + * Get the underlying value. + */ + virtual T getValue() const { return _obj; } + + /** + * Set the underlying value. + * + * This method will dereference the pointer and change the + * variable's value. + */ + virtual bool setValue (T value) { _obj = value; return true; } + + /** + * Create a copy of this raw value. + */ + virtual SGRaw* clone () const { + return new SGRawValueContainer(_obj); + } + +private: + T _obj; +}; + +template +SGRawExtended* SGRawBase::makeContainer() const +{ + return new SGRawValueContainer(static_cast*>(this) + ->getValue()); +} + +template +std::ostream& SGRawBase::printOn(std::ostream& stream) const +{ + return stream << static_cast*>(this)->getValue(); +} + +template +std::istream& SGRawBase::readFrom(std::istream& stream) +{ + T value; + simgear::readFrom(stream, value); + static_cast*>(this)->setValue(value); + return stream; +} + +template<> +std::ostream& SGRawBase::printOn(std::ostream& stream) const; +template<> +std::ostream& SGRawBase::printOn(std::ostream& stream) const; + /** * The smart pointer that manage reference counting @@ -444,6 +702,11 @@ class SGPropertyNode; typedef SGSharedPtr SGPropertyNode_ptr; typedef SGSharedPtr SGConstPropertyNode_ptr; +namespace simgear +{ +typedef std::vector PropertyList; +} + /** * The property change listener interface. @@ -484,22 +747,6 @@ public: MAX_STRING_LEN = 1024 }; - /** - * Property value types. - */ - enum Type { - NONE = 0, - ALIAS, - BOOL, - INT, - LONG, - FLOAT, - DOUBLE, - STRING, - UNSPECIFIED - }; - - /** * Access mode attributes. * @@ -513,7 +760,10 @@ public: REMOVED = 8, TRACE_READ = 16, TRACE_WRITE = 32, - USERARCHIVE = 64 + USERARCHIVE = 64, + PRESERVE = 128 + // beware: if you add another attribute here, + // also update value of "LAST_USED_ATTRIBUTE". }; @@ -550,7 +800,7 @@ public: /** * Test whether this node contains a primitive leaf value. */ - bool hasValue () const { return (_type != NONE); } + bool hasValue () const { return (_type != simgear::props::NONE); } /** @@ -558,11 +808,15 @@ public: */ const char * getName () const { return _name.c_str(); } + /** + * Get the node's simple name as a string. + */ + const std::string& getNameString () const { return _name; } /** * Get the node's pretty display name, with subscript when needed. */ - const char * getDisplayName (bool simplify = false) const; + std::string getDisplayName (bool simplify = false) const; /** @@ -591,7 +845,7 @@ public: /** * Get the number of child nodes. */ - int nChildren () const { return _children.size(); } + int nChildren () const { return (int)_children.size(); } /** @@ -622,21 +876,18 @@ public: return (getChild(name, index) != 0); } - /** - * Get a child node by name and index. + * Create a child node after the last node with the same name. */ - SGPropertyNode * getChild (const char * name, int index = 0, - bool create = false); + SGPropertyNode * addChild (const char * name); /** * Get a child node by name and index. */ + SGPropertyNode * getChild (const char* name, int index = 0, + bool create = false); SGPropertyNode * getChild (const std::string& name, int index = 0, - bool create = false) - { return getChild(name.c_str(), index, create); } - - + bool create = false); /** * Get a const child node by name and index. */ @@ -652,12 +903,12 @@ public: /** * Get a vector of all children with the specified name. */ - std::vector getChildren (const char * name) const; + simgear::PropertyList getChildren (const char * name) const; /** * Get a vector of all children with the specified name. */ - std::vector getChildren (const std::string& name) const + simgear::PropertyList getChildren (const std::string& name) const { return getChildren(name.c_str()); } /** @@ -682,15 +933,13 @@ public: /** * Remove all children with the specified name. */ - std::vector removeChildren (const char * name, - bool keep = true); - + simgear::PropertyList removeChildren (const char * name, bool keep = true); /** * Remove all children with the specified name. */ - std::vector removeChildren (const std::string& name, - bool keep = true) + simgear::PropertyList removeChildren (const std::string& name, + bool keep = true) { return removeChildren(name.c_str(), keep); } // @@ -725,7 +974,7 @@ public: /** * Test whether the node's leaf value is aliased to another's. */ - bool isAlias () const { return (_type == ALIAS); } + bool isAlias () const { return (_type == simgear::props::ALIAS); } /** @@ -748,7 +997,7 @@ public: /** * Get the path to this node from the root. */ - const char * getPath (bool simplify = false) const; + std::string getPath (bool simplify = false) const; /** @@ -870,7 +1119,7 @@ public: /** * Get the type of leaf value, if any, for this node. */ - Type getType () const; + simgear::props::Type getType () const; /** @@ -908,7 +1157,17 @@ public: */ const char * getStringValue () const; - + /** + * Get a value from a node. If the actual type of the node doesn't + * match the desired type, a conversion isn't guaranteed. + */ + template + T getValue(typename boost::enable_if_c::Internal> + ::type* dummy = 0) const; + // Getter for extended property + template + T getValue(typename boost::disable_if_c::Internal> + ::type* dummy = 0) const; /** * Set a bool value for this node. @@ -957,7 +1216,27 @@ public: */ bool setUnspecifiedValue (const char * value); + template + bool setValue(const T& val, + typename boost::enable_if_c::Internal> + ::type* dummy = 0); + template + bool setValue(const T& val, + typename boost::disable_if_c::Internal> + ::type* dummy = 0); + + template + bool setValue(const char (&val)[N]) + { + return setValue(&val[0]); + } + + /** + * Print the value of the property to a stream. + */ + std::ostream& printOn(std::ostream& stream) const; + // // Data binding. // @@ -968,42 +1247,11 @@ public: */ bool isTied () const { return _tied; } - - /** - * Bind this node to an external bool source. - */ - bool tie (const SGRawValue &rawValue, bool useDefault = true); - - - /** - * Bind this node to an external int source. - */ - bool tie (const SGRawValue &rawValue, bool useDefault = true); - - - /** - * Bind this node to an external long int source. - */ - bool tie (const SGRawValue &rawValue, bool useDefault = true); - - - /** - * Bind this node to an external float source. - */ - bool tie (const SGRawValue &rawValue, bool useDefault = true); - - - /** - * Bind this node to an external double source. - */ - bool tie (const SGRawValue &rawValue, bool useDefault = true); - - - /** - * Bind this node to an external string source. - */ - bool tie (const SGRawValue &rawValue, bool useDefault = true); - + /** + * Bind this node to an external source. + */ + template + bool tie(const SGRawValue &rawValue, bool useDefault = true); /** * Unbind this node from any external data source. @@ -1020,12 +1268,12 @@ public: /** * Get another node's type. */ - Type getType (const char * relative_path) const; + simgear::props::Type getType (const char * relative_path) const; /** * Get another node's type. */ - Type getType (const std::string& relative_path) const + simgear::props::Type getType (const std::string& relative_path) const { return getType(relative_path.c_str()); } /** @@ -1186,12 +1434,17 @@ public: */ bool setStringValue (const char * relative_path, const char * value); + bool setStringValue(const char * relative_path, const std::string& value) + { return setStringValue(relative_path, value.c_str()); } /** * Set another node's value as a string. */ bool setStringValue (const std::string& relative_path, const char * value) { return setStringValue(relative_path.c_str(), value); } + bool setStringValue (const std::string& relative_path, + const std::string& value) + { return setStringValue(relative_path.c_str(), value.c_str()); } /** * Set another node's value with no specified type. @@ -1323,7 +1576,7 @@ public: /** * Get the number of listeners. */ - int nListeners () const { return _listeners ? _listeners->size() : 0; } + int nListeners () const { return _listeners ? (int)_listeners->size() : 0; } /** @@ -1349,6 +1602,16 @@ public: */ void clearValue (); + /** + * Compare two property trees. The property trees are equal if: 1) + * They have no children, and have the same type and the values are + * equal, or 2) have the same number of children, and the + * corresponding children in each tree are equal. "corresponding" + * means have the same name and index. + * + * Attributes, removed children, and aliases aren't considered. + */ + static bool compare (const SGPropertyNode& lhs, const SGPropertyNode& rhs); protected: @@ -1359,12 +1622,13 @@ protected: /** * Protected constructor for making new nodes on demand. */ - SGPropertyNode (const char * name, int index, SGPropertyNode * parent); - + SGPropertyNode (const std::string& name, int index, SGPropertyNode * parent); + template + SGPropertyNode (Itr begin, Itr end, int index, SGPropertyNode * parent); private: - // Get the raw value + // Get the raw value bool get_bool () const; int get_int () const; long get_long () const; @@ -1372,7 +1636,7 @@ private: double get_double () const; const char * get_string () const; - // Set the raw value + // Set the raw value bool set_bool (bool value); bool set_int (int value); bool set_long (long value); @@ -1386,7 +1650,6 @@ private: */ const char * make_string () const; - /** * Trace a read access. */ @@ -1398,40 +1661,22 @@ private: */ void trace_write () const; - - /** - * Remove this node from all nodes that link to it in their path cache. - */ - void remove_from_path_caches(); - - - class hash_table; - int _index; std::string _name; - mutable std::string _display_name; /// To avoid cyclic reference counting loops this shall not be a reference /// counted pointer SGPropertyNode * _parent; - std::vector _children; - std::vector _removedChildren; - std::vector _linkedNodes; - mutable std::string _path; + simgear::PropertyList _children; + simgear::PropertyList _removedChildren; mutable std::string _buffer; - hash_table * _path_cache; - Type _type; + simgear::props::Type _type; bool _tied; int _attr; - // The right kind of pointer... + // The right kind of pointer... union { SGPropertyNode * alias; - SGRawValue * bool_val; - SGRawValue * int_val; - SGRawValue * long_val; - SGRawValue * float_val; - SGRawValue * double_val; - SGRawValue * string_val; + SGRaw* val; } _value; union { @@ -1445,70 +1690,22 @@ private: std::vector * _listeners; - - /** - * Register/unregister node that links to this node in its path cache. - */ - void add_linked_node (hash_table * node) { _linkedNodes.push_back(node); } - bool remove_linked_node (hash_table * node); - - - /** - * A very simple hash table. - */ - class hash_table { - public: - - /** - * An entry in a bucket in a hash table. - */ - 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: - std::string _key; - SGSharedPtr _value; - }; - - - /** - * A bucket in a hash table. - */ - 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; - }; - + // Pass name as a pair of iterators + template + SGPropertyNode * getChildImpl (Itr begin, Itr end, int index = 0, bool create = false); + // very internal method + template + SGPropertyNode* getExistingChild (Itr begin, Itr end, int index, bool create); + // very internal path parsing function + template + friend SGPropertyNode* find_node_aux(SGPropertyNode * current, SplitItr& itr, + bool create, int last_index); + // For boost + friend size_t hash_value(const SGPropertyNode& node); }; -// Convenice functions for use in templates +// Convenience functions for use in templates template T getValue(const SGPropertyNode*); @@ -1574,6 +1771,173 @@ inline bool setValue (SGPropertyNode* node, const std::string& value) return node->setStringValue(value.c_str()); } +template +bool SGPropertyNode::tie(const SGRawValue &rawValue, bool useDefault) +{ + using namespace simgear::props; + if (_type == ALIAS || _tied) + return false; + + useDefault = useDefault && hasValue(); + T old_val = SGRawValue::DefaultValue(); + if (useDefault) + old_val = getValue(this); + clearValue(); + if (PropertyTraits::Internal) + _type = PropertyTraits::type_tag; + else + _type = EXTENDED; + _tied = true; + _value.val = rawValue.clone(); + if (useDefault) { + int save_attributes = getAttributes(); + setAttribute( WRITE, true ); + setValue(old_val); + setAttributes( save_attributes ); + } + return true; +} + +template<> +bool SGPropertyNode::tie (const SGRawValue &rawValue, + bool useDefault); + +template +T SGPropertyNode::getValue(typename boost::disable_if_c::Internal>::type* dummy) const +{ + using namespace simgear::props; + if (_attr == (READ|WRITE) && _type == EXTENDED + && _value.val->getType() == PropertyTraits::type_tag) { + return static_cast*>(_value.val)->getValue(); + } + if (getAttribute(TRACE_READ)) + trace_read(); + if (!getAttribute(READ)) + return SGRawValue::DefaultValue(); + switch (_type) { + case EXTENDED: + if (_value.val->getType() == PropertyTraits::type_tag) + return static_cast*>(_value.val)->getValue(); + break; + case STRING: + case UNSPECIFIED: + return simgear::parseString(make_string()); + break; + default: // avoid compiler warning + break; + } + return SGRawValue::DefaultValue(); +} + +template +inline T SGPropertyNode::getValue(typename boost::enable_if_c::Internal>::type* dummy) const +{ + return ::getValue(this); +} + +template +bool SGPropertyNode::setValue(const T& val, + typename boost::disable_if_c::Internal>::type* dummy) +{ + using namespace simgear::props; + if (_attr == (READ|WRITE) && _type == EXTENDED + && _value.val->getType() == PropertyTraits::type_tag) { + static_cast*>(_value.val)->setValue(val); + return true; + } + if (getAttribute(WRITE) + && ((_type == EXTENDED + && _value.val->getType() == PropertyTraits::type_tag) + || _type == NONE || _type == UNSPECIFIED)) { + if (_type == NONE || _type == UNSPECIFIED) { + clearValue(); + _type = EXTENDED; + _value.val = new SGRawValueContainer(val); + } else { + static_cast*>(_value.val)->setValue(val); + } + if (getAttribute(TRACE_WRITE)) + trace_write(); + return true; + } + return false; +} + +template +inline bool SGPropertyNode::setValue(const T& val, + typename boost::enable_if_c::Internal>::type* dummy) +{ + return ::setValue(this, val); +} + +/** + * Utility function for creation of a child property node. + */ +inline SGPropertyNode* makeChild(SGPropertyNode* parent, const char* name, + int index = 0) +{ + return parent->getChild(name, index, true); +} + +/** + * Utility function for creation of a child property node using a + * relative path. + */ +namespace simgear +{ +template +inline SGPropertyNode* makeNode(SGPropertyNode* parent, const StringType& name) +{ + return parent->getNode(name, true); +} +} + +// For boost::hash +size_t hash_value(const SGPropertyNode& node); + +// Helper comparison and hash functions for common cases + +namespace simgear +{ +namespace props +{ +struct Compare +{ + bool operator()(const SGPropertyNode* lhs, const SGPropertyNode* rhs) const + { + return SGPropertyNode::compare(*lhs, *rhs); + } + bool operator()(SGPropertyNode_ptr lhs, const SGPropertyNode* rhs) const + { + return SGPropertyNode::compare(*lhs, *rhs); + } + bool operator()(const SGPropertyNode* lhs, SGPropertyNode_ptr rhs) const + { + return SGPropertyNode::compare(*lhs, *rhs); + } + bool operator()(SGPropertyNode_ptr lhs, SGPropertyNode_ptr rhs) const + { + return SGPropertyNode::compare(*lhs, *rhs); + } +}; + +struct Hash +{ + size_t operator()(const SGPropertyNode* node) const + { + return hash_value(*node); + } + size_t operator()(SGPropertyNode_ptr node) const + { + return hash_value(*node); + } +}; +} +} #endif // __PROPS_HXX // end of props.hxx