C++ ptree::get_child方法代码示例

//------------------------------------------------------------------------------
void
Image::set(ptree pt)
{
    if(pt.get_child_optional("UV"))        this->setUV(Box(pt.get_child("UV")), getBoolFromPT(pt, "UV.normalized", false));
    if(pt.get_child_optional("NinePatch")) this->setNinePatchData(NinePatchData(pt.get_child("NinePatch")));
    if(pt.get_child_optional("color"))     this->color = Color(pt.get("color", "#FFF"));
};

void AVRRobot::Config::readTree(const ptree &pt) {
	compass.readTree(pt.get_child("compass"));
	sonar1.readTree(pt.get_child("sonar1"));
	sonar2.readTree(pt.get_child("sonar2"));
	wheels.readTree(pt.get_child("wheels"));
	stepper.readTree(pt.get_child("stepper"));
}

bool AnimaMaterial::ReadObject(const ptree& objectTree, AnimaScene* scene, bool readName)
{
	try
	{
		if(readName)
			SetName(objectTree.get<AnimaString>("AnimaMaterial.Name"));
		
		for(auto& shadersName : objectTree.get_child("AnimaMaterial.ShaderNames"))
		{
			if(shadersName.first == "ShaderName")
			{
				AnimaString shaderName = shadersName.second.get_value<AnimaString>("");
				_shadersNames.push_back(shaderName);
			}
		}
		
		ptree mappedValuesTree = objectTree.get_child("AnimaMaterial.MappedValues");
		
		return AnimaMappedValues::ReadObject(mappedValuesTree, scene, false);
	}
	catch (boost::property_tree::ptree_bad_path& exception)
	{
		AnimaLogger::LogMessageFormat("ERROR - Error parsing material: %s", exception.what());
		return false;
	}
	catch (boost::property_tree::ptree_bad_data& exception)
	{
		AnimaLogger::LogMessageFormat("ERROR - Error parsing material: %s", exception.what());
		return false;
	}
}

void WheelsControl::Config::readTree(const ptree &pt) {
	left.readTree(pt.get_child("left"));
	right.readTree(pt.get_child("right"));
	back.readTree(pt.get_child("back"));

	turnhysteresis = (int16_t)pt.get<int>("turnhysteresis");
}

void DriveEquation::Config::readTree(const ptree &pt) {
	left.readTree(pt.get_child("left"));
	right.readTree(pt.get_child("right"));
	back.readTree(pt.get_child("back"));

	wheelangleoffset = Angle::fromDegrees(pt.get<float>("wheelangleoffset_deg"));
	minspeed = pt.get<float>("minspeed");
}

void AttackCommand::deserialize(ptree serial)
{
    assertCompatibility(serial.get<std::string>("type"), "AttackCommand");
    queued = serial.get<bool>("queued");
    time = _atoi64(serial.get<string>("time").c_str());
    unit.deserialize(serial.get_child("unit"));
    target.deserialize(serial.get_child("target"));
}

 /// Parses relation as simple relation with non-relation children. If child is single, then
 /// calls visitor with this child instead of relation.
 void processSimpleRelation(Visitor &visitor, std::uint32_t featureId, const ptree &feature) const {
   auto relation = parseRelation(featureId, feature.get_child("geometry.coordinates"));
   if (relation.elements.size()==1) {
     parseProperties(*relation.elements[0], featureId, feature.get_child("properties"));
     visitor.add(*relation.elements[0]);
   } else {
     parseProperties(relation, featureId, feature.get_child("properties"));
     visitor.add(relation);
   }
 }

//------------------------------------------------------------------------------
void
WTextInput::_set(ptree n)
{
	WText::_set(n);

	if(n.get_child_optional("border_normal"))
		this->setBorderNormal (kernel->graphicsMgr->loadImage(n.get_child("border_normal")));

	if(n.get_child_optional("border_focused"))
		this->setBorderFocused(kernel->graphicsMgr->loadImage(n.get_child("border_focused")));
};

Department
parseDepartment(const ptree& tree)
{
    std::vector<Employee> empls;
    for (const auto& child : tree.get_child("employees", {}))
        empls.push_back(parseEmployee(child.second));

    std::vector<Department> depts;
    for (const auto& child : tree.get_child("departments", {}))
        depts.push_back(parseDepartment(child.second));

    return {tree.get<std::string>("name"), empls, depts};
}

 /// Parses relation with relations from multipolygon and notifies visitor.
 void parseMultiPolygon(Visitor &visitor, std::uint32_t featureId, const ptree &feature) const {
   utymap::entities::Relation relation;
   parseProperties(relation, featureId, feature.get_child("properties"));
   for (const ptree::value_type &geometry : feature.get_child("geometry.coordinates")) {
     auto child = parseRelation(featureId, geometry.second);
     if (child.elements.size()==1) {
       FoldRelation fold;
       child.elements[0]->accept(fold);
       relation.elements.push_back(fold.element);
     } else {
       relation.elements.push_back(std::make_shared<utymap::entities::Relation>(child));
     }
   }
   visitor.add(relation);
 }

void BasicTest::CheckProperty(int type, const std::string &name)
{
    ptree element_pt = pt_.get_child("property." + name);
    const teamstyle16::Property &element_info = teamstyle16::kProperty[type];

    EXPECT_EQ(element_pt.get("level", -1),
              element_info.level) << "Element type: " << name;
    EXPECT_EQ(element_pt.get("health_max", -1),
              element_info.health_max) << "Element type: " << name;
    EXPECT_EQ(element_pt.get("fuel_max", -1),
              element_info.fuel_max) << "Element type: " << name;
    EXPECT_EQ(element_pt.get("ammo_max", -1),
              element_info.ammo_max) << "Element type: " << name;
    EXPECT_EQ(element_pt.get("ammo_once", -1),
              element_info.ammo_once) << "Element type: " << name;
    EXPECT_EQ(element_pt.get("metal_max", -1),
              element_info.metal_max) << "Element type: " << name;
    EXPECT_EQ(element_pt.get("speed", -1),
              element_info.speed) << "Element type: " << name;
    EXPECT_EQ(element_pt.get("cost", -1),
              element_info.cost) << "Element type: " << name;
    EXPECT_EQ(element_pt.get("build_round", -1),
              element_info.build_round) << "Element type: " << name;
    EXPECT_EQ(element_pt.get("population", -1),
              element_info.population) << "Element type: " << name;
}

// load
void configuration::load(const ptree& in_conf) {
  try {

    settings_ = in_conf.get_child(settings_path_);
    LOG_INFO(settings_path_, "Loading settings");

    auto model = settings_.get_optional<std::string>(model_key_);
    if (!model) {
      throw configuration_error("model descriptor '" + model_key_ +
                                "' has to be set in " + settings_path_);
    }
    defaults_path_ += "." + *model;
    auto def = in_conf.get_child_optional(defaults_path_);
    if (def) {
      LOG_INFO(settings_path_, *model + " defaults found.");
      defaults_ = *def;
    } else {
      LOG_INFO(settings_path_, "No default settings provided for this board.");
    }
  } catch (ptree_bad_path& e) {
    throw path_error(e.path<std::string>());
  } catch (ptree_error& e) {
    // shouldn't happen
    throw configuration_error("Processing error", e.what());
  }
}

boost::shared_ptr<scxml_parser::transition> scxml_parser::parse_transition(const ptree &pt)
{
	const ptree &xmlattr = pt.get_child("<xmlattr>");
	boost::shared_ptr<transition> tr = boost::make_shared<transition>();
	try {
		using namespace boost::algorithm;
		boost::optional<string> target(xmlattr.get_optional<string>("target"));
		if(target) split(tr->target, *target, is_any_of(" "), token_compress_on);
		if(tr->target.size() > 1) parallel_target_sizes.insert(tr->target.size());
		tr->event = xmlattr.get_optional<string>("event");

		for (ptree::const_iterator it = pt.begin(); it != pt.end(); ++it) {
			if (it->first == "<xmlcomment>") ; // ignore comments
			else if (it->first == "<xmlattr>") ; // ignore, parsed above
			else if (it->first == "script") tr->actions.push_back(parse_script(it->second));
			else if (it->first == "log") tr->actions.push_back(parse_log(it->second));
			else if (it->first == "raise") tr->actions.push_back(parse_raise(it->second));
			else cerr << "warning: unknown item '" << it->first << "' in <transition>" << endl;
		}
	}
	catch (ptree_error e) {
		cerr << "error: transition: " << e.what() << endl;
		exit(1);
	}
	return tr;
}

        bool get_child(ptree& ptin, const std::string& path, ptree& ptout)
        {
            static boost::mutex io_mutex;
			boost::mutex::scoped_lock lock(io_mutex);
			//if(&ptin)return false;
			try
			{
			     ptout = ptin.get_child(path);
			     return true;
			}
			catch(std::exception& err)
			{
                LOG_BASELINE_ERROR<< "json get_child(): has error, " << err.what();
				//return (ptree&)NULL;
				return false;
            }
            catch(...)
            {
                LOG_BASELINE_ERROR << "json get_child(): has unknown error!\n";
				//return (ptree&)NULL;
				return false;
            }
			//return (ptree&)NULL;
			return false;
        }

void LisLinearSolver::setOption(const ptree &option)
{
    boost::optional<ptree> ptSolver = option.get_child("LinearSolver");
    if (!ptSolver)
        return;

    boost::optional<std::string> solver_type = ptSolver->get_optional<std::string>("solver_type");
    if (solver_type) {
        _option.solver_type = _option.getSolverType(*solver_type);
    }
    boost::optional<std::string> precon_type = ptSolver->get_optional<std::string>("precon_type");
    if (precon_type) {
        _option.precon_type = _option.getPreconType(*precon_type);
    }
    boost::optional<std::string> matrix_type = ptSolver->get_optional<std::string>("matrix_type");
    if (matrix_type) {
        _option.matrix_type = _option.getMatrixType(*matrix_type);
    }
    boost::optional<double> error_tolerance = ptSolver->get_optional<double>("error_tolerance");
    if (error_tolerance) {
        _option.error_tolerance = *error_tolerance;
    }
    boost::optional<int> max_iteration_step = ptSolver->get_optional<int>("max_iteration_step");
    if (max_iteration_step) {
        _option.max_iterations = *max_iteration_step;
    }
}