X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=simgear%2Fprops%2Fprops_io.cxx;h=232e3c2c79f4b2c4c4da20d00fa2c54e1c00d5f7;hb=07da1e7e1a753c59b805a6a071766ee08ac3c826;hp=d661223784a1b19ca2d217f0787ebdb1e70d1f18;hpb=d219c5c4c613e4f36d8ff1ce8af674fc96dcb543;p=simgear.git

diff --git a/simgear/props/props_io.cxx b/simgear/props/props_io.cxx
index d6612237..232e3c2c 100644
--- a/simgear/props/props_io.cxx
+++ b/simgear/props/props_io.cxx
@@ -18,25 +18,27 @@
 
 #include <simgear/sg_inlines.h>
 #include <simgear/debug/logstream.hxx>
+#include <simgear/math/SGMath.hxx>
 #include <simgear/misc/sg_path.hxx>
 #include <simgear/xml/easyxml.hxx>
 
 #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;
 
@@ -52,8 +54,11 @@ class PropsVisitor : public XMLVisitor
 {
 public:
 
-  PropsVisitor (SGPropertyNode * root, const string &base, int default_mode = 0)
-    : _default_mode(default_mode), _root(root), _level(0), _base(base), _hasException(false) {}
+  PropsVisitor (SGPropertyNode * root, const string &base, int default_mode = 0,
+                bool extended = false)
+    : _default_mode(default_mode), _root(root), _level(0), _base(base),
+      _hasException(false), _extended(extended)
+  {}
 
   virtual ~PropsVisitor () {}
 
@@ -75,22 +80,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,11 +109,13 @@ private:
   int _default_mode;
   string _data;
   SGPropertyNode * _root;
+  SGPropertyNode null;
   int _level;
   vector<State> _state_stack;
   string _base;
   sg_io_exception _exception;
   bool _hasException;
+  bool _extended;
 };
 
 void
@@ -165,7 +173,7 @@ PropsVisitor::startElement (const char * name, const XMLAttributes &atts)
       SGPath path(SGPath(_base).dir());
       path.append(attval);
       try {
-	readProperties(path.str(), _root);
+	readProperties(path.str(), _root, 0, _extended);
       } catch (sg_io_exception &e) {
 	setException(e);
       }
@@ -189,6 +197,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,36 +235,25 @@ 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());
       path.append(attval);
       try {
-	readProperties(path.str(), node);
+	readProperties(path.str(), node, 0, _extended);
       } catch (sg_io_exception &e) {
 	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);
   }
 }
 
@@ -279,6 +281,12 @@ PropsVisitor::endElement (const char * name)
       ret = st.node->setDoubleValue(strtod(_data.c_str(), 0));
     } else if (st.type == "string") {
       ret = st.node->setStringValue(_data.c_str());
+    } else if (st.type == "vec3d" && _extended) {
+      ret = st.node
+        ->setValue(simgear::parseString<SGVec3d>(_data));
+    } else if (st.type == "vec4d" && _extended) {
+      ret = st.node
+        ->setValue(simgear::parseString<SGVec4d>(_data));
     } else if (st.type == "unspecified") {
       ret = st.node->setUnspecifiedValue(_data.c_str());
     } else if (_level == 1) {
@@ -301,6 +309,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();
 }
 
@@ -335,9 +356,9 @@ PropsVisitor::warning (const char * message, int line, int column)
  */
 void
 readProperties (istream &input, SGPropertyNode * start_node,
-		const string &base, int default_mode)
+		const string &base, int default_mode, bool extended)
 {
-  PropsVisitor visitor(start_node, base, default_mode);
+  PropsVisitor visitor(start_node, base, default_mode, extended);
   readXML(input, visitor, base);
   if (visitor.hasException())
     throw visitor.getException();
@@ -353,9 +374,9 @@ readProperties (istream &input, SGPropertyNode * start_node,
  */
 void
 readProperties (const string &file, SGPropertyNode * start_node,
-                int default_mode)
+                int default_mode, bool extended)
 {
-  PropsVisitor visitor(start_node, file, default_mode);
+  PropsVisitor visitor(start_node, file, default_mode, extended);
   readXML(file, visitor);
   if (visitor.hasException())
     throw visitor.getException();
@@ -371,9 +392,10 @@ readProperties (const string &file, SGPropertyNode * start_node,
  * @return true if the read succeeded, false otherwise.
  */
 void readProperties (const char *buf, const int size,
-                     SGPropertyNode * start_node, int default_mode)
+                     SGPropertyNode * start_node, int default_mode,
+                     bool extended)
 {
-  PropsVisitor visitor(start_node, "", default_mode);
+  PropsVisitor visitor(start_node, "", default_mode, extended);
   readXML(buf, size, visitor);
   if (visitor.hasException())
     throw visitor.getException();
@@ -390,26 +412,33 @@ 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;
   switch (type) {
-  case SGPropertyNode::UNSPECIFIED:
+  case props::UNSPECIFIED:
     return "unspecified";
-  case SGPropertyNode::BOOL:
+  case props::BOOL:
     return "bool";
-  case SGPropertyNode::INT:
+  case props::INT:
     return "int";
-  case SGPropertyNode::LONG:
+  case props::LONG:
     return "long";
-  case SGPropertyNode::FLOAT:
+  case props::FLOAT:
     return "float";
-  case SGPropertyNode::DOUBLE:
+  case props::DOUBLE:
     return "double";
-  case SGPropertyNode::STRING:
+  case props::STRING:
     return "string";
-  case SGPropertyNode::ALIAS:
-  case SGPropertyNode::NONE:
+  case props::VEC3D:
+    return "vec3d";
+  case props::VEC4D:
+    return "vec4d";
+  case props::ALIAS:
+  case props::NONE:
     return "unspecified";
+  default: // avoid compiler warning
+    break;
   }
 
   // keep the compiler from squawking
@@ -515,7 +544,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,40 +619,49 @@ writeProperties (const string &file, const SGPropertyNode * start_node,
 bool
 copyProperties (const SGPropertyNode *in, SGPropertyNode *out)
 {
+  using namespace simgear;
   bool retval = true;
 
 				// First, copy the actual value,
 				// if any.
   if (in->hasValue()) {
     switch (in->getType()) {
-    case SGPropertyNode::BOOL:
+    case props::BOOL:
       if (!out->setBoolValue(in->getBoolValue()))
 	retval = false;
       break;
-    case SGPropertyNode::INT:
+    case props::INT:
       if (!out->setIntValue(in->getIntValue()))
 	retval = false;
       break;
-    case SGPropertyNode::LONG:
+    case props::LONG:
       if (!out->setLongValue(in->getLongValue()))
 	retval = false;
       break;
-    case SGPropertyNode::FLOAT:
+    case props::FLOAT:
       if (!out->setFloatValue(in->getFloatValue()))
 	retval = false;
       break;
-    case SGPropertyNode::DOUBLE:
+    case props::DOUBLE:
       if (!out->setDoubleValue(in->getDoubleValue()))
 	retval = false;
       break;
-    case SGPropertyNode::STRING:
+    case props::STRING:
       if (!out->setStringValue(in->getStringValue()))
 	retval = false;
       break;
-    case SGPropertyNode::UNSPECIFIED:
+    case props::UNSPECIFIED:
       if (!out->setUnspecifiedValue(in->getStringValue()))
 	retval = false;
       break;
+    case props::VEC3D:
+      if (!out->setValue(in->getValue<SGVec3d>()))
+        retval = false;
+      break;
+    case props::VEC4D:
+      if (!out->setValue(in->getValue<SGVec4d>()))
+        retval = false;
+      break;
     default:
       if (in->isAlias())
 	break;