32 #ifndef LSST_PEX_POLICY_DICTIONARY_H
33 #define LSST_PEX_POLICY_DICTIONARY_H
37 #include <boost/regex.hpp>
55 class ValidationError :
public lsst::pex::exceptions::LogicError {
93 WRONG_OCCURRENCE_COUNT = 30,
96 VALUE_DISALLOWED = 32,
102 VALUE_OUT_OF_RANGE = 64,
114 BAD_DEFINITION = 256,
123 static const std::string& getErrorMessageFor(ErrorType err) {
124 if (_errmsgs.size() == 0) _loadMessages();
125 MsgLookup::iterator it = _errmsgs.find(err);
126 if (it != _errmsgs.end())
131 static std::string result;
133 std::ostringstream os;
135 for (std::map<int,std::string>::const_iterator j = _errmsgs.begin();
136 j != _errmsgs.end(); ++j) {
137 if (j->first != OK && (err & j->first) == j->first) {
138 os << (first ?
"" :
"; ") << j->second;
147 static const std::string EMPTY;
149 ValidationError(std::string
const & message) : lsst::pex::exceptions::LogicError(message), _errors()
156 ValidationError(
char const* ex_file,
int ex_line,
char const* ex_func)
157 : lsst::pex::exceptions::LogicError(ex_file, ex_line, ex_func,
158 "Policy has unknown validation errors"),
162 virtual lsst::pex::exceptions::Exception *clone()
const;
163 virtual char const *getType(
void)
const throw();
168 ValidationError(const ValidationError& that)
169 : lsst::pex::exceptions::LogicError(that), _errors(that._errors)
172 ValidationError& operator=(
const ValidationError& that) {
173 LogicError::operator=(that);
174 _errors = that._errors;
188 virtual ~ValidationError() throw();
193 int getParamCount()
const {
return _errors.size(); }
199 void paramNames(std::list<std::string>& names)
const {
200 ParamLookup::const_iterator it;
201 for(it = _errors.begin(); it != _errors.end(); it++)
202 names.push_back(it->first);
209 std::vector<std::string> getParamNames()
const;
214 int getErrors(
const std::string& name)
const {
215 ParamLookup::const_iterator it = _errors.find(name);
216 if (it != _errors.end())
225 void addError(
const std::string& name, ErrorType e) {
233 int getErrors()
const {
235 ParamLookup::const_iterator it;
236 for(it = _errors.begin(); it != _errors.end(); it++)
246 std::string describe(std::string prefix =
"")
const;
251 virtual char const* what(
void)
const throw();
254 typedef std::map<
int, std::
string> MsgLookup;
255 typedef std::map<std::
string,
int> ParamLookup;
257 static MsgLookup _errmsgs;
259 static
void _loadMessages();
268 class Definition : public lsst::daf::base::Citizen {
275 Definition(
const std::string& paramName =
"")
276 : lsst::daf::base::Citizen(typeid(*this)), _type(Policy::UNDETERMINED),
277 _name(paramName), _policy(), _wildcard(false)
279 _policy.reset(
new Policy());
287 Definition(
const std::string& paramName,
const Policy::Ptr& defn)
288 : lsst::daf::base::Citizen(typeid(*this)), _type(Policy::UNDETERMINED),
289 _name(paramName), _policy(defn), _wildcard(false)
297 : lsst::daf::base::Citizen(typeid(*this)), _type(Policy::UNDETERMINED),
298 _name(), _policy(defn), _wildcard(false)
304 Definition(
const Definition& that)
305 : lsst::daf::base::Citizen(typeid(*this)), _type(Policy::UNDETERMINED),
306 _name(that._name), _policy(that._policy), _wildcard(false)
312 Definition& operator=(
const Definition& that) {
315 _policy = that._policy;
316 _prefix = that._prefix;
317 _wildcard = that._wildcard;
325 Definition& operator=(
const Policy::Ptr& defdata) {
330 virtual ~Definition();
335 const std::string& getName()
const {
return _name; }
342 const std::string getPrefix()
const {
return _prefix; }
343 void setPrefix(
const std::string& prefix) { _prefix = prefix; }
351 const bool isChildDefinition()
const {
return _wildcard; }
352 void setChildDefinition(
bool wildcard) { _wildcard = wildcard; }
353 const bool isWildcard()
const {
return _wildcard; }
354 void setWildcard(
bool wildcard) { _wildcard = wildcard; }
361 void setName(
const std::string& newname) { _name = newname; }
366 const Policy::Ptr& getData()
const {
return _policy; }
388 std::string getTypeName()
const {
395 std::string getDefault()
const {
396 return _policy->str(
"default");
403 const std::string getDescription()
const;
409 const int getMaxOccurs()
const;
415 const int getMinOccurs()
const;
423 void setDefaultIn(Policy& policy, ValidationError* errs=0)
const {
424 setDefaultIn(policy, _name, errs);
432 void setDefaultIn(Policy& policy,
const std::string& withName,
433 ValidationError* errs=0)
const;
438 template <
typename T>
void setDefaultIn(Policy& policy,
439 const std::string& withName,
440 ValidationError* errs=0)
const;
455 void validate(
const Policy& policy,
const std::string& name,
456 ValidationError *errs=0)
const;
470 void validate(
const Policy& policy, ValidationError *errs=0)
const {
471 validate(policy, _name, errs);
498 void validate(
const std::string& name,
bool value,
int curcount=-1,
499 ValidationError *errs=0)
const;
500 void validate(
const std::string& name,
int value,
int curcount=-1,
501 ValidationError *errs=0)
const;
502 void validate(
const std::string& name,
double value,
int curcount=-1,
503 ValidationError *errs=0)
const;
504 void validate(
const std::string& name, std::string value,
int curcount=-1,
505 ValidationError *errs=0)
const;
506 void validate(
const std::string& name,
const Policy& value,
int curcount=-1,
507 ValidationError *errs=0)
const;
529 ValidationError *errs=0)
const;
531 ValidationError *errs=0)
const;
533 ValidationError *errs=0)
const;
534 void validate(
const std::string& name,
536 ValidationError *errs=0)
const;
537 void validate(
const std::string& name,
539 ValidationError *errs=0)
const;
561 template <
typename T>
void validateBasic
562 (
const std::string& name,
const Policy& policy,
563 ValidationError *errs=0)
const;
575 template <
typename T>
void validateBasic
576 (
const std::string& name,
const T& value,
int curcount=-1,
577 ValidationError *errs=0)
const;
578 template <
typename T>
void validateBasic
579 (
const std::string& name,
const std::vector<T>& value,
580 ValidationError *errs=0)
const;
592 ValidationError *errs)
const;
594 void validateRecurse(
const std::string& name,
const Policy& value,
595 ValidationError *errs)
const;
614 void validateCount(
const std::string& name,
int count,
615 ValidationError *errs)
const;
617 static const std::string EMPTY;
627 inline std::ostream&
operator<<(std::ostream& os,
const Definition& d) {
628 d.getData()->print(os, d.getName());
722 class Dictionary :
public Policy {
726 static const char *KW_DICT;
727 static const char *KW_DICT_FILE;
728 static const char *KW_TYPE;
729 static const char *KW_DESCRIPTION;
730 static const char *KW_DEFAULT;
731 static const char *KW_DEFINITIONS;
732 static const char *KW_CHILD_DEF;
733 static const char *KW_ALLOWED;
734 static const char *KW_MIN_OCCUR;
735 static const char *KW_MAX_OCCUR;
736 static const char *KW_MIN;
737 static const char *KW_MAX;
738 static const char *KW_VALUE;
744 Dictionary() : Policy() { }
752 Dictionary(
const Policy& pol)
753 : Policy( (pol.isPolicy(
"dictionary")) ? *(pol.getPolicy(
"dictionary"))
762 Dictionary(
const Dictionary& dict) : Policy(dict) {
770 explicit Dictionary(
const char *filePath);
771 explicit Dictionary(
const std::string& filePath);
772 explicit Dictionary(
const PolicyFile& filePath);
780 return getPolicy(
"definitions");
783 return getPolicy(
"definitions");
797 int definedNames(std::list<std::string>& names,
bool append=
false)
const {
798 return getDefinitions()->names(names,
true, append);
804 StringArray definedNames()
const {
805 return getDefinitions()->names(
true);
812 Definition getDef(
const std::string& name) {
813 Definition *def = makeDef(name);
814 Definition out(*def);
827 Definition* makeDef(
const std::string& name)
const;
834 bool hasSubDictionary(
const std::string& name)
const {
835 std::string key = std::string(
"definitions.") + name +
"." + KW_DICT;
848 DictPtr getSubDictionary(
const std::string& name)
const;
868 void validate(
const Policy& pol, ValidationError *errs=0)
const;
886 int loadPolicyFiles(
bool strict=
true) {
887 return loadPolicyFiles(boost::filesystem::path(), strict);
898 virtual int loadPolicyFiles(
const boost::filesystem::path& repository,
906 const std::string getPrefix()
const {
return _prefix; }
907 void setPrefix(
const std::string& prefix) { _prefix = prefix; }
912 static const boost::regex FIELDSEP_RE;
918 template <
typename T>
919 void Definition::validateBasic(
const std::string& name,
const Policy& policy,
920 ValidationError *errs)
const
922 validateBasic(name, policy.getValueArray<T>(name), errs);
925 template <
typename T>
926 void Definition::validateBasic(
const std::string& name,
const std::vector<T>& value,
927 ValidationError *errs)
const
929 ValidationError ve(LSST_EXCEPT_HERE);
930 ValidationError *use = &ve;
931 if (errs != 0) use = errs;
933 validateCount(name, value.size(), use);
935 for (
typename std::vector<T>::const_iterator i = value.begin();
938 validateBasic<T>(name, *i, -1, use);
940 if (errs == 0 && ve.getParamCount() > 0)
throw ve;
943 template <
typename T>
944 void Definition::setDefaultIn(Policy& policy,
const std::string& withName,
945 ValidationError *errs)
const
947 ValidationError ve(LSST_EXCEPT_HERE);
948 ValidationError *use = (errs == 0 ? &ve : errs);
950 if (_policy->exists(
"default")) {
951 const std::vector<T> defs = _policy->getValueArray<T>(
"default");
952 validateBasic(withName, defs, use);
953 if (use->getErrors(withName) == ValidationError::OK) {
954 policy.remove(withName);
955 for (
typename std::vector<T>::const_iterator i = defs.begin();
958 policy.addValue<T>(withName, *i);
962 if (errs == 0 && ve.getParamCount() > 0)
throw ve;
967 #endif // LSST_PEX_POLICY_POLICY_H
std::vector< int > IntArray
std::shared_ptr< Policy > Ptr
static const char *const typeName[]
c-string forms for the supported value types.
std::ostream & operator<<(std::ostream &os, const Policy &p)
std::vector< std::string > StringArray
definition of Policy-specific exceptions classes
std::vector< double > DoubleArray
std::vector< bool > BoolArray
std::shared_ptr< const Policy > ConstPtr
std::vector< ConstPtr > ConstPolicyPtrArray
ValueType
an enumeration for the supported policy types