bool
KnobSerialization::checkForDefaultValueNode(const YAML::Node& node, const std::string& nodeType, bool dataTypeSet)
{
std::string defaultString("Default");
std::string defaultTypeName = defaultString + nodeType;
if (!node[defaultTypeName]) {
return false;
}
// If the _dataType member was set in checkForValueNode, ensure that the data type of the value is the same as
// the default value.
if (dataTypeSet) {
SerializationValueVariantTypeEnum type = dataTypeFromString(nodeType);
if (type != _dataType) {
throw std::invalid_argument(_scriptName + ": Default value and value type differ!");
}
} else {
_dataType = dataTypeFromString(nodeType);
}
YAML::Node defNode = node[defaultTypeName];
int nDims = defNode.IsSequence() ? defNode.size() : 1;
_defaultValues.resize(nDims);
for (int i = 0; i < nDims; ++i) {
_defaultValues[i].serializeDefaultValue = true;
YAML::Node dimNode = defNode.IsSequence() ? defNode[i] : defNode;
decodeValueFromNode(dimNode, _defaultValues[i].value, _dataType);
}
return true;
}
/**
* Loads the map data set from a YAML file.
* @param node YAML node.
*/
void MapDataSet::load(const YAML::Node &node)
{
for (YAML::const_iterator i = node.begin(); i != node.end(); ++i)
{
_name = i->as<std::string>(_name);
}
}
void ScServer::handleRuningStateChangedMsg( const QString & data )
{
std::stringstream stream;
stream << data.toStdString();
YAML::Parser parser(stream);
bool serverRunningState;
std::string hostName;
int port;
YAML::Node doc;
while(parser.GetNextDocument(doc)) {
assert(doc.Type() == YAML::NodeType::Sequence);
bool success = doc[0].Read(serverRunningState);
if (!success) return; // LATER: report error?
success = doc[1].Read(hostName);
if (!success) return; // LATER: report error?
success = doc[2].Read(port);
if (!success) return; // LATER: report error?
}
QString qstrHostName( hostName.c_str() );
onRunningStateChanged( serverRunningState, qstrHostName, port );
emit runningStateChange( serverRunningState, qstrHostName, port );
}
//==============================================================================
/// Parse the derived dimension list from a document.
///
/// \param [in] dim_list The YAML list node for the dimensions.
///
void DefinitionParser::ParseDerivedDimensions( const YAML::Node& dim_list )
{
for ( YAML::Iterator it = dim_list.begin(); it != dim_list.end(); ++it )
{
ParseDerivedDimension( *it );
}
}
void FileBundle::Import(const YAML::Node& config)
{
switch (config.Type())
{
case YAML::NodeType::Scalar:
ImportScalarNode(config);
break;
case YAML::NodeType::Sequence:
for (auto i = config.begin(); i != config.end(); ++i)
{
const YAML::Node& node = *i;
switch(node.Type())
{
case YAML::NodeType::Scalar:
ImportScalarNode(node);
break;
case YAML::NodeType::Map:
for (auto k = node.begin(); k != node.end(); ++k)
{
auto file = ImportScalarNode(k->second);
file->name = k->first.as<string>();
}
break;
}
}
break;
case YAML::NodeType::Map:
ImportCompositeBundle(config);
break;
}
}
/**
reads all the regular expressions from the database.
and compile them
*/
void
RegexManager::load_config(YAML::Node cfg)
{
try
{
TSDebug(BANJAX_PLUGIN_NAME, "Setting regex re2 options");
RE2::Options opt;
opt.set_log_errors(false);
opt.set_perl_classes(true);
opt.set_posix_syntax(true);
TSDebug(BANJAX_PLUGIN_NAME, "Loading regex manager conf");
//now we compile all of them and store them for later use
for(YAML::const_iterator it = cfg.begin(); it != cfg.end(); ++it) {
string cur_rule = (const char*) (*it)["rule"].as<std::string>().c_str();
TSDebug(BANJAX_PLUGIN_NAME, "initiating rule %s", cur_rule.c_str());
unsigned int observation_interval = (*it)["interval"].as<unsigned int>();
unsigned int threshold = (*it)["hits_per_interval"].as<unsigned int>();
rated_banning_regexes.push_back(new RatedRegex(cur_rule, new RE2((const char*)((*it)["regex"].as<std::string>().c_str()), opt), observation_interval * 1000, threshold /(double)(observation_interval* 1000)));
}
}
catch(YAML::RepresentationException& e)
{
TSDebug(BANJAX_PLUGIN_NAME, "Error loading regex manager conf [%s].", e.what());
return;
}
TSDebug(BANJAX_PLUGIN_NAME, "Done loading regex manager conf");
}
// Incrementally load YAML
static NEVER_INLINE void operator +=(YAML::Node& left, const YAML::Node& node)
{
if (node && !node.IsNull())
{
if (node.IsMap())
{
for (const auto& pair : node)
{
if (pair.first.IsScalar())
{
auto&& lhs = left[pair.first.Scalar()];
lhs += pair.second;
}
else
{
// Exotic case (TODO: probably doesn't work)
auto&& lhs = left[YAML::Clone(pair.first)];
lhs += pair.second;
}
}
}
else if (node.IsScalar() || node.IsSequence())
{
// Scalars and sequences are replaced completely, but this may change in future.
// This logic may be overwritten by custom demands of every specific cfg:: node.
left = node;
}
}
}
int main(int argc, char* argv[])
{
try
{
YAML::Node config = YAML::LoadFile(argv[1]);
YAML::const_iterator iter =config.begin();
yaml::ConfigNodePtr np;
while( iter != config.end())
{
const YAML::Node& node = *iter;
std::string module_name = node["module_name"].as<std::string>();
np = yaml::NodeFactory::Instance().Create( module_name );
np->Decode(node);
np->Print(std::cout);
++iter;
}
}
catch ( YAML::ParserException& e )
{
std::cout << e.what();
}
return 0;
}
void LootSettings::upgradeYaml(YAML::Node& yaml) {
// Upgrade YAML settings' keys and values from those used in earlier
// versions of LOOT.
if (yaml["Debug Verbosity"] && !yaml["enableDebugLogging"])
yaml["enableDebugLogging"] = yaml["Debug Verbosity"].as<unsigned int>() > 0;
if (yaml["Update Masterlist"] && !yaml["updateMasterlist"])
yaml["updateMasterlist"] = yaml["Update Masterlist"];
if (yaml["Game"] && !yaml["game"])
yaml["game"] = yaml["Game"];
if (yaml["Language"] && !yaml["language"])
yaml["language"] = yaml["Language"];
if (yaml["Last Game"] && !yaml["lastGame"])
yaml["lastGame"] = yaml["Last Game"];
if (yaml["Games"] && !yaml["games"]) {
yaml["games"] = yaml["Games"];
for (auto node : yaml["games"]) {
if (node["url"]) {
node["repo"] = node["url"];
node["branch"] = "master"; // It'll get updated to the correct default
}
}
}
if (yaml["games"]) {
// Handle exception if YAML is invalid, eg. if an unrecognised
// game type is used (which can happen if downgrading from a
// later version of LOOT that supports more game types).
// However, can't remove elements from a sequence Node, so have to
// copy the valid elements into a new node then overwrite the
// original.
YAML::Node validGames;
for (auto node : yaml["games"]) {
try {
GameSettings settings(node.as<GameSettings>());
if (!yaml["Games"]) {
// Update existing default branch, if the default
// repositories are used.
if (settings.RepoURL() == GameSettings(settings.Type()).RepoURL()
&& settings.IsRepoBranchOldDefault()) {
settings.SetRepoBranch(GameSettings(settings.Type()).RepoBranch());
}
}
validGames.push_back(settings);
} catch (...) {}
}
yaml["games"] = validGames;
}
if (yaml["filters"])
yaml["filters"].remove("contentFilter");
}
bool BandwidthGui::groupFromYaml(const std::string& yaml, GroupMap* groupMap)
{
YAML::Node grpInfo = YAML::Load(yaml);
if (grpInfo.IsNull())
{
return true;
}
if (grpInfo.Type() != YAML::NodeType::Map)
{
return false;
}
for (const auto& pair : grpInfo)
{
if(pair.first.Type() != YAML::NodeType::Scalar)
{
return false;
}
std::string key = pair.first.as<std::string>();
for (const auto& element : pair.second)
{
if(element.Type() != YAML::NodeType::Scalar)
{
return false;
}
(*groupMap)[key].push_back(element.as<std::string>());
}
}
return true;
}
string M3JointArrayClient::GetCompDir(string component)
{
YAML::Node doc;
GetYamlDoc("m3_config.yml",doc);
if(!doc.FindValue("rt_components"))
{
ROS_ERROR("No rt_components key in m3_config.yml.");
return "";
}
for(YAML::Iterator it=doc["rt_components"].begin();it!=doc["rt_components"].end();++it)
{
string dir;
it.first() >> dir;
for(YAML::Iterator it_dir=doc["rt_components"][dir.c_str()].begin();
it_dir!=doc["rt_components"][dir.c_str()].end();++it_dir)
{
string name, type;
it_dir.first() >> name;
it_dir.second() >> type;
if (name == component)
return dir;
}
}
ROS_ERROR("No Robot Found.");
return "";
}
/**
* LoadDevices
*
* Loads devices from configuration object(YAML::Node)
*/
void
InsteonNetwork::loadDevices() {
YAML::Node device = config_["DEVICES"];
for (auto it = device.begin(); it != device.end(); ++it) {
addDevice(it->first.as<int>(0));
}
}
void WorldYamlSource::loadPropertySystems() {
// iterate through each section (each section is a system)
std::vector<YAML::Node> nodes = YAML::LoadAllFromFile(dir + "PropertySystems.yaml");
for (size_t i = 0; i < nodes.size(); i++) {
YamlWrapper yaml(nodes[i]);
// parse which system this section is for
String typeName = yaml.read<String>("Which", "NONE", "Invalid property system.");
ThingType type = ThingType::fromString(typeName);
// create the system
propertySystems[type].reset(new PropertySystem());
PropertySystem& system = *propertySystems[type];
// parse the properties of the system
YAML::Node propertiesNode = yaml["Properties"].getNode();
for (auto iter = propertiesNode.begin(); iter != propertiesNode.end(); ++iter) {
YamlWrapper propertyYaml(*iter);
String name = propertyYaml.read<String>("Name", "", "Property name not given.");
Type type = Type::fromString(propertyYaml.read<String>("Type"));
Variant def = readVariant(propertyYaml["Default"].getNode(), type);
bool mainKey = propertyYaml.read<bool>("MainKey", false);
system.add(name, type, def, mainKey);
}
}
}
void WorldYamlSource::loadItems() {
if (!propertySystems[ThingType::ITEM]) return;
PropertySystem& itemSys = *propertySystems[ThingType::ITEM];
std::vector<YAML::Node> nodes = YAML::LoadAllFromFile(dir + "Items.yaml");
for (size_t i = 0; i < nodes.size(); i++) {
YamlWrapper yaml(nodes[i]);
// read base
String baseName = yaml.read<String>("Base", "", "Item lacks a base.");
if (baseName == "") continue;
auto iter = itemBaseNameMap.find(baseName);
if (iter == itemBaseNameMap.end()) {
LOG(ERROR) << "'" << baseName << "' is not an existing item base.";
continue;
}
BaseThing& base = *iter->second;
items.emplace_back(new Item(base, items.size() + 1));
Item& item = *items.back();
// read location
if (yaml["Location"]->IsSequence()) {
item.moveTo(yaml.read<Coord>("Location", Coord()));
}
// read properties
YAML::Node propertiesNode = yaml["Properties"].getNode();
for (auto iter = propertiesNode.begin(); iter != propertiesNode.end(); ++iter) {
const Property& property = itemSys[iter->first.as<String>()];
item.setValue(property, readVariant(iter->second, property.type));
}
}
}
bool Sampler::parseConfig(const string &config_string) {
YAML::Node node = YAML::Load(config_string);
for (YAML::const_iterator it = node.begin(); it != node.end(); ++it) {
string sample_name = it->first.as<string>();
ui << sample_name << "\n";
YAML::Node sample_data = it->second;
if (!sample_data["file"]) {
ui << "file is required for each sample\n";
continue;
}
string file(sample_data["file"].as<string>());
float pan = 0.;
if (sample_data["pan"]) {
pan = sample_data["pan"].as<float>();
}
midi_data_t midi_data = sample_data["midi"].as<int>();
addSample(midi_data, file, pan);
}
return true;
}
inline bool load(doid_t do_id, YAML::Node &document)
{
ifstream stream(filename(do_id));
document = YAML::Load(stream);
if(!document.IsDefined() || document.IsNull())
{
m_log->error() << "obj-" << do_id << " does not exist in database." << endl;
return false;
}
if(!document["class"].IsDefined() || document["class"].IsNull())
{
m_log->error() << filename(do_id) << " does not contain the 'class' key." << endl;
return false;
}
if(!document["fields"].IsDefined() || document["fields"].IsNull())
{
m_log->error() << filename(do_id) << " does not contain the 'fields' key." << endl;
return false;
}
// Read object's DistributedClass
string dc_name = document["class"].as<string>();
if(!g_dcf->get_class_by_name(dc_name))
{
m_log->error() << "Class '" << dc_name << "', loaded from '" << filename(do_id)
<< "', does not exist." << endl;
return false;
}
return true;
}
void
RotoStrokeItemSerialization::decode(const YAML::Node& node)
{
if (!node.IsMap()) {
throw YAML::InvalidNode();
}
KnobTableItemSerialization::decode(node);
if (node["SubStrokes"]) {
YAML::Node strokesNode = node["SubStrokes"];
for (std::size_t i = 0; i < strokesNode.size(); ++i) {
YAML::Node strokeN = strokesNode[i];
PointCurves p;
p.x.reset(new CurveSerialization);
p.y.reset(new CurveSerialization);
p.pressure.reset(new CurveSerialization);
p.x->decode(strokeN["x"]);
p.y->decode(strokeN["y"]);
p.pressure->decode(strokeN["pressure"]);
_subStrokes.push_back(p);
}
}
}
void set_field(doid_t do_id, const Field* field, const val_t &value)
{
m_log->trace() << "Setting field on obj-" << do_id << endl;
YAML::Node document;
if(!load(do_id, document))
{
return;
}
// Get the fields from the file that are not being updated
const Class* dcc = g_dcf->get_class_by_name(document["class"].as<string>());
ObjectData dbo(dcc->get_id());
YAML::Node existing = document["fields"];
for(auto it = existing.begin(); it != existing.end(); ++it)
{
const Field* field = dcc->get_field_by_name(it->first.as<string>());
if(!field)
{
m_log->warning() << "Field '" << it->first.as<string>()
<< "', loaded from '" << filename(do_id)
<< "', does not exist." << endl;
continue;
}
vector<uint8_t> value = read_yaml_field(field, it->second, do_id);
if(value.size() > 0)
{
dbo.fields[field] = value;
}
}
dbo.fields[field] = value;
write_yaml_object(do_id, dcc, dbo);
}
virtual Node* getNode(const char* key) {
std::string path = key;
YAML::Node result;
for(size_t i = 0; i < entries.size(); i++) {
YAML::Node node = entries[i];
size_t pos = 0;
while(pos < path.size()) {
std::string subpath;
size_t end = path.find('.', pos);
if(end == std::string::npos) {
subpath = path.substr(pos);
pos = path.size();
} else {
subpath = path.substr(pos, end - pos);
pos = end + 1;
}
if(!node.IsNull()) {
node.reset(node[subpath]);
}
}
if(!node.IsNull() && node.IsDefined()) {
return new NodeImpl(node);
}
}
return NULL;
}
bool get_field(doid_t do_id, const Field* field, val_t &value)
{
m_log->trace() << "Getting field on obj-" << do_id << endl;
YAML::Node document;
if(!load(do_id, document))
{
return false;
}
// Get the fields from the file that are not being updated
YAML::Node node = document["fields"][field->get_name()];
if(!node.IsDefined() || node.IsNull())
{
return false;
}
m_log->trace() << "Found requested field: " + field->get_name() << endl;
value = read_yaml_field(field, node, do_id);
if(value.size() > 0)
{
return true;
}
return false;
}
int GazeboRosPulson::ParseBeaconMapFile(std::string f)
{
ROS_INFO("Opening Beacon Map File: %s", f.c_str());
// open file
std::fstream fs;
fs.open(f.c_str());
if (!fs.is_open())
return -1;
YAML::Node map = YAML::LoadFile(f.c_str());
assert(map.IsSequence());
num_beacons_ = map.size();
// read beacon locations
for (int i = 0; i < num_beacons_; i++)
{
Beacon b;
b.x = (double) map[i]["x"].as<double>();
b.y = (double) map[i]["y"].as<double>();
b.z = (double) map[i]["z"].as<double>();
b.id = (int) map[i]["id"].as<int>();
ROS_INFO("Beacon %d at : %f %f %f", b.id, b.x, b.y, b.z);
beacons_.push_back(b);
}
// close file
fs.close();
return 0;
}
bool get_fields(doid_t do_id, const vector<const Field*> &fields, map_t &values)
{
m_log->trace() << "Getting fields on obj-" << do_id << endl;
YAML::Node document;
if(!load(do_id, document))
{
return false;
}
// Get the fields from the file that are not being updated
for(auto it = fields.begin(); it != fields.end(); ++it)
{
const Field* field = *it;
m_log->trace() << "Searching for field: " << field->get_name() << endl;
YAML::Node existing = document["fields"];
for(auto it2 = existing.begin(); it2 != existing.end(); ++it2)
{
if(it2->first.as<string>() == field->get_name())
{
vector<uint8_t> value = read_yaml_field(field, it2->second, do_id);
if(value.size() > 0)
{
values[*it] = value;
m_log->trace() << "Found requested field: " + field->get_name() << endl;
}
}
}
}
return true;
}
//==============================================================================
/// Parse the converted units list from a document.
///
/// \param [in] unit_list The list of converted units.
///
void DefinitionParser::ParseConvertedUnits( const YAML::Node& unit_list )
{
for ( YAML::Iterator it = unit_list.begin(); it != unit_list.end(); ++it )
{
ParseConvertedUnit( *it );
}
}
TEST(TransferParticlesToPointCloudBehaviorTests, SerializationTest)
{
std::shared_ptr<Framework::Component> particles = std::make_shared<Particles::SphRepresentation>("Particles");
std::shared_ptr<Framework::Component> pointCloud =
std::make_shared<Graphics::OsgPointCloudRepresentation>("Graphics");
auto behavior = std::make_shared<TransferParticlesToPointCloudBehavior>("Behavior");
EXPECT_NO_THROW(behavior->setValue("Source", particles));
EXPECT_NO_THROW(behavior->setValue("Target", pointCloud));
YAML::Node node;
ASSERT_NO_THROW(node = YAML::convert<Framework::Component>::encode(*behavior));
EXPECT_EQ(1u, node.size());
YAML::Node data = node["SurgSim::Blocks::TransferParticlesToPointCloudBehavior"];
EXPECT_EQ(5u, data.size());
std::shared_ptr<TransferParticlesToPointCloudBehavior> newBehavior;
std::shared_ptr<Framework::Component> nodeAsComponent = node.as<std::shared_ptr<Framework::Component>>();
ASSERT_NO_THROW(newBehavior = std::dynamic_pointer_cast<TransferParticlesToPointCloudBehavior>(nodeAsComponent));
EXPECT_EQ("SurgSim::Blocks::TransferParticlesToPointCloudBehavior", newBehavior->getClassName());
EXPECT_NE(nullptr, newBehavior->getValue<std::shared_ptr<Particles::Representation>>("Source"));
EXPECT_NE(nullptr, newBehavior->getValue<std::shared_ptr<Graphics::PointCloudRepresentation>>("Target"));
}
static Value toValue(const YAML::Node& node, NTA_BasicType dataType)
{
if (node.Type() == YAML::NodeType::Map || node.Type() == YAML::NodeType::Null)
{
NTA_THROW << "YAML string does not not represent a value.";
}
if (node.Type() == YAML::NodeType::Scalar)
{
if (dataType == NTA_BasicType_Byte)
{
// node >> *str;
std::string val;
node.Read(val);
boost::shared_ptr<std::string> str(new std::string(val));
Value v(str);
return v;
} else {
boost::shared_ptr<Scalar> s(new Scalar(dataType));
_toScalar(node, s);
Value v(s);
return v;
}
} else {
// array
boost::shared_ptr<Array> a(new Array(dataType));
_toArray(node, a);
Value v(a);
return v;
}
}
void
Module::loadConfigurationFile( const QString& configFileName ) //throws YAML::Exception
{
foreach ( const QString& path, moduleConfigurationCandidates( Settings::instance()->debugMode(), m_name, configFileName ) )
{
QFile configFile( path );
if ( configFile.exists() && configFile.open( QFile::ReadOnly | QFile::Text ) )
{
QByteArray ba = configFile.readAll();
YAML::Node doc = YAML::Load( ba.constData() );
if ( doc.IsNull() )
{
cDebug() << "Found empty module configuration" << path;
// Special case: empty config files are valid,
// but aren't a map.
return;
}
if ( !doc.IsMap() )
{
cWarning() << "Bad module configuration format" << path;
return;
}
cDebug() << "Loaded module configuration" << path;
m_configurationMap = CalamaresUtils::yamlMapToVariant( doc ).toMap();
m_emergency = m_maybe_emergency
&& m_configurationMap.contains( EMERGENCY )
&& m_configurationMap[ EMERGENCY ].toBool();
return;
}
}
void GraphIO::saveFulcrums(YAML::Node& fulcrum, const ConnectionDescription& connection)
{
fulcrum["from"] = connection.from.getFullName();
fulcrum["to"] = connection.to.getFullName();
for (const Fulcrum& f : connection.fulcrums) {
YAML::Node pt;
pt.push_back(f.pos().x);
pt.push_back(f.pos().y);
fulcrum["pts"].push_back(pt);
}
for (const Fulcrum& f : connection.fulcrums) {
YAML::Node handle;
handle.push_back(f.handleIn().x);
handle.push_back(f.handleIn().y);
handle.push_back(f.handleOut().x);
handle.push_back(f.handleOut().y);
fulcrum["handles"].push_back(handle);
}
for (const Fulcrum& f : connection.fulcrums) {
fulcrum["types"].push_back(f.type());
}
}
YAML::Node YamlPath::get(YAML::Node node) {
size_t beginToken = 0, endToken = 0, pathSize = codedPath.size();
auto delimiter = MAP_DELIM; // First token must be a map key.
while (endToken < pathSize) {
beginToken = endToken;
endToken = pathSize;
endToken = std::min(endToken, codedPath.find(SEQ_DELIM, beginToken));
endToken = std::min(endToken, codedPath.find(MAP_DELIM, beginToken));
if (delimiter == SEQ_DELIM) {
int index = std::stoi(&codedPath[beginToken]);
node.reset(node[index]);
} else if (delimiter == MAP_DELIM) {
auto key = codedPath.substr(beginToken, endToken - beginToken);
node.reset(node[key]);
} else {
return Node(); // Path is malformed, return null node.
}
delimiter = codedPath[endToken]; // Get next character as the delimiter.
++endToken; // Move past the delimiter.
if (endToken < pathSize && !node) {
return Node(); // A node in the path was missing, return null node.
}
}
return node;
}
bool Bases()
{
std::string input =
"- 15\n"
"- 0x10\n"
"- 030\n"
"- 0xffffffff\n";
std::stringstream stream(input);
YAML::Parser parser(stream);
YAML::Node doc;
parser.GetNextDocument(doc);
if(doc.size() != 4)
return false;
if(doc[0] != 15)
return false;
if(doc[1] != 0x10)
return false;
if(doc[2] != 030)
return false;
if(doc[3] != 0xffffffff)
return false;
return true;
}
bool
KnobSerialization::checkForValueNode(const YAML::Node& node, const std::string& nodeType)
{
if (!node[nodeType]) {
return false;
}
// We need to figure out of the knob is multi-view and if multi-dimensional
YAML::Node valueNode = node[nodeType];
_dataType = dataTypeFromString(nodeType);
// If the "Value" is a map, this can be either a multi-view knob or a single-view
// and single-dimensional knob with animation.
// Check to find any of the keys of a single dimension map. If we find it, that means
// this is not the multi-view map and that this is a single-dimensional knob
if (!valueNode.IsMap()) {
decodeValueNode("Main", valueNode);
} else {
if (valueNode["Curve"] || valueNode["pyMultiExpr"] || valueNode["pyExpr"] || valueNode["exprtk"] || valueNode["N"] || valueNode["T"] ||
valueNode["K"] || valueNode["D"] || valueNode["V"]) {
decodeValueNode("Main", valueNode);
} else {
// Multi-view
for (YAML::const_iterator it = valueNode.begin(); it != valueNode.end(); ++it) {
decodeValueNode(it->first.as<std::string>(), it->second);
}
}
}
return true;
}
