2375 lines
46 KiB
C++
2375 lines
46 KiB
C++
// props.cxx - implementation of a property list.
|
|
// Started Fall 2000 by David Megginson, david@megginson.com
|
|
// This code is released into the Public Domain.
|
|
//
|
|
// See props.html for documentation [replace with URL when available].
|
|
//
|
|
// $Id$
|
|
|
|
#include "props.hxx"
|
|
|
|
#include <algorithm>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#if PROPS_STANDALONE
|
|
|
|
#include <iostream>
|
|
using std::cerr;
|
|
using std::endl;
|
|
using std::find;
|
|
using std::sort;
|
|
using std::vector;
|
|
|
|
#else
|
|
|
|
#include <simgear/compiler.h>
|
|
#include <simgear/debug/logstream.hxx>
|
|
|
|
SG_USING_STD(sort);
|
|
SG_USING_STD(find);
|
|
SG_USING_STD(vector);
|
|
|
|
#ifdef _MSC_VER
|
|
// MSVC is buggy, and needs something strange here
|
|
SG_USING_STD(vector<SGPropertyNode_ptr>);
|
|
SG_USING_STD(vector<SGPropertyChangeListener *>);
|
|
SG_USING_STD(vector<SGPropertyNode *>);
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Local classes.
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* Comparator class for sorting by index.
|
|
*/
|
|
class CompareIndices
|
|
{
|
|
public:
|
|
int operator() (const SGPropertyNode_ptr n1, const SGPropertyNode_ptr n2) const {
|
|
return (n1->getIndex() < n2->getIndex());
|
|
}
|
|
};
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Convenience macros for value access.
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
#define TEST_READ(dflt) if (!getAttribute(READ)) return dflt
|
|
#define TEST_WRITE if (!getAttribute(WRITE)) return false
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Default values for every type.
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
const bool SGRawValue<bool>::DefaultValue = false;
|
|
const int SGRawValue<int>::DefaultValue = 0;
|
|
const long SGRawValue<long>::DefaultValue = 0L;
|
|
const float SGRawValue<float>::DefaultValue = 0.0;
|
|
const double SGRawValue<double>::DefaultValue = 0.0L;
|
|
const char * const SGRawValue<const char *>::DefaultValue = "";
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Local path normalization code.
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* A component in a path.
|
|
*/
|
|
struct PathComponent
|
|
{
|
|
string name;
|
|
int index;
|
|
};
|
|
|
|
/**
|
|
* Parse the name for a path component.
|
|
*
|
|
* Name: [_a-zA-Z][-._a-zA-Z0-9]*
|
|
*/
|
|
static inline const string
|
|
parse_name (const string &path, int &i)
|
|
{
|
|
string name = "";
|
|
int max = path.size();
|
|
|
|
if (path[i] == '.') {
|
|
i++;
|
|
if (i < max && path[i] == '.') {
|
|
i++;
|
|
name = "..";
|
|
} else {
|
|
name = ".";
|
|
}
|
|
if (i < max && path[i] != '/')
|
|
throw string(string("Illegal character after ") + name);
|
|
}
|
|
|
|
else if (isalpha(path[i]) || path[i] == '_') {
|
|
name += path[i];
|
|
i++;
|
|
|
|
// The rules inside a name are a little
|
|
// less restrictive.
|
|
while (i < max) {
|
|
if (isalpha(path[i]) || isdigit(path[i]) || path[i] == '_' ||
|
|
path[i] == '-' || path[i] == '.') {
|
|
name += path[i];
|
|
} else if (path[i] == '[' || path[i] == '/') {
|
|
break;
|
|
} else {
|
|
throw string("name may contain only ._- and alphanumeric characters");
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
else {
|
|
if (name.size() == 0)
|
|
throw string("name must begin with alpha or '_'");
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
|
|
/**
|
|
* Parse the optional integer index for a path component.
|
|
*
|
|
* Index: "[" [0-9]+ "]"
|
|
*/
|
|
static inline int
|
|
parse_index (const string &path, int &i)
|
|
{
|
|
int index = 0;
|
|
|
|
if (path[i] != '[')
|
|
return 0;
|
|
else
|
|
i++;
|
|
|
|
for (int max = path.size(); i < max; i++) {
|
|
if (isdigit(path[i])) {
|
|
index = (index * 10) + (path[i] - '0');
|
|
} else if (path[i] == ']') {
|
|
i++;
|
|
return index;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
throw string("unterminated index (looking for ']')");
|
|
}
|
|
|
|
|
|
/**
|
|
* Parse a single path component.
|
|
*
|
|
* Component: Name Index?
|
|
*/
|
|
static inline PathComponent
|
|
parse_component (const string &path, int &i)
|
|
{
|
|
PathComponent component;
|
|
component.name = parse_name(path, i);
|
|
if (component.name[0] != '.')
|
|
component.index = parse_index(path, i);
|
|
else
|
|
component.index = -1;
|
|
return component;
|
|
}
|
|
|
|
|
|
/**
|
|
* Parse a path into its components.
|
|
*/
|
|
static void
|
|
parse_path (const string &path, vector<PathComponent> &components)
|
|
{
|
|
int pos = 0;
|
|
int max = path.size();
|
|
|
|
// Check for initial '/'
|
|
if (path[pos] == '/') {
|
|
PathComponent root;
|
|
root.name = "";
|
|
root.index = -1;
|
|
components.push_back(root);
|
|
pos++;
|
|
while (pos < max && path[pos] == '/')
|
|
pos++;
|
|
}
|
|
|
|
while (pos < max) {
|
|
components.push_back(parse_component(path, pos));
|
|
while (pos < max && path[pos] == '/')
|
|
pos++;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Other static utility functions.
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
static char *
|
|
copy_string (const char * s)
|
|
{
|
|
// FIXME: potential buffer overflow.
|
|
// For some reason, strnlen and
|
|
// strncpy cause all kinds of crashes.
|
|
char * copy = new char[strlen(s) + 1];
|
|
strcpy(copy, s);
|
|
return copy;
|
|
}
|
|
|
|
static bool
|
|
compare_strings (const char * s1, const char * s2)
|
|
{
|
|
return !strncmp(s1, s2, SGPropertyNode::MAX_STRING_LEN);
|
|
}
|
|
|
|
/**
|
|
* Locate a child node by name and index.
|
|
*/
|
|
static int
|
|
find_child (const char * name, int index, vector<SGPropertyNode_ptr> nodes)
|
|
{
|
|
int nNodes = nodes.size();
|
|
for (int i = 0; i < nNodes; i++) {
|
|
SGPropertyNode * node = nodes[i];
|
|
if (compare_strings(node->getName(), name) && node->getIndex() == index)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
/**
|
|
* Locate another node, given a relative path.
|
|
*/
|
|
static SGPropertyNode *
|
|
find_node (SGPropertyNode * current,
|
|
const vector<PathComponent> &components,
|
|
int position,
|
|
bool create)
|
|
{
|
|
// Run off the end of the list
|
|
if (current == 0) {
|
|
return 0;
|
|
}
|
|
|
|
// Success! This is the one we want.
|
|
else if (position >= (int)components.size()) {
|
|
return current;
|
|
}
|
|
|
|
// Empty component means root.
|
|
else if (components[position].name == "") {
|
|
return find_node(current->getRootNode(), components, position + 1, create);
|
|
}
|
|
|
|
// . means current directory
|
|
else if (components[position].name == ".") {
|
|
return find_node(current, components, position + 1, create);
|
|
}
|
|
|
|
// .. means parent directory
|
|
else if (components[position].name == "..") {
|
|
SGPropertyNode * parent = current->getParent();
|
|
if (parent == 0)
|
|
throw string("Attempt to move past root with '..'");
|
|
else
|
|
return find_node(parent, components, position + 1, create);
|
|
}
|
|
|
|
// Otherwise, a child name
|
|
else {
|
|
SGPropertyNode * child =
|
|
current->getChild(components[position].name.c_str(),
|
|
components[position].index,
|
|
create);
|
|
return find_node(child, components, position + 1, create);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Private methods from SGPropertyNode (may be inlined for speed).
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
inline bool
|
|
SGPropertyNode::get_bool () const
|
|
{
|
|
if (_tied)
|
|
return _value.bool_val->getValue();
|
|
else
|
|
return _local_val.bool_val;
|
|
}
|
|
|
|
inline int
|
|
SGPropertyNode::get_int () const
|
|
{
|
|
if (_tied)
|
|
return _value.int_val->getValue();
|
|
else
|
|
return _local_val.int_val;
|
|
}
|
|
|
|
inline long
|
|
SGPropertyNode::get_long () const
|
|
{
|
|
if (_tied)
|
|
return _value.long_val->getValue();
|
|
else
|
|
return _local_val.long_val;
|
|
}
|
|
|
|
inline float
|
|
SGPropertyNode::get_float () const
|
|
{
|
|
if (_tied)
|
|
return _value.float_val->getValue();
|
|
else
|
|
return _local_val.float_val;
|
|
}
|
|
|
|
inline double
|
|
SGPropertyNode::get_double () const
|
|
{
|
|
if (_tied)
|
|
return _value.double_val->getValue();
|
|
else
|
|
return _local_val.double_val;
|
|
}
|
|
|
|
inline const char *
|
|
SGPropertyNode::get_string () const
|
|
{
|
|
if (_tied)
|
|
return _value.string_val->getValue();
|
|
else
|
|
return _local_val.string_val;
|
|
}
|
|
|
|
inline bool
|
|
SGPropertyNode::set_bool (bool val)
|
|
{
|
|
if (_tied) {
|
|
if (_value.bool_val->setValue(val)) {
|
|
fireValueChanged();
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
_local_val.bool_val = val;
|
|
fireValueChanged();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
inline bool
|
|
SGPropertyNode::set_int (int val)
|
|
{
|
|
if (_tied) {
|
|
if (_value.int_val->setValue(val)) {
|
|
fireValueChanged();
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
_local_val.int_val = val;
|
|
fireValueChanged();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
inline bool
|
|
SGPropertyNode::set_long (long val)
|
|
{
|
|
if (_tied) {
|
|
if (_value.long_val->setValue(val)) {
|
|
fireValueChanged();
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
_local_val.long_val = val;
|
|
fireValueChanged();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
inline bool
|
|
SGPropertyNode::set_float (float val)
|
|
{
|
|
if (_tied) {
|
|
if (_value.float_val->setValue(val)) {
|
|
fireValueChanged();
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
_local_val.float_val = val;
|
|
fireValueChanged();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
inline bool
|
|
SGPropertyNode::set_double (double val)
|
|
{
|
|
if (_tied) {
|
|
if (_value.double_val->setValue(val)) {
|
|
fireValueChanged();
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
_local_val.double_val = val;
|
|
fireValueChanged();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
inline bool
|
|
SGPropertyNode::set_string (const char * val)
|
|
{
|
|
if (_tied) {
|
|
if (_value.string_val->setValue(val)) {
|
|
fireValueChanged();
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
delete [] _local_val.string_val;
|
|
_local_val.string_val = copy_string(val);
|
|
fireValueChanged();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
void
|
|
SGPropertyNode::clear_value ()
|
|
{
|
|
switch (_type) {
|
|
case NONE:
|
|
break;
|
|
case ALIAS:
|
|
_value.alias = 0;
|
|
break;
|
|
case BOOL:
|
|
if (_tied) {
|
|
delete _value.bool_val;
|
|
_value.bool_val = 0;
|
|
}
|
|
_local_val.bool_val = SGRawValue<bool>::DefaultValue;
|
|
break;
|
|
case INT:
|
|
if (_tied) {
|
|
delete _value.int_val;
|
|
_value.int_val = 0;
|
|
}
|
|
_local_val.int_val = SGRawValue<int>::DefaultValue;
|
|
break;
|
|
case LONG:
|
|
if (_tied) {
|
|
delete _value.long_val;
|
|
_value.long_val = 0L;
|
|
}
|
|
_local_val.long_val = SGRawValue<long>::DefaultValue;
|
|
break;
|
|
case FLOAT:
|
|
if (_tied) {
|
|
delete _value.float_val;
|
|
_value.float_val = 0;
|
|
}
|
|
_local_val.float_val = SGRawValue<float>::DefaultValue;
|
|
break;
|
|
case DOUBLE:
|
|
if (_tied) {
|
|
delete _value.double_val;
|
|
_value.double_val = 0;
|
|
}
|
|
_local_val.double_val = SGRawValue<double>::DefaultValue;
|
|
break;
|
|
case STRING:
|
|
case UNSPECIFIED:
|
|
if (_tied) {
|
|
delete _value.string_val;
|
|
_value.string_val = 0;
|
|
} else {
|
|
delete [] _local_val.string_val;
|
|
}
|
|
_local_val.string_val = 0;
|
|
break;
|
|
}
|
|
_tied = false;
|
|
_type = NONE;
|
|
}
|
|
|
|
|
|
/**
|
|
* Get the value as a string.
|
|
*/
|
|
const char *
|
|
SGPropertyNode::make_string () const
|
|
{
|
|
if (!getAttribute(READ))
|
|
return "";
|
|
|
|
switch (_type) {
|
|
case ALIAS:
|
|
return _value.alias->getStringValue();
|
|
case BOOL:
|
|
if (get_bool())
|
|
return "true";
|
|
else
|
|
return "false";
|
|
case INT:
|
|
sprintf(_buffer, "%d", get_int());
|
|
return _buffer;
|
|
case LONG:
|
|
sprintf(_buffer, "%ld", get_long());
|
|
return _buffer;
|
|
case FLOAT:
|
|
sprintf(_buffer, "%f", get_float());
|
|
return _buffer;
|
|
case DOUBLE:
|
|
sprintf(_buffer, "%f", get_double());
|
|
return _buffer;
|
|
case STRING:
|
|
case UNSPECIFIED:
|
|
return get_string();
|
|
case NONE:
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Trace a write access for a property.
|
|
*/
|
|
void
|
|
SGPropertyNode::trace_write () const
|
|
{
|
|
#if PROPS_STANDALONE
|
|
cerr << "TRACE: Write node " << getPath () << ", value\""
|
|
<< make_string() << '"' << endl;
|
|
#else
|
|
SG_LOG(SG_GENERAL, SG_INFO, "TRACE: Write node " << getPath()
|
|
<< ", value\"" << make_string() << '"');
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* Trace a read access for a property.
|
|
*/
|
|
void
|
|
SGPropertyNode::trace_read () const
|
|
{
|
|
#if PROPS_STANDALONE
|
|
cerr << "TRACE: Write node " << getPath () << ", value \""
|
|
<< make_string() << '"' << endl;
|
|
#else
|
|
SG_LOG(SG_GENERAL, SG_INFO, "TRACE: Read node " << getPath()
|
|
<< ", value \"" << make_string() << '"');
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* Increment reference counter
|
|
*/
|
|
void
|
|
SGPropertyNode::incrementRef()
|
|
{
|
|
++_count;
|
|
}
|
|
|
|
/**
|
|
* Decrement reference counter
|
|
*/
|
|
int
|
|
SGPropertyNode::decrementRef()
|
|
{
|
|
return --_count;
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Public methods from SGPropertyNode.
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* Last used attribute
|
|
* Update as needed when enum Attribute is changed
|
|
*/
|
|
const int SGPropertyNode::LAST_USED_ATTRIBUTE = TRACE_WRITE;
|
|
|
|
/**
|
|
* Default constructor: always creates a root node.
|
|
*/
|
|
SGPropertyNode::SGPropertyNode ()
|
|
: _name(copy_string("")),
|
|
_display_name(0),
|
|
_index(0),
|
|
_parent(0),
|
|
_path(0),
|
|
_path_cache(0),
|
|
_type(NONE),
|
|
_tied(false),
|
|
_attr(READ|WRITE),
|
|
_count(0),
|
|
_listeners(0)
|
|
{
|
|
_local_val.string_val = 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* Copy constructor.
|
|
*/
|
|
SGPropertyNode::SGPropertyNode (const SGPropertyNode &node)
|
|
: _display_name(0),
|
|
_index(node._index),
|
|
_parent(0), // don't copy the parent
|
|
_path(0),
|
|
_path_cache(0),
|
|
_type(node._type),
|
|
_tied(node._tied),
|
|
_attr(node._attr),
|
|
_count(0),
|
|
_listeners(0) // CHECK!!
|
|
{
|
|
_name = copy_string(node._name);
|
|
_local_val.string_val = 0;
|
|
switch (_type) {
|
|
case NONE:
|
|
break;
|
|
case ALIAS:
|
|
_value.alias = node._value.alias;
|
|
_tied = false;
|
|
break;
|
|
case BOOL:
|
|
if (_tied) {
|
|
_tied = true;
|
|
_value.bool_val = node._value.bool_val->clone();
|
|
} else {
|
|
_tied = false;
|
|
set_bool(node.get_bool());
|
|
}
|
|
break;
|
|
case INT:
|
|
if (_tied) {
|
|
_tied = true;
|
|
_value.int_val = node._value.int_val->clone();
|
|
} else {
|
|
_tied = false;
|
|
set_int(node.get_int());
|
|
}
|
|
break;
|
|
case LONG:
|
|
if (_tied) {
|
|
_tied = true;
|
|
_value.long_val = node._value.long_val->clone();
|
|
} else {
|
|
_tied = false;
|
|
set_long(node.get_long());
|
|
}
|
|
break;
|
|
case FLOAT:
|
|
if (_tied) {
|
|
_tied = true;
|
|
_value.float_val = node._value.float_val->clone();
|
|
} else {
|
|
_tied = false;
|
|
set_float(node.get_float());
|
|
}
|
|
break;
|
|
case DOUBLE:
|
|
if (_tied) {
|
|
_tied = true;
|
|
_value.double_val = node._value.double_val->clone();
|
|
} else {
|
|
_tied = false;
|
|
set_double(node.get_double());
|
|
}
|
|
break;
|
|
case STRING:
|
|
case UNSPECIFIED:
|
|
if (_tied) {
|
|
_tied = true;
|
|
_value.string_val = node._value.string_val->clone();
|
|
} else {
|
|
_tied = false;
|
|
set_string(node.get_string());
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Convenience constructor.
|
|
*/
|
|
SGPropertyNode::SGPropertyNode (const char * name,
|
|
int index,
|
|
SGPropertyNode * parent)
|
|
: _display_name(0),
|
|
_index(index),
|
|
_parent(parent),
|
|
_path(0),
|
|
_path_cache(0),
|
|
_type(NONE),
|
|
_tied(false),
|
|
_attr(READ|WRITE),
|
|
_count(0),
|
|
_listeners(0)
|
|
{
|
|
_name = copy_string(name);
|
|
_local_val.string_val = 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
SGPropertyNode::~SGPropertyNode ()
|
|
{
|
|
delete [] _name;
|
|
delete [] _display_name;
|
|
delete [] _path;
|
|
delete _path_cache;
|
|
clear_value();
|
|
delete _listeners;
|
|
}
|
|
|
|
|
|
/**
|
|
* Alias to another node.
|
|
*/
|
|
bool
|
|
SGPropertyNode::alias (SGPropertyNode * target)
|
|
{
|
|
if (target == 0 || _type == ALIAS || _tied)
|
|
return false;
|
|
clear_value();
|
|
_value.alias = target;
|
|
_type = ALIAS;
|
|
return true;
|
|
}
|
|
|
|
|
|
/**
|
|
* Alias to another node by path.
|
|
*/
|
|
bool
|
|
SGPropertyNode::alias (const char * path)
|
|
{
|
|
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 target of an alias.
|
|
*/
|
|
SGPropertyNode *
|
|
SGPropertyNode::getAliasTarget ()
|
|
{
|
|
return (_type == ALIAS ? _value.alias : 0);
|
|
}
|
|
|
|
|
|
const SGPropertyNode *
|
|
SGPropertyNode::getAliasTarget () const
|
|
{
|
|
return (_type == ALIAS ? _value.alias : 0);
|
|
}
|
|
|
|
|
|
/**
|
|
* 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 char * name, int index, bool create)
|
|
{
|
|
int pos = find_child(name, index, _children);
|
|
if (pos >= 0) {
|
|
return _children[pos];
|
|
} else if (create) {
|
|
SGPropertyNode_ptr node;
|
|
pos = find_child(name, index, _removedChildren);
|
|
if (pos >= 0) {
|
|
vector<SGPropertyNode_ptr>::iterator it = _removedChildren.begin();
|
|
it += pos;
|
|
node = _removedChildren[pos];
|
|
_removedChildren.erase(it);
|
|
node->setAttribute(REMOVED, false);
|
|
} else {
|
|
node = new SGPropertyNode(name, index, this);
|
|
}
|
|
_children.push_back(node);
|
|
fireChildAdded(node);
|
|
return node;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Get a const child by name and index.
|
|
*/
|
|
const SGPropertyNode *
|
|
SGPropertyNode::getChild (const char * 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_ptr>
|
|
SGPropertyNode::getChildren (const char * name) const
|
|
{
|
|
vector<SGPropertyNode_ptr> children;
|
|
int max = _children.size();
|
|
|
|
for (int i = 0; i < max; i++)
|
|
if (compare_strings(_children[i]->getName(), name))
|
|
children.push_back(_children[i]);
|
|
|
|
sort(children.begin(), children.end(), CompareIndices());
|
|
return children;
|
|
}
|
|
|
|
|
|
/**
|
|
* Remove a child node
|
|
*/
|
|
SGPropertyNode_ptr
|
|
SGPropertyNode::removeChild (const char * name, int index, bool keep)
|
|
{
|
|
SGPropertyNode_ptr ret;
|
|
int pos = find_child(name, index, _children);
|
|
if (pos >= 0) {
|
|
vector<SGPropertyNode_ptr>::iterator it = _children.begin();
|
|
it += pos;
|
|
SGPropertyNode_ptr node = _children[pos];
|
|
_children.erase(it);
|
|
if (keep) {
|
|
_removedChildren.push_back(node);
|
|
}
|
|
node->setAttribute(REMOVED, true);
|
|
ret = node;
|
|
fireChildRemoved(node);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
const char *
|
|
SGPropertyNode::getDisplayName (bool simplify) const
|
|
{
|
|
string display = _name;
|
|
if (_index != 0 || !simplify) {
|
|
char buffer[64];
|
|
sprintf(buffer, "[%d]", _index);
|
|
display += buffer;
|
|
}
|
|
_display_name = copy_string(display.c_str());
|
|
return _display_name;
|
|
}
|
|
|
|
|
|
const char *
|
|
SGPropertyNode::getPath (bool simplify) const
|
|
{
|
|
// Calculate the complete path only once.
|
|
if (_path == 0) {
|
|
string path;
|
|
if (_parent == 0) {
|
|
path = "";
|
|
} else {
|
|
path = _parent->getPath(simplify);
|
|
path += '/';
|
|
path += getDisplayName(simplify);
|
|
}
|
|
_path = copy_string(path.c_str());
|
|
}
|
|
|
|
return _path;
|
|
}
|
|
|
|
SGPropertyNode::Type
|
|
SGPropertyNode::getType () const
|
|
{
|
|
if (_type == ALIAS)
|
|
return _value.alias->getType();
|
|
else
|
|
return _type;
|
|
}
|
|
|
|
|
|
bool
|
|
SGPropertyNode::getBoolValue () const
|
|
{
|
|
// Shortcut for common case
|
|
if (_attr == (READ|WRITE) && _type == BOOL)
|
|
return get_bool();
|
|
|
|
if (getAttribute(TRACE_READ))
|
|
trace_read();
|
|
if (!getAttribute(READ))
|
|
return SGRawValue<bool>::DefaultValue;
|
|
switch (_type) {
|
|
case ALIAS:
|
|
return _value.alias->getBoolValue();
|
|
case BOOL:
|
|
return get_bool();
|
|
case INT:
|
|
return get_int() == 0 ? false : true;
|
|
case LONG:
|
|
return get_long() == 0L ? false : true;
|
|
case FLOAT:
|
|
return get_float() == 0.0 ? false : true;
|
|
case DOUBLE:
|
|
return get_double() == 0.0L ? false : true;
|
|
case STRING:
|
|
case UNSPECIFIED:
|
|
return (compare_strings(get_string(), "true") || getDoubleValue() != 0.0L);
|
|
case NONE:
|
|
default:
|
|
return SGRawValue<bool>::DefaultValue;
|
|
}
|
|
}
|
|
|
|
int
|
|
SGPropertyNode::getIntValue () const
|
|
{
|
|
// Shortcut for common case
|
|
if (_attr == (READ|WRITE) && _type == INT)
|
|
return get_int();
|
|
|
|
if (getAttribute(TRACE_READ))
|
|
trace_read();
|
|
if (!getAttribute(READ))
|
|
return SGRawValue<int>::DefaultValue;
|
|
switch (_type) {
|
|
case ALIAS:
|
|
return _value.alias->getIntValue();
|
|
case BOOL:
|
|
return int(get_bool());
|
|
case INT:
|
|
return get_int();
|
|
case LONG:
|
|
return int(get_long());
|
|
case FLOAT:
|
|
return int(get_float());
|
|
case DOUBLE:
|
|
return int(get_double());
|
|
case STRING:
|
|
case UNSPECIFIED:
|
|
return atoi(get_string());
|
|
case NONE:
|
|
default:
|
|
return SGRawValue<int>::DefaultValue;
|
|
}
|
|
}
|
|
|
|
long
|
|
SGPropertyNode::getLongValue () const
|
|
{
|
|
// Shortcut for common case
|
|
if (_attr == (READ|WRITE) && _type == LONG)
|
|
return get_long();
|
|
|
|
if (getAttribute(TRACE_READ))
|
|
trace_read();
|
|
if (!getAttribute(READ))
|
|
return SGRawValue<long>::DefaultValue;
|
|
switch (_type) {
|
|
case ALIAS:
|
|
return _value.alias->getLongValue();
|
|
case BOOL:
|
|
return long(get_bool());
|
|
case INT:
|
|
return long(get_int());
|
|
case LONG:
|
|
return get_long();
|
|
case FLOAT:
|
|
return long(get_float());
|
|
case DOUBLE:
|
|
return long(get_double());
|
|
case STRING:
|
|
case UNSPECIFIED:
|
|
return strtol(get_string(), 0, 0);
|
|
case NONE:
|
|
default:
|
|
return SGRawValue<long>::DefaultValue;
|
|
}
|
|
}
|
|
|
|
float
|
|
SGPropertyNode::getFloatValue () const
|
|
{
|
|
// Shortcut for common case
|
|
if (_attr == (READ|WRITE) && _type == FLOAT)
|
|
return get_float();
|
|
|
|
if (getAttribute(TRACE_READ))
|
|
trace_read();
|
|
if (!getAttribute(READ))
|
|
return SGRawValue<float>::DefaultValue;
|
|
switch (_type) {
|
|
case ALIAS:
|
|
return _value.alias->getFloatValue();
|
|
case BOOL:
|
|
return float(get_bool());
|
|
case INT:
|
|
return float(get_int());
|
|
case LONG:
|
|
return float(get_long());
|
|
case FLOAT:
|
|
return get_float();
|
|
case DOUBLE:
|
|
return float(get_double());
|
|
case STRING:
|
|
case UNSPECIFIED:
|
|
return atof(get_string());
|
|
case NONE:
|
|
default:
|
|
return SGRawValue<float>::DefaultValue;
|
|
}
|
|
}
|
|
|
|
double
|
|
SGPropertyNode::getDoubleValue () const
|
|
{
|
|
// Shortcut for common case
|
|
if (_attr == (READ|WRITE) && _type == DOUBLE)
|
|
return get_double();
|
|
|
|
if (getAttribute(TRACE_READ))
|
|
trace_read();
|
|
if (!getAttribute(READ))
|
|
return SGRawValue<double>::DefaultValue;
|
|
|
|
switch (_type) {
|
|
case ALIAS:
|
|
return _value.alias->getDoubleValue();
|
|
case BOOL:
|
|
return double(get_bool());
|
|
case INT:
|
|
return double(get_int());
|
|
case LONG:
|
|
return double(get_long());
|
|
case FLOAT:
|
|
return double(get_float());
|
|
case DOUBLE:
|
|
return get_double();
|
|
case STRING:
|
|
case UNSPECIFIED:
|
|
return strtod(get_string(), 0);
|
|
case NONE:
|
|
default:
|
|
return SGRawValue<double>::DefaultValue;
|
|
}
|
|
}
|
|
|
|
const char *
|
|
SGPropertyNode::getStringValue () const
|
|
{
|
|
// Shortcut for common case
|
|
if (_attr == (READ|WRITE) && _type == STRING)
|
|
return get_string();
|
|
|
|
if (getAttribute(TRACE_READ))
|
|
trace_read();
|
|
if (!getAttribute(READ))
|
|
return SGRawValue<const char *>::DefaultValue;
|
|
return make_string();
|
|
}
|
|
|
|
bool
|
|
SGPropertyNode::setBoolValue (bool value)
|
|
{
|
|
// Shortcut for common case
|
|
if (_attr == (READ|WRITE) && _type == BOOL)
|
|
return set_bool(value);
|
|
|
|
bool result = false;
|
|
TEST_WRITE;
|
|
if (_type == NONE || _type == UNSPECIFIED) {
|
|
clear_value();
|
|
_tied = false;
|
|
_type = BOOL;
|
|
}
|
|
|
|
switch (_type) {
|
|
case ALIAS:
|
|
result = _value.alias->setBoolValue(value);
|
|
break;
|
|
case BOOL:
|
|
result = set_bool(value);
|
|
break;
|
|
case INT:
|
|
result = set_int(int(value));
|
|
break;
|
|
case LONG:
|
|
result = set_long(long(value));
|
|
break;
|
|
case FLOAT:
|
|
result = set_float(float(value));
|
|
break;
|
|
case DOUBLE:
|
|
result = set_double(double(value));
|
|
break;
|
|
case STRING:
|
|
case UNSPECIFIED:
|
|
result = set_string(value ? "true" : "false");
|
|
break;
|
|
case NONE:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (getAttribute(TRACE_WRITE))
|
|
trace_write();
|
|
return result;
|
|
}
|
|
|
|
bool
|
|
SGPropertyNode::setIntValue (int value)
|
|
{
|
|
// Shortcut for common case
|
|
if (_attr == (READ|WRITE) && _type == INT)
|
|
return set_int(value);
|
|
|
|
bool result = false;
|
|
TEST_WRITE;
|
|
if (_type == NONE || _type == UNSPECIFIED) {
|
|
clear_value();
|
|
_type = INT;
|
|
_local_val.int_val = 0;
|
|
}
|
|
|
|
switch (_type) {
|
|
case ALIAS:
|
|
result = _value.alias->setIntValue(value);
|
|
break;
|
|
case BOOL:
|
|
result = set_bool(value == 0 ? false : true);
|
|
break;
|
|
case INT:
|
|
result = set_int(value);
|
|
break;
|
|
case LONG:
|
|
result = set_long(long(value));
|
|
break;
|
|
case FLOAT:
|
|
result = set_float(float(value));
|
|
break;
|
|
case DOUBLE:
|
|
result = set_double(double(value));
|
|
break;
|
|
case STRING:
|
|
case UNSPECIFIED: {
|
|
char buf[128];
|
|
sprintf(buf, "%d", value);
|
|
result = set_string(buf);
|
|
break;
|
|
}
|
|
case NONE:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (getAttribute(TRACE_WRITE))
|
|
trace_write();
|
|
return result;
|
|
}
|
|
|
|
bool
|
|
SGPropertyNode::setLongValue (long value)
|
|
{
|
|
// Shortcut for common case
|
|
if (_attr == (READ|WRITE) && _type == LONG)
|
|
return set_long(value);
|
|
|
|
bool result = false;
|
|
TEST_WRITE;
|
|
if (_type == NONE || _type == UNSPECIFIED) {
|
|
clear_value();
|
|
_type = LONG;
|
|
_local_val.long_val = 0L;
|
|
}
|
|
|
|
switch (_type) {
|
|
case ALIAS:
|
|
result = _value.alias->setLongValue(value);
|
|
break;
|
|
case BOOL:
|
|
result = set_bool(value == 0L ? false : true);
|
|
break;
|
|
case INT:
|
|
result = set_int(int(value));
|
|
break;
|
|
case LONG:
|
|
result = set_long(value);
|
|
break;
|
|
case FLOAT:
|
|
result = set_float(float(value));
|
|
break;
|
|
case DOUBLE:
|
|
result = set_double(double(value));
|
|
break;
|
|
case STRING:
|
|
case UNSPECIFIED: {
|
|
char buf[128];
|
|
sprintf(buf, "%ld", value);
|
|
result = set_string(buf);
|
|
break;
|
|
}
|
|
case NONE:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (getAttribute(TRACE_WRITE))
|
|
trace_write();
|
|
return result;
|
|
}
|
|
|
|
bool
|
|
SGPropertyNode::setFloatValue (float value)
|
|
{
|
|
// Shortcut for common case
|
|
if (_attr == (READ|WRITE) && _type == FLOAT)
|
|
return set_float(value);
|
|
|
|
bool result = false;
|
|
TEST_WRITE;
|
|
if (_type == NONE || _type == UNSPECIFIED) {
|
|
clear_value();
|
|
_type = FLOAT;
|
|
_local_val.float_val = 0;
|
|
}
|
|
|
|
switch (_type) {
|
|
case ALIAS:
|
|
result = _value.alias->setFloatValue(value);
|
|
break;
|
|
case BOOL:
|
|
result = set_bool(value == 0.0 ? false : true);
|
|
break;
|
|
case INT:
|
|
result = set_int(int(value));
|
|
break;
|
|
case LONG:
|
|
result = set_long(long(value));
|
|
break;
|
|
case FLOAT:
|
|
result = set_float(value);
|
|
break;
|
|
case DOUBLE:
|
|
result = set_double(double(value));
|
|
break;
|
|
case STRING:
|
|
case UNSPECIFIED: {
|
|
char buf[128];
|
|
sprintf(buf, "%f", value);
|
|
result = set_string(buf);
|
|
break;
|
|
}
|
|
case NONE:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (getAttribute(TRACE_WRITE))
|
|
trace_write();
|
|
return result;
|
|
}
|
|
|
|
bool
|
|
SGPropertyNode::setDoubleValue (double value)
|
|
{
|
|
// Shortcut for common case
|
|
if (_attr == (READ|WRITE) && _type == DOUBLE)
|
|
return set_double(value);
|
|
|
|
bool result = false;
|
|
TEST_WRITE;
|
|
if (_type == NONE || _type == UNSPECIFIED) {
|
|
clear_value();
|
|
_local_val.double_val = value;
|
|
_type = DOUBLE;
|
|
}
|
|
|
|
switch (_type) {
|
|
case ALIAS:
|
|
result = _value.alias->setDoubleValue(value);
|
|
break;
|
|
case BOOL:
|
|
result = set_bool(value == 0.0L ? false : true);
|
|
break;
|
|
case INT:
|
|
result = set_int(int(value));
|
|
break;
|
|
case LONG:
|
|
result = set_long(long(value));
|
|
break;
|
|
case FLOAT:
|
|
result = set_float(float(value));
|
|
break;
|
|
case DOUBLE:
|
|
result = set_double(value);
|
|
break;
|
|
case STRING:
|
|
case UNSPECIFIED: {
|
|
char buf[128];
|
|
sprintf(buf, "%f", value);
|
|
result = set_string(buf);
|
|
break;
|
|
}
|
|
case NONE:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (getAttribute(TRACE_WRITE))
|
|
trace_write();
|
|
return result;
|
|
}
|
|
|
|
bool
|
|
SGPropertyNode::setStringValue (const char * value)
|
|
{
|
|
// Shortcut for common case
|
|
if (_attr == (READ|WRITE) && _type == STRING)
|
|
return set_string(value);
|
|
|
|
bool result = false;
|
|
TEST_WRITE;
|
|
if (_type == NONE || _type == UNSPECIFIED) {
|
|
clear_value();
|
|
_type = STRING;
|
|
}
|
|
|
|
switch (_type) {
|
|
case ALIAS:
|
|
result = _value.alias->setStringValue(value);
|
|
break;
|
|
case BOOL:
|
|
result = set_bool((compare_strings(value, "true")
|
|
|| atoi(value)) ? true : false);
|
|
break;
|
|
case INT:
|
|
result = set_int(atoi(value));
|
|
break;
|
|
case LONG:
|
|
result = set_long(strtol(value, 0, 0));
|
|
break;
|
|
case FLOAT:
|
|
result = set_float(atof(value));
|
|
break;
|
|
case DOUBLE:
|
|
result = set_double(strtod(value, 0));
|
|
break;
|
|
case STRING:
|
|
case UNSPECIFIED:
|
|
result = set_string(value);
|
|
break;
|
|
case NONE:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (getAttribute(TRACE_WRITE))
|
|
trace_write();
|
|
return result;
|
|
}
|
|
|
|
bool
|
|
SGPropertyNode::setUnspecifiedValue (const char * value)
|
|
{
|
|
bool result = false;
|
|
TEST_WRITE;
|
|
if (_type == NONE) {
|
|
clear_value();
|
|
_type = UNSPECIFIED;
|
|
}
|
|
|
|
switch (_type) {
|
|
case ALIAS:
|
|
result = _value.alias->setUnspecifiedValue(value);
|
|
break;
|
|
case BOOL:
|
|
result = set_bool((compare_strings(value, "true")
|
|
|| atoi(value)) ? true : false);
|
|
break;
|
|
case INT:
|
|
result = set_int(atoi(value));
|
|
break;
|
|
case LONG:
|
|
result = set_long(strtol(value, 0, 0));
|
|
break;
|
|
case FLOAT:
|
|
result = set_float(atof(value));
|
|
break;
|
|
case DOUBLE:
|
|
result = set_double(strtod(value, 0));
|
|
break;
|
|
case STRING:
|
|
case UNSPECIFIED:
|
|
result = set_string(value);
|
|
break;
|
|
case NONE:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (getAttribute(TRACE_WRITE))
|
|
trace_write();
|
|
return result;
|
|
}
|
|
|
|
bool
|
|
SGPropertyNode::tie (const SGRawValue<bool> &rawValue, bool useDefault)
|
|
{
|
|
if (_type == ALIAS || _tied)
|
|
return false;
|
|
|
|
useDefault = useDefault && hasValue();
|
|
bool old_val = false;
|
|
if (useDefault)
|
|
old_val = getBoolValue();
|
|
|
|
clear_value();
|
|
_type = BOOL;
|
|
_tied = true;
|
|
_value.bool_val = rawValue.clone();
|
|
|
|
if (useDefault)
|
|
setBoolValue(old_val);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
SGPropertyNode::tie (const SGRawValue<int> &rawValue, bool useDefault)
|
|
{
|
|
if (_type == ALIAS || _tied)
|
|
return false;
|
|
|
|
useDefault = useDefault && hasValue();
|
|
int old_val = 0;
|
|
if (useDefault)
|
|
old_val = getIntValue();
|
|
|
|
clear_value();
|
|
_type = INT;
|
|
_tied = true;
|
|
_value.int_val = rawValue.clone();
|
|
|
|
if (useDefault)
|
|
setIntValue(old_val);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
SGPropertyNode::tie (const SGRawValue<long> &rawValue, bool useDefault)
|
|
{
|
|
if (_type == ALIAS || _tied)
|
|
return false;
|
|
|
|
useDefault = useDefault && hasValue();
|
|
long old_val = 0;
|
|
if (useDefault)
|
|
old_val = getLongValue();
|
|
|
|
clear_value();
|
|
_type = LONG;
|
|
_tied = true;
|
|
_value.long_val = rawValue.clone();
|
|
|
|
if (useDefault)
|
|
setLongValue(old_val);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
SGPropertyNode::tie (const SGRawValue<float> &rawValue, bool useDefault)
|
|
{
|
|
if (_type == ALIAS || _tied)
|
|
return false;
|
|
|
|
useDefault = useDefault && hasValue();
|
|
float old_val = 0.0;
|
|
if (useDefault)
|
|
old_val = getFloatValue();
|
|
|
|
clear_value();
|
|
_type = FLOAT;
|
|
_tied = true;
|
|
_value.float_val = rawValue.clone();
|
|
|
|
if (useDefault)
|
|
setFloatValue(old_val);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
SGPropertyNode::tie (const SGRawValue<double> &rawValue, bool useDefault)
|
|
{
|
|
if (_type == ALIAS || _tied)
|
|
return false;
|
|
|
|
useDefault = useDefault && hasValue();
|
|
double old_val = 0.0;
|
|
if (useDefault)
|
|
old_val = getDoubleValue();
|
|
|
|
clear_value();
|
|
_type = DOUBLE;
|
|
_tied = true;
|
|
_value.double_val = rawValue.clone();
|
|
|
|
if (useDefault)
|
|
setDoubleValue(old_val);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool
|
|
SGPropertyNode::tie (const SGRawValue<const char *> &rawValue, bool useDefault)
|
|
{
|
|
if (_type == ALIAS || _tied)
|
|
return false;
|
|
|
|
useDefault = useDefault && hasValue();
|
|
string old_val;
|
|
if (useDefault)
|
|
old_val = getStringValue();
|
|
|
|
clear_value();
|
|
_type = STRING;
|
|
_tied = true;
|
|
_value.string_val = rawValue.clone();
|
|
|
|
if (useDefault)
|
|
setStringValue(old_val.c_str());
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
SGPropertyNode::untie ()
|
|
{
|
|
if (!_tied)
|
|
return false;
|
|
|
|
switch (_type) {
|
|
case BOOL: {
|
|
bool val = getBoolValue();
|
|
clear_value();
|
|
_type = BOOL;
|
|
_local_val.bool_val = val;
|
|
break;
|
|
}
|
|
case INT: {
|
|
int val = getIntValue();
|
|
clear_value();
|
|
_type = INT;
|
|
_local_val.int_val = val;
|
|
break;
|
|
}
|
|
case LONG: {
|
|
long val = getLongValue();
|
|
clear_value();
|
|
_type = LONG;
|
|
_local_val.long_val = val;
|
|
break;
|
|
}
|
|
case FLOAT: {
|
|
float val = getFloatValue();
|
|
clear_value();
|
|
_type = FLOAT;
|
|
_local_val.float_val = val;
|
|
break;
|
|
}
|
|
case DOUBLE: {
|
|
double val = getDoubleValue();
|
|
clear_value();
|
|
_type = DOUBLE;
|
|
_local_val.double_val = val;
|
|
break;
|
|
}
|
|
case STRING:
|
|
case UNSPECIFIED: {
|
|
string val = getStringValue();
|
|
clear_value();
|
|
_type = STRING;
|
|
_local_val.string_val = copy_string(val.c_str());
|
|
break;
|
|
}
|
|
case NONE:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
_tied = false;
|
|
return true;
|
|
}
|
|
|
|
SGPropertyNode *
|
|
SGPropertyNode::getRootNode ()
|
|
{
|
|
if (_parent == 0)
|
|
return this;
|
|
else
|
|
return _parent->getRootNode();
|
|
}
|
|
|
|
const SGPropertyNode *
|
|
SGPropertyNode::getRootNode () const
|
|
{
|
|
if (_parent == 0)
|
|
return this;
|
|
else
|
|
return _parent->getRootNode();
|
|
}
|
|
|
|
SGPropertyNode *
|
|
SGPropertyNode::getNode (const char * relative_path, bool create)
|
|
{
|
|
if (_path_cache == 0)
|
|
_path_cache = new hash_table;
|
|
|
|
SGPropertyNode * result = _path_cache->get(relative_path);
|
|
if (result == 0) {
|
|
vector<PathComponent> components;
|
|
parse_path(relative_path, components);
|
|
result = find_node(this, components, 0, create);
|
|
if (result != 0)
|
|
_path_cache->put(relative_path, result);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
SGPropertyNode *
|
|
SGPropertyNode::getNode (const char * relative_path, int index, bool create)
|
|
{
|
|
vector<PathComponent> components;
|
|
parse_path(relative_path, components);
|
|
if (components.size() > 0)
|
|
components[components.size()-1].index = index;
|
|
return find_node(this, components, 0, create);
|
|
}
|
|
|
|
const SGPropertyNode *
|
|
SGPropertyNode::getNode (const char * relative_path) const
|
|
{
|
|
return ((SGPropertyNode *)this)->getNode(relative_path, false);
|
|
}
|
|
|
|
const SGPropertyNode *
|
|
SGPropertyNode::getNode (const char * relative_path, int index) const
|
|
{
|
|
return ((SGPropertyNode *)this)->getNode(relative_path, index, false);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Convenience methods using relative paths.
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
/**
|
|
* Test whether another node has a value attached.
|
|
*/
|
|
bool
|
|
SGPropertyNode::hasValue (const char * relative_path) const
|
|
{
|
|
const SGPropertyNode * node = getNode(relative_path);
|
|
return (node == 0 ? false : node->hasValue());
|
|
}
|
|
|
|
|
|
/**
|
|
* Get the value type for another node.
|
|
*/
|
|
SGPropertyNode::Type
|
|
SGPropertyNode::getType (const char * relative_path) const
|
|
{
|
|
const SGPropertyNode * node = getNode(relative_path);
|
|
return (node == 0 ? UNSPECIFIED : (Type)(node->getType()));
|
|
}
|
|
|
|
|
|
/**
|
|
* Get a bool value for another node.
|
|
*/
|
|
bool
|
|
SGPropertyNode::getBoolValue (const char * relative_path,
|
|
bool defaultValue) const
|
|
{
|
|
const SGPropertyNode * node = getNode(relative_path);
|
|
return (node == 0 ? defaultValue : node->getBoolValue());
|
|
}
|
|
|
|
|
|
/**
|
|
* Get an int value for another node.
|
|
*/
|
|
int
|
|
SGPropertyNode::getIntValue (const char * relative_path,
|
|
int defaultValue) const
|
|
{
|
|
const SGPropertyNode * node = getNode(relative_path);
|
|
return (node == 0 ? defaultValue : node->getIntValue());
|
|
}
|
|
|
|
|
|
/**
|
|
* Get a long value for another node.
|
|
*/
|
|
long
|
|
SGPropertyNode::getLongValue (const char * relative_path,
|
|
long defaultValue) const
|
|
{
|
|
const SGPropertyNode * node = getNode(relative_path);
|
|
return (node == 0 ? defaultValue : node->getLongValue());
|
|
}
|
|
|
|
|
|
/**
|
|
* Get a float value for another node.
|
|
*/
|
|
float
|
|
SGPropertyNode::getFloatValue (const char * relative_path,
|
|
float defaultValue) const
|
|
{
|
|
const SGPropertyNode * node = getNode(relative_path);
|
|
return (node == 0 ? defaultValue : node->getFloatValue());
|
|
}
|
|
|
|
|
|
/**
|
|
* Get a double value for another node.
|
|
*/
|
|
double
|
|
SGPropertyNode::getDoubleValue (const char * relative_path,
|
|
double defaultValue) const
|
|
{
|
|
const SGPropertyNode * node = getNode(relative_path);
|
|
return (node == 0 ? defaultValue : node->getDoubleValue());
|
|
}
|
|
|
|
|
|
/**
|
|
* Get a string value for another node.
|
|
*/
|
|
const char *
|
|
SGPropertyNode::getStringValue (const char * relative_path,
|
|
const char * defaultValue) const
|
|
{
|
|
const SGPropertyNode * node = getNode(relative_path);
|
|
return (node == 0 ? defaultValue : node->getStringValue());
|
|
}
|
|
|
|
|
|
/**
|
|
* Set a bool value for another node.
|
|
*/
|
|
bool
|
|
SGPropertyNode::setBoolValue (const char * relative_path, bool value)
|
|
{
|
|
return getNode(relative_path, true)->setBoolValue(value);
|
|
}
|
|
|
|
|
|
/**
|
|
* Set an int value for another node.
|
|
*/
|
|
bool
|
|
SGPropertyNode::setIntValue (const char * relative_path, int value)
|
|
{
|
|
return getNode(relative_path, true)->setIntValue(value);
|
|
}
|
|
|
|
|
|
/**
|
|
* Set a long value for another node.
|
|
*/
|
|
bool
|
|
SGPropertyNode::setLongValue (const char * relative_path, long value)
|
|
{
|
|
return getNode(relative_path, true)->setLongValue(value);
|
|
}
|
|
|
|
|
|
/**
|
|
* Set a float value for another node.
|
|
*/
|
|
bool
|
|
SGPropertyNode::setFloatValue (const char * relative_path, float value)
|
|
{
|
|
return getNode(relative_path, true)->setFloatValue(value);
|
|
}
|
|
|
|
|
|
/**
|
|
* Set a double value for another node.
|
|
*/
|
|
bool
|
|
SGPropertyNode::setDoubleValue (const char * relative_path, double value)
|
|
{
|
|
return getNode(relative_path, true)->setDoubleValue(value);
|
|
}
|
|
|
|
|
|
/**
|
|
* Set a string value for another node.
|
|
*/
|
|
bool
|
|
SGPropertyNode::setStringValue (const char * relative_path, const char * value)
|
|
{
|
|
return getNode(relative_path, true)->setStringValue(value);
|
|
}
|
|
|
|
|
|
/**
|
|
* Set an unknown value for another node.
|
|
*/
|
|
bool
|
|
SGPropertyNode::setUnspecifiedValue (const char * relative_path,
|
|
const char * value)
|
|
{
|
|
return getNode(relative_path, true)->setUnspecifiedValue(value);
|
|
}
|
|
|
|
|
|
/**
|
|
* Test whether another node is tied.
|
|
*/
|
|
bool
|
|
SGPropertyNode::isTied (const char * relative_path) const
|
|
{
|
|
const SGPropertyNode * node = getNode(relative_path);
|
|
return (node == 0 ? false : node->isTied());
|
|
}
|
|
|
|
|
|
/**
|
|
* Tie a node reached by a relative path, creating it if necessary.
|
|
*/
|
|
bool
|
|
SGPropertyNode::tie (const char * relative_path,
|
|
const SGRawValue<bool> &rawValue,
|
|
bool useDefault)
|
|
{
|
|
return getNode(relative_path, true)->tie(rawValue, useDefault);
|
|
}
|
|
|
|
|
|
/**
|
|
* Tie a node reached by a relative path, creating it if necessary.
|
|
*/
|
|
bool
|
|
SGPropertyNode::tie (const char * relative_path,
|
|
const SGRawValue<int> &rawValue,
|
|
bool useDefault)
|
|
{
|
|
return getNode(relative_path, true)->tie(rawValue, useDefault);
|
|
}
|
|
|
|
|
|
/**
|
|
* Tie a node reached by a relative path, creating it if necessary.
|
|
*/
|
|
bool
|
|
SGPropertyNode::tie (const char * relative_path,
|
|
const SGRawValue<long> &rawValue,
|
|
bool useDefault)
|
|
{
|
|
return getNode(relative_path, true)->tie(rawValue, useDefault);
|
|
}
|
|
|
|
|
|
/**
|
|
* Tie a node reached by a relative path, creating it if necessary.
|
|
*/
|
|
bool
|
|
SGPropertyNode::tie (const char * relative_path,
|
|
const SGRawValue<float> &rawValue,
|
|
bool useDefault)
|
|
{
|
|
return getNode(relative_path, true)->tie(rawValue, useDefault);
|
|
}
|
|
|
|
|
|
/**
|
|
* Tie a node reached by a relative path, creating it if necessary.
|
|
*/
|
|
bool
|
|
SGPropertyNode::tie (const char * relative_path,
|
|
const SGRawValue<double> &rawValue,
|
|
bool useDefault)
|
|
{
|
|
return getNode(relative_path, true)->tie(rawValue, useDefault);
|
|
}
|
|
|
|
|
|
/**
|
|
* Tie a node reached by a relative path, creating it if necessary.
|
|
*/
|
|
bool
|
|
SGPropertyNode::tie (const char * relative_path,
|
|
const SGRawValue<const char *> &rawValue,
|
|
bool useDefault)
|
|
{
|
|
return getNode(relative_path, true)->tie(rawValue, useDefault);
|
|
}
|
|
|
|
|
|
/**
|
|
* Attempt to untie another node reached by a relative path.
|
|
*/
|
|
bool
|
|
SGPropertyNode::untie (const char * relative_path)
|
|
{
|
|
SGPropertyNode * node = getNode(relative_path);
|
|
return (node == 0 ? false : node->untie());
|
|
}
|
|
|
|
void
|
|
SGPropertyNode::addChangeListener (SGPropertyChangeListener * listener)
|
|
{
|
|
if (_listeners == 0)
|
|
_listeners = new vector<SGPropertyChangeListener *>;
|
|
_listeners->push_back(listener);
|
|
listener->register_property(this);
|
|
}
|
|
|
|
void
|
|
SGPropertyNode::removeChangeListener (SGPropertyChangeListener * listener)
|
|
{
|
|
vector<SGPropertyChangeListener *>::iterator it =
|
|
find(_listeners->begin(), _listeners->end(), listener);
|
|
if (it != _listeners->end()) {
|
|
_listeners->erase(it);
|
|
listener->unregister_property(this);
|
|
if (_listeners->empty()) {
|
|
vector<SGPropertyChangeListener *> * tmp = _listeners;
|
|
_listeners = 0;
|
|
delete tmp;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
SGPropertyNode::fireValueChanged ()
|
|
{
|
|
fireValueChanged(this);
|
|
}
|
|
|
|
void
|
|
SGPropertyNode::fireChildAdded (SGPropertyNode * child)
|
|
{
|
|
fireChildAdded(this, child);
|
|
}
|
|
|
|
void
|
|
SGPropertyNode::fireChildRemoved (SGPropertyNode * child)
|
|
{
|
|
fireChildRemoved(this, child);
|
|
}
|
|
|
|
void
|
|
SGPropertyNode::fireValueChanged (SGPropertyNode * node)
|
|
{
|
|
if (_listeners != 0) {
|
|
for (unsigned int i = 0; i < _listeners->size(); i++) {
|
|
(*_listeners)[i]->valueChanged(node);
|
|
}
|
|
}
|
|
if (_parent != 0)
|
|
_parent->fireValueChanged(node);
|
|
}
|
|
|
|
void
|
|
SGPropertyNode::fireChildAdded (SGPropertyNode * parent,
|
|
SGPropertyNode * child)
|
|
{
|
|
if (_listeners != 0) {
|
|
for (unsigned int i = 0; i < _listeners->size(); i++) {
|
|
(*_listeners)[i]->childAdded(parent, child);
|
|
}
|
|
}
|
|
if (_parent != 0)
|
|
_parent->fireChildAdded(parent, child);
|
|
}
|
|
|
|
void
|
|
SGPropertyNode::fireChildRemoved (SGPropertyNode * parent,
|
|
SGPropertyNode * child)
|
|
{
|
|
if (_listeners != 0) {
|
|
for (unsigned int i = 0; i < _listeners->size(); i++) {
|
|
(*_listeners)[i]->childRemoved(parent, child);
|
|
}
|
|
}
|
|
if (_parent != 0)
|
|
_parent->fireChildRemoved(parent, child);
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Simplified hash table for caching paths.
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
#define HASH_TABLE_SIZE 199
|
|
|
|
SGPropertyNode::hash_table::entry::entry ()
|
|
: _key(0),
|
|
_value(0)
|
|
{
|
|
}
|
|
|
|
SGPropertyNode::hash_table::entry::~entry ()
|
|
{
|
|
// Don't delete the value; we don't own
|
|
// the pointer.
|
|
delete [] _key;
|
|
}
|
|
|
|
void
|
|
SGPropertyNode::hash_table::entry::set_key (const char * key)
|
|
{
|
|
_key = copy_string(key);
|
|
}
|
|
|
|
void
|
|
SGPropertyNode::hash_table::entry::set_value (SGPropertyNode * value)
|
|
{
|
|
_value = value;
|
|
}
|
|
|
|
SGPropertyNode::hash_table::bucket::bucket ()
|
|
: _length(0),
|
|
_entries(0)
|
|
{
|
|
}
|
|
|
|
SGPropertyNode::hash_table::bucket::~bucket ()
|
|
{
|
|
for (int i = 0; i < _length; i++)
|
|
delete _entries[i];
|
|
}
|
|
|
|
SGPropertyNode::hash_table::entry *
|
|
SGPropertyNode::hash_table::bucket::get_entry (const char * key, bool create)
|
|
{
|
|
int i;
|
|
for (i = 0; i < _length; i++) {
|
|
if (!strcmp(_entries[i]->get_key(), key))
|
|
return _entries[i];
|
|
}
|
|
if (create) {
|
|
entry ** new_entries = new entry*[_length+1];
|
|
for (i = 0; i < _length; i++) {
|
|
new_entries[i] = _entries[i];
|
|
}
|
|
delete [] _entries;
|
|
_entries = new_entries;
|
|
_entries[_length] = new entry;
|
|
_entries[_length]->set_key(key);
|
|
_length++;
|
|
return _entries[_length - 1];
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
SGPropertyNode::hash_table::hash_table ()
|
|
: _data_length(0),
|
|
_data(0)
|
|
{
|
|
}
|
|
|
|
SGPropertyNode::hash_table::~hash_table ()
|
|
{
|
|
for (unsigned int i = 0; i < _data_length; i++)
|
|
delete _data[i];
|
|
}
|
|
|
|
SGPropertyNode *
|
|
SGPropertyNode::hash_table::get (const char * key)
|
|
{
|
|
if (_data_length == 0)
|
|
return 0;
|
|
unsigned int index = hashcode(key) % _data_length;
|
|
if (_data[index] == 0)
|
|
return 0;
|
|
entry * e = _data[index]->get_entry(key);
|
|
if (e == 0)
|
|
return 0;
|
|
else
|
|
return e->get_value();
|
|
}
|
|
|
|
void
|
|
SGPropertyNode::hash_table::put (const char * key, SGPropertyNode * value)
|
|
{
|
|
if (_data_length == 0) {
|
|
_data = new bucket*[HASH_TABLE_SIZE];
|
|
_data_length = HASH_TABLE_SIZE;
|
|
for (unsigned int i = 0; i < HASH_TABLE_SIZE; i++)
|
|
_data[i] = 0;
|
|
}
|
|
unsigned int index = hashcode(key) % _data_length;
|
|
if (_data[index] == 0) {
|
|
_data[index] = new bucket;
|
|
}
|
|
entry * e = _data[index]->get_entry(key, true);
|
|
e->set_value(value);
|
|
}
|
|
|
|
unsigned int
|
|
SGPropertyNode::hash_table::hashcode (const char * key)
|
|
{
|
|
unsigned int hash = 0;
|
|
while (*key != 0) {
|
|
hash = 31 * hash + *key;
|
|
key++;
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Default constructor
|
|
*/
|
|
SGPropertyNode_ptr::SGPropertyNode_ptr()
|
|
{
|
|
_ptr = 0;
|
|
}
|
|
|
|
/**
|
|
* Copy constructor
|
|
*/
|
|
SGPropertyNode_ptr::SGPropertyNode_ptr( const SGPropertyNode_ptr &r )
|
|
{
|
|
_ptr = r._ptr;
|
|
if (_ptr)
|
|
_ptr->incrementRef();
|
|
}
|
|
|
|
/**
|
|
* Constructor from a pointer to a node
|
|
*/
|
|
SGPropertyNode_ptr::SGPropertyNode_ptr( SGPropertyNode *p )
|
|
{
|
|
_ptr = p;
|
|
if (_ptr)
|
|
_ptr->incrementRef();
|
|
}
|
|
|
|
/**
|
|
* Destructor
|
|
*/
|
|
SGPropertyNode_ptr::~SGPropertyNode_ptr()
|
|
{
|
|
if (_ptr && _ptr->decrementRef() == 0)
|
|
delete _ptr;
|
|
}
|
|
|
|
/**
|
|
* Assignement operator
|
|
*/
|
|
SGPropertyNode_ptr &
|
|
SGPropertyNode_ptr::operator=( const SGPropertyNode_ptr &r )
|
|
{
|
|
if (_ptr && _ptr->decrementRef() == 0)
|
|
delete _ptr;
|
|
_ptr = r._ptr;
|
|
if (_ptr)
|
|
_ptr->incrementRef();
|
|
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* Pointer access operator
|
|
*/
|
|
SGPropertyNode *
|
|
SGPropertyNode_ptr::operator->()
|
|
{
|
|
return _ptr;
|
|
}
|
|
|
|
/**
|
|
* Pointer access operator (const)
|
|
*/
|
|
const SGPropertyNode *
|
|
SGPropertyNode_ptr::operator->() const
|
|
{
|
|
return _ptr;
|
|
}
|
|
|
|
/**
|
|
* Conversion to SGPropertyNode * operator
|
|
*/
|
|
SGPropertyNode_ptr::operator SGPropertyNode *()
|
|
{
|
|
return _ptr;
|
|
}
|
|
|
|
/**
|
|
* Conversion to const SGPropertyNode * operator
|
|
*/
|
|
SGPropertyNode_ptr::operator const SGPropertyNode *() const
|
|
{
|
|
return _ptr;
|
|
}
|
|
|
|
/**
|
|
* Validity test
|
|
*/
|
|
bool
|
|
SGPropertyNode_ptr::valid() const
|
|
{
|
|
return _ptr != 0;
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Implementation of SGPropertyChangeListener.
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
SGPropertyChangeListener::~SGPropertyChangeListener ()
|
|
{
|
|
// This will come back and remove
|
|
// the current item each time. Is
|
|
// that OK?
|
|
vector<SGPropertyNode *>::iterator it;
|
|
for (it = _properties.begin(); it != _properties.end(); it++)
|
|
(*it)->removeChangeListener(this);
|
|
}
|
|
|
|
void
|
|
SGPropertyChangeListener::valueChanged (SGPropertyNode * node)
|
|
{
|
|
// NO-OP
|
|
}
|
|
|
|
void
|
|
SGPropertyChangeListener::childAdded (SGPropertyNode * node,
|
|
SGPropertyNode * child)
|
|
{
|
|
// NO-OP
|
|
}
|
|
|
|
void
|
|
SGPropertyChangeListener::childRemoved (SGPropertyNode * parent,
|
|
SGPropertyNode * child)
|
|
{
|
|
// NO-OP
|
|
}
|
|
|
|
void
|
|
SGPropertyChangeListener::register_property (SGPropertyNode * node)
|
|
{
|
|
_properties.push_back(node);
|
|
}
|
|
|
|
void
|
|
SGPropertyChangeListener::unregister_property (SGPropertyNode * node)
|
|
{
|
|
vector<SGPropertyNode *>::iterator it =
|
|
find(_properties.begin(), _properties.end(), node);
|
|
if (it != _properties.end())
|
|
_properties.erase(it);
|
|
}
|
|
|
|
|
|
// end of props.cxx
|