Dictionary.cc

Go to the documentation of this file.

/*
 * LSST Data Management System
 * Copyright 2008-2016 LSST Corporation.
 *
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the LSST License Statement and
 * the GNU General Public License along with this program.  If not,
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */

/*
 * Dictionary
 */
#include "lsst/pex/policy/Dictionary.h"
#include "lsst/pex/policy/PolicyFile.h"
// #include "lsst/pex/utils/Trace.h"

#include <boost/regex.hpp>

#include <memory>
#include <stdexcept>
#include <string>
#include <set>

namespace pexExcept = lsst::pex::exceptions;

namespace lsst {
namespace pex {
namespace policy {

//@cond

using namespace std;

const string ValidationError::EMPTY;

ValidationError::MsgLookup ValidationError::_errmsgs;

POL_EXCEPT_VIRTFUNCS(lsst::pex::policy::ValidationError)

void ValidationError::_loadMessages() {
    _errmsgs[OK] = EMPTY;
    _errmsgs[WRONG_TYPE] = "value has the incorrect type";
    _errmsgs[MISSING_REQUIRED] = "no value available for required parameter";
    _errmsgs[NOT_AN_ARRAY] = "value is not an array as required";
    _errmsgs[ARRAY_TOO_SHORT] = "insufficient number of array values";
    _errmsgs[TOO_FEW_VALUES] = "not enough values for parameter";
    _errmsgs[TOO_MANY_VALUES] = "too many values provided for parameter";
    _errmsgs[WRONG_OCCURRENCE_COUNT]="incorrect number of values for parameter";
    _errmsgs[VALUE_DISALLOWED] = "value is not among defined set";
    _errmsgs[VALUE_OUT_OF_RANGE] = "value is out of range";
    _errmsgs[BAD_VALUE] = "illegal value";
    _errmsgs[UNKNOWN_NAME] = "parameter name is unknown";
    _errmsgs[BAD_DEFINITION] = "malformed definition";
    _errmsgs[NOT_LOADED] = "file not loaded"
        " -- call Policy.loadPolicyFiles() before validating";
    _errmsgs[UNKNOWN_ERROR] = "unknown error";
}

vector<string> ValidationError::getParamNames() const {
    vector<string> result;
    ParamLookup::const_iterator i;
    for (i = _errors.begin(); i != _errors.end(); ++i)
        result.push_back(i->first);
    return result;
}

string ValidationError::describe(string prefix) const {
    ostringstream os;
    list<string> names;
    paramNames(names);
    for (list<string>::const_iterator i = names.begin(); i != names.end(); ++i)
        os << prefix << *i << ": "
           << getErrorMessageFor((ErrorType)getErrors(*i)) << endl;
    return os.str();
}

char const* ValidationError::what(void) const throw() {
    // static to avoid memory issue -- but a concurrency problem?
    // copied from pex/exceptions/src/Exception.cc
    static string buffer;
    ostringstream os;
    int n = getParamCount();
    os << "Validation error";
    if (n == 1) os << " (1 error)";
    else if (n > 1) os << " (" << getParamCount() << " errors)";
    if (getParamCount() == 0)
        os << ": no errors" << "\n";
    else {
        os << ": \n" << describe("  * ");
    }
    buffer = os.str();
    return buffer.c_str();
}

ValidationError::~ValidationError() throw() { }

//  Definition

Definition::~Definition() { }

Policy::ValueType Definition::_determineType() const {
    if (_policy->isString(Dictionary::KW_TYPE)) {
        const string& type = _policy->getString(Dictionary::KW_TYPE);
        Policy::ValueType result;
        try {
            result = Policy::getTypeByName(type);
        } catch(BadNameError&) {
            throw LSST_EXCEPT
                (DictionaryError, string("Unknown type: \"") + type + "\".");
        }
        if (result == Policy::FILE)
            throw LSST_EXCEPT(DictionaryError, string("Illegal type: \"") + type
                              + "\"; use \"" + Policy::typeName[Policy::POLICY]
                              + "\" instead.");
        else return result;
    }
    else if (_policy->exists(Dictionary::KW_TYPE)) {
        throw LSST_EXCEPT
            (DictionaryError, string("Expected string for \"type\"; found ")
             + _policy->getTypeName(Dictionary::KW_TYPE) + " instead.");
    }

    else return Policy::UNDEF;
}

const string Definition::getDescription() const {
    if (_policy->exists(Dictionary::KW_DESCRIPTION))
        return _policy->getString(Dictionary::KW_DESCRIPTION);
    else return "";
}

const int Definition::getMaxOccurs() const {
    if (_policy->exists(Dictionary::KW_MAX_OCCUR))
        return _policy->getInt(Dictionary::KW_MAX_OCCUR);
    else return -1;
}

const int Definition::getMinOccurs() const {
    if (_policy->exists(Dictionary::KW_MIN_OCCUR))
        return _policy->getInt(Dictionary::KW_MIN_OCCUR);
    else return 0;
}


/*
 * the default value into the given policy
 * @param policy   the policy object update
 * @param withName the name to look for the value under.  This must be
 *                    a non-hierarchical name.
 * @exception ValidationError if the value does not conform to this definition.
 */
void Definition::setDefaultIn(Policy& policy, const string& withName,
                              ValidationError* errs) const
{
    if (! _policy->exists("default")) return;
/*
    Policy::ValueType type = getType();
    if (type == Policy::UNDEF)
        type = _policy->getValueType("default");
*/
    Policy::ValueType type = _policy->getValueType("default");

    if (type == Policy::BOOL)
        setDefaultIn<bool>(policy, withName, errs);
    else if (type == Policy::INT)
        setDefaultIn<int>(policy, withName, errs);
    else if (type == Policy::DOUBLE)
        setDefaultIn<double>(policy, withName, errs);
    else if (type == Policy::STRING)
        setDefaultIn<string>(policy, withName, errs);
    else if (type == Policy::POLICY)
        setDefaultIn<Policy::Ptr>(policy, withName, errs);
    else throw LSST_EXCEPT(pexExcept::LogicError,
                           string("Programmer Error: Unknown type for \"")
                           + getPrefix() + withName + "\": "
                           + Policy::typeName[getType()]);
}

/*
 * confirm that a Policy parameter conforms to this definition
 * @param policy   the policy object to inspect
 * @param name     the name to look for the value under.  If not given
 *                  the name set in this definition will be used.
 * @exception ValidationError   if the value does not conform.  The message
 *                 should explain why.
 */
void Definition::validate(const Policy& policy, const string& name,
                          ValidationError *errs) const
{
    ValidationError ve(LSST_EXCEPT_HERE);
    ValidationError *use = &ve;
    if (errs != 0) use = errs;

    if (! policy.exists(name)) {
        if (getMinOccurs() > 0)
            use->addError(getPrefix() + name, ValidationError::MISSING_REQUIRED);
        return;
    }

    // What type is actually present in the policy?
    Policy::ValueType type = policy.getValueType(name);

    switch (type) {
    case Policy::BOOL:
        validateBasic<bool>(name, policy, use);
        break;

    case Policy::INT:
        validateBasic<int>(name, policy, use);
        break;

    case Policy::DOUBLE:
        validateBasic<double>(name, policy, use);
        break;

    case Policy::STRING:
        validateBasic<string>(name, policy, use);
        break;

    case Policy::POLICY:
        validateBasic<Policy::ConstPtr>(name, policy, use);
        validateRecurse(name, policy.getConstPolicyArray(name), use);
        break;

    case Policy::FILE:
        use->addError(getPrefix() + name, ValidationError::NOT_LOADED);
        break;

    default:
        throw LSST_EXCEPT(pexExcept::LogicError,
                          string("Unknown type for \"") + getPrefix() + name
                          + "\": \"" + policy.getTypeName(name) + "\"");
    }

    if (errs == 0 && ve.getParamCount() > 0) throw ve;
}

void Definition::validateCount(const string& name, int count,
                               ValidationError *errs) const {
    int max = getMaxOccurs(); // -1 means no limit / undefined
    if (max >= 0 && count > max)
        errs->addError(getPrefix() + name, ValidationError::TOO_MANY_VALUES);
    if (count < getMinOccurs()) {
        if (count == 0)
            errs->addError(getPrefix() + name, ValidationError::MISSING_REQUIRED);
        else if (count == 1)
            errs->addError(getPrefix() + name, ValidationError::NOT_AN_ARRAY);
        else
            errs->addError(getPrefix() + name, ValidationError::ARRAY_TOO_SHORT);
    }
}

bool operator<(const Policy& a, const Policy& b) { return true; }
bool operator<(const Policy::ConstPtr& a, const Policy::ConstPtr& b) { return true; }
bool operator<(const Policy::FilePtr& a, const Policy::FilePtr& b) { return true; }

void Definition::validateRecurse(const string& name,
                                 Policy::ConstPolicyPtrArray value,
                                 ValidationError *errs) const
{
    for (Policy::ConstPolicyPtrArray::const_iterator i = value.begin();
         i != value.end(); ++i) {
        Policy::ConstPtr p = *i;
        validateRecurse(name, *p, errs);
    }
}

/* Validate a sub-policy using a sub-dictionary. */
void Definition::validateRecurse(const string& name, const Policy& value,
                                 ValidationError *errs) const
{
    if (_policy->exists(Dictionary::KW_DICT)) {
        if (!_policy->isPolicy(Dictionary::KW_DICT))
            throw LSST_EXCEPT
                (DictionaryError, string("Wrong type for ") + getPrefix() + name
                 + " \"" + Dictionary::KW_DICT + "\": expected Policy, but found "
                 + _policy->getTypeName(Dictionary::KW_DICT) + ".");
        else {
            Dictionary subdict(*(_policy->getPolicy(Dictionary::KW_DICT)));
            subdict.setPrefix(_prefix + name + ".");
            subdict.validate(value, errs);
        }
    }
    // is there an unresolved link here?
    else if (_policy->exists(Dictionary::KW_DICT_FILE)) {
        throw LSST_EXCEPT
            (pexExcept::LogicError, _prefix + name
             + "." + Dictionary::KW_DICT_FILE + " needs to be loaded with "
             "Dictionary.loadPolicyFiles() before validating.");
    }
    // there's a policy type defined here, but no sub-definition (that is, no
    // constraints -- it could be any policy), so anything is okay.
    else { }
}

// TODO: integrate all checks into check() rather than having them in validate()
template <class T>
void Definition::validateBasic(const string& name, const T& value,
                               int curcount, ValidationError *errs) const
{
    ValidationError ve(LSST_EXCEPT_HERE);
    ValidationError *use = &ve;
    if (errs != 0) use = errs;

    // check if we're going to get too many
    if (curcount >= 0) {
        int maxOccurs = getMaxOccurs();
        if (maxOccurs >= 0 && curcount + 1 > maxOccurs)
            use->addError(getPrefix() + name, ValidationError::TOO_MANY_VALUES);
    }

    if (getType() != Policy::UNDEF && getType() != Policy::getValueType<T>()) {
        use->addError(getPrefix() + name, ValidationError::WRONG_TYPE);
    }
    else if (_policy->isPolicy(Dictionary::KW_ALLOWED)) {
        Policy::PolicyPtrArray allowed
            = _policy->getPolicyArray(Dictionary::KW_ALLOWED);

        T min, max;
        bool minFound = false, maxFound = false;
        set<T> allvals;
        // iterate over the keys inside the "allowed" sub-policy
        for (Policy::PolicyPtrArray::const_iterator it = allowed.begin();
             it != allowed.end(); ++it)
        {
            Policy::Ptr a = *it;
            if (a->exists(Dictionary::KW_MIN)) {
                if (minFound) {
                    // Would like to catch this in Dictionary::check(), but that
                    // would require some fancy type-based logic.
                    throw LSST_EXCEPT
                        (DictionaryError,
                         string("Min value for ") + getPrefix() + name
                         + " already specified; additional value not allowed.");
                }
                try {
                    min = a->getValue<T>(Dictionary::KW_MIN);
                    minFound = true; // after min assign, in case of exceptions
                } catch(TypeError& e) {
                    throw LSST_EXCEPT
                        (DictionaryError,
                         string("Wrong type for ") + getPrefix() + name
                         + " min value: expected " + getTypeName() + ", found "
                         + a->getTypeName(Dictionary::KW_MIN) + ".");
                } catch(...) {
                    throw;
                }
            }
            if (a->exists(Dictionary::KW_MAX)) {
                if (maxFound)
                    throw LSST_EXCEPT
                        (DictionaryError,
                         string("Max value for ") + getPrefix() + name
                         + " already specified; additional value not allowed.");
                try {
                    max = a->getValue<T>(Dictionary::KW_MAX);
                    maxFound = true; // after max assign, in case of exceptions
                } catch(TypeError& e) {
                    throw LSST_EXCEPT
                        (DictionaryError,
                         string("Wrong type for ") + getPrefix() + name
                         + " max value: expected " + getTypeName() + ", found "
                         + a->getTypeName(Dictionary::KW_MAX) + ".");
                }
            }
            if (a->exists(Dictionary::KW_VALUE)) {
                const T& value = a->getValue<T>(Dictionary::KW_VALUE);

                allvals.insert(value);
                // allvals.insert(a->getValue<T>(Dictionary::KW_VALUE));
                vector<T> values = a->getValueArray<T>(Dictionary::KW_VALUE);
                for (typename vector<T>::const_iterator vi = values.begin();
                     vi != values.end(); ++vi)
                    allvals.insert(*vi);
            }
        }

        if ((minFound && value < min) || (maxFound && max < value))
            use->addError(getPrefix() + name, ValidationError::VALUE_OUT_OF_RANGE);

        if (allvals.size() > 0 && allvals.count(value) == 0)
            use->addError(getPrefix() + name, ValidationError::VALUE_DISALLOWED);
    }
    if (errs == 0 && ve.getParamCount() > 0) throw ve;
}

// instantiate to keep gcc 4.4 happy when compiling with opt=2
// (why? -- see LSST Trac ticket #1253)
template void Definition::validateBasic<Policy::Ptr>
(std::string const &, Policy::Ptr const &, int, ValidationError*) const;

/*
 * confirm that a Policy parameter name-value combination is consistent
 * with this dictionary.  This does not check occurrence compliance
 * @param name     the name of the parameter being checked
 * @param value    the value of the parameter to check.
 * @exception ValidationError   if the value does not conform.  The message
 *                 should explain why.
 */
void Definition::validate(const string& name, bool value, int curcount,
                          ValidationError *errs) const
{
    validateBasic<bool>(name, value, curcount, errs);
}

void Definition::validate(const string& name, int value, int curcount,
                          ValidationError *errs) const
{
    validateBasic<int>(name, value, curcount, errs);
}

void Definition::validate(const string& name, double value, int curcount,
                          ValidationError *errs) const
{
    validateBasic<double>(name, value, curcount, errs);
}

void Definition::validate(const string& name, string value, int curcount,
                          ValidationError *errs) const
{
    validateBasic<string>(name, value, curcount, errs);
}

void Definition::validate(const string& name, const Policy& value,
                          int curcount, ValidationError *errs) const
{
    validateBasic<Policy>(name, value, curcount, errs);
    validateRecurse(name, value, errs);
}

/*
 * confirm that a Policy parameter name-array value combination is
 * consistent with this dictionary.  Unlike the scalar version,
 * this does check occurrence compliance.
 * @param name     the name of the parameter being checked
 * @param value    the value of the parameter to check.
 * @exception ValidationError   if the value does not conform.  The message
 *                 should explain why.
 */
void Definition::validate(const string& name, const Policy::BoolArray& value,
                          ValidationError *errs) const
{
    validateBasic<bool>(name, value, errs);
}

void Definition::validate(const string& name, const Policy::IntArray& value,
                          ValidationError *errs) const
{
    validateBasic<int>(name, value, errs);
}

void Definition::validate(const string& name, const Policy::DoubleArray& value,
                          ValidationError *errs) const
{
    validateBasic<double>(name, value, errs);
}
void Definition::validate(const string& name, const Policy::StringArray& value,
                          ValidationError *errs) const
{
    validateBasic<string>(name, value, errs);
}

void Definition::validate(const string& name, const Policy::ConstPolicyPtrArray& value,
                          ValidationError *errs) const
{
    validateBasic<Policy::ConstPtr>(name, value, errs);
    validateRecurse(name, value, errs);
}

void Definition::check() const {
    static set<string> okayKeywords;
    if (okayKeywords.size() == 0) {
        okayKeywords.insert(Dictionary::KW_TYPE);
        okayKeywords.insert(Dictionary::KW_DICT);
        okayKeywords.insert(Dictionary::KW_DICT_FILE);
        okayKeywords.insert(Policy::typeName[Policy::FILE]);
        okayKeywords.insert(Dictionary::KW_MIN_OCCUR);
        okayKeywords.insert(Dictionary::KW_MAX_OCCUR);
        okayKeywords.insert(Dictionary::KW_MIN);
        okayKeywords.insert(Dictionary::KW_MAX);
        okayKeywords.insert(Dictionary::KW_ALLOWED);
        okayKeywords.insert(Dictionary::KW_DESCRIPTION);
        okayKeywords.insert(Dictionary::KW_DEFAULT);
    }
    Policy::StringArray terms = _policy->names(true);
    for (Policy::StringArray::const_iterator i = terms.begin();
         i != terms.end(); ++i)
    {
        if (okayKeywords.count(*i) == 1) continue;
        else throw LSST_EXCEPT
            (DictionaryError, string("Unknown Dictionary property found at ")
             + _prefix + _name + ": " + *i);
    }
}

//  Dictionary

const char* Dictionary::KW_DICT = "dictionary";
const char* Dictionary::KW_DICT_FILE = "dictionaryFile";
const char* Dictionary::KW_TYPE = "type";
const char* Dictionary::KW_DESCRIPTION = "description";
const char* Dictionary::KW_DEFAULT = "default";
const char* Dictionary::KW_DEFINITIONS = "definitions";
const char* Dictionary::KW_CHILD_DEF = "childDefinition";
const char* Dictionary::KW_ALLOWED = "allowed";
const char* Dictionary::KW_MIN_OCCUR = "minOccurs";
const char* Dictionary::KW_MAX_OCCUR = "maxOccurs";
const char* Dictionary::KW_MIN = "min";
const char* Dictionary::KW_MAX = "max";
const char* Dictionary::KW_VALUE = "value";

const boost::regex Dictionary::FIELDSEP_RE("\\.");

/*
 * load a dictionary from a file
 */
Dictionary::Dictionary(const char *filePath) : Policy(filePath) {
    if (!exists(KW_DEFINITIONS))
        throw LSST_EXCEPT(pexExcept::RuntimeError, string(filePath)
                          + ": does not contain a Dictionary");
    check();
}
Dictionary::Dictionary(const string& filePath) : Policy(filePath) {
    if (!exists(KW_DEFINITIONS))
        throw LSST_EXCEPT(pexExcept::RuntimeError, string(filePath)
                          + ": does not contain a Dictionary");
    check();
}
Dictionary::Dictionary(const PolicyFile& filePath) : Policy(filePath) {
    if (!exists(KW_DEFINITIONS))
        throw LSST_EXCEPT(pexExcept::RuntimeError, filePath.getPath()
                          + ": does not contain a Dictionary");
    check();
}

/*
 * return a definition for the named parameter.  The caller is responsible
 * for deleting the returned object.  This is slightly more efficient than
 * getDef().
 * @param name    the hierarchical name for the parameter
 */
Definition* Dictionary::makeDef(const string& name) const {
    Policy *p = const_cast<Dictionary*>(this);
    Policy::Ptr sp; // sub-policy

    // split the name
    boost::sregex_token_iterator it = boost::make_regex_token_iterator(name, FIELDSEP_RE, -1);
    boost::sregex_token_iterator end;
    string find;
    bool isWildcard = false; // was the immediate parent a wildcard childDefinition?
    while (it != end) {
        find = *it;
        if (! p->isPolicy(KW_DEFINITIONS))
            throw LSST_EXCEPT(DictionaryError, "Definition for " + find
                              + " not found.");
        sp = p->getPolicy(KW_DEFINITIONS);
        if (sp->isPolicy(find)) {
            sp = sp->getPolicy(find);
            isWildcard = false; // update each time, to get only immediate parent
        }
        else if (sp->isPolicy(Dictionary::KW_CHILD_DEF)) {
            if (sp->valueCount(Dictionary::KW_CHILD_DEF) > 1)
                throw LSST_EXCEPT
                    (DictionaryError, string("Multiple ") + KW_CHILD_DEF
                     + "s found " + "that match " + getPrefix() + name + ".");
            sp = sp->getPolicy(Dictionary::KW_CHILD_DEF);
            isWildcard = true;
        }
        else throw LSST_EXCEPT(NameNotFound, find);
        p = sp.get();
        if (++it != end) {
            if (! sp->isPolicy(Dictionary::KW_DICT))
                throw LSST_EXCEPT(DictionaryError,
                                  find + "." + KW_DICT + " not found.");
            sp = sp->getPolicy(Dictionary::KW_DICT);
            p = sp.get();
        }
    }
    Definition* result = new Definition(name, sp);
    result->setWildcard(isWildcard);
    result->setPrefix(getPrefix());
    return result;
}

Policy::DictPtr Dictionary::getSubDictionary(const string& name) const {
    string subname = string(KW_DEFINITIONS) + "." + name + ".dictionary";
    if (!exists(subname)) throw LSST_EXCEPT
        (pexExcept::LogicError,
         string("sub-policy \"") + subname + "\" not found.");
    if (!isPolicy(subname)) throw LSST_EXCEPT
        (DictionaryError, subname + " is a " + getTypeName(subname)
         + " instead of a " + Policy::typeName[Policy::POLICY] + ".");
    ConstPtr subpol = getPolicy(subname);
    Policy::DictPtr result = std::make_shared<Dictionary>(*subpol);
    result->setPrefix(_prefix + name + ".");
    return result;
}

int Dictionary::loadPolicyFiles(const boost::filesystem::path& repository, bool strict) {
    int maxLevel = 16;
    int result = 0;
    // loop until we reach the leaves
    for (int level = 0; level < maxLevel; ++level) {
        // find the "dictionaryFile" parameters
        list<string> params;
        paramNames(params, false);
        list<string> toRemove;
        for (list<string>::const_iterator ni=params.begin(); ni != params.end(); ++ni) {
            // loop over the keys that end with ".dictionaryFile"
            static string endswith = string(".") + KW_DICT_FILE;
            size_t p = ni->rfind(endswith);
            if (p == ni->length()-endswith.length()) {
                string parent = ni->substr(0, p);
                Policy::Ptr defin = getPolicy(parent);

                // these will get dereferenced with the call to super method
                if (isFile(*ni))
                    defin->set(Dictionary::KW_DICT, getFile(*ni));
                else
                    defin->set(Dictionary::KW_DICT,
                               std::make_shared<PolicyFile>(getString(*ni)));

                toRemove.push_back(*ni);
            }
        }

        // if no new loads, then we've loaded everything
        int newLoads = Policy::loadPolicyFiles(repository, strict);

        // remove obsolete dictionaryFile references, to prevent re-loading
        for (list<string>::iterator i = toRemove.begin(); i != toRemove.end(); ++i)
            remove(*i);

        if (newLoads == 0) {
            check(); // validate self after everything is loaded
            return result;
        }
        else result += newLoads;
    }
    throw LSST_EXCEPT
        (DictionaryError, string("Exceeded recursion limit (")
         + std::to_string(maxLevel)
         + ") loading policy files; does this dictionary contain a circular"
         " definition?");
}

void Dictionary::check() const {
    PolicyPtrArray defs = getValueArray<Policy::Ptr>(KW_DEFINITIONS);
    if (defs.size() == 0)
        throw LSST_EXCEPT(DictionaryError,
                          string("no \"") + KW_DEFINITIONS + "\" section found");
    if (defs.size() > 1)
        throw LSST_EXCEPT
            (DictionaryError, string("expected a single \"") + KW_DEFINITIONS
             + "\" section; found " + std::to_string(defs.size()));

    Policy::StringArray names = defs[0]->names(true);
    for (Policy::StringArray::const_iterator i = names.begin();
         i != names.end(); ++i)
    {
        std::unique_ptr<Definition> def(makeDef(*i));
        def->check();

        if (hasSubDictionary(*i)) {
            // if the subdict is a policy file, skip it -- it will have to be
            // checked later, when it is loaded
            ConstPtr subPol = defs[0]->getPolicy(*i);
            if (subPol->getValueType(KW_DICT) != Policy::FILE)
                getSubDictionary(*i)->check();
            // TODO: test that loading a subdict from a reference gets re-checked
        }
    }
}

/*
 * validate a Policy against this Dictionary
 */
void Dictionary::validate(const Policy& pol, ValidationError *errs) const {
    ValidationError ve(LSST_EXCEPT_HERE);
    ValidationError *use = &ve;
    if (errs != 0) use = errs;
    Policy::StringArray params = pol.names(true);

    // validate each item in policy
    for (Policy::StringArray::const_iterator i = params.begin();
         i != params.end(); ++i)
    {
        try {
            std::unique_ptr<Definition> def(makeDef(*i));
            def->validate(pol, *i, use);
        }
        catch (NameNotFound& e) {
            use->addError(getPrefix() + *i, ValidationError::UNKNOWN_NAME);
        }
    }

    // check definitions of missing elements for required elements
    Policy::ConstPtr defs = getDefinitions();
    Policy::StringArray dn = defs->names(true);
    for (Policy::StringArray::const_iterator i = dn.begin(); i != dn.end(); ++i) {
        const string& name = *i;
        if (!pol.exists(name)) { // item in dictionary, but not in policy
            std::unique_ptr<Definition> def(makeDef(name));
            if (name != Dictionary::KW_CHILD_DEF && def->getMinOccurs() > 0)
                use->addError(getPrefix() + name,
                              ValidationError::MISSING_REQUIRED);
        }
    }

    if (errs == 0 && ve.getParamCount() > 0) throw ve;
}

//@endcond

} // namespace policy
} // namespace pex
} // namespace lsst