- made getValue methods protected, so that they won't be invoked outside

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

diff --git a/simgear/misc/props_io.cxx b/simgear/misc/props_io.cxx
index 1951c229c01b1d4cabd3d96a54f68c7d3b139859..ff438fc640dbc28210977bad4eb81126e3131af8 100644 (file)
--- a/simgear/misc/props_io.cxx
+++ b/simgear/misc/props_io.cxx
@@ -1,20 +1,17 @@
 
-#ifdef HAVE_CONFIG_H
-#  include <config.h>
-#endif
-
 #include <simgear/compiler.h>
 
 #include <stdlib.h>            // atof() atoi()
 
+#include <simgear/sg_inlines.h>
 #include <simgear/debug/logstream.hxx>
 #include <simgear/xml/easyxml.hxx>
 
-#include "fgpath.hxx"
+#include "sg_path.hxx"
 #include "props.hxx"
 
 #include STL_IOSTREAM
-#if !defined(FG_HAVE_NATIVE_SGI_COMPILERS)
+#if !defined(SG_HAVE_NATIVE_SGI_COMPILERS)
 #  include <fstream>
 #else
 #  include <fstream.h>
@@ -23,15 +20,15 @@
 #include <vector>
 #include <map>
 
-#if !defined(FG_HAVE_NATIVE_SGI_COMPILERS)
-FG_USING_STD(istream);
-FG_USING_STD(ifstream);
-FG_USING_STD(ostream);
-FG_USING_STD(ofstream);
+#if !defined(SG_HAVE_NATIVE_SGI_COMPILERS)
+SG_USING_STD(istream);
+SG_USING_STD(ifstream);
+SG_USING_STD(ostream);
+SG_USING_STD(ofstream);
 #endif
-FG_USING_STD(string);
-FG_USING_STD(vector);
-FG_USING_STD(map);
+SG_USING_STD(string);
+SG_USING_STD(vector);
+SG_USING_STD(map);
 
 
 \f
@@ -112,8 +109,8 @@ PropsVisitor::startElement (const char * name, const XMLAttributes &atts)
   State &st = state();
 
   if (_level == 0) {
-    if (string(name) != "PropertyList") {
-      FG_LOG(FG_INPUT, FG_ALERT, "Root element name is " <<
+    if (string(name) != (string)"PropertyList") {
+      SG_LOG(SG_INPUT, SG_ALERT, "Root element name is " <<
             name << "; expected PropertyList");
       _ok = false;
     }
@@ -126,7 +123,7 @@ PropsVisitor::startElement (const char * name, const XMLAttributes &atts)
     int index = 0;
     if (att_n != 0) {
       index = atoi(att_n);
-      st.counters[name] = max(st.counters[name], index+1);
+      st.counters[name] = SG_MAX2(st.counters[name], index+1);
     } else {
       index = st.counters[name];
       st.counters[name]++;
@@ -137,18 +134,18 @@ PropsVisitor::startElement (const char * name, const XMLAttributes &atts)
     const char * att_alias = atts.getValue("alias");
     if (att_alias != 0) {
       if (!node->alias(att_alias))
-       FG_LOG(FG_INPUT, FG_ALERT, "Failed to set alias to " << att_alias);
+       SG_LOG(SG_INPUT, SG_ALERT, "Failed to set alias to " << att_alias);
     }
 
                                // Check for an include.
     const char * att_include = atts.getValue("include");
     if (att_include != 0) {
-      FGPath path(FGPath(_base).dir());
+      SGPath path(SGPath(_base).dir());
       cerr << "Base is " << _base << endl;
-      cerr << "Dir is " << FGPath(_base).dir() << endl;
+      cerr << "Dir is " << SGPath(_base).dir() << endl;
       path.append(att_include);
       if (!readProperties(path.str(), node)) {
-       FG_LOG(FG_INPUT, FG_ALERT, "Failed to read include file "
+       SG_LOG(SG_INPUT, SG_ALERT, "Failed to read include file "
               << att_include);
        _ok = false;
       }
@@ -174,21 +171,23 @@ PropsVisitor::endElement (const char * name)
        ret = st.node->setBoolValue(false);
     } else if (st.type == "int") {
       ret = st.node->setIntValue(atoi(_data.c_str()));
+    } else if (st.type == "long") {
+      ret = st.node->setLongValue(strtol(_data.c_str(), 0, 0));
     } else if (st.type == "float") {
       ret = st.node->setFloatValue(atof(_data.c_str()));
     } else if (st.type == "double") {
-      ret = st.node->setDoubleValue(atof(_data.c_str()));
+      ret = st.node->setDoubleValue(strtod(_data.c_str(), 0));
     } else if (st.type == "string") {
       ret = st.node->setStringValue(_data);
     } else if (st.type == "unknown") {
       ret = st.node->setUnknownValue(_data);
     } else {
-      FG_LOG(FG_INPUT, FG_ALERT, "Unknown data type " << st.type
+      SG_LOG(SG_INPUT, SG_ALERT, "Unknown data type " << st.type
             << " assuming 'unknown'");
       ret = st.node->setUnknownValue(_data);
     }
     if (!ret)
-      FG_LOG(FG_INPUT, FG_ALERT, "readProperties: Failed to set "
+      SG_LOG(SG_INPUT, SG_ALERT, "readProperties: Failed to set "
             << st.node->getPath() << " to value \""
             << _data << "\" with type " << st.type);
   }
@@ -206,14 +205,14 @@ PropsVisitor::data (const char * s, int length)
 void
 PropsVisitor::warning (const char * message, int line, int column)
 {
-  FG_LOG(FG_INPUT, FG_ALERT, "readProperties: warning: "
+  SG_LOG(SG_INPUT, SG_ALERT, "readProperties: warning: "
         << message << " at line " << line << ", column " << column);
 }
 
 void
 PropsVisitor::error (const char * message, int line, int column)
 {
-  FG_LOG(FG_INPUT, FG_ALERT, "readProperties: FATAL: " <<
+  SG_LOG(SG_INPUT, SG_ALERT, "readProperties: FATAL: " <<
         message << " at line " << line << ", column " << column);
   _ok = false;
 }
@@ -257,7 +256,7 @@ readProperties (const string &file, SGPropertyNode * start_node)
   if (input.good()) {
     return readProperties(input, start_node, file);
   } else {
-    FG_LOG(FG_INPUT, FG_ALERT, "Error reading property list from file "
+    SG_LOG(SG_INPUT, SG_ALERT, "Error reading property list from file "
           << file);
     return false;
   }
@@ -275,7 +274,7 @@ readProperties (const string &file, SGPropertyNode * start_node)
  * Return the type name.
  */
 static const char *
-getTypeName (SGValue::Type type)
+getTypeName (SGPropertyNode::Type type)
 {
   switch (type) {
   case SGValue::UNKNOWN:
@@ -284,6 +283,8 @@ getTypeName (SGValue::Type type)
     return "bool";
   case SGValue::INT:
     return "int";
+  case SGValue::LONG:
+    return "long";
   case SGValue::FLOAT:
     return "float";
   case SGValue::DOUBLE:
@@ -341,24 +342,26 @@ writeNode (ostream &output, const SGPropertyNode * node, int indent)
                                // write it first.
   if (node->hasValue()) {
     doIndent(output, indent);
-    output << '<' << name << " n=\"" << index;
-    if (node->isAlias() && node->getAliasTarget() != 0) {
-      output << "\" alias=\""
-            << node->getAliasTarget()->getPath() << "\"/>" << endl;
-    } else {
-      if (node->getType() != SGValue::UNKNOWN)
-       output << "\" type=\"" << getTypeName(node->getType()) << '"';
+    output << '<' << name << " n=\"" << index << '"';
+    if (node->isAlias() && node->getAliasTarget() != 0)
+      output << " alias=\"" << node->getAliasTarget()->getPath() << "\"/>";
+    else {
+      if (node->getType() != SGPropertyNode::UNKNOWN)
+       output << " type=\"" << getTypeName(node->getType()) << '"';
       output << '>';
       writeData(output, node->getStringValue());
-      output << "</" << name << '>' << endl;;
+      output << "</" << name << '>' << endl;
     }
   }
 
                                // If there are children, write them
                                // next.
-  if (nChildren > 0) {
+  if (nChildren > 0 || node->isAlias()) {
     doIndent(output, indent);
-    output << '<' << name << " n=\"" << index << "\">" << endl;;
+    output << '<' << name << " n=\"" << index << '"';
+    if (node->isAlias() && node->getAliasTarget() != 0)
+      output << " alias=\"" << node->getAliasTarget()->getPath() << '"';
+    output << '>' << endl;
     for (int i = 0; i < nChildren; i++)
       writeNode(output, node->getChild(i), indent + INDENT_STEP);
     doIndent(output, indent);
@@ -368,10 +371,10 @@ writeNode (ostream &output, const SGPropertyNode * node, int indent)
                                // If there were no children and no
                                // value, at least note the presence
                                // of the node.
-  if (nChildren == 0 && !node->hasValue()) {
-    doIndent(output, indent);
-    output << '<' << name << " n=\"" << index << "\"/>" << endl;
-  }
+//   if (nChildren == 0 && !node->isAlias() && !node->hasValue()) {
+//     doIndent(output, indent);
+//     output << '<' << name << " n=\"" << index << "\"/>" << endl;
+//   }
 
   return true;
 }
@@ -416,7 +419,7 @@ writeProperties (const string &file, const SGPropertyNode * start_node)
   if (output.good()) {
     return writeProperties(output, start_node);
   } else {
-    FG_LOG(FG_INPUT, FG_ALERT, "Cannot write properties to file "
+    SG_LOG(SG_INPUT, SG_ALERT, "Cannot write properties to file "
           << file);
     return false;
   }
@@ -454,6 +457,10 @@ copyProperties (const SGPropertyNode *in, SGPropertyNode *out)
       if (!out->setIntValue(in->getIntValue()))
        retval = false;
       break;
+    case SGValue::LONG:
+      if (!out->setLongValue(in->getLongValue()))
+       retval = false;
+      break;
     case SGValue::FLOAT:
       if (!out->setFloatValue(in->getFloatValue()))
        retval = false;