lsst::pex::policy Namespace Reference

Namespaces
	paf
	policy
	version

Classes
class	BadNameError
	an exception thrown when Policy parameter name has an illegal form. More...
class	DefaultPolicyFile
	a representation of a default Policy file that is stored as a file in the installation directory of an LSST product. More...
class	DictionaryError
	There is a problem with a dictionary. More...
class	EOFError
	an exception indicated that the stream being parsed ended prematurely. More...
class	FormatSyntaxError
	an exception thrown because a syntax error specific to the format being parsed was encountered. More...
class	NameNotFound
	an exception indicating that a policy parameter of a given name can not be found in a Policy object. More...
class	ParserError
	an parent exception for errors that occur during the parsing of policy files. More...
class	Policy
	a container for holding hierarchical configuration data in memory. More...
class	PolicyConfigured
	an interface to indicate that a class is configured with a Policy More...
class	PolicyDestination
	a class representing a destination to serialize Policy parameter data to. More...
class	PolicyFile
	a representation of a file containing Policy parameter data. More...
class	PolicyParser
	an abstract class for parsing serialized Policy data and loading it into a Policy object. More...
class	PolicyParserFactory
	an abstract factory class for creating PolicyParser instances. More...
class	PolicySource
	an abstract class representing a source of serialized Policy parameter data. More...
class	PolicyStreamDestination
	a generic stream destination for policy data More...
class	PolicyString
	a representation of a string containing Policy parameter data More...
class	PolicyStringDestination
	a generic stream destination for policy data More...
class	PolicyWriter
	An abstract interface for writing policy data to streams. More...
class	SupportedFormats
	a list of supported Policy formats. More...
class	SyntaxError
	an exception thrown because a general syntax error was encountered. More...
class	TypeError
	an exception indicating that a policy parameter with a given name has a type different from the one that was requested. More...
class	UnsupportedSyntax
	an exception thrown because syntax was encountered that is legal for the format being parsed but which is not supported for encoding Policies. More...
class	UrnPolicyFile
	A Policy file in the installation directory of an LSST product, referred to using a URN. More...

Functions
std::ostream &	operator<< (std::ostream &os, const Policy &p)
template<>
std::string	Policy::getValue< std::string > (const std::string &name) const
template<>
Policy::FilePtr	Policy::getValue< Policy::FilePtr > (const std::string &name) const
template<>
Policy::ConstPtr	Policy::getValue< Policy::ConstPtr > (const std::string &name) const
template<>
std::vector< std::string >	Policy::getValueArray< std::string > (const std::string &name) const
template<>
Policy::FilePtrArray	Policy::getValueArray< Policy::FilePtr > (const std::string &name) const
template<>
Policy::PolicyPtrArray	Policy::getValueArray< Policy::Ptr > (const std::string &name) const
template<>
Policy::ConstPolicyPtrArray	Policy::getValueArray< Policy::ConstPtr > (const std::string &name) const
template<>
Policy::ValueType	Policy::getValueType< std::string > ()
template<>
Policy::ValueType	Policy::getValueType< Policy::FilePtr > ()
template<>
Policy::ValueType	Policy::getValueType< Policy::Ptr > ()
template<>
Policy::ValueType	Policy::getValueType< Policy::ConstPtr > ()
template<>
void	Policy::setValue< std::string > (const std::string &name, const std::string &value)
template<>
void	Policy::setValue< Policy::Ptr > (const std::string &name, const Policy::Ptr &value)
template<>
void	Policy::setValue< Policy::FilePtr > (const std::string &name, const Policy::FilePtr &value)
template<>
void	Policy::addValue< std::string > (const std::string &name, const std::string &value)
template<>
void	Policy::addValue< Policy::Ptr > (const std::string &name, const Policy::Ptr &value)
template<>
void	Policy::addValue< Policy::FilePtr > (const std::string &name, const Policy::FilePtr &value)
	PYBIND11_MODULE (defaultPolicyFile, mod)
	PYBIND11_MODULE (dictionary, mod)
	PYBIND11_MODULE (policy, mod)
	PYBIND11_MODULE (policyFile, mod)
	PYBIND11_MODULE (policySource, mod)
	PYBIND11_MODULE (policyString, mod)
	PYBIND11_MODULE (policyStringDestination, mod)
	PYBIND11_MODULE (supportedFormats, mod)
	PYBIND11_MODULE (urnPolicyFile, mod)

Function Documentation

operator<<()

std::ostream& lsst::pex::policy::operator<< ( std::ostream &  os, const Policy &  p  )

inline

Definition at line 848 of file Policy.h.

                                                               {
    p.print(os);
    return os;
}

Policy::addValue< Policy::FilePtr >()

template<>

void lsst::pex::policy::Policy::addValue< Policy::FilePtr >	(	const std::string &	name,
		const Policy::FilePtr &	value
	)

Policy::addValue< Policy::Ptr >()

template<>

void lsst::pex::policy::Policy::addValue< Policy::Ptr >	(	const std::string &	name,
		const Policy::Ptr &	value
	)

Policy::addValue< std::string >()

template<>

void lsst::pex::policy::Policy::addValue< std::string >	(	const std::string &	name,
		const std::string &	value
	)

Policy::getValue< Policy::ConstPtr >()

template<>

Policy::ConstPtr lsst::pex::policy::Policy::getValue< Policy::ConstPtr >

(

const std::string &

name

)

const

Policy::getValue< Policy::FilePtr >()

template<>

Policy::FilePtr lsst::pex::policy::Policy::getValue< Policy::FilePtr >

(

const std::string &

name

)

const

Policy::getValue< std::string >()

template<>

std::string lsst::pex::policy::Policy::getValue< std::string >

(

const std::string &

name

)

const

Policy::getValueArray< Policy::ConstPtr >()

template<>

Policy::ConstPolicyPtrArray lsst::pex::policy::Policy::getValueArray< Policy::ConstPtr >

(

const std::string &

name

)

const

Policy::getValueArray< Policy::FilePtr >()

template<>

Policy::FilePtrArray lsst::pex::policy::Policy::getValueArray< Policy::FilePtr >

(

const std::string &

name

)

const

Policy::getValueArray< Policy::Ptr >()

template<>

Policy::PolicyPtrArray lsst::pex::policy::Policy::getValueArray< Policy::Ptr >

(

const std::string &

name

)

const

Policy::getValueArray< std::string >()

template<>

std::vector<std::string> lsst::pex::policy::Policy::getValueArray< std::string >

(

const std::string &

name

)

const

Policy::getValueType< Policy::ConstPtr >()

template<>

Policy::ValueType lsst::pex::policy::Policy::getValueType< Policy::ConstPtr >

(

)

Policy::getValueType< Policy::FilePtr >()

template<>

Policy::ValueType lsst::pex::policy::Policy::getValueType< Policy::FilePtr >

(

)

Policy::getValueType< Policy::Ptr >()

template<>

Policy::ValueType lsst::pex::policy::Policy::getValueType< Policy::Ptr >

(

)

Policy::getValueType< std::string >()

template<>

Policy::ValueType lsst::pex::policy::Policy::getValueType< std::string >

(

)

Policy::setValue< Policy::FilePtr >()

template<>

void lsst::pex::policy::Policy::setValue< Policy::FilePtr >	(	const std::string &	name,
		const Policy::FilePtr &	value
	)

Policy::setValue< Policy::Ptr >()

template<>

void lsst::pex::policy::Policy::setValue< Policy::Ptr >	(	const std::string &	name,
		const Policy::Ptr &	value
	)

Policy::setValue< std::string >()

template<>

void lsst::pex::policy::Policy::setValue< std::string >	(	const std::string &	name,
		const std::string &	value
	)

PYBIND11_MODULE() [1/9]

lsst::pex::policy::PYBIND11_MODULE	(	supportedFormats	,
		mod
	)

Definition at line 33 of file supportedFormats.cc.

                                       {
    py::class_<SupportedFormats, std::shared_ptr<SupportedFormats>> cls(mod, "SupportedFormats");

    cls.def(py::init<>());

    cls.def("registerFormat", &SupportedFormats::registerFormat);
    cls.def("recognizeType", &SupportedFormats::recognizeType);
    cls.def("supports", &SupportedFormats::supports);
    cls.def("size", &SupportedFormats::size);
}

PYBIND11_MODULE() [2/9]

lsst::pex::policy::PYBIND11_MODULE	(	policySource	,
		mod
	)

Definition at line 33 of file policySource.cc.

                                   {
    py::module::import("lsst.pex.exceptions");
    py::class_<PolicySource, std::shared_ptr<PolicySource>> cls(mod, "PolicySource");
}

PYBIND11_MODULE() [3/9]

lsst::pex::policy::PYBIND11_MODULE	(	policyString	,
		mod
	)

Definition at line 34 of file policyString.cc.

                                   {
    py::class_<PolicyString, std::shared_ptr<PolicyString>, PolicySource> cls(mod, "PolicyString");

    cls.def(py::init<const std::string&, const SupportedFormats::Ptr&>(), "data"_a,
            "fmts"_a = PolicyString::defaultFormats);

    cls.def(py::init<const SupportedFormats::Ptr&>(), "fmts"_a = PolicyString::defaultFormats);
}

PYBIND11_MODULE() [4/9]

lsst::pex::policy::PYBIND11_MODULE	(	policyFile	,
		mod
	)

Definition at line 34 of file policyFile.cc.

                                 {
    py::class_<PolicyFile, std::shared_ptr<PolicyFile>, PolicySource> cls(mod, "PolicyFile");

    // SupportedFormats is not exposed to Python so don't export the default argument
    cls.def(py::init([](std::string const& filepath) { return new PolicyFile(filepath); }));

    cls.def("getPath", &PolicyFile::getPath);
    cls.def("exists", &PolicyFile::exists);
    cls.def("getFormatName", (const std::string& (PolicyFile::*)()) & PolicyFile::getFormatName);
    cls.def("load", (void (PolicyFile::*)(Policy&)) & PolicyFile::load);

    cls.def_readonly_static("EXT_PAF", &PolicyFile::EXT_PAF);
    cls.def_readonly_static("EXT_XML", &PolicyFile::EXT_XML);
}

PYBIND11_MODULE() [5/9]

lsst::pex::policy::PYBIND11_MODULE	(	policyStringDestination	,
		mod
	)

Definition at line 34 of file policyStringDestination.cc.

                                              {
    py::class_<PolicyStringDestination> cls(mod, "PolicyStringDestination");

    cls.def(py::init<>());
    cls.def(py::init<const std::string&>());
    cls.def("getData", &PolicyStringDestination::getData);
}

PYBIND11_MODULE() [6/9]

lsst::pex::policy::PYBIND11_MODULE	(	defaultPolicyFile	,
		mod
	)

Definition at line 35 of file defaultPolicyFile.cc.

                                        {
    py::class_<DefaultPolicyFile, std::shared_ptr<DefaultPolicyFile>, PolicyFile> cls(mod,
                                                                                      "DefaultPolicyFile");

    cls.def(py::init<const char* const, const std::string&, const std::string&, bool>(), "productName"_a,
            "filepath"_a, "repos"_a = "", "strict"_a = true);

    cls.def("load", &DefaultPolicyFile::load);
    cls.def("getRepositoryPath",
            [](DefaultPolicyFile const& self) -> std::string { return self.getRepositoryPath().native(); });
}

PYBIND11_MODULE() [7/9]

lsst::pex::policy::PYBIND11_MODULE	(	urnPolicyFile	,
		mod
	)

Definition at line 35 of file urnPolicyFile.cc.

                                    {
    py::class_<UrnPolicyFile, std::shared_ptr<UrnPolicyFile>, DefaultPolicyFile> cls(mod, "UrnPolicyFile");

    cls.def(py::init<const std::string&, bool, bool>(), "urn"_a, "strictUrn"_a = false,
            "strictLoads"_a = true);

    cls.def_static("productNameFromUrn", &UrnPolicyFile::productNameFromUrn);
    cls.def_static("filePathFromUrn", &UrnPolicyFile::filePathFromUrn);
    cls.def_static("reposFromUrn", &UrnPolicyFile::reposFromUrn);
    cls.def_readonly_static("URN_PREFIX", &UrnPolicyFile::URN_PREFIX);
    cls.def_readonly_static("URN_PREFIX_ABBREV", &UrnPolicyFile::URN_PREFIX_ABBREV);
    cls.def_static("looksLikeUrn", &UrnPolicyFile::looksLikeUrn);
}

PYBIND11_MODULE() [8/9]

lsst::pex::policy::PYBIND11_MODULE	(	dictionary	,
		mod
	)

Definition at line 37 of file dictionary.cc.

                                 {
    py::class_<Dictionary, std::shared_ptr<Dictionary>, Policy> clsDictionary(mod, "Dictionary");

    clsDictionary.def(py::init<>());
    clsDictionary.def(py::init<std::string &>());
    clsDictionary.def(py::init<const Dictionary &>());
    clsDictionary.def(py::init<PolicyFile &>());
    clsDictionary.def(py::init<const Policy &>());

    clsDictionary.def("getDefinitions", (Policy::Ptr (Dictionary::*)()) & Dictionary::getDefinitions);
    clsDictionary.def("check", &Dictionary::check);
    clsDictionary.def("definedNames",
                      (int (Dictionary::*)(std::list<std::string> &, bool) const) & Dictionary::definedNames,
                      "names"_a, "append"_a = false);
    clsDictionary.def("definedNames",
                      (Dictionary::StringArray (Dictionary::*)() const) & Dictionary::definedNames);
    clsDictionary.def("getDef", &Dictionary::getDef);
    clsDictionary.def("makeDef", &Dictionary::makeDef);
    clsDictionary.def("hasSubDictionary", &Dictionary::hasSubDictionary);
    clsDictionary.def("getSubDictionary", &Dictionary::getSubDictionary);

    // For some strange reason pybind11 doesn't like it if we use the default argument here
    clsDictionary.def("validate",
                      [](Dictionary const &self, Policy const &pol) { return self.validate(pol); }, "pol"_a);
    clsDictionary.def("validate", [](Dictionary const &self, Policy const &pol,
                                     ValidationError *errs) { self.validate(pol, errs); },
                      "pol"_a, "errs"_a);

    clsDictionary.def("loadPolicyFiles", (int (Dictionary::*)(bool)) & Dictionary::loadPolicyFiles,
                      "strict"_a = true);
    clsDictionary.def("loadPolicyFiles", [](Dictionary &self, std::string const &repository) {
        return self.loadPolicyFiles(repository);
    });
    clsDictionary.def("loadPolicyFiles", [](Dictionary &self, std::string const &repository, bool strict) {
        return self.loadPolicyFiles(repository, strict);
    });

    clsDictionary.def("getPrefix", &Dictionary::getPrefix);

    py::class_<Definition> clsDefinition(mod, "Definition");

    clsDefinition.def(py::init<const std::string &>(), "paramName"_a = "");

    clsDefinition.def("getName", &Definition::getName);
    clsDefinition.def("getPrefix", &Definition::getPrefix);
    clsDefinition.def("setPrefix", &Definition::setPrefix);
    clsDefinition.def("isChildDefinition", &Definition::isChildDefinition);
    clsDefinition.def("setChildDefinition", &Definition::setChildDefinition);
    clsDefinition.def("isWildcard", &Definition::isWildcard);
    clsDefinition.def("setWildcard", &Definition::setWildcard);
    clsDefinition.def("setName", &Definition::setName);
    clsDefinition.def("getData", &Definition::getData);
    clsDefinition.def("setData", &Definition::setData);
    clsDefinition.def("getType", &Definition::getType);
    clsDefinition.def("getTypeName", &Definition::getTypeName);
    clsDefinition.def("getDefault", &Definition::getDefault);
    clsDefinition.def("getDescription", &Definition::getDescription);
    clsDefinition.def("getMaxOccurs", &Definition::getMaxOccurs);
    clsDefinition.def("getMinOccurs", &Definition::getMinOccurs);
    clsDefinition.def("check", &Definition::check);
}

PYBIND11_MODULE() [9/9]

lsst::pex::policy::PYBIND11_MODULE	(	policy	,
		mod
	)

Definition at line 41 of file policy.cc.

                             {
    exceptions::python::declareException<BadNameError, exceptions::RuntimeError>(mod, "BadNameError",
                                                                                 "RuntimeError");
    exceptions::python::declareException<DictionaryError, exceptions::DomainError>(mod, "DictionaryError",
                                                                                   "DomainError");
    exceptions::python::declareException<NameNotFound, exceptions::NotFoundError>(mod, "NameNotFound",
                                                                                  "NotFoundError");
    exceptions::python::declareException<TypeError, exceptions::DomainError>(mod, "TypeError", "DomainError");
    auto clsValidationError =
            exceptions::python::declareException<ValidationError>(mod, "ValidationError", "LogicError");

    py::enum_<ValidationError::ErrorType>(clsValidationError, "ErrorType")
            .value("OK", ValidationError::ErrorType::OK)
            .value("WRONG_TYPE", ValidationError::ErrorType::WRONG_TYPE)
            .value("MISSING_REQUIRED", ValidationError::ErrorType::MISSING_REQUIRED)
            .value("NOT_AN_ARRAY", ValidationError::ErrorType::NOT_AN_ARRAY)
            .value("ARRAY_TOO_SHORT", ValidationError::ErrorType::ARRAY_TOO_SHORT)
            .value("TOO_FEW_VALUES", ValidationError::ErrorType::TOO_FEW_VALUES)
            .value("TOO_MANY_VALUES", ValidationError::ErrorType::TOO_MANY_VALUES)
            .value("WRONG_OCCURRENCE_COUNT", ValidationError::ErrorType::WRONG_OCCURRENCE_COUNT)
            .value("VALUE_DISALLOWED", ValidationError::ErrorType::VALUE_DISALLOWED)
            .value("VALUE_OUT_OF_RANGE", ValidationError::ErrorType::VALUE_OUT_OF_RANGE)
            .value("BAD_VALUE", ValidationError::ErrorType::BAD_VALUE)
            .value("UNKNOWN_NAME", ValidationError::ErrorType::UNKNOWN_NAME)
            .value("BAD_DEFINITION", ValidationError::ErrorType::BAD_DEFINITION)
            .value("NOT_LOADED", ValidationError::ErrorType::NOT_LOADED)
            .value("UNKNOWN_ERROR", ValidationError::ErrorType::UNKNOWN_ERROR)
            .export_values();

    clsValidationError.def(py::init<const std::string&>());
    clsValidationError.def(py::init<char const*, int, char const*>());

    clsValidationError.def_readonly_static("EMPTY", &ValidationError::EMPTY);
    clsValidationError.def("getErrorMessageFor", &ValidationError::getErrorMessageFor);
    clsValidationError.def("getParamCount", &ValidationError::getParamCount);
    clsValidationError.def("paramNames", &ValidationError::paramNames);
    clsValidationError.def("getParamNames", &ValidationError::getParamNames);
    clsValidationError.def("getErrors",
                           (int (ValidationError::*)(const std::string&) const) & ValidationError::getErrors);
    clsValidationError.def("getErrors", (int (ValidationError::*)() const) & ValidationError::getErrors);
    clsValidationError.def("describe", &ValidationError::describe);
    clsValidationError.def("what", &ValidationError::what);

    py::class_<Policy, std::shared_ptr<Policy>> clsPolicy(mod, "Policy");

    py::enum_<Policy::ValueType>(clsPolicy, "ValueType")
            .value("UNDETERMINED", Policy::ValueType::UNDETERMINED)
            .value("UNDEF", Policy::ValueType::UNDEF)
            .value("BOOL", Policy::ValueType::BOOL)
            .value("INT", Policy::ValueType::INT)
            .value("DOUBLE", Policy::ValueType::DOUBLE)
            .value("STRING", Policy::ValueType::STRING)
            .value("POLICY", Policy::ValueType::POLICY)
            .value("FILE", Policy::ValueType::FILE)
            .export_values();

    clsPolicy.def(py::init<>());
    clsPolicy.def(py::init<bool, const Dictionary&>());
    clsPolicy.def(py::init<const std::string&>());
    clsPolicy.def(py::init<Policy&, bool>(), "pol"_a, "deep"_a = false);
    clsPolicy.def(py::init<const PolicySource&>());

    clsPolicy.def_static("createPolicyFromUrn", &Policy::createPolicyFromUrn, "urn"_a, "validate"_a = true);
    clsPolicy.def_static("createPolicy", (Policy * (*)(PolicySource&, bool, bool)) & Policy::createPolicy,
                         "input"_a, "doIncludes"_a = true, "validate"_a = true);
    clsPolicy.def_static("createPolicy",
                         (Policy * (*)(const std::string&, bool, bool)) & Policy::createPolicy, "input"_a,
                         "doIncludes"_a = true, "validate"_a = true);
    clsPolicy.def_static("createPolicy",
                         (Policy * (*)(PolicySource&, const std::string&, bool)) & Policy::createPolicy,
                         "input"_a, "repos"_a, "validate"_a = true);
    clsPolicy.def_static("createPolicy",
                         (Policy * (*)(const std::string&, const std::string&, bool)) & Policy::createPolicy,
                         "input"_a, "repos"_a, "validate"_a = true);
    clsPolicy.def("getValueType",
                  (Policy::ValueType (Policy::*)(const std::string&) const) & Policy::getValueType);
    clsPolicy.def("nameCount", &Policy::nameCount);
    clsPolicy.def("names", (int (Policy::*)(std::list<std::string>&, bool, bool) const) & Policy::names,
                  "names"_a, "topLevelOnly"_a = false, "append"_a = false);
    clsPolicy.def("paramNames",
                  (int (Policy::*)(std::list<std::string>&, bool, bool) const) & Policy::paramNames,
                  "names"_a, "topLevelOnly"_a = false, "append"_a = false);
    clsPolicy.def("policyNames",
                  (int (Policy::*)(std::list<std::string>&, bool, bool) const) & Policy::policyNames,
                  "names"_a, "topLevelOnly"_a = false, "append"_a = false);
    clsPolicy.def("fileNames",
                  (int (Policy::*)(std::list<std::string>&, bool, bool) const) & Policy::fileNames, "names"_a,
                  "topLevelOnly"_a = false, "append"_a = false);
    clsPolicy.def("names", (Policy::StringArray (Policy::*)(bool) const) & Policy::names,
                  "topLevelOnly"_a = false);
    clsPolicy.def("paramNames", (Policy::StringArray (Policy::*)(bool) const) & Policy::paramNames,
                  "topLevelOnly"_a = false);
    clsPolicy.def("policyNames", (Policy::StringArray (Policy::*)(bool) const) & Policy::policyNames,
                  "topLevelOnly"_a = false);
    clsPolicy.def("fileNames", (Policy::StringArray (Policy::*)(bool) const) & Policy::fileNames,
                  "topLevelOnly"_a = false);
    clsPolicy.def("isDictionary", &Policy::isDictionary);
    clsPolicy.def("canValidate", &Policy::canValidate);
    clsPolicy.def("getDictionary", &Policy::getDictionary);
    clsPolicy.def("setDictionary", &Policy::setDictionary);
    // Somehow default arguments don't work here
    clsPolicy.def("validate", [](Policy const& self) { return self.validate(); });
    clsPolicy.def("validate", [](Policy const& self, ValidationError* errs) { return self.validate(errs); });
    clsPolicy.def("valueCount", &Policy::valueCount);
    clsPolicy.def("isArray", &Policy::isArray);
    clsPolicy.def("exists", &Policy::exists);
    clsPolicy.def("isBool", &Policy::isBool);
    clsPolicy.def("isInt", &Policy::isInt);
    clsPolicy.def("isDouble", &Policy::isDouble);
    clsPolicy.def("isString", &Policy::isString);
    clsPolicy.def("isPolicy", &Policy::isPolicy);
    clsPolicy.def("isFile", &Policy::isFile);
    clsPolicy.def("getTypeInfo", &Policy::getTypeInfo);
    clsPolicy.def("getPolicy", (Policy::Ptr (Policy::*)(const std::string&)) & Policy::getPolicy);
    clsPolicy.def("getFile", &Policy::getFile);
    clsPolicy.def("getBool", &Policy::getBool);
    clsPolicy.def("getInt", &Policy::getInt);
    clsPolicy.def("getDouble", &Policy::getDouble);
    clsPolicy.def("getString", &Policy::getString);
    clsPolicy.def("getPolicyArray", &Policy::getPolicyArray);
    clsPolicy.def("getFileArray", &Policy::getFileArray);
    clsPolicy.def("getBoolArray", &Policy::getBoolArray);
    clsPolicy.def("getIntArray", &Policy::getIntArray);
    clsPolicy.def("getDoubleArray", &Policy::getDoubleArray);
    clsPolicy.def("getStringArray", &Policy::getStringArray);
    // _set is called from Python set
    clsPolicy.def("_set", (void (Policy::*)(const std::string&, const Policy::Ptr&)) & Policy::set);
    clsPolicy.def("_set", (void (Policy::*)(const std::string&, bool)) & Policy::set);
    clsPolicy.def("_set", (void (Policy::*)(const std::string&, int)) & Policy::set);
    clsPolicy.def("_set", (void (Policy::*)(const std::string&, double)) & Policy::set);
    clsPolicy.def("_set", (void (Policy::*)(const std::string&, const std::string&)) & Policy::set);
    clsPolicy.def("add", (void (Policy::*)(const std::string&, const Policy::Ptr&)) & Policy::add);
    clsPolicy.def("add", (void (Policy::*)(const std::string&, bool)) & Policy::add);
    clsPolicy.def("add", (void (Policy::*)(const std::string&, int)) & Policy::add);
    clsPolicy.def("add", (void (Policy::*)(const std::string&, double)) & Policy::add);
    clsPolicy.def("add", (void (Policy::*)(const std::string&, const std::string&)) & Policy::add);
    clsPolicy.def("remove", &Policy::remove);
    clsPolicy.def("loadPolicyFiles", (int (Policy::*)(bool)) & Policy::loadPolicyFiles, "strict"_a = true);

    // boost::filesystem::path is equivalent to str in Python
    clsPolicy.def("loadPolicyFiles",
                  [](Policy& self, const std::string& path, bool strict = true) -> int {
                      return self.loadPolicyFiles(boost::filesystem::path(path), strict);
                  },
                  "repository"_a, "strict"_a = true);

    clsPolicy.def("mergeDefaults", &Policy::mergeDefaults, "defaultPol"_a, "keepForValidation"_a = true,
                  "errs"_a = nullptr);
    clsPolicy.def("str", &Policy::str, "name"_a, "indent"_a = "");
    clsPolicy.def("toString", &Policy::toString);
    clsPolicy.def("__str__", &Policy::toString);  // Cleanup stringification later
    clsPolicy.def("asPropertySet", &Policy::asPropertySet);
}