C++ Node::IsSequence方法代码示例

    bool AreDetailsEqual(const YAML::Node& lhs, const YAML::Node& rhs) {
        //We want to check for plugin order and messages. 
        if (lhs.IsSequence() && rhs.IsSequence()) {
            std::list<std::string> lhs_names, rhs_names;
            std::list<Message> lhs_messages, rhs_messages;
            
            for (YAML::const_iterator it = lhs.begin(); it != lhs.end(); ++it) {
                if ((*it)["name"])
                    lhs_names.push_back((*it)["name"].as<std::string>());
                if ((*it)["messages"]) {
                    std::list<Message> messages = (*it)["messages"].as< std::list<Message> >();
                    lhs_messages.insert(lhs_messages.end(), messages.begin(), messages.end());
                }
            }
            for (YAML::const_iterator it = rhs.begin(); it != rhs.end(); ++it) {
                if ((*it)["name"])
                    rhs_names.push_back((*it)["name"].as<std::string>());
                if ((*it)["messages"]) {
                    std::list<Message> messages = (*it)["messages"].as< std::list<Message> >();
                    rhs_messages.insert(rhs_messages.end(), messages.begin(), messages.end());
                }
            }

            return lhs_names == rhs_names && lhs_messages == rhs_messages;
        }
        else
            return false;
    }

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;
}

bool YamlPath::get(YAML::Node root, YAML::Node& out) {
    size_t beginToken = 0, endToken = 0, pathSize = codedPath.size();
    auto delimiter = MAP_DELIM; // First token must be a map key.
    while (endToken < pathSize) {
        if (!root.IsDefined()) {
            return false; // A node before the end of the path was mising, quit!
        }
        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]);
            if (root.IsSequence()) {
                root.reset(root[index]);
            } else {
                return false;
            }
        } else if (delimiter == MAP_DELIM) {
            auto key = codedPath.substr(beginToken, endToken - beginToken);
            if (root.IsMap()) {
                root.reset(root[key]);
            } else {
                return false;
            }
        } else {
            return false; // Path is malformed, return null node.
        }
        delimiter = codedPath[endToken]; // Get next character as the delimiter.
        ++endToken; // Move past the delimiter.
    }
    // Success! Assign the result.
    out.reset(root);
    return true;
}

// 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 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;
    }

Vector from_yaml(type_t<Vector>, const YAML::Node& value)
{
    if (!value.IsSequence())
        throw deserialize_error{"type must be a sequence but is " +
                                yaml_type_name(value)};

    Vector ret{};
    vector_reserve(ret, value.size(), has_reserve<Vector>{});

    for (const auto& item : value)
    {
        try
        {
            ret.push_back(yaml::deserialize<typename Vector::value_type>(item));
        }
        catch (deserialize_error& ex)
        {
            std::string msg = "error when deserializing element " +
                              std::to_string(ret.size());
            ex.add(msg.c_str());
            throw;
        }
    }

    return ret;
}

/*
 * This function checks to see if the current YAML::Node contains only keys
 * that we care about. Unknown keys should cause PLFS to spit out an error
 * rather than being silently ignored.
 * This is a bit nasty as it drills through the entire tree recursively
 * but it will catch any unknowns in one pass
 *
 * Returns true if all keys are valid
 *
 * Returns false if unknown keys are found and sets bad_key to an error
 * message that points out what key is invalid
 */
bool
is_valid_node(const YAML::Node node, string** bad_key) {
    set<string> key_list(Valid_Keys, 
                         Valid_Keys + 
                         (sizeof(Valid_Keys) / sizeof(Valid_Keys[0]))
                        );
    string key;
    string err = "\nBad key or value in plfsrc: ";
    if(node.IsMap()) {
        for(YAML::const_iterator it=node.begin();it!=node.end();it++) {
            if(!it->first.IsNull()) {
                key = it->first.as<string>();
                if(!is_valid_node(node[key],bad_key)) // recurse
                    return false;
                if(key_list.find(key) == key_list.end()) {
                    err.append(key);
                    *bad_key = new string (err);
                    return false; // this is an unknown key
                }
            }
        }
    }
    else if (node.IsSequence()) {
        for(unsigned int i = 0; i < node.size(); i++)
            if(!is_valid_node(node[i],bad_key)) // recurse
                return false;
    }
    else if (node.IsScalar() && node.as<string>().find(" ") != string::npos) {
        err.append(node.as<string>());
        *bad_key = new string (err);
        return false; // no spaces in values allowed
    }
    return true; // all keys are valid
}

bool ParamManager::load_from_file(std::string filename)
{
  try
  {
    YAML::Node root = YAML::LoadFile(filename);
    assert(root.IsSequence());

    for (int i = 0; i < root.size(); i++)
    {
      if (root[i].IsMap() && root[i]["name"] && root[i]["type"] && root[i]["value"])
      {
        if (is_param_id(root[i]["name"].as<std::string>()))
        {
          Param param = params_.find(root[i]["name"].as<std::string>())->second;
          if ((MAV_PARAM_TYPE) root[i]["type"].as<int>() == param.getType())
          {
            set_param_value(root[i]["name"].as<std::string>(), root[i]["value"].as<double>());
          }
        }
      }
    }

    return true;
  }
  catch (...)
  {
    return false;
  }
}

std::tuple<Ts...> from_yaml(type_t<std::tuple<Ts...>>, const YAML::Node& value)
{
    if (!value.IsSequence())
        throw deserialize_error{"type must be a sequence but is " +
                                yaml_type_name(value)};

    return tuple_from_yaml<std::tuple<Ts...>>(
        value, make_index_sequence<sizeof...(Ts)>{});
}

void
NonKeyParamsSerialization::decode(const YAML::Node& node)
{
    if (!node.IsSequence() || node.size() != 3) {
        throw YAML::InvalidNode();
    }
    dataTypeSize = node[0].as<std::size_t>();
    nComps = node[1].as<int>();
    bounds.decode(node[2]);
}

int main(int argc, char **argv) {
  ros::init(argc, argv, "apriltag_ros");
  ros::NodeHandle nh("~");
  image_transport::ImageTransport it(nh);
  image_transport::CameraSubscriber camera_sub =
      it.subscribeCamera("image_raw", 1, cam_callback);
  pose_pub = nh.advertise<geometry_msgs::PoseStamped>("pose_cam", 1);

  //  load YAML file with tag positions
  std::string yamlPath;
  if (!nh.hasParam("map_file")) {
    ROS_ERROR("Error: You must specify the map_file parameter.");
    return -1;
  }
  nh.getParam("map_file", yamlPath);

  try {
    YAML::Node mapNode = YAML::LoadFile(yamlPath);

    if (!mapNode.IsSequence()) {
      throw std::runtime_error("YAML file should be a sequence of tags");
    }

    for (size_t i=0; i < mapNode.size(); i++) {
      apriltag_ros::Tag tag = mapNode[i].as<apriltag_ros::Tag>();
      tagsWorld[tag.id] = tag;  //  add to map
    }

    if (tagsWorld.empty()) {
      throw std::runtime_error("No tags were loaded");
    } else {
      ROS_INFO("Loaded %lu tags from the map file", tagsWorld.size());
    }
  }
  catch(std::exception& e) {
    ROS_ERROR("Error: Failed to load map file: %s", yamlPath.c_str());
    ROS_ERROR("Reason: %s", e.what());
    return -1;
  }

  image_pub = nh.advertise<sensor_msgs::Image>("image", 1);
  tag_pub   = nh.advertise<apriltag_ros::tags>("tags", 1);

  ros::Rate r(10.0);
  while(nh.ok())
  {
    r.sleep();
    ros::spinOnce();
  }

  return 0;
}

static void decodeBezierCPCurve(const YAML::Node& node, double* x, CurveSerialization* curve)
{
    try {
        if (node.IsSequence()) {
            curve->decode(node);
            if (!curve->keys.empty()) {
                *x = curve->keys.front().value;
            }
        } else {
            *x = node.as<double>();
        }
    } catch (const YAML::BadConversion& /*e*/) {
        assert(false);
    }
}

void
BezierCPSerialization::decode(const YAML::Node& node)
{
    if (!node.IsSequence() || node.size() != 6) {
        throw YAML::InvalidNode();
    }

    decodeBezierCPCurve(node[0], &x, &xCurve);
    decodeBezierCPCurve(node[1], &y, &yCurve);
    decodeBezierCPCurve(node[2], &leftX, &leftCurveX);
    decodeBezierCPCurve(node[3], &leftY, &leftCurveY);
    decodeBezierCPCurve(node[4], &rightX, &rightCurveX);
    decodeBezierCPCurve(node[5], &rightY, &rightCurveY);

}

static bool decodeMat(const YAML::Node &node, kr::Mat<Scalar, Rows, Cols> &M) {
  static_assert(Rows != Eigen::Dynamic && Cols != Eigen::Dynamic,
                "Static matrices only");

  if (!node.IsSequence() || node.size() != Rows*Cols) {
    return false;
  }

  for (int i = 0; i < Rows; i++) {
    for (int j = 0; j < Cols; j++) {
      M(i, j) = static_cast<Scalar>(node[i * Cols + j].as<double>());
    }
  }
  return true;
}

void GameConfiguration::parseYAML(const string archivoAParsear){
	//VERIFICA SI ARCHIVO ESTA CORRUPTO O TIENE FORMATO VALIDO DE YAML, EN ESE CASO PARSEA DIRECTAMENTE EL ARCHIVO POR DEFECTO
	this->loadFile(archivoAParsear);

	this->pantalla = PantallaConfig(this->nodoRaiz["pantalla"]);
	this->configuracion = ConfiguracionConfig(this->nodoRaiz["configuracion"]);
	YAML::Node nodoTipos = this->nodoRaiz["tipos"];
	this->escenario = EscenarioConfig(this->nodoRaiz["escenario"]);


	if(!nodoTipos.IsSequence()){
		Log().Get(TAG,logERROR) << "Nodo tipos tiene que ser una secuencia";
	} else {
		for (std::size_t i=0;i < nodoTipos.size();i++) {
		  TipoConfig* newNodo = new TipoConfig(nodoTipos[i]);
		  tipos.push_back(*newNodo);
		}
	}
}