+/**
+ * \file props_io.cxx
+ * Started Fall 2000 by David Megginson, david@megginson.com
+ * This code is released into the Public Domain.
+ *
+ * See props.html for documentation [replace with URL when available].
+ *
+ * $Id$
+ */
+
+#ifdef HAVE_CONFIG_H
+# include <simgear_config.h>
+#endif
#include <simgear/compiler.h>
#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 <simgear/misc/ResourceManager.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;
#define DEFAULT_MODE (SGPropertyNode::READ|SGPropertyNode::WRITE)
{
public:
- PropsVisitor (SGPropertyNode * root, const string &base, int default_mode = 0)
- : _root(root), _level(0), _base(base), _hasException(false), _default_mode(default_mode) {}
+ 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 () {}
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 = "";
}
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
// Check for an include.
attval = atts.getValue("include");
if (attval != 0) {
- SGPath path(SGPath(_base).dir());
- path.append(attval);
try {
- readProperties(path.str(), _root);
+ SGPath path = simgear::ResourceManager::instance()->findPath(attval, SGPath(_base).dir());
+ if (path.isNull())
+ {
+ throw sg_io_exception("Cannot open file", sg_location(attval));
+ }
+ readProperties(path.str(), _root, 0, _extended);
} catch (sg_io_exception &e) {
- setException(e);
+ setException(e);
}
}
// Get the index.
attval = atts.getValue("n");
int index = 0;
+ string strName(name);
if (attval != 0) {
index = atoi(attval);
- st.counters[name] = SG_MAX2(st.counters[name], index+1);
+ st.counters[strName] = SG_MAX2(st.counters[strName], index+1);
} else {
- index = st.counters[name];
- st.counters[name]++;
+ index = st.counters[strName];
+ st.counters[strName]++;
}
// Got the index, so grab the node.
- SGPropertyNode * node = st.node->getChild(name, index, true);
+ SGPropertyNode * node = st.node->getChild(strName, 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
attval = atts.getValue("userarchive");
if (checkFlag(attval, false))
mode |= SGPropertyNode::USERARCHIVE;
+ attval = atts.getValue("preserve");
+ if (checkFlag(attval, false))
+ mode |= SGPropertyNode::PRESERVE;
// Check for an alias.
attval = atts.getValue("alias");
}
// 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);
+ SGPath path = simgear::ResourceManager::instance()->findPath(attval, SGPath(_base).dir());
+ if (path.isNull())
+ {
+ throw sg_io_exception("Cannot open file", sg_location(attval));
+ }
+ readProperties(path.str(), node, 0, _extended);
} catch (sg_io_exception &e) {
- setException(e);
+ setException(e);
}
+
+ 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);
}
}
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) {
+ ret = true; // empty <PropertyList>
} else {
string message = "Unrecognized data type '";
message += st.type;
// 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();
}
*/
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();
*/
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();
* @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();
* 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
static void
-writeAtts (ostream &output, const SGPropertyNode * node)
+writeAtts (ostream &output, const SGPropertyNode * node, bool forceindex)
{
int index = node->getIndex();
- if (index != 0)
+ if (index != 0 || forceindex)
output << " n=\"" << index << '"';
#if 0
const string name = node->getName();
int nChildren = node->nChildren();
+ bool node_has_value = false;
// If there is a literal value,
// write it first.
if (node->hasValue() && (write_all || node->getAttribute(archive_flag))) {
doIndent(output, indent);
output << '<' << name;
- writeAtts(output, node);
+ writeAtts(output, node, nChildren != 0);
if (node->isAlias() && node->getAliasTarget() != 0) {
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());
output << "</" << name << '>' << endl;
}
+ node_has_value = true;
}
// If there are children, write them next.
if (nChildren > 0) {
doIndent(output, indent);
output << '<' << name;
- writeAtts(output, node);
+ writeAtts(output, node, node_has_value);
output << '>' << endl;
for (int i = 0; i < nChildren; i++)
writeNode(output, node->getChild(i), write_all, indent + INDENT_STEP, archive_flag);
writeProperties (const string &file, const SGPropertyNode * start_node,
bool write_all, SGPropertyNode::Attribute archive_flag)
{
+ SGPath path(file.c_str());
+ path.create_dir(0777);
+
ofstream output(file.c_str());
if (output.good()) {
writeProperties(output, start_node, write_all, archive_flag);
}
}
+// Another variation, useful when called from gdb
+void
+writeProperties (const char* file, const SGPropertyNode * start_node)
+{
+ writeProperties(string(file), start_node, true);
+}
+
\f
////////////////////////////////////////////////////////////////////////
*
* @param in The source property tree.
* @param out The destination property tree.
+ * @param attr_value Only copy properties with given attribute values.
+ * @param attr_mask Mask for attributes to be considered by attr_value
+ * (default is 0 = attributes not considered, all
+ * properties copied).
* @return true if all properties were copied, false if some failed
* (for example, if the property's value is tied read-only).
*/
bool
-copyProperties (const SGPropertyNode *in, SGPropertyNode *out)
+copyProperties (const SGPropertyNode *in, SGPropertyNode *out,
+ int attr_value, int attr_mask)
{
+ 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;
}
}
- // copy the attributes.
+ // copy the attributes.
out->setAttributes( in->getAttributes() );
- // Next, copy the children.
+ // Next, copy the children.
int nChildren = in->nChildren();
for (int i = 0; i < nChildren; i++) {
const SGPropertyNode * in_child = in->getChild(i);
- SGPropertyNode * out_child = out->getChild(in_child->getName(),
- in_child->getIndex(),
- true);
- if (!copyProperties(in_child, out_child))
- retval = false;
+ int mask = attr_mask;
+ /* attributes have no meaning for nodes without values - except
+ * the PRESERVE flag. So ignore them. */
+ if (!in_child->hasValue())
+ mask &= SGPropertyNode::PRESERVE;
+ if ((in_child->getAttributes() & mask) == (attr_value & mask))
+ {
+ SGPropertyNode * out_child = out->getChild(in_child->getNameString(),
+ in_child->getIndex(),
+ false);
+ if (!out_child)
+ {
+ out_child = out->getChild(in_child->getNameString(),
+ in_child->getIndex(),
+ true);
+ }
+ else
+ {
+ mask = attr_mask;
+ if (!out_child->hasValue())
+ mask &= SGPropertyNode::PRESERVE;
+ if ((out_child->getAttributes() & mask) != (attr_value & mask))
+ out_child = NULL;
+ }
+ if (out_child &&
+ (!copyProperties(in_child, out_child, attr_value, attr_mask)))
+ retval = false;
+ }
}
return retval;
projects / simgear.git / blobdiff