From: curt Date: Thu, 28 Jun 2001 21:53:24 +0000 (+0000) Subject: - attempting to tie an aliased node now fails; the node must be X-Git-Url: https://git.mxchange.org/?a=commitdiff_plain;h=d063b319e8084847bcec80f3778f5493d356227c;p=simgear.git - attempting to tie an aliased node now fails; the node must be unaliased first - renamed UNKNOWN to UNSPECIED and setUnknownValue to setUnspecifiedValue - modified get*Value and set*Value methods to respect READ and WRITE attributes --- diff --git a/simgear/misc/props.cxx b/simgear/misc/props.cxx index 9415b28f..5c835c50 100644 --- a/simgear/misc/props.cxx +++ b/simgear/misc/props.cxx @@ -39,6 +39,9 @@ public: // Convenience macros for value access. //////////////////////////////////////////////////////////////////////// +#define TEST_READ(dflt) if (!getAttribute(READ)) return dflt +#define TEST_WRITE if (!getAttribute(WRITE)) return false + #define GET_BOOL (_value.bool_val->getValue()) #define GET_INT (_value.int_val->getValue()) #define GET_LONG (_value.long_val->getValue()) @@ -281,64 +284,83 @@ find_node (SGPropertyNode * current, //////////////////////////////////////////////////////////////////////// -// Implementation of SGValue. +// Implementation of SGPropertyNode. //////////////////////////////////////////////////////////////////////// /** - * Default constructor. - * - * The type will be UNKNOWN and the raw value will be "". + * Default constructor: always creates a root node. */ -SGValue::SGValue () - : _type(UNKNOWN), _tied(false) +SGPropertyNode::SGPropertyNode () + : _name(""), + _index(0), + _parent(0), + _type(NONE), + _tied(false), + _attr(READ|WRITE|ARCHIVE) { - _value.string_val = new SGRawValueInternal; } /** * Copy constructor. */ -SGValue::SGValue (const SGValue &source) +SGPropertyNode::SGPropertyNode (const SGPropertyNode &node) + : _name(node._name), + _index(node._index), + _parent(0), // don't copy the parent + _type(node._type), + _tied(node._tied), + _attr(node._attr) { - _type = source._type; - _tied = source._tied; - switch (source._type) { + switch (_type) { + case NONE: + break; case ALIAS: - // FIXME!!! - _value.alias = (SGValue *)(source.getAlias()); + _value.alias = node._value.alias; break; case BOOL: - _value.bool_val = source._value.bool_val->clone(); + _value.bool_val = node._value.bool_val->clone(); break; case INT: - _value.int_val = source._value.int_val->clone(); + _value.int_val = node._value.int_val->clone(); break; case LONG: - _value.long_val = source._value.long_val->clone(); + _value.long_val = node._value.long_val->clone(); break; case FLOAT: - _value.float_val = source._value.float_val->clone(); + _value.float_val = node._value.float_val->clone(); break; case DOUBLE: - _value.double_val = source._value.double_val->clone(); + _value.double_val = node._value.double_val->clone(); break; case STRING: - case UNKNOWN: - _value.string_val = source._value.string_val->clone(); + case UNSPECIFIED: + _value.string_val = node._value.string_val->clone(); break; } } +/** + * Convenience constructor. + */ +SGPropertyNode::SGPropertyNode (const string &name, + int index, SGPropertyNode * parent) + : _name(name), _index(index), _parent(parent), _type(NONE), + _tied(false), _attr(READ|WRITE|ARCHIVE) +{ +} + + /** * Destructor. */ -SGValue::~SGValue () +SGPropertyNode::~SGPropertyNode () { - if (_type != ALIAS) - clear_value(); + for (int i = 0; i < (int)_children.size(); i++) + delete _children[i]; + clear_value(); } @@ -346,11 +368,13 @@ SGValue::~SGValue () * Delete and clear the current value. */ void -SGValue::clear_value () +SGPropertyNode::clear_value () { switch (_type) { + case NONE: case ALIAS: - _value.alias->clear_value(); + _value.alias = 0; + break; case BOOL: delete _value.bool_val; _value.bool_val = 0; @@ -372,86 +396,196 @@ SGValue::clear_value () _value.double_val = 0; break; case STRING: - case UNKNOWN: + case UNSPECIFIED: delete _value.string_val; _value.string_val = 0; break; } + _type = NONE; } /** - * Get the current type. - * - * Does not return a type of ALIAS. + * Alias to another node. */ -SGValue::Type -SGValue::getType () const +bool +SGPropertyNode::alias (SGPropertyNode * target) { - if (_type == ALIAS) - return _value.alias->getType(); - else - return (Type)_type; + if (target == 0 || _type == ALIAS || _tied) + return false; + clear_value(); + _value.alias = target; + _type = ALIAS; + return true; } /** - * Get the current aliased value. + * Alias to another node by path. */ -SGValue * -SGValue::getAlias () +bool +SGPropertyNode::alias (const string &path) { - return (_type == ALIAS ? _value.alias : 0); + return alias(getNode(path, true)); +} + + +/** + * Remove an alias. + */ +bool +SGPropertyNode::unalias () +{ + if (_type != ALIAS) + return false; + _type = NONE; + _value.alias = 0; + return true; } /** - * Get the current aliased value. + * Get the target of an alias. */ -const SGValue * -SGValue::getAlias () const +SGPropertyNode * +SGPropertyNode::getAliasTarget () +{ + return (_type == ALIAS ? _value.alias : 0); +} + + +const SGPropertyNode * +SGPropertyNode::getAliasTarget () const { return (_type == ALIAS ? _value.alias : 0); } /** - * Alias to another value. + * Get a non-const child by index. */ -bool -SGValue::alias (SGValue * alias) +SGPropertyNode * +SGPropertyNode::getChild (int position) { - if (alias == 0 || _type == ALIAS || _tied) - return false; - clear_value(); - _value.alias = alias; - _type = ALIAS; - return true; + if (position >= 0 && position < nChildren()) + return _children[position]; + else + return 0; } /** - * Unalias from another value. + * Get a const child by index. */ -bool -SGValue::unalias () +const SGPropertyNode * +SGPropertyNode::getChild (int position) const { - // FIXME: keep copy of previous value, - // as with untie() - if (_type != ALIAS) - return false; - _value.string_val = new SGRawValueInternal; - _type = UNKNOWN; - return true; + if (position >= 0 && position < nChildren()) + return _children[position]; + else + return 0; } /** - * Get a boolean value. + * Get a non-const child by name and index, creating if necessary. */ -bool -SGValue::getBoolValue () const +SGPropertyNode * +SGPropertyNode::getChild (const string &name, int index, bool create) +{ + int pos = find_child(name, index, _children); + if (pos >= 0) { + return _children[pos]; + } else if (create) { + _children.push_back(new SGPropertyNode(name, index, this)); + return _children[_children.size()-1]; + } else { + return 0; + } +} + + +/** + * Get a const child by name and index. + */ +const SGPropertyNode * +SGPropertyNode::getChild (const string &name, int index) const +{ + int pos = find_child(name, index, _children); + if (pos >= 0) + return _children[pos]; + else + return 0; +} + + +/** + * Get all children with the same name (but different indices). + */ +vector +SGPropertyNode::getChildren (const string &name) +{ + vector children; + int max = _children.size(); + + for (int i = 0; i < max; i++) + if (_children[i]->getName() == name) + children.push_back(_children[i]); + + sort(children.begin(), children.end(), CompareIndices()); + return children; +} + + +/** + * Get all children const with the same name (but different indices). + */ +vector +SGPropertyNode::getChildren (const string &name) const +{ + vector children; + int max = _children.size(); + + for (int i = 0; i < max; i++) + if (_children[i]->getName() == name) + children.push_back(_children[i]); + + sort(children.begin(), children.end(), CompareIndices()); + return children; +} + + +string +SGPropertyNode::getPath (bool simplify) const +{ + if (_parent == 0) + return ""; + + string path = _parent->getPath(simplify); + path += '/'; + path += _name; + if (_index != 0 || !simplify) { + char buffer[128]; + sprintf(buffer, "[%d]", _index); + path += buffer; + } + return path; +} + +SGPropertyNode::Type +SGPropertyNode::getType () const +{ + if (_type == ALIAS) + return _value.alias->getType(); + else + return _type; +} + + +bool +SGPropertyNode::getBoolValue () const { + TEST_READ(false); switch (_type) { case ALIAS: return _value.alias->getBoolValue(); @@ -466,20 +600,17 @@ SGValue::getBoolValue () const case DOUBLE: return GET_DOUBLE == 0.0L ? false : true; case STRING: - case UNKNOWN: + case UNSPECIFIED: return (GET_STRING == "true" || getDoubleValue() != 0.0L); } - return false; + return false; // if NONE } - -/** - * Get an integer value. - */ -int -SGValue::getIntValue () const +int +SGPropertyNode::getIntValue () const { + TEST_READ(0); switch (_type) { case ALIAS: return _value.alias->getIntValue(); @@ -494,20 +625,17 @@ SGValue::getIntValue () const case DOUBLE: return int(GET_DOUBLE); case STRING: - case UNKNOWN: + case UNSPECIFIED: return atoi(GET_STRING.c_str()); } - return 0; + return 0; // if NONE } - -/** - * Get a long integer value. - */ -long -SGValue::getLongValue () const +long +SGPropertyNode::getLongValue () const { + TEST_READ(0L); switch (_type) { case ALIAS: return _value.alias->getLongValue(); @@ -522,18 +650,17 @@ SGValue::getLongValue () const case DOUBLE: return long(GET_DOUBLE); case STRING: - case UNKNOWN: + case UNSPECIFIED: return strtol(GET_STRING.c_str(), 0, 0); } -} + return 0L; // if NONE +} -/** - * Get a float value. - */ -float -SGValue::getFloatValue () const +float +SGPropertyNode::getFloatValue () const { + TEST_READ(0.0); switch (_type) { case ALIAS: return _value.alias->getFloatValue(); @@ -548,20 +675,17 @@ SGValue::getFloatValue () const case DOUBLE: return float(GET_DOUBLE); case STRING: - case UNKNOWN: + case UNSPECIFIED: return atof(GET_STRING.c_str()); } - return 0.0; + return 0.0; // if NONE } - -/** - * Get a double value. - */ -double -SGValue::getDoubleValue () const +double +SGPropertyNode::getDoubleValue () const { + TEST_READ(0.0L); switch (_type) { case ALIAS: return _value.alias->getDoubleValue(); @@ -576,20 +700,17 @@ SGValue::getDoubleValue () const case DOUBLE: return GET_DOUBLE; case STRING: - case UNKNOWN: + case UNSPECIFIED: return strtod(GET_STRING.c_str(), 0); } - return 0.0; + return 0.0L; // if NONE } - -/** - * Get a string value. - */ string -SGValue::getStringValue () const +SGPropertyNode::getStringValue () const { + TEST_READ(""); char buf[128]; switch (_type) { @@ -613,21 +734,18 @@ SGValue::getStringValue () const sprintf(buf, "%f", GET_DOUBLE); return buf; case STRING: - case UNKNOWN: + case UNSPECIFIED: return GET_STRING; } - return ""; + return ""; // if NONE } - -/** - * Set a bool value. - */ bool -SGValue::setBoolValue (bool value) +SGPropertyNode::setBoolValue (bool value) { - if (_type == UNKNOWN) { + TEST_WRITE; + if (_type == NONE || _type == UNSPECIFIED) { clear_value(); _value.bool_val = new SGRawValueInternal; _type = BOOL; @@ -650,17 +768,14 @@ SGValue::setBoolValue (bool value) return SET_STRING(value ? "true" : "false"); } - return false; + return false; // should never happen } - -/** - * Set an int value. - */ bool -SGValue::setIntValue (int value) +SGPropertyNode::setIntValue (int value) { - if (_type == UNKNOWN) { + TEST_WRITE; + if (_type == NONE || _type == UNSPECIFIED) { clear_value(); _value.int_val = new SGRawValueInternal; _type = INT; @@ -686,17 +801,14 @@ SGValue::setIntValue (int value) } } - return false; + return false; // should never happen } - -/** - * Set a long value. - */ bool -SGValue::setLongValue (long value) +SGPropertyNode::setLongValue (long value) { - if (_type == UNKNOWN) { + TEST_WRITE; + if (_type == NONE || _type == UNSPECIFIED) { clear_value(); _value.long_val = new SGRawValueInternal; _type = LONG; @@ -722,17 +834,14 @@ SGValue::setLongValue (long value) } } - return false; + return false; // should never happen } - -/** - * Set a float value. - */ bool -SGValue::setFloatValue (float value) +SGPropertyNode::setFloatValue (float value) { - if (_type == UNKNOWN) { + TEST_WRITE; + if (_type == NONE || _type == UNSPECIFIED) { clear_value(); _value.float_val = new SGRawValueInternal; _type = FLOAT; @@ -758,17 +867,14 @@ SGValue::setFloatValue (float value) } } - return false; + return false; // should never happen } - -/** - * Set a double value. - */ bool -SGValue::setDoubleValue (double value) +SGPropertyNode::setDoubleValue (double value) { - if (_type == UNKNOWN) { + TEST_WRITE; + if (_type == NONE || _type == UNSPECIFIED) { clear_value(); _value.double_val = new SGRawValueInternal; _type = DOUBLE; @@ -794,17 +900,14 @@ SGValue::setDoubleValue (double value) } } - return false; + return false; // should never happen } - -/** - * Set a string value. - */ bool -SGValue::setStringValue (string value) +SGPropertyNode::setStringValue (string value) { - if (_type == UNKNOWN) { + TEST_WRITE; + if (_type == NONE || _type == UNSPECIFIED) { clear_value(); _value.string_val = new SGRawValueInternal; _type = STRING; @@ -827,19 +930,22 @@ SGValue::setStringValue (string value) return SET_STRING(value); } - return false; + return false; // should never happen } - -/** - * Set a value of unknown type (stored as a string). - */ bool -SGValue::setUnknownValue (string value) +SGPropertyNode::setUnspecifiedValue (string value) { + TEST_WRITE; + if (_type == NONE) { + clear_value(); + _value.string_val = new SGRawValueInternal; + _type = UNSPECIFIED; + } + switch (_type) { case ALIAS: - return _value.alias->setUnknownValue(value); + return _value.alias->setUnspecifiedValue(value); case BOOL: return SET_BOOL((value == "true" || atoi(value.c_str())) ? true : false); case INT: @@ -851,192 +957,151 @@ SGValue::setUnknownValue (string value) case DOUBLE: return SET_DOUBLE(strtod(value.c_str(), 0)); case STRING: - case UNKNOWN: + case UNSPECIFIED: return SET_STRING(value); } - return false; + return false; // should never happen } - -/** - * Tie a bool value. - */ bool -SGValue::tie (const SGRawValue &value, bool use_default) +SGPropertyNode::tie (const SGRawValue &rawValue, bool useDefault) { - if (_type == ALIAS) - return _value.alias->tie(value, use_default); - else if (_tied) + if (_type == ALIAS || _tied) return false; bool old_val = false; - if (use_default) + if (useDefault) old_val = getBoolValue(); clear_value(); _type = BOOL; _tied = true; - _value.bool_val = value.clone(); + _value.bool_val = rawValue.clone(); - if (use_default) + if (useDefault) setBoolValue(old_val); return true; } - -/** - * Tie an int value. - */ bool -SGValue::tie (const SGRawValue &value, bool use_default) +SGPropertyNode::tie (const SGRawValue &rawValue, bool useDefault) { - if (_type == ALIAS) - return _value.alias->tie(value, use_default); - else if (_tied) + if (_type == ALIAS || _tied) return false; int old_val = 0; - if (use_default) + if (useDefault) old_val = getIntValue(); clear_value(); _type = INT; _tied = true; - _value.int_val = value.clone(); + _value.int_val = rawValue.clone(); - if (use_default) + if (useDefault) setIntValue(old_val); return true; } - -/** - * Tie a long value. - */ bool -SGValue::tie (const SGRawValue &value, bool use_default) +SGPropertyNode::tie (const SGRawValue &rawValue, bool useDefault) { - if (_type == ALIAS) - return _value.alias->tie(value, use_default); - else if (_tied) + if (_type == ALIAS || _tied) return false; long old_val; - if (use_default) + if (useDefault) old_val = getLongValue(); clear_value(); _type = LONG; _tied = true; - _value.long_val = value.clone(); + _value.long_val = rawValue.clone(); - if (use_default) + if (useDefault) setLongValue(old_val); return true; } - -/** - * Tie a float value. - */ bool -SGValue::tie (const SGRawValue &value, bool use_default) +SGPropertyNode::tie (const SGRawValue &rawValue, bool useDefault) { - if (_type == ALIAS) - return _value.alias->tie(value, use_default); - else if (_tied) + if (_type == ALIAS || _tied) return false; float old_val = 0.0; - if (use_default) + if (useDefault) old_val = getFloatValue(); clear_value(); _type = FLOAT; _tied = true; - _value.float_val = value.clone(); + _value.float_val = rawValue.clone(); - if (use_default) + if (useDefault) setFloatValue(old_val); return true; } - -/** - * Tie a double value. - */ bool -SGValue::tie (const SGRawValue &value, bool use_default) +SGPropertyNode::tie (const SGRawValue &rawValue, bool useDefault) { - if (_type == ALIAS) - return _value.alias->tie(value, use_default); - else if (_tied) + if (_type == ALIAS || _tied) return false; double old_val = 0.0; - if (use_default) + if (useDefault) old_val = getDoubleValue(); clear_value(); _type = DOUBLE; _tied = true; - _value.double_val = value.clone(); + _value.double_val = rawValue.clone(); - if (use_default) + if (useDefault) setDoubleValue(old_val); return true; -} +} -/** - * Tie a string value. - */ bool -SGValue::tie (const SGRawValue &value, bool use_default) +SGPropertyNode::tie (const SGRawValue &rawValue, bool useDefault) { - if (_type == ALIAS) - return _value.alias->tie(value, use_default); - else if (_tied) + if (_type == ALIAS || _tied) return false; string old_val; - if (use_default) + if (useDefault) old_val = getStringValue(); clear_value(); _type = STRING; _tied = true; - _value.string_val = value.clone(); + _value.string_val = rawValue.clone(); - if (use_default) + if (useDefault) setStringValue(old_val); return true; } - -/** - * Untie a value. - */ bool -SGValue::untie () +SGPropertyNode::untie () { if (!_tied) return false; switch (_type) { - case ALIAS: { - return _value.alias->untie(); - } case BOOL: { bool val = getBoolValue(); clear_value(); + _type = BOOL; _value.bool_val = new SGRawValueInternal; SET_BOOL(val); break; @@ -1044,6 +1109,7 @@ SGValue::untie () case INT: { int val = getIntValue(); clear_value(); + _type = INT; _value.int_val = new SGRawValueInternal; SET_INT(val); break; @@ -1051,6 +1117,7 @@ SGValue::untie () case LONG: { long val = getLongValue(); clear_value(); + _type = LONG; _value.long_val = new SGRawValueInternal; SET_LONG(val); break; @@ -1058,6 +1125,7 @@ SGValue::untie () case FLOAT: { float val = getFloatValue(); clear_value(); + _type = FLOAT; _value.float_val = new SGRawValueInternal; SET_FLOAT(val); break; @@ -1065,6 +1133,7 @@ SGValue::untie () case DOUBLE: { double val = getDoubleValue(); clear_value(); + _type = DOUBLE; _value.double_val = new SGRawValueInternal; SET_DOUBLE(val); break; @@ -1072,6 +1141,7 @@ SGValue::untie () case STRING: { string val = getStringValue(); clear_value(); + _type = STRING; _value.string_val = new SGRawValueInternal; SET_STRING(val); break; @@ -1082,436 +1152,6 @@ SGValue::untie () return true; } - - -//////////////////////////////////////////////////////////////////////// -// Implementation of SGPropertyNode. -//////////////////////////////////////////////////////////////////////// - - -/** - * Utility function: given a value, find the property node. - */ -static SGPropertyNode * -find_node_by_value (SGPropertyNode * start_node, const SGValue * value) -{ - if (start_node->getValue() == value) { - return start_node; - } else for (int i = 0; i < start_node->nChildren(); i++) { - SGPropertyNode * child = - find_node_by_value(start_node->getChild(i), value); - if (child != 0) - return child; - } - return 0; -} - - -/** - * Default constructor: always creates a root node. - */ -SGPropertyNode::SGPropertyNode () - : _value(0), _name(""), _index(0), _parent(0), _target(0) -{ -} - - -/** - * Convenience constructor. - */ -SGPropertyNode::SGPropertyNode (const string &name, - int index, SGPropertyNode * parent) - : _value(0), _name(name), _index(index), _parent(parent), _target(0) -{ -} - - -/** - * Destructor. - */ -SGPropertyNode::~SGPropertyNode () -{ - delete _value; - for (int i = 0; i < (int)_children.size(); i++) - delete _children[i]; -} - - -/** - * Get a value, optionally creating it if not present. - */ -SGValue * -SGPropertyNode::getValue (bool create) -{ - if (_value == 0 && create) - _value = new SGValue(); - return _value; -} - - -/** - * Alias to another node. - */ -bool -SGPropertyNode::alias (SGPropertyNode * target) -{ - if (_value == 0) - _value = new SGValue(); - _target = target; - return _value->alias(target->getValue(true)); -} - - -/** - * Alias to another node by path. - */ -bool -SGPropertyNode::alias (const string &path) -{ - return alias(getNode(path, true)); -} - - -/** - * Remove an alias. - */ -bool -SGPropertyNode::unalias () -{ - _target = 0; - return (_value != 0 ? _value->unalias() : false); -} - - -/** - * Test whether this node is aliased. - */ -bool -SGPropertyNode::isAlias () const -{ - return (_value != 0 ? _value->isAlias() : false); -} - - -/** - * Get the target of an alias. - * - * This is tricky, because it is actually the value that is aliased, - * and someone could realias or unalias the value directly without - * going through the property node. The node caches its best guess, - * but it may have to search the whole property tree. - * - * @return The target node for the alias, or 0 if the node is not aliased. - */ -SGPropertyNode * -SGPropertyNode::getAliasTarget () -{ - if (_value == 0 || !_value->isAlias()) { - return 0; - } else if (_target != 0 && _target->getValue() == _value->getAlias()) { - return _target; - } else { - _target = find_node_by_value(getRootNode(), _value->getAlias()); - return _target; - } -} - - -const SGPropertyNode * -SGPropertyNode::getAliasTarget () const -{ - if (_value == 0 || !_value->isAlias()) { - return 0; - } else if (_target != 0 && _target->getValue() == _value->getAlias()) { - return _target; - } else { - // FIXME: const cast - _target = - find_node_by_value((SGPropertyNode *)getRootNode(), _value->getAlias()); - return _target; - } -} - - -/** - * Get a non-const child by index. - */ -SGPropertyNode * -SGPropertyNode::getChild (int position) -{ - if (position >= 0 && position < nChildren()) - return _children[position]; - else - return 0; -} - - -/** - * Get a const child by index. - */ -const SGPropertyNode * -SGPropertyNode::getChild (int position) const -{ - if (position >= 0 && position < nChildren()) - return _children[position]; - else - return 0; -} - - -/** - * Get a non-const child by name and index, creating if necessary. - */ -SGPropertyNode * -SGPropertyNode::getChild (const string &name, int index, bool create) -{ - int pos = find_child(name, index, _children); - if (pos >= 0) { - return _children[pos]; - } else if (create) { - _children.push_back(new SGPropertyNode(name, index, this)); - return _children[_children.size()-1]; - } else { - return 0; - } -} - - -/** - * Get a const child by name and index. - */ -const SGPropertyNode * -SGPropertyNode::getChild (const string &name, int index) const -{ - int pos = find_child(name, index, _children); - if (pos >= 0) - return _children[pos]; - else - return 0; -} - - -/** - * Get all children with the same name (but different indices). - */ -vector -SGPropertyNode::getChildren (const string &name) -{ - vector children; - int max = _children.size(); - - for (int i = 0; i < max; i++) - if (_children[i]->getName() == name) - children.push_back(_children[i]); - - sort(children.begin(), children.end(), CompareIndices()); - return children; -} - - -/** - * Get all children const with the same name (but different indices). - */ -vector -SGPropertyNode::getChildren (const string &name) const -{ - vector children; - int max = _children.size(); - - for (int i = 0; i < max; i++) - if (_children[i]->getName() == name) - children.push_back(_children[i]); - - sort(children.begin(), children.end(), CompareIndices()); - return children; -} - - -string -SGPropertyNode::getPath (bool simplify) const -{ - if (_parent == 0) - return ""; - - string path = _parent->getPath(simplify); - path += '/'; - path += _name; - if (_index != 0 || !simplify) { - char buffer[128]; - sprintf(buffer, "[%d]", _index); - path += buffer; - } - return path; -} - -SGPropertyNode::Type -SGPropertyNode::getType () const -{ - if (_value != 0) - return (Type)(_value->getType()); - else - return UNKNOWN; -} - - -bool -SGPropertyNode::getBoolValue () const -{ - return (_value == 0 ? SGRawValue::DefaultValue - : _value->getBoolValue()); -} - -int -SGPropertyNode::getIntValue () const -{ - return (_value == 0 ? SGRawValue::DefaultValue - : _value->getIntValue()); -} - -long -SGPropertyNode::getLongValue () const -{ - return (_value == 0 ? SGRawValue::DefaultValue - : _value->getLongValue()); -} - -float -SGPropertyNode::getFloatValue () const -{ - return (_value == 0 ? SGRawValue::DefaultValue - : _value->getFloatValue()); -} - -double -SGPropertyNode::getDoubleValue () const -{ - return (_value == 0 ? SGRawValue::DefaultValue - : _value->getDoubleValue()); -} - -string -SGPropertyNode::getStringValue () const -{ - return (_value == 0 ? SGRawValue::DefaultValue - : _value->getStringValue()); -} - -bool -SGPropertyNode::setBoolValue (bool val) -{ - if (_value == 0) - _value = new SGValue(); - return _value->setBoolValue(val); -} - -bool -SGPropertyNode::setIntValue (int val) -{ - if (_value == 0) - _value = new SGValue(); - return _value->setIntValue(val); -} - -bool -SGPropertyNode::setLongValue (long val) -{ - if (_value == 0) - _value = new SGValue(); - return _value->setLongValue(val); -} - -bool -SGPropertyNode::setFloatValue (float val) -{ - if (_value == 0) - _value = new SGValue(); - return _value->setFloatValue(val); -} - -bool -SGPropertyNode::setDoubleValue (double val) -{ - if (_value == 0) - _value = new SGValue(); - return _value->setDoubleValue(val); -} - -bool -SGPropertyNode::setStringValue (string val) -{ - if (_value == 0) - _value = new SGValue(); - return _value->setStringValue(val); -} - -bool -SGPropertyNode::setUnknownValue (string val) -{ - if (_value == 0) - _value = new SGValue(); - return _value->setUnknownValue(val); -} - -bool -SGPropertyNode::isTied () const -{ - return (_value == 0 ? false : _value->isTied()); -} - -bool -SGPropertyNode::tie (const SGRawValue &rawValue, bool useDefault) -{ - if (_value == 0) - _value = new SGValue(); - return _value->tie(rawValue, useDefault); -} - -bool -SGPropertyNode::tie (const SGRawValue &rawValue, bool useDefault) -{ - if (_value == 0) - _value = new SGValue(); - return _value->tie(rawValue, useDefault); -} - -bool -SGPropertyNode::tie (const SGRawValue &rawValue, bool useDefault) -{ - if (_value == 0) - _value = new SGValue(); - return _value->tie(rawValue, useDefault); -} - -bool -SGPropertyNode::tie (const SGRawValue &rawValue, bool useDefault) -{ - if (_value == 0) - _value = new SGValue(); - return _value->tie(rawValue, useDefault); -} - -bool -SGPropertyNode::tie (const SGRawValue &rawValue, bool useDefault) -{ - if (_value == 0) - _value = new SGValue(); - return _value->tie(rawValue, useDefault); -} - -bool -SGPropertyNode::tie (const SGRawValue &rawValue, bool useDefault) -{ - if (_value == 0) - _value = new SGValue(); - return _value->tie(rawValue, useDefault); -} - -bool -SGPropertyNode::untie () -{ - return (_value == 0 ? false : _value->untie()); -} - SGPropertyNode * SGPropertyNode::getRootNode () { @@ -1565,30 +1205,6 @@ SGPropertyNode::hasValue (const string &relative_path) const } -/** - * Get the value for another node. - */ -SGValue * -SGPropertyNode::getValue (const string &relative_path, bool create) -{ - SGPropertyNode * node = getNode(relative_path, create); - if (node != 0 && !node->hasValue()) - node->setUnknownValue(""); - return (node == 0 ? 0 : node->getValue(create)); -} - - -/** - * Get the value for another node. - */ -const SGValue * -SGPropertyNode::getValue (const string &relative_path) const -{ - const SGPropertyNode * node = getNode(relative_path); - return (node == 0 ? 0 : node->getValue()); -} - - /** * Get the value type for another node. */ @@ -1596,7 +1212,7 @@ SGPropertyNode::Type SGPropertyNode::getType (const string &relative_path) const { const SGPropertyNode * node = getNode(relative_path); - return (node == 0 ? UNKNOWN : (Type)(node->getType())); + return (node == 0 ? UNSPECIFIED : (Type)(node->getType())); } @@ -1736,9 +1352,9 @@ SGPropertyNode::setStringValue (const string &relative_path, string value) * Set an unknown value for another node. */ bool -SGPropertyNode::setUnknownValue (const string &relative_path, string value) +SGPropertyNode::setUnspecifiedValue (const string &relative_path, string value) { - return getNode(relative_path, true)->setUnknownValue(value); + return getNode(relative_path, true)->setUnspecifiedValue(value); }