Patch from Frederic Bouvier:

[simgear.git] / simgear / misc / props.cxx

diff --git a/simgear/misc/props.cxx b/simgear/misc/props.cxx
index 9aeb2385450b8c1e0678dc824dacc35cfa6dec13..19cb3a98d38dfb62d2599782767ed93cfd5fcc93 100644 (file)
--- a/simgear/misc/props.cxx
+++ b/simgear/misc/props.cxx
@@ -215,7 +215,7 @@ parse_path (const string &path, vector<PathComponent> &components)
 ////////////////////////////////////////////////////////////////////////
 
 
-static const char *
+static char *
 copy_string (const char * s)
 {
                                // FIXME: potential buffer overflow.
@@ -417,7 +417,7 @@ SGPropertyNode::set_string (const char * val)
   if (_tied) {
     return _value.string_val->setValue(val);
   } else {
-    delete [] (char *)_local_val.string_val;
+    delete [] _local_val.string_val;
     _local_val.string_val = copy_string(val);
     return true;
   }
@@ -473,7 +473,7 @@ SGPropertyNode::clear_value ()
       delete _value.string_val;
       _value.string_val = 0;
     } else {
-      delete [] (char *)_local_val.string_val;
+      delete [] _local_val.string_val;
     }
     _local_val.string_val = 0;
     break;
@@ -675,11 +675,11 @@ SGPropertyNode::SGPropertyNode (const char * name,
  */
 SGPropertyNode::~SGPropertyNode ()
 {
-  delete [] (char *)_name;
+  delete [] _name;
   for (int i = 0; i < (int)_children.size(); i++) {
     delete _children[i];
   }
-//   delete _path_cache;
+  delete _path_cache;
   clear_value();
 }
 
@@ -1598,22 +1598,19 @@ SGPropertyNode::getRootNode () const
 SGPropertyNode *
 SGPropertyNode::getNode (const char * relative_path, bool create)
 {
-//   if (_path_cache == 0)
-//     _path_cache = new cache_map;
-
-//   SGPropertyNode * result = (*_path_cache)[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)[relative_path] = result;
-//   }
+  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;
-  vector<PathComponent> components;
-  parse_path(relative_path, components);
-  return find_node(this, components, 0, create);
+  return result;
 }
 
 SGPropertyNode *
@@ -1902,4 +1899,129 @@ SGPropertyNode::untie (const char * relative_path)
   return (node == 0 ? false : node->untie());
 }
 
+
+\f
+////////////////////////////////////////////////////////////////////////
+// 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 (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;
+}
+
 // end of props.cxx