void linear_population_growth_generator::parseConfig( boost::property_tree::ptree & config ) {
if( config.get_child_optional( "A" ) == boost::none ) {
config.put( "A", m_A);
} else {
m_A = config.get<double>( "A", m_A );
}
if( config.get_child_optional( "B" ) == boost::none ) {
config.put("B", m_B );
} else {
m_B = config.get<double>( "B", m_B );
}
}
void ReadParticles(PartList &list,
const boost::property_tree::ptree &pt) {
auto particleTree = pt.get_child_optional("ParticleList");
if (!particleTree)
return;
for (auto const &v : particleTree.get()) {
auto tmp = ParticleProperties(v.second);
auto p = std::make_pair(tmp.name(), tmp);
auto last = list.insert(p);
if (!last.second) {
LOG(INFO) << "ReadParticles() | Particle " << last.first->first
<< " already exists in list. We overwrite its parameters!";
last.first->second = tmp;
}
tmp = last.first->second;
// cparity is optional
double cparity = 0.0;
try {
cparity = tmp.GetQuantumNumber("Cparity");
} catch (std::exception &ex) {
}
LOG(DEBUG) << "ReadParticles() | Particle " << tmp.name()
<< " (id=" << tmp.GetId() << ") "
<< " J(PC)=" << tmp.GetSpinQuantumNumber("Spin") << "("
<< tmp.GetQuantumNumber("Parity") << cparity << ") "
<< " mass=" << tmp.GetMass()
<< " decayType=" << tmp.GetDecayType();
}
return;
}
bool rai_daemon::daemon_config::upgrade_json (unsigned version_a, boost::property_tree::ptree & tree_a)
{
auto result (false);
switch (version_a)
{
case 1:
{
auto opencl_enable_l (tree_a.get_optional <bool> ("opencl_enable"));
if (!opencl_enable_l)
{
tree_a.put ("opencl_enable", "false");
}
auto opencl_l (tree_a.get_child_optional ("opencl"));
if (!opencl_l)
{
boost::property_tree::ptree opencl_l;
opencl.serialize_json (opencl_l);
tree_a.put_child ("opencl", opencl_l);
}
tree_a.put ("version", "2");
result = true;
}
case 2:
break;
default:
throw std::runtime_error ("Unknown daemon_config version");
}
return result;
}
void Key::unSerialize(boost::property_tree::ptree& node)
{
LOG(LogLevel::INFOS) << "Unserializing Key...";
if (node.get_child_optional("KeyDiversification"))
{
boost::property_tree::ptree keydivnode = node.get_child("KeyDiversification");
d_key_diversification = KeyDiversification::getKeyDiversificationFromType(keydivnode.get_child("<xmlattr>.keyDiversificationType").get_value<std::string>());
boost::property_tree::ptree kdnode = keydivnode.get_child(d_key_diversification->getDefaultXmlNodeName());
if (!kdnode.empty())
{
d_key_diversification->unSerialize(kdnode);
}
}
d_storeCipheredData = node.get_child("IsCiphered").get_value<bool>(false);
uncipherKeyData(node);
LOG(LogLevel::INFOS) << "Unserializing Key storage...";
d_key_storage = KeyStorage::getKeyStorageFromType(static_cast<KeyStorageType>(node.get_child("<xmlattr>.keyStorageType").get_value<unsigned int>()));
if (d_key_storage)
{
boost::property_tree::ptree ksnode = node.get_child(d_key_storage->getDefaultXmlNodeName());
if (!ksnode.empty())
{
d_key_storage->unSerialize(ksnode);
}
}
}
std::vector<STEMScannerGeometry*> TF_Datasource::parseProjectionStackProperties(const boost::property_tree::ptree& node, unsigned int imageCount)
{
if (!node.get_child_optional("convergent").is_initialized())
throw Exception("TF_Datasource can only read projection metadata of type TF_ProjectionMetaData");
std::string filename = node.get_child("image").get<std::string>("<xmlattr>.filename");
float tiltAngle = node.get_child("tiltAngle").get<float>("<xmlattr>.value");
float focalDistanceBase = node.get_child("focalDistanceBase").get<float>("<xmlattr>.value");
float focusAtImage = node.get_child("focusAtImage").get<float>("<xmlattr>.value");
float focalDistanceBetweenImages = node.get_child("focalDistanceBetweenImages").get<float>("<xmlattr>.value");
float beamOpeningAngle = node.get_child("beamOpeningAngle").get<float>("<xmlattr>.value");
boost::filesystem::path pathToImage( filename );
unsigned int imagesInStack = ImageDeserializer::getNumberOfImagesInStack( getAbsoluteImageLocation(pathToImage).string() );
std::vector<STEMScannerGeometry*> result;
for (unsigned int i = 0; i < imagesInStack; i++)
{
ScannerGeometry* rotatedGeometry = satRotator.createRotatedScannerGeometry(tiltAngle, 0.0f);
STEMScannerGeometry* stemGeometry = dynamic_cast<STEMScannerGeometry*>(rotatedGeometry);
stemGeometry->setFocalDifferenceBetweenImages(focalDistanceBetweenImages);
stemGeometry->setConfocalOpeningHalfAngle(beamOpeningAngle);
float focusPosition = focalDistanceBase + (focalDistanceBetweenImages * (float) (imagesInStack-i) );
stemGeometry->setFocalDepth(focusPosition);
stemGeometry->setTiltAngle(tiltAngle);
result.push_back(stemGeometry);
}
return result;
}
ImageStackDirectoryDatasource::MetaDataNode ImageStackDirectoryDatasource::parseProjectionProperties(const boost::property_tree::ptree& node) const
{
MetaDataNode props;
props.onLogarithmicScale = node.get_child_optional("logscale").is_initialized();
props.tiltAngle = node.get_child("tiltAngle").get<float>("<xmlattr>.value");
props.xmlNode = node;
return props;
}
void ptree_entry_to_query(const boost::property_tree::ptree& ptree,
const std::string& entry_name,
LayerParameters* p_params) {
auto given_entry = ptree.get_child_optional(entry_name);
if (given_entry) {
(*p_params)[entry_name] = given_entry.get().data();
}
}
bool upgrade_json (unsigned version_a, boost::property_tree::ptree & tree_a)
{
auto result (false);
switch (version_a)
{
case 1:
{
rai::account account;
account.decode_account (tree_a.get<std::string> ("account"));
tree_a.erase ("account");
tree_a.put ("account", account.to_account ());
tree_a.erase ("version");
tree_a.put ("version", "2");
result = true;
}
case 2:
{
boost::property_tree::ptree rpc_l;
rpc.serialize_json (rpc_l);
tree_a.put ("rpc_enable", "false");
tree_a.put_child ("rpc", rpc_l);
tree_a.erase ("version");
tree_a.put ("version", "3");
result = true;
}
case 3:
{
auto opencl_enable_l (tree_a.get_optional<bool> ("opencl_enable"));
if (!opencl_enable_l)
{
tree_a.put ("opencl_enable", "false");
}
auto opencl_l (tree_a.get_child_optional ("opencl"));
if (!opencl_l)
{
boost::property_tree::ptree opencl_l;
opencl.serialize_json (opencl_l);
tree_a.put_child ("opencl", opencl_l);
}
tree_a.put ("version", "4");
result = true;
}
case 4:
break;
default:
throw std::runtime_error ("Unknown qt_wallet_config version");
}
return result;
}
ParticleProperties::ParticleProperties(boost::property_tree::ptree pt)
: Properties(pt.get<std::string>("<xmlattr>.Name"), pt.get<pid>("Pid")) {
for (const auto &v : pt.get_child("")) {
if (v.first == "QuantumNumber") {
// QuantumNumbers which can be of type int or ComPWA::Spin
std::string type = v.second.get<std::string>("<xmlattr>.Type");
// We have to distinguish between spin and integer quantum numbers
if (v.second.get<std::string>("<xmlattr>.Class") == "Spin") {
auto value = v.second.get<double>("<xmlattr>.Value");
double valueZ = 0.0;
try { // Projection of spin is optional (e.g. (I,I3))
valueZ = v.second.get<double>("<xmlattr>.Projection");
} catch (std::exception &ex) {
}
spinQuantumNumbers_.insert(
std::make_pair(type, ComPWA::Spin(value, valueZ)));
} else if (v.second.get<std::string>("<xmlattr>.Class") == "Int") {
auto value = v.second.get<int>("<xmlattr>.Value");
intQuantumNumbers_.insert(std::make_pair(type, value));
} else {
throw BadParameter(
"ParticleProperties::ParticleProperties() | "
"QuantumNumber is neither of type 'Spin' nor of type "
"'Int'!");
}
} else if (v.first == "Parameter") {
// Parameter (e.g. Mass)
if (v.second.get<std::string>("<xmlattr>.Type") != "Mass")
continue;
Mass = FitParameter();
Mass.load(v.second);
} else {
}
}
// Info on the particle decay is stored as it is as property_tree and later
// used by AbstractDynamicalFunctions (e.g. RelativisticBreitWigner).
auto decayInfo = pt.get_child_optional("DecayInfo");
if (decayInfo) {
DecayInfo = decayInfo.get();
} else {
DecayInfo.put("<xmlattr>.Type", "Stable");
}
}
void ReprojectPCL::updateConfig(const boost::property_tree::ptree &pt) {
BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << " " << id();
using namespace boost::property_tree;
Filter::updateConfig(pt);
boost::optional<const boost::property_tree::ptree& > ocvo = pt.get_child_optional( "options.cameraMatrix" );
if (ocvo.is_initialized()) {
if( toffy::commons::checkOCVNone(*ocvo) ) {
boost::property_tree::ptree os;
os.put_child("cameraMatrix",*ocvo);
cv::FileStorage fs = commons::loadOCVnode(os);
//Mat val;
fs.getFirstTopLevelNode() >> _cameraMatrix;
cout << fs.getFirstTopLevelNode().name() << endl;
fs.release();
} else
void
plugin_factory::load_settings(const boost::property_tree::ptree& settings)
{
using boost::property_tree::ptree;
BOOST_AUTO(path, settings.get_child_optional("path"));
if (path) {
BOOST_FOREACH(const ptree::value_type& v, *path) {
boost::filesystem::path plugin_path(v.second.get<std::string>(""));
if (plugin_path.is_absolute()) {
load_dir(plugin_path);
}
else {
load_dir(boost::filesystem::current_path() / plugin_path);
}
}
}
else {
/* static */ bool Parser::parse_description( std::string & description, boost::property_tree::ptree const & root )
{
OptionalPTree values = root.get_child_optional( "values" );
if( !values )
{
return false;
}
boost::optional<std::string> desc = values->get_optional<std::string>( "statusmessage" );
if( !desc )
{
return false;
}
description = *desc;
return true;
}
/* static */ bool Parser::parse_server_state(ServerState & server_state, GazeData & gaze_data, CalibResult & calib_result, Screen & screen, boost::property_tree::ptree const & root, bool& has_gaze_data, bool& has_calib_result)
{
OptionalPTree values = root.get_child_optional("values");
if (!values)
{
return false;
}
Parser::parse_calib_result(calib_result, root, has_calib_result);
OptionalPTree frame = values->get_child_optional("frame");
has_gaze_data = static_cast<bool>(frame);
if (has_gaze_data)
{
gaze_data.time = frame->get<int>("time");
gaze_data.fix = frame->get<bool>("fix");
gaze_data.state = frame->get<int>("state");
parse_point2d(gaze_data.raw, frame->get_child("raw"));
parse_point2d(gaze_data.raw, frame->get_child("avg"));
parse_eye(gaze_data.lefteye, frame->get_child("lefteye"));
parse_eye(gaze_data.righteye, frame->get_child("righteye"));
}
server_state.push = values->get<bool>("push", server_state.push);
server_state.heartbeatinterval = values->get<int>("heartbeatinterval", server_state.heartbeatinterval);
server_state.version = values->get<int>("version", server_state.version);
server_state.trackerstate = values->get<int>("trackerstate", server_state.trackerstate);
server_state.framerate = values->get<int>("framerate", server_state.framerate);
server_state.iscalibrated = values->get<bool>("iscalibrated", server_state.iscalibrated);
server_state.iscalibrating = values->get<bool>("iscalibrating", server_state.iscalibrating);
screen.screenindex = values->get<int>("screenindex", screen.screenindex);
screen.screenresw = values->get<int>("screenresw", screen.screenresw);
screen.screenresh = values->get<int>("screenresh", screen.screenresh);
screen.screenpsyw = values->get<float>("screenpsyw", screen.screenpsyw);
screen.screenpsyh = values->get<float>("screenpsyh", screen.screenpsyh);
return true;
}
bool AstProvider::parse(const ::boost::property_tree::ptree& tree, MessageCallback callback)
{
boost::optional< const pt::ptree& > child = tree.get_child_optional("provider");
if (!child) {
CompileMessage error(CompileMessage::type_t::Error, CdefMessage::CDE101, callback, "Provider block not defined");
return false;
}
// get the name associated with this collection
_label = child.get().get_value<string>();
// Loop through all properties on this level
for (const pt::ptree::value_type &v : child.get())
{
if (boost::iequals(v.first.data(), "application"))
_application = child.get().get<string>("application");
else if (boost::iequals(v.first.data(), "uuid")) {
// read and Validate the uuid
string uuid = v.second.data();
if (!isValidUuid(uuid)) {
CompileMessage error(CompileMessage::type_t::Error, CdefMessage::CDE102, callback, "The provider '%s' contains an invalid uuid", _label.c_str());
return false;
}
_uuid = string_generator()(uuid);
}
else if (boost::iequals(v.first.data(), "counterset")) {
AstCounterSetPtr counterset = AstCounterSet::create();
if(!counterset->parse(v.second, callback))
return false;
counterset->setParent(shared_from_this());
// the contructor will throw an exception if a syntax error was detected.
this->push_back(counterset);
}
}
return isSane(callback);
}
void Key::unSerialize(boost::property_tree::ptree& node)
{
LOG(LogLevel::INFOS) << "Unserializing Key...";
if (node.get_child_optional("KeyDiversification"))
{
boost::property_tree::ptree keydivnode = node.get_child("KeyDiversification");
d_key_diversification = KeyDiversification::getKeyDiversificationFromType(keydivnode.get_child("<xmlattr>.keyDiversificationType").get_value<std::string>());
boost::property_tree::ptree kdnode = keydivnode.get_child(d_key_diversification->getDefaultXmlNodeName());
if (!kdnode.empty())
{
d_key_diversification->unSerialize(kdnode);
std::shared_ptr<ComputerMemoryKeyStorage> cmks = std::dynamic_pointer_cast<ComputerMemoryKeyStorage>(d_key_diversification);
if (cmks)
{
if (cmks->getRandom())
{
fromString(AccessInfo::generateSimpleKey(getLength()));
}
}
}
}
d_storeCipheredData = node.get_child("IsCiphered").get_value<bool>(false);
uncipherKeyData(node);
LOG(LogLevel::INFOS) << "Unserializing Key storage...";
d_key_storage = KeyStorage::getKeyStorageFromType(static_cast<KeyStorageType>(node.get_child("<xmlattr>.keyStorageType").get_value<unsigned int>()));
if (d_key_storage)
{
boost::property_tree::ptree ksnode = node.get_child(d_key_storage->getDefaultXmlNodeName());
if (!ksnode.empty())
{
d_key_storage->unSerialize(ksnode);
}
}
}
TEST (PCL, KdTreeFLANN_32_vs_64_bit)
{
KdTreeFLANN<PointXYZ> tree;
tree.setInputCloud (cloud_in);
std::vector<std::vector<int> > nn_indices_vector;
for (size_t i = 0; i < cloud_in->size (); ++i)
if (isFinite ((*cloud_in)[i]))
{
std::vector<int> nn_indices;
std::vector<float> nn_dists;
tree.radiusSearch ((*cloud_in)[i], 0.02, nn_indices, nn_dists);
nn_indices_vector.push_back (nn_indices);
}
for (size_t vec_i = 0; vec_i < nn_indices_vector.size (); ++vec_i)
{
char str[512];
sprintf (str, "point_%d", int (vec_i));
boost::optional<boost::property_tree::ptree&> tree = xml_property_tree.get_child_optional (str);
if (!tree)
FAIL ();
int vec_size = tree.get ().get<int> ("size");
EXPECT_EQ (vec_size, nn_indices_vector[vec_i].size ());
for (size_t n_i = 0; n_i < nn_indices_vector[vec_i].size (); ++n_i)
{
sprintf (str, "nn_%d", int (n_i));
int neighbor_index = tree.get ().get<int> (str);
EXPECT_EQ (neighbor_index, nn_indices_vector[vec_i][n_i]);
}
}
}
void parse_configuration( boost::property_tree::ptree & config ) {
boost::property_tree::ptree lconfig;
if( config.get_child_optional( "mutation" ) != boost::none ) {
lconfig = config.get_child( "mutation" );
}
if( lconfig.get_child_optional( "mutation_per_sequence" ) == boost::none ) {
lconfig.put("mutation_per_sequence", m_mutation_rate );
} else {
m_mutation_rate = lconfig.get< real_type >( "mutation_per_sequence", m_mutation_rate );
}
if( lconfig.get_child_optional( "rng.seed" ) != boost::none ) {
m_seed = lconfig.get< seed_type >( "rng.seed", m_seed );
}
if( m_seed == 0 ) {
m_seed = clotho::utility::clock_type::now().time_since_epoch().count();
lconfig.put("rng.seed", m_seed );
}
config.put_child( "mutation", lconfig );
}
void Agent::setProperties(const boost::property_tree::ptree& properties) {
static const std::string LOG_LEVEL("log.level");
static const std::string ENDPOINT_SOURCE_PATH("endpoint-sources.filesystem");
static const std::string SERVICE_SOURCE_PATH("service-sources.filesystem");
static const std::string OPFLEX_PEERS("opflex.peers");
static const std::string OPFLEX_SSL_MODE("opflex.ssl.mode");
static const std::string OPFLEX_SSL_CA_STORE("opflex.ssl.ca-store");
static const std::string OPFLEX_SSL_CERT_PATH("opflex.ssl.client-cert.path");
static const std::string OPFLEX_SSL_CERT_PASS("opflex.ssl.client-cert.password");
static const std::string HOSTNAME("hostname");
static const std::string PORT("port");
static const std::string OPFLEX_INSPECTOR("opflex.inspector.enabled");
static const std::string OPFLEX_INSPECTOR_SOCK("opflex.inspector.socket-name");
static const std::string OPFLEX_NOTIF("opflex.notif.enabled");
static const std::string OPFLEX_NOTIF_SOCK("opflex.notif.socket-name");
static const std::string OPFLEX_NOTIF_OWNER("opflex.notif.socket-owner");
static const std::string OPFLEX_NOTIF_GROUP("opflex.notif.socket-group");
static const std::string OPFLEX_NOTIF_PERMS("opflex.notif.socket-permissions");
static const std::string OPFLEX_NAME("opflex.name");
static const std::string OPFLEX_DOMAIN("opflex.domain");
static const std::string RENDERERS_STITCHED_MODE("renderers.stitched-mode");
optional<std::string> logLvl =
properties.get_optional<std::string>(LOG_LEVEL);
if (logLvl) {
setLoggingLevel(logLvl.get());
}
boost::optional<std::string> ofName =
properties.get_optional<std::string>(OPFLEX_NAME);
if (ofName) opflexName = ofName;
boost::optional<std::string> ofDomain =
properties.get_optional<std::string>(OPFLEX_DOMAIN);
if (ofDomain) opflexDomain = ofDomain;
boost::optional<bool> enabInspector =
properties.get_optional<bool>(OPFLEX_INSPECTOR);
boost::optional<std::string> inspSocket =
properties.get_optional<std::string>(OPFLEX_INSPECTOR_SOCK);
if (enabInspector) enableInspector = enabInspector;
if (inspSocket) inspectorSock = inspSocket;
boost::optional<bool> enabNotif =
properties.get_optional<bool>(OPFLEX_NOTIF);
boost::optional<std::string> notSocket =
properties.get_optional<std::string>(OPFLEX_NOTIF_SOCK);
boost::optional<std::string> notOwner =
properties.get_optional<std::string>(OPFLEX_NOTIF_OWNER);
boost::optional<std::string> notGrp =
properties.get_optional<std::string>(OPFLEX_NOTIF_GROUP);
boost::optional<std::string> notPerms =
properties.get_optional<std::string>(OPFLEX_NOTIF_PERMS);
if (enabNotif) enableNotif = enabNotif;
if (notSocket) notifSock = notSocket;
if (notOwner) notifOwner = notOwner;
if (notGrp) notifGroup = notGrp;
if (notPerms) notifPerms = notPerms;
optional<const ptree&> endpointSource =
properties.get_child_optional(ENDPOINT_SOURCE_PATH);
if (endpointSource) {
for (const ptree::value_type &v : endpointSource.get())
endpointSourcePaths.insert(v.second.data());
}
optional<const ptree&> serviceSource =
properties.get_child_optional(SERVICE_SOURCE_PATH);
if (serviceSource) {
for (const ptree::value_type &v : serviceSource.get())
serviceSourcePaths.insert(v.second.data());
}
optional<const ptree&> peers =
properties.get_child_optional(OPFLEX_PEERS);
if (peers) {
for (const ptree::value_type &v : peers.get()) {
optional<std::string> h =
v.second.get_optional<std::string>(HOSTNAME);
optional<int> p =
v.second.get_optional<int>(PORT);
if (h && p) {
opflexPeers.insert(make_pair(h.get(), p.get()));
}
}
}
boost::optional<std::string> confSslMode =
properties.get_optional<std::string>(OPFLEX_SSL_MODE);
boost::optional<std::string> confsslCaStore =
properties.get_optional<std::string>(OPFLEX_SSL_CA_STORE);
boost::optional<std::string> confsslClientCert =
properties.get_optional<std::string>(OPFLEX_SSL_CERT_PATH);
boost::optional<std::string> confsslClientCertPass =
properties.get_optional<std::string>(OPFLEX_SSL_CERT_PASS);
if (confSslMode)
sslMode = confSslMode;
if (confsslCaStore)
sslCaStore = confsslCaStore;
if (confsslClientCert)
sslClientCert = confsslClientCert;
if (confsslClientCertPass)
sslClientCertPass = confsslClientCertPass;
typedef Renderer* (*rend_create)(Agent&);
typedef std::unordered_map<std::string, rend_create> rend_map_t;
static rend_map_t rend_map =
boost::assign::map_list_of(RENDERERS_STITCHED_MODE,
StitchedModeRenderer::create);
for (rend_map_t::value_type& v : rend_map) {
optional<const ptree&> rtree =
properties.get_child_optional(v.first);
if (rtree) {
Renderer* r = v.second(*this);
renderers.push_back(r);
r->setProperties(rtree.get());
}
}
}
/* static */ bool Parser::parse_calib_result( CalibResult & calib_result, boost::property_tree::ptree const & root, bool & has_calib_result )
{
OptionalPTree values = root.get_child_optional( "values" );
has_calib_result = false;
if( !values )
{
return true;
}
OptionalPTree calibresult = values->get_child_optional( "calibresult" );
if( !calibresult )
{
return false;
}
calib_result.result = calibresult->get<bool>( "result" );
calib_result.deg = calibresult->get<float>( "deg" );
calib_result.degl = calibresult->get<float>( "degl" );
calib_result.degr = calibresult->get<float>( "degr" );
OptionalPTree calibpoints = calibresult->get_child_optional( "calibpoints" );
if( !calibpoints )
{
return false;
}
std::vector<CalibPoint> & calibpoints_vector = calib_result.calibpoints;
calibpoints_vector.reserve( calibpoints->size() );
boost::property_tree::ptree::const_iterator it = calibpoints->begin();
boost::property_tree::ptree::const_iterator end = calibpoints->end();
for( ; it != end; ++it )
{
CalibPoint calib_point;
calib_point.state = it->second.get<int>( "state" );
parse_point2d( calib_point.cp, it->second.get_child( "cp" ) );
parse_point2d( calib_point.mecp, it->second.get_child( "mecp" ) );
PTree const & acd = it->second.get_child( "acd" );
calib_point.acd.ad = acd.get<float>( "ad" );
calib_point.acd.adl = acd.get<float>( "adl" );
calib_point.acd.adr = acd.get<float>( "adr" );
PTree const & mepix = it->second.get_child( "mepix" );
calib_point.mepix.mep = mepix.get<float>( "mep" );
calib_point.mepix.mepl = mepix.get<float>( "mepl" );
calib_point.mepix.mepr = mepix.get<float>( "mepr" );
PTree const & asdp = it->second.get_child( "asdp" );
calib_point.asdp.asd = asdp.get<float>( "asd" );
calib_point.asdp.asdl = asdp.get<float>( "asdl" );
calib_point.asdp.asdr = asdp.get<float>( "asdr" );
calibpoints_vector.push_back( calib_point );
}
has_calib_result = true;
return true;
}
Logging::InitResult Logging::Init( const char* processName,
const boost::property_tree::ptree& loggingSection )
{
// Logging configuration settings block
boost::log::settings configSettings;
// Start by loading the core configuration
{
auto coreSection = loggingSection.get_child_optional( "core" );
if( !coreSection.is_initialized() )
{
Logger( "LoggingConfigInit" ).WarningStream() << "Missing 'core' section in logging configuration." << std::endl;
}
else
{
CoreSettings coreSettings;
auto parseResult = coreSettings.Parse( *coreSection );
if( parseResult.Failed() )
{
Logger( "LoggingConfigInit" ).ErrorStream() << "Error parsing 'core' settings in logging configuration. Using Default Config." << std::endl;
g_boostLogManager.DefaultLoggingConfig( processName );
return( InitResult::Failure( ErrorCodes::BAD_CORE_SETTINGS, "Bad Logging Core Settings. Using Default Config." ) );
}
SetIfInitialized( configSettings, "Core.DisableLogging", coreSettings.fieldValue( "disable_logging" ) );
SetIfInitialized( configSettings, "Core.Filter", coreSettings.fieldValue( "filter" ) );
}
}
// Next, the console(s) configuration
{
auto consolesSection = loggingSection.get_child_optional( "consoles" );
auto consoleSection = loggingSection.get_child_optional( "console" );
if( !consolesSection.is_initialized() && !consoleSection.is_initialized() )
{
Logger( "LoggingConfigInit" ).WarningStream() << "No console(s) section in logging configuration." << std::endl;
}
else
{
if( consolesSection.is_initialized() )
{
auto consoleRange = consolesSection->equal_range( "console" );
for( auto itrConsoleSpec = consoleRange.first; itrConsoleSpec != consoleRange.second; ++itrConsoleSpec )
{
ConsoleSpec consoleSpec;
auto parseResult = consoleSpec.Parse( itrConsoleSpec->second );
if( parseResult.Failed() )
{
Logger( "LoggingConfigInit" ).ErrorStream() << "Error parsing 'console' specification in logging configuration. Skipping bad console specification." << std::endl;
continue;
}
std::string prefix = std::string( "Sinks." ) + consoleSpec.sink_name();
configSettings[prefix + ".Destination"] = "Console";
configSettings[prefix + ".AutoFlush"] = consoleSpec.auto_flush();
SetIfInitialized( configSettings, prefix + std::string( ".Filter" ), consoleSpec.fieldValue( "filter" ) );
SetIfInitialized( configSettings, prefix + std::string( ".Format" ), consoleSpec.fieldValue( "format" ) );
SetIfInitialized( configSettings, prefix + std::string( ".Asynchronous" ), consoleSpec.fieldValue( "asynchronous" ) );
}
}
}
if( consoleSection.is_initialized() )
{
ConsoleSpec consoleSpec;
auto parseResult = consoleSpec.Parse( *consoleSection );
if( parseResult.Failed() )
{
Logger( "LoggingConfigInit" ).ErrorStream() << "Error parsing 'console' specification in logging configuration. Skipping bad console specification." << std::endl;
}
else
{
std::string prefix = std::string( "Sinks." ) + consoleSpec.sink_name();
configSettings[prefix + ".Destination"] = "Console";
configSettings[prefix + ".AutoFlush"] = consoleSpec.auto_flush();
SetIfInitialized( configSettings, prefix + std::string( ".Filter" ), consoleSpec.fieldValue( "filter" ) );
SetIfInitialized( configSettings, prefix + std::string( ".Format" ), consoleSpec.fieldValue( "format" ) );
SetIfInitialized( configSettings, prefix + std::string( ".Asynchronous" ), consoleSpec.fieldValue( "asynchronous" ) );
}
}
}
// Get a collection of all the logging files to open
{
auto filesSection = loggingSection.get_child_optional( "files" );
if( !filesSection.is_initialized() )
{
Logger( "LoggingConfigInit" ).ErrorStream() << "Missing 'files' section in logging configuration. Using Default Config." << std::endl;
g_boostLogManager.DefaultLoggingConfig( processName );
return( InitResult::Failure( ErrorCodes::MISSING_FILES_SECTION, "Missing 'files' section in logging configuration. Using Default Config." ) );
}
auto fileRange = filesSection->equal_range( "file" );
for( auto itrFileSpec = fileRange.first; itrFileSpec != fileRange.second; ++itrFileSpec )
{
LogFileSpec fileSpec;
auto parseResult = fileSpec.Parse( itrFileSpec->second );
if( parseResult.Failed() )
{
Logger( "LoggingConfigInit" ).ErrorStream() << "Error parsing 'file' specification in logging configuration. Using Default Config." << std::endl;
g_boostLogManager.DefaultLoggingConfig( processName );
return( InitResult::Failure( ErrorCodes::BAD_FILE_SPEC, "Bad File Specification. Using Default Config." ) );
}
std::string prefix = std::string( "Sinks." ) + fileSpec.sink_name();
configSettings[prefix + ".Destination"] = "TextFile";
configSettings[prefix + ".FileName"] = fileSpec.file_name();
configSettings[prefix + ".AutoFlush"] = fileSpec.auto_flush();
SetIfInitialized( configSettings, prefix + std::string( ".Target" ), fileSpec.fieldValue( "target" ) );
SetIfInitialized( configSettings, prefix + std::string( ".Filter" ), fileSpec.fieldValue( "filter" ) );
SetIfInitialized( configSettings, prefix + std::string( ".Format" ), fileSpec.fieldValue( "format" ) );
SetIfInitialized( configSettings, prefix + std::string( ".Asynchronous" ), fileSpec.fieldValue( "asynchronous" ) );
SetIfInitialized( configSettings, prefix + std::string( ".RotationSize" ), fileSpec.fieldValue( "rotation_size" ) );
if( fileSpec.fieldValue( "rotation_interval" ).is_initialized() && fileSpec.fieldValue( "rotation_time_period" ).is_initialized() )
{
Logger( "LoggingConfigInit" ).ErrorStream() << "Both 'rotation_interval' and 'rotation_time_period' are defined in configuration. Using 'rotation_interval'." << std::endl;
SetIfInitialized( configSettings, prefix + std::string( ".RotationInterval" ), fileSpec.fieldValue( "rotation_interval" ) );
}
else
{
SetIfInitialized( configSettings, prefix + std::string( ".RotationInterval" ), fileSpec.fieldValue( "rotation_interval" ) );
SetIfInitialized( configSettings, prefix + std::string( ".RotationTimePoint" ), fileSpec.fieldValue( "rotation_time_point" ) );
}
SetIfInitialized( configSettings, prefix + std::string( ".MaxSize" ), fileSpec.fieldValue( "max_size" ) );
SetIfInitialized( configSettings, prefix + std::string( ".MinFreeSpace" ), fileSpec.fieldValue( "min_free_space" ) );
SetIfInitialized( configSettings, prefix + std::string( ".ScanForFiles" ), fileSpec.fieldValue( "scan_for_files" ) );
}
}
// Start by stripping out all the existing sinks. There should only be the startup console and file anyway.
boost::log::core::get()->remove_all_sinks();
// Initialize from the settings we just pulled from the config and signal that the filters have changed
boost::log::init_from_settings( configSettings );
// Add the common attributes
boost::log::add_common_attributes();
// Signal that the filters have changed
FiltersChanged();
// Write to the log file
Logger( "LoggingConfigInit" ).NormalStream() << "Logging initialized from configuration file." << std::endl;
// Finished with Success
return( InitResult::Success() );
}
style_rules::style_rules(const pt::ptree &conf)
{
// see if there are any style rewrite rules
optional<const pt::ptree &> rewrites = conf.get_child_optional("rewrite");
if (rewrites)
{
for (pt::ptree::const_iterator itr = rewrites->begin();
itr != rewrites->end(); ++itr)
{
string from_style = itr->first;
string to_style = rewrites->get<string>(from_style);
m_rewrites.insert(make_pair(from_style, to_style));
}
}
// see if there are any style format listings
optional<const pt::ptree &> formats = conf.get_child_optional("formats");
if (formats)
{
for (pt::ptree::const_iterator itr = formats->begin();
itr != formats->end(); ++itr)
{
string style = itr->first;
string fmt_str = formats->get<string>(style);
protoFmt fmts = parse_formats(fmt_str);
m_formats.insert(make_pair(style, fmts));
}
}
// see if we're forcing the return types. yeah, it's a nasty hack
// and we should lean on the toolkit guys to get rid of this as
// soon as we can...
optional<const pt::ptree &> forced_formats = conf.get_child_optional("forced_formats");
if (forced_formats)
{
for (pt::ptree::const_iterator itr = forced_formats->begin();
itr != forced_formats->end(); ++itr)
{
string style = itr->first;
string fmt_str = forced_formats->get<string>(style);
protoFmt fmt = get_format_for(fmt_str);
if (fmt == fmtNone)
{
throw std::runtime_error((boost::format("In [forced_formats] for style `%1%', the string `%2%' is not recognised as a format.") % style % fmt_str).str());
}
m_forced_formats.insert(make_pair(style, fmt));
}
}
// find out what the max zoom levels are for each tile so
// that the check can check whether or not the tile is
// within the world, as far as TMS coords are concerned.
optional<const pt::ptree &> zoom_limits = conf.get_child_optional("zoom_limits");
if (zoom_limits)
{
for (pt::ptree::const_iterator itr = zoom_limits->begin();
itr != zoom_limits->end(); ++itr)
{
string style = itr->first;
int max_zoom = zoom_limits->get<int>(style);
m_zoom_limits.insert(make_pair(style, max_zoom));
}
}
}
