FlagHandler.h

Go to the documentation of this file.

/*// -*- lsst-c++ -*-
 * LSST Data Management System
 * Copyright 2008-2014 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/>.
 */
 
#ifndef LSST_MEAS_BASE_FlagHandler_h_INCLUDED
#define LSST_MEAS_BASE_FlagHandler_h_INCLUDED
 
#include <vector>
 
#include "lsst/afw/table/Schema.h"
#include "lsst/afw/table/BaseRecord.h"
#include "lsst/meas/base/exceptions.h"
 
namespace lsst {
namespace meas {
namespace base {
struct FlagDefinition {
    static constexpr std::size_t number_undefined = SIZE_MAX;
 
    FlagDefinition() : name(), doc(), number() {}
 
    FlagDefinition(std::string const& name, std::string const& doc, std::size_t number = number_undefined)
            : name(name), doc(doc), number(number) {}
    FlagDefinition(std::string const& name, std::string const& doc, std::size_t number = number_undefined) {…}
 
    // equality of this type is based solely on the name attribute
    bool operator==(FlagDefinition const& other) const { return (other.name == name); }
    bool operator!=(FlagDefinition const& other) const { return (other.name != name); }
 
    std::string name;
    std::string doc;
    std::size_t number;
};
struct FlagDefinition {…};

class FlagDefinitionList {
public:
    FlagDefinitionList(){};

    FlagDefinitionList(std::initializer_list<FlagDefinition> const& list) {
        for (FlagDefinition const* iter = list.begin(); iter < list.end(); iter++) {
            add(iter->name, iter->doc);
        }
    }
    FlagDefinitionList(std::initializer_list<FlagDefinition> const& list) {…}
 
    static FlagDefinitionList const& getEmptyList() {
        static FlagDefinitionList list;
        return list;
    }
    static FlagDefinitionList const& getEmptyList() {…}

    FlagDefinition getDefinition(std::size_t index) const;
    FlagDefinition getDefinition(std::string const& name) const {
        for (std::size_t i = 0; i < size(); i++) {
            if (_vector[i].name == name) return _vector[i];
        }
        throw FatalAlgorithmError("No Flag Definition for " + name);
    }
    FlagDefinition getDefinition(std::string const& name) const  {…}

    FlagDefinition operator[](std::size_t index) const { return getDefinition(index); }
    bool hasDefinition(std::string const& name) const {
        for (std::size_t i = 0; i < size(); i++) {
            if (_vector[i].name == name) return true;
        }
        return false;
    }
    bool hasDefinition(std::string const& name) const  {…}

    FlagDefinition addFailureFlag(std::string const& doc = "General Failure Flag");

    FlagDefinition add(std::string const& name, std::string const& doc) {
        FlagDefinition flagDef = FlagDefinition(name, doc, _vector.size());
        _vector.push_back(flagDef);
        return _vector.back();
    }
    FlagDefinition add(std::string const& name, std::string const& doc) {…}

 
    std::size_t size() const { return _vector.size(); }
 
private:
    mutable std::vector<FlagDefinition> _vector;
};
class FlagDefinitionList {…};

class FlagHandler {
public:

    FlagHandler() : failureFlagNumber(FlagDefinition::number_undefined) {}

    static std::string const& getFailureFlagName() {
        static std::string name = "flag";
        return name;
    }
    static std::string const& getFailureFlagName() {…}

    static FlagHandler addFields(afw::table::Schema& schema, std::string const& prefix,
                                 FlagDefinitionList const& flagDefs,
                                 FlagDefinitionList const& exclDefs = FlagDefinitionList::getEmptyList());
    FlagHandler(afw::table::SubSchema const& s, FlagDefinitionList const& flagDefs,
                FlagDefinitionList const& exclDefs = FlagDefinitionList::getEmptyList());
    unsigned int getFlagNumber(std::string const& flagName) const {
        for (unsigned int i = 0; i < _vector.size(); i++) {
            if (_vector[i].first == flagName && _vector[i].second.isValid()) {
                return i;
            }
        }
        throw FatalAlgorithmError("No FlagHandler entry for " + flagName);
    }
    unsigned int getFlagNumber(std::string const& flagName) const  {…}

    std::string getFlagName(std::size_t i) const {
        if (i < _vector.size() && _vector[i].second.isValid()) {
            return _vector[i].first;
        }
        throw FatalAlgorithmError("No legal FlagHandler entry number " + std::to_string(i));
    }
    std::string getFlagName(std::size_t i) const  {…}

    bool getValue(afw::table::BaseRecord const& record, std::size_t i) const {
        if (i < _vector.size() && _vector[i].second.isValid()) {
            return record.get(_vector[i].second);
        }
        throw FatalAlgorithmError("No legal FlagHandler entry number " + std::to_string(i));
    }
    bool getValue(afw::table::BaseRecord const& record, std::size_t i) const  {…}

    bool getValue(afw::table::BaseRecord const& record, std::string const& flagName) const {
        for (std::size_t i = 0; i < _vector.size(); i++) {
            if (_vector[i].first == flagName && _vector[i].second.isValid()) {
                return record.get(_vector[i].second);
            }
        }
        throw FatalAlgorithmError("No FlagHandler entry for " + flagName);
    }
    bool getValue(afw::table::BaseRecord const& record, std::string const& flagName) const  {…}

    void setValue(afw::table::BaseRecord& record, std::size_t i, bool value) const {
        if (i < _vector.size() && _vector[i].second.isValid()) {
            record.set(_vector[i].second, value);
            return;
        }
        throw FatalAlgorithmError("No legal FlagHandler entry number " + std::to_string(i));
    }
    void setValue(afw::table::BaseRecord& record, std::size_t i, bool value) const  {…}

    void setValue(afw::table::BaseRecord& record, std::string const& flagName, bool value) const {
        for (std::size_t i = 0; i < _vector.size(); i++) {
            if (_vector[i].first == flagName && _vector[i].second.isValid()) {
                record.set(_vector[i].second, value);
                return;
            }
        }
        throw FatalAlgorithmError("No FlagHandler entry for " + flagName);
    }
    void setValue(afw::table::BaseRecord& record, std::string const& flagName, bool value) const  {…}

    std::size_t getFailureFlagNumber() const { return failureFlagNumber; }
    void handleFailure(afw::table::BaseRecord& record, MeasurementError const* error = nullptr) const;
 
    std::size_t failureFlagNumber;
 
private:
    typedef std::vector<std::pair<std::string, afw::table::Key<afw::table::Flag> > > Vector;
    Vector _vector;
};
class FlagHandler {…};
 
}  // namespace base
}  // namespace meas
}  // namespace lsst
 
#endif  // !LSST_MEAS_BASE_FlagHandler_h_INCLUDED