SG_USING_STD(find);
SG_USING_STD(vector);
-#ifdef _MSC_VER
-// MSVC is buggy, and needs something strange here
+#if ( _MSC_VER == 1200 )
+// MSVC 6 is buggy, and needs something strange here
SG_USING_STD(vector<SGPropertyNode_ptr>);
SG_USING_STD(vector<SGPropertyChangeListener *>);
SG_USING_STD(vector<SGPropertyNode *>);
// 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 = "";
+template<> const bool SGRawValue<bool>::DefaultValue = false;
+template<> const int SGRawValue<int>::DefaultValue = 0;
+template<> const long SGRawValue<long>::DefaultValue = 0L;
+template<> const float SGRawValue<float>::DefaultValue = 0.0;
+template<> const double SGRawValue<double>::DefaultValue = 0.0L;
+template<> const char * const SGRawValue<const char *>::DefaultValue = "";
\f
name = ".";
}
if (i < max && path[i] != '/')
- throw string(string("Illegal character after ") + name);
+ throw string("Illegal character after " + name);
}
else if (isalpha(path[i]) || path[i] == '_') {
// Success! This is the one we want.
else if (position >= (int)components.size()) {
- return current;
+ return (current->getAttribute(SGPropertyNode::REMOVED) ? 0 : current);
}
// Empty component means root.
}
void
-SGPropertyNode::clear_value ()
+SGPropertyNode::clearValue ()
{
switch (_type) {
case NONE:
delete [] _display_name;
delete [] _path;
delete _path_cache;
- clear_value();
+ clearValue();
delete _listeners;
}
{
if (target == 0 || _type == ALIAS || _tied)
return false;
- clear_value();
+ clearValue();
_value.alias = target;
_type = ALIAS;
return true;
if (keep) {
_removedChildren.push_back(node);
}
+ if (_path_cache)
+ _path_cache->erase(name); // EMH - TODO: Take "index" into account!
node->setAttribute(REMOVED, true);
+ node->clearValue();
ret = node;
fireChildRemoved(node);
}
bool result = false;
TEST_WRITE;
if (_type == NONE || _type == UNSPECIFIED) {
- clear_value();
+ clearValue();
_tied = false;
_type = BOOL;
}
bool result = false;
TEST_WRITE;
if (_type == NONE || _type == UNSPECIFIED) {
- clear_value();
+ clearValue();
_type = INT;
_local_val.int_val = 0;
}
bool result = false;
TEST_WRITE;
if (_type == NONE || _type == UNSPECIFIED) {
- clear_value();
+ clearValue();
_type = LONG;
_local_val.long_val = 0L;
}
bool result = false;
TEST_WRITE;
if (_type == NONE || _type == UNSPECIFIED) {
- clear_value();
+ clearValue();
_type = FLOAT;
_local_val.float_val = 0;
}
bool result = false;
TEST_WRITE;
if (_type == NONE || _type == UNSPECIFIED) {
- clear_value();
+ clearValue();
_local_val.double_val = value;
_type = DOUBLE;
}
bool result = false;
TEST_WRITE;
if (_type == NONE || _type == UNSPECIFIED) {
- clear_value();
+ clearValue();
_type = STRING;
}
bool result = false;
TEST_WRITE;
if (_type == NONE) {
- clear_value();
+ clearValue();
_type = UNSPECIFIED;
}
if (useDefault)
old_val = getBoolValue();
- clear_value();
+ clearValue();
_type = BOOL;
_tied = true;
_value.bool_val = rawValue.clone();
if (useDefault)
old_val = getIntValue();
- clear_value();
+ clearValue();
_type = INT;
_tied = true;
_value.int_val = rawValue.clone();
if (useDefault)
old_val = getLongValue();
- clear_value();
+ clearValue();
_type = LONG;
_tied = true;
_value.long_val = rawValue.clone();
if (useDefault)
old_val = getFloatValue();
- clear_value();
+ clearValue();
_type = FLOAT;
_tied = true;
_value.float_val = rawValue.clone();
if (useDefault)
old_val = getDoubleValue();
- clear_value();
+ clearValue();
_type = DOUBLE;
_tied = true;
_value.double_val = rawValue.clone();
if (useDefault)
old_val = getStringValue();
- clear_value();
+ clearValue();
_type = STRING;
_tied = true;
_value.string_val = rawValue.clone();
switch (_type) {
case BOOL: {
bool val = getBoolValue();
- clear_value();
+ clearValue();
_type = BOOL;
_local_val.bool_val = val;
break;
}
case INT: {
int val = getIntValue();
- clear_value();
+ clearValue();
_type = INT;
_local_val.int_val = val;
break;
}
case LONG: {
long val = getLongValue();
- clear_value();
+ clearValue();
_type = LONG;
_local_val.long_val = val;
break;
}
case FLOAT: {
float val = getFloatValue();
- clear_value();
+ clearValue();
_type = FLOAT;
_local_val.float_val = val;
break;
}
case DOUBLE: {
double val = getDoubleValue();
- clear_value();
+ clearValue();
_type = DOUBLE;
_local_val.double_val = val;
break;
case STRING:
case UNSPECIFIED: {
string val = getStringValue();
- clear_value();
+ clearValue();
_type = STRING;
_local_val.string_val = copy_string(val.c_str());
break;
vector<PathComponent> components;
parse_path(relative_path, components);
if (components.size() > 0)
- components[components.size()-1].index = index;
+ components.back().index = index;
return find_node(this, components, 0, create);
}
}
}
+void
+SGPropertyNode::hash_table::bucket::erase (const char * key)
+{
+ int i;
+ for (i = 0; i < _length; i++) {
+ if (!strcmp(_entries[i]->get_key(), key))
+ break;
+ }
+
+ if (i < _length) {
+ for (++i; i < _length; i++) {
+ _entries[i-1] = _entries[i];
+ }
+ _length--;
+ }
+}
+
SGPropertyNode::hash_table::hash_table ()
: _data_length(0),
e->set_value(value);
}
+void
+SGPropertyNode::hash_table::erase (const char * key)
+{
+ if (_data_length == 0)
+ return;
+ unsigned int index = hashcode(key) % _data_length;
+ if (_data[index] == 0)
+ return;
+ _data[index]->erase(key);
+}
+
unsigned int
SGPropertyNode::hash_table::hashcode (const char * key)
{