using std::endl;
using std::find;
using std::sort;
-using std::string;
using std::vector;
using std::stringstream;
i++;
}
if (i != max && *i != '/')
- throw string("illegal character after . or ..");
+ throw std::string("illegal character after . or ..");
} else if (isalpha(*i) || *i == '_') {
i++;
} else if (*i == '[' || *i == '/') {
break;
} else {
- string err = "'";
+ std::string err = "'";
err.push_back(*i);
err.append("' found in propertyname after '"+node->getNameString()+"'");
err.append("\nname may contain only ._- and alphanumeric characters");
else {
if (path.begin() == i) {
- string err = "'";
+ std::string err = "'";
err.push_back(*i);
err.append("' found in propertyname after '"+node->getNameString()+"'");
err.append("\nname must begin with alpha or '_'");
}
// Validate the name of a single node
-inline bool validateName(const string& name)
+inline bool validateName(const std::string& name)
{
using namespace boost;
if (name.empty())
if (equals(name, "..")) {
SGPropertyNode * parent = current->getParent();
if (parent == 0)
- throw string("attempt to move past root with '..'");
+ throw std::string("attempt to move past root with '..'");
return find_node_aux(parent, ++itr, create, last_index);
}
int index = -1;
}
}
if (i == token.end() || *i != ']')
- throw string("unterminated index (looking for ']')");
+ throw std::string("unterminated index (looking for ']')");
} else {
- throw string("illegal characters in token: ")
- + string(name.begin(), name.end());
+ throw std::string("illegal characters in token: ")
+ + std::string(name.begin(), name.end());
}
}
}
_local_val.string_val = 0;
_value.val = 0;
if (!validateName(_name))
- throw string("plain name expected instead of '") + _name + '\'';
+ throw std::string("plain name expected instead of '") + _name + '\'';
}
-SGPropertyNode::SGPropertyNode (const string& name,
- int index,
- SGPropertyNode * parent)
+SGPropertyNode::SGPropertyNode( const std::string& name,
+ int index,
+ SGPropertyNode * parent)
: _index(index),
_name(name),
_parent(parent),
_local_val.string_val = 0;
_value.val = 0;
if (!validateName(name))
- throw string("plain name expected instead of '") + _name + '\'';
+ throw std::string("plain name expected instead of '") + _name + '\'';
}
/**
}
SGPropertyNode *
-SGPropertyNode::getChild (const string& name, int index, bool create)
+SGPropertyNode::getChild (const std::string& name, int index, bool create)
{
SGPropertyNode* node = getExistingChild(name.begin(), name.end(), index);
if (node) {
_children.clear();
}
-string
+std::string
SGPropertyNode::getDisplayName (bool simplify) const
{
- string display_name = _name;
+ std::string display_name = _name;
if (_index != 0 || !simplify) {
stringstream sstr;
sstr << '[' << _index << ']';
return display_name;
}
-string
+std::string
SGPropertyNode::getPath (bool simplify) const
{
typedef std::vector<SGConstPropertyNode_ptr> PList;
PList pathList;
for (const SGPropertyNode* node = this; node->_parent; node = node->_parent)
pathList.push_back(node);
- string result;
+ std::string result;
for (PList::reverse_iterator itr = pathList.rbegin(),
rend = pathList.rend();
itr != rend;
//------------------------------------------------------------------------------
bool SGPropertyNode::interpolate( const std::string& type,
- const PropertyList& values,
+ const simgear::PropertyList& values,
const double_list& deltas,
const std::string& easing )
{
}
case props::STRING:
case props::UNSPECIFIED: {
- string val = getStringValue();
+ std::string val = getStringValue();
clearValue();
_type = props::STRING;
_local_val.string_val = copy_string(val.c_str());