Extend properties to support new property types.

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

diff --git a/simgear/props/props_io.cxx b/simgear/props/props_io.cxx
index d661223784a1b19ca2d217f0787ebdb1e70d1f18..881abe8c931e22baf382af8367bb861fbb2cd4eb 100644 (file)
--- a/simgear/props/props_io.cxx
+++ b/simgear/props/props_io.cxx
@@ -24,19 +24,20 @@
 #include "props.hxx"
 #include "props_io.hxx"
 
-#include STL_IOSTREAM
-#include STL_FSTREAM
-#include STL_STRING
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <cstring>             // strcmp()
 #include <vector>
 #include <map>
 
-SG_USING_STD(istream);
-SG_USING_STD(ifstream);
-SG_USING_STD(ostream);
-SG_USING_STD(ofstream);
-SG_USING_STD(string);
-SG_USING_STD(vector);
-SG_USING_STD(map);
+using std::istream;
+using std::ifstream;
+using std::ostream;
+using std::ofstream;
+using std::string;
+using std::vector;
+using std::map;
 
 using std::endl;
 
@@ -75,22 +76,23 @@ private:
 
   struct State
   {
-    State () : node(0), type(""), mode(DEFAULT_MODE) {}
-    State (SGPropertyNode * _node, const char * _type, int _mode)
-      : node(_node), type(_type), mode(_mode) {}
+    State () : node(0), type(""), mode(DEFAULT_MODE), omit(false) {}
+    State (SGPropertyNode * _node, const char * _type, int _mode, bool _omit)
+      : node(_node), type(_type), mode(_mode), omit(_omit) {}
     SGPropertyNode * node;
     string type;
     int mode;
+    bool omit;
     map<string,int> counters;
   };
 
   State &state () { return _state_stack[_state_stack.size() - 1]; }
 
-  void push_state (SGPropertyNode * node, const char * type, int mode) {
+  void push_state (SGPropertyNode * node, const char * type, int mode, bool omit = false) {
     if (type == 0)
-      _state_stack.push_back(State(node, "unspecified", mode));
+      _state_stack.push_back(State(node, "unspecified", mode, omit));
     else
-      _state_stack.push_back(State(node, type, mode));
+      _state_stack.push_back(State(node, type, mode, omit));
     _level++;
     _data = "";
   }
@@ -103,6 +105,7 @@ private:
   int _default_mode;
   string _data;
   SGPropertyNode * _root;
+  SGPropertyNode null;
   int _level;
   vector<State> _state_stack;
   string _base;
@@ -189,6 +192,11 @@ PropsVisitor::startElement (const char * name, const XMLAttributes &atts)
 
                                // Got the index, so grab the node.
     SGPropertyNode * node = st.node->getChild(name, index, true);
+    if (!node->getAttribute(SGPropertyNode::WRITE)) {
+      SG_LOG(SG_INPUT, SG_ALERT, "Not overwriting write-protected property "
+          << node->getPath(true));
+      node = &null;
+    }
 
                                // Get the access-mode attributes,
                                // but don't set yet (in case they
@@ -222,6 +230,7 @@ PropsVisitor::startElement (const char * name, const XMLAttributes &atts)
     }
 
                                // Check for an include.
+    bool omit = false;
     attval = atts.getValue("include");
     if (attval != 0) {
       SGPath path(SGPath(_base).dir());
@@ -232,26 +241,14 @@ PropsVisitor::startElement (const char * name, const XMLAttributes &atts)
        setException(e);
       }
 
-      const char *omit = atts.getValue("omit-node");
-      if (omit && !strcmp(omit, "y")) {
-        int nChildren = node->nChildren();
-        for (int i = 0; i < nChildren; i++) {
-          SGPropertyNode *src = node->getChild(i);
-          const char *name = src->getName();
-          int index = st.counters[name];
-          st.counters[name]++;
-          SGPropertyNode *dst = st.node->getChild(name, index, true);
-          copyProperties(src, dst);
-        }
-        st.node->removeChild(node->getName(), node->getIndex(), false);
-        node = st.node;
-      }
+      attval = atts.getValue("omit-node");
+      omit = checkFlag(attval, false);
     }
 
     const char *type = atts.getValue("type");
     if (type)
       node->clearValue();
-    push_state(node, type, mode);
+    push_state(node, type, mode, omit);
   }
 }
 
@@ -301,6 +298,19 @@ PropsVisitor::endElement (const char * name)
                                // assigned.
   st.node->setAttributes(st.mode);
 
+  if (st.omit) {
+    State &parent = _state_stack[_state_stack.size() - 2];
+    int nChildren = st.node->nChildren();
+    for (int i = 0; i < nChildren; i++) {
+      SGPropertyNode *src = st.node->getChild(i);
+      const char *name = src->getName();
+      int index = parent.counters[name];
+      parent.counters[name]++;
+      SGPropertyNode *dst = parent.node->getChild(name, index, true);
+      copyProperties(src, dst);
+    }
+    parent.node->removeChild(st.node->getName(), st.node->getIndex(), false);
+  }
   pop_state();
 }
 
@@ -390,25 +400,26 @@ void readProperties (const char *buf, const int size,
  * Return the type name.
  */
 static const char *
-getTypeName (SGPropertyNode::Type type)
+getTypeName (simgear::props::Type type)
 {
+  using namespace simgear::props;
   switch (type) {
-  case SGPropertyNode::UNSPECIFIED:
+  case UNSPECIFIED:
     return "unspecified";
-  case SGPropertyNode::BOOL:
+  case BOOL:
     return "bool";
-  case SGPropertyNode::INT:
+  case INT:
     return "int";
-  case SGPropertyNode::LONG:
+  case LONG:
     return "long";
-  case SGPropertyNode::FLOAT:
+  case FLOAT:
     return "float";
-  case SGPropertyNode::DOUBLE:
+  case DOUBLE:
     return "double";
-  case SGPropertyNode::STRING:
+  case STRING:
     return "string";
-  case SGPropertyNode::ALIAS:
-  case SGPropertyNode::NONE:
+  case ALIAS:
+  case NONE:
     return "unspecified";
   }
 
@@ -515,7 +526,7 @@ writeNode (ostream &output, const SGPropertyNode * node,
       output << " alias=\"" << node->getAliasTarget()->getPath()
             << "\"/>" << endl;
     } else {
-      if (node->getType() != SGPropertyNode::UNSPECIFIED)
+      if (node->getType() != simgear::props::UNSPECIFIED)
        output << " type=\"" << getTypeName(node->getType()) << '"';
       output << '>';
       writeData(output, node->getStringValue());
@@ -590,37 +601,38 @@ writeProperties (const string &file, const SGPropertyNode * start_node,
 bool
 copyProperties (const SGPropertyNode *in, SGPropertyNode *out)
 {
+  using namespace simgear::props;
   bool retval = true;
 
                                // First, copy the actual value,
                                // if any.
   if (in->hasValue()) {
     switch (in->getType()) {
-    case SGPropertyNode::BOOL:
+    case BOOL:
       if (!out->setBoolValue(in->getBoolValue()))
        retval = false;
       break;
-    case SGPropertyNode::INT:
+    case INT:
       if (!out->setIntValue(in->getIntValue()))
        retval = false;
       break;
-    case SGPropertyNode::LONG:
+    case LONG:
       if (!out->setLongValue(in->getLongValue()))
        retval = false;
       break;
-    case SGPropertyNode::FLOAT:
+    case FLOAT:
       if (!out->setFloatValue(in->getFloatValue()))
        retval = false;
       break;
-    case SGPropertyNode::DOUBLE:
+    case DOUBLE:
       if (!out->setDoubleValue(in->getDoubleValue()))
        retval = false;
       break;
-    case SGPropertyNode::STRING:
+    case STRING:
       if (!out->setStringValue(in->getStringValue()))
        retval = false;
       break;
-    case SGPropertyNode::UNSPECIFIED:
+    case UNSPECIFIED:
       if (!out->setUnspecifiedValue(in->getStringValue()))
        retval = false;
       break;