FGFS-4.1/simgear
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

- removed all reference to SGValue

Browse Source 
- renamed UNKNOWN to UNSPECIED and setUnknownValue to
  setUnspecifiedValue
- modified routines to use 'read', 'write', and 'archive' attribute
  for access-mode attributes (only if non-default; they all default to
  'y')
- modified write routine to honour ARCHIVE attribute (won't write
  subtree if ARCHIVE is not set)
This commit is contained in:
curt 2001-06-28 21:53:46 +00:00
parent 05eaa7135f
commit e7b9e55599
1 changed files with 123 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

182
simgear/misc/props_io.cxx
View File

@ -30,6 +30,8 @@ SG_USING_STD(string);
SG_USING_STD(vector); SG_USING_STD(vector);
SG_USING_STD(map); SG_USING_STD(map);
#define DEFAULT_MODE (SGPropertyNode::READ|SGPropertyNode::WRITE|SGPropertyNode::ARCHIVE)
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
@ -57,21 +59,22 @@ private:
struct State struct State
{ {
State () : node(0), type("") {} State () : node(0), type(""), mode(DEFAULT_MODE) {}
State (SGPropertyNode * _node, const char * _type) State (SGPropertyNode * _node, const char * _type, int _mode)
: node(_node), type(_type) {} : node(_node), type(_type), mode(_mode) {}
SGPropertyNode * node; SGPropertyNode * node;
string type; string type;
int mode;
map<string,int> counters; map<string,int> counters;
}; };
State &state () { return _state_stack[_state_stack.size() - 1]; } State &state () { return _state_stack[_state_stack.size() - 1]; }
void push_state (SGPropertyNode * node, const char * type) { void push_state (SGPropertyNode * node, const char * type, int mode) {
if (type == 0) if (type == 0)
_state_stack.push_back(State(node, "unknown")); _state_stack.push_back(State(node, "unspecified", mode));
else else
_state_stack.push_back(State(node, type)); _state_stack.push_back(State(node, type, mode));
_level++; _level++;
_data = ""; _data = "";
} }
@ -103,6 +106,24 @@ PropsVisitor::endXML ()
_state_stack.resize(0); _state_stack.resize(0);
} }
/**
* Check a yes/no flag that defaults to 'yes'.
*/
static bool
checkFlag (const char * flag)
{
if (flag == 0 || string(flag) == "y")
return true;
else if (string(flag) == "n")
return false;
else {
SG_LOG(SG_INPUT, SG_ALERT, "Unrecognized flag value '" << flag
<< "', assuming 'y'");
return true;
}
}
void void
PropsVisitor::startElement (const char * name, const XMLAttributes &atts) PropsVisitor::startElement (const char * name, const XMLAttributes &atts)
{ {
@ -114,44 +135,63 @@ PropsVisitor::startElement (const char * name, const XMLAttributes &atts)
name << "; expected PropertyList"); name << "; expected PropertyList");
_ok = false; _ok = false;
} }
push_state(_root, ""); push_state(_root, "", DEFAULT_MODE);
} }
else { else {
const char * attval;
// Get the index. // Get the index.
const char * att_n = atts.getValue("n"); attval = atts.getValue("n");
int index = 0; int index = 0;
if (att_n != 0) { if (attval != 0) {
index = atoi(att_n); index = atoi(attval);
st.counters[name] = SG_MAX2(st.counters[name], index+1); st.counters[name] = SG_MAX2(st.counters[name], index+1);
} else { } else {
index = st.counters[name]; index = st.counters[name];
st.counters[name]++; st.counters[name]++;
} }
// Check for an alias. // Got the index, so grab the node.
SGPropertyNode * node = st.node->getChild(name, index, true); SGPropertyNode * node = st.node->getChild(name, index, true);
const char * att_alias = atts.getValue("alias");
if (att_alias != 0) { // Get the access-mode attributes,
if (!node->alias(att_alias)) // but don't set yet (in case they
SG_LOG(SG_INPUT, SG_ALERT, "Failed to set alias to " << att_alias); // prevent us from recording the value).
int mode = 0;
attval = atts.getValue("read");
if (checkFlag(attval))
mode |= SGPropertyNode::READ;
attval = atts.getValue("write");
if (checkFlag(attval))
mode |= SGPropertyNode::WRITE;
attval = atts.getValue("archive");
if (checkFlag(attval))
mode |= SGPropertyNode::ARCHIVE;
// Check for an alias.
attval = atts.getValue("alias");
if (attval != 0) {
if (!node->alias(attval))
SG_LOG(SG_INPUT, SG_ALERT, "Failed to set alias to " << attval);
} }
// Check for an include. // Check for an include.
const char * att_include = atts.getValue("include"); attval = atts.getValue("include");
if (att_include != 0) { if (attval != 0) {
SGPath path(SGPath(_base).dir()); SGPath path(SGPath(_base).dir());
cerr << "Base is " << _base << endl; cerr << "Base is " << _base << endl;
cerr << "Dir is " << SGPath(_base).dir() << endl; cerr << "Dir is " << SGPath(_base).dir() << endl;
path.append(att_include); path.append(attval);
if (!readProperties(path.str(), node)) { if (!readProperties(path.str(), node)) {
SG_LOG(SG_INPUT, SG_ALERT, "Failed to read include file " SG_LOG(SG_INPUT, SG_ALERT, "Failed to read include file "
<< att_include); << attval);
_ok = false; _ok = false;
} }
} }
push_state(node, atts.getValue("type")); push_state(node, atts.getValue("type"), mode);
} }
} }
@ -179,12 +219,12 @@ PropsVisitor::endElement (const char * name)
ret = st.node->setDoubleValue(strtod(_data.c_str(), 0)); ret = st.node->setDoubleValue(strtod(_data.c_str(), 0));
} else if (st.type == "string") { } else if (st.type == "string") {
ret = st.node->setStringValue(_data); ret = st.node->setStringValue(_data);
} else if (st.type == "unknown") { } else if (st.type == "unspecified") {
ret = st.node->setUnknownValue(_data); ret = st.node->setUnspecifiedValue(_data);
} else { } else {
SG_LOG(SG_INPUT, SG_ALERT, "Unknown data type " << st.type SG_LOG(SG_INPUT, SG_ALERT, "Unrecognized data type " << st.type
<< " assuming 'unknown'"); << " assuming 'unspecified'");
ret = st.node->setUnknownValue(_data); ret = st.node->setUnspecifiedValue(_data);
} }
if (!ret) if (!ret)
SG_LOG(SG_INPUT, SG_ALERT, "readProperties: Failed to set " SG_LOG(SG_INPUT, SG_ALERT, "readProperties: Failed to set "
@ -192,6 +232,11 @@ PropsVisitor::endElement (const char * name)
<< _data << "\" with type " << st.type); << _data << "\" with type " << st.type);
} }
// Set the access-mode attributes now,
// once the value has already been
// assigned.
st.node->setAttributes(st.mode);
pop_state(); pop_state();
} }
@ -277,24 +322,24 @@ static const char *
getTypeName (SGPropertyNode::Type type) getTypeName (SGPropertyNode::Type type)
{ {
switch (type) { switch (type) {
case SGValue::UNKNOWN: case SGPropertyNode::UNSPECIFIED:
return "unknown"; return "unspecified";
case SGValue::BOOL: case SGPropertyNode::BOOL:
return "bool"; return "bool";
case SGValue::INT: case SGPropertyNode::INT:
return "int"; return "int";
case SGValue::LONG: case SGPropertyNode::LONG:
return "long"; return "long";
case SGValue::FLOAT: case SGPropertyNode::FLOAT:
return "float"; return "float";
case SGValue::DOUBLE: case SGPropertyNode::DOUBLE:
return "double"; return "double";
case SGValue::STRING: case SGPropertyNode::STRING:
return "string"; return "string";
} }
// keep the compiler from squawking // keep the compiler from squawking
return "unknown"; return "unspecified";
} }
@ -331,9 +376,35 @@ doIndent (ostream &output, int indent)
} }
static void
writeAtts (ostream &output, const SGPropertyNode * node)
{
int index = node->getIndex();
if (index != 0)
output << " n = \"" << index << '"';
if (!node->getAttribute(SGPropertyNode::READ))
output << " read=\"n\"";
if (!node->getAttribute(SGPropertyNode::WRITE))
output << " write=\"n\"";
if (!node->getAttribute(SGPropertyNode::ARCHIVE))
output << " archive=\"n\"";
}
static bool static bool
writeNode (ostream &output, const SGPropertyNode * node, int indent) writeNode (ostream &output, const SGPropertyNode * node, int indent)
{ {
// Don't write the node or any of
// its descendants unless it is
// allowed to be archived.
if (!node->getAttribute(SGPropertyNode::ARCHIVE))
return true; // Everything's OK, but we won't write.
const string &name = node->getName(); const string &name = node->getName();
int index = node->getIndex(); int index = node->getIndex();
int nChildren = node->nChildren(); int nChildren = node->nChildren();
@ -342,11 +413,13 @@ writeNode (ostream &output, const SGPropertyNode * node, int indent)
// write it first. // write it first.
if (node->hasValue()) { if (node->hasValue()) {
doIndent(output, indent); doIndent(output, indent);
output << '<' << name << " n=\"" << index << '"'; output << '<' << name;
if (node->isAlias() && node->getAliasTarget() != 0) writeAtts(output, node);
output << " alias=\"" << node->getAliasTarget()->getPath() << "\"/>"; if (node->isAlias() && node->getAliasTarget() != 0) {
else { output << " alias=\"" << node->getAliasTarget()->getPath()
if (node->getType() != SGPropertyNode::UNKNOWN) << "\"/>" << endl;
} else {
if (node->getType() != SGPropertyNode::UNSPECIFIED)
output << " type=\"" << getTypeName(node->getType()) << '"'; output << " type=\"" << getTypeName(node->getType()) << '"';
output << '>'; output << '>';
writeData(output, node->getStringValue()); writeData(output, node->getStringValue());
@ -358,9 +431,8 @@ writeNode (ostream &output, const SGPropertyNode * node, int indent)
// next. // next.
if (nChildren > 0 || node->isAlias()) { if (nChildren > 0 || node->isAlias()) {
doIndent(output, indent); doIndent(output, indent);
output << '<' << name << " n=\"" << index << '"'; output << '<' << name;
if (node->isAlias() && node->getAliasTarget() != 0) writeAtts(output, node);
output << " alias=\"" << node->getAliasTarget()->getPath() << '"';
output << '>' << endl; output << '>' << endl;
for (int i = 0; i < nChildren; i++) for (int i = 0; i < nChildren; i++)
writeNode(output, node->getChild(i), indent + INDENT_STEP); writeNode(output, node->getChild(i), indent + INDENT_STEP);
@ -368,14 +440,6 @@ writeNode (ostream &output, const SGPropertyNode * node, int indent)
output << "</" << name << '>' << endl; output << "</" << name << '>' << endl;
} }
// If there were no children and no
// value, at least note the presence
// of the node.
// if (nChildren == 0 && !node->isAlias() && !node->hasValue()) {
// doIndent(output, indent);
// output << '<' << name << " n=\"" << index << "\"/>" << endl;
// }
return true; return true;
} }
@ -449,36 +513,36 @@ copyProperties (const SGPropertyNode *in, SGPropertyNode *out)
// if any. // if any.
if (in->hasValue()) { if (in->hasValue()) {
switch (in->getType()) { switch (in->getType()) {
case SGValue::BOOL: case SGPropertyNode::BOOL:
if (!out->setBoolValue(in->getBoolValue())) if (!out->setBoolValue(in->getBoolValue()))
retval = false; retval = false;
break; break;
case SGValue::INT: case SGPropertyNode::INT:
if (!out->setIntValue(in->getIntValue())) if (!out->setIntValue(in->getIntValue()))
retval = false; retval = false;
break; break;
case SGValue::LONG: case SGPropertyNode::LONG:
if (!out->setLongValue(in->getLongValue())) if (!out->setLongValue(in->getLongValue()))
retval = false; retval = false;
break; break;
case SGValue::FLOAT: case SGPropertyNode::FLOAT:
if (!out->setFloatValue(in->getFloatValue())) if (!out->setFloatValue(in->getFloatValue()))
retval = false; retval = false;
break; break;
case SGValue::DOUBLE: case SGPropertyNode::DOUBLE:
if (!out->setDoubleValue(in->getDoubleValue())) if (!out->setDoubleValue(in->getDoubleValue()))
retval = false; retval = false;
break; break;
case SGValue::STRING: case SGPropertyNode::STRING:
if (!out->setStringValue(in->getStringValue())) if (!out->setStringValue(in->getStringValue()))
retval = false; retval = false;
break; break;
case SGValue::UNKNOWN: case SGPropertyNode::UNSPECIFIED:
if (!out->setUnknownValue(in->getStringValue())) if (!out->setUnspecifiedValue(in->getStringValue()))
retval = false; retval = false;
break; break;
default: default:
throw string("Unknown SGValue type"); throw string("Unrecognized SGPropertyNode type");
} }
} }