Schema.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
#ifndef AFW_TABLE_Schema_h_INCLUDED
#define AFW_TABLE_Schema_h_INCLUDED

#include <memory>
#include <vector>

#include "ndarray.h"
#include "lsst/base.h"
#include "lsst/afw/fits.h"
#include "lsst/afw/fitsDefaults.h"
#include "lsst/afw/table/Key.h"
#include "lsst/afw/table/Field.h"
#include "lsst/afw/table/detail/SchemaImpl.h"
#include "lsst/afw/table/Flag.h"
#include "lsst/afw/table/AliasMap.h"

namespace lsst {
namespace afw {
namespace table {

class SubSchema;
class BaseRecord;

class Schema final {
    typedef detail::SchemaImpl Impl;

public:
    // This variable is defined in SchemaImpl, but is replicated here as
    // so that it is available to Python.
    static int const VERSION = detail::SchemaImpl::VERSION;

    enum ComparisonFlags {
        EQUAL_KEYS = 0x01,     
        EQUAL_NAMES = 0x02,    
        EQUAL_DOCS = 0x04,     
        EQUAL_UNITS = 0x08,    
        EQUAL_FIELDS = 0x0F,   
        EQUAL_ALIASES = 0x10,  
        IDENTICAL = 0x1F       
    };

    std::string join(std::string const& a, std::string const& b) const;
    std::string join(std::string const& a, std::string const& b, std::string const& c) const {
        return join(join(a, b), c);
    }
    std::string join(std::string const& a, std::string const& b, std::string const& c,
                     std::string const& d) const {
        return join(join(a, b), join(c, d));
    }

    template <typename T>
    SchemaItem<T> find(std::string const& name) const;

    template <typename T>
    SchemaItem<T> find(Key<T> const& key) const;

    template <typename F>
    void findAndApply(std::string const& name, F&& func) const {
        _impl->findAndApply(_aliases->apply(name), std::forward<F>(func));
    }

    SubSchema operator[](std::string const& name) const;

    std::set<std::string> getNames(bool topOnly = false) const;

    int getRecordSize() const { return _impl->getRecordSize(); }

    int getFieldCount() const { return _impl->getFieldCount(); }

    int getFlagFieldCount() const { return _impl->getFlagFieldCount(); }

    int getNonFlagFieldCount() const { return _impl->getNonFlagFieldCount(); }

    template <typename T>
    Key<T> addField(Field<T> const& field, bool doReplace = false);

    template <typename T>
    Key<T> addField(std::string const& name, std::string const& doc, std::string const& units = "",
                    FieldBase<T> const& base = FieldBase<T>(), bool doReplace = false) {
        return addField(Field<T>(name, doc, units, base), doReplace);
    }

    template <typename T>
    Key<T> addField(std::string const& name, std::string const& doc, FieldBase<T> const& base,
                    bool doReplace = false) {
        return addField(Field<T>(name, doc, base), doReplace);
    }

    template <typename T>
    void replaceField(Key<T> const& key, Field<T> const& field);

    template <typename F>
    void forEach(F&& func) const {
        Impl::VisitorWrapper<F> visitor(std::forward<F>(func));
        std::for_each(_impl->getItems().begin(), _impl->getItems().end(), visitor);
    }


    bool operator==(Schema const& other) const { return compare(other, EQUAL_KEYS); }
    bool operator!=(Schema const& other) const { return !this->operator==(other); }

    std::size_t hash_value() const noexcept;

    int compare(Schema const& other, int flags = EQUAL_KEYS) const;

    int contains(Schema const& other, int flags = EQUAL_KEYS) const;

    template <typename T>
    int contains(SchemaItem<T> const& item, int flags = EQUAL_KEYS) const;

    std::shared_ptr<AliasMap> getAliasMap() const { return _aliases; }

    void setAliasMap(std::shared_ptr<AliasMap> aliases);

    void disconnectAliases();

    Schema();

    Schema(Schema const& other);
    Schema(Schema&& other);

    Schema& operator=(Schema const& other);
    Schema& operator=(Schema&& other);
    ~Schema();

    static Schema readFits(std::string const& filename, int hdu = fits::DEFAULT_HDU);
    static Schema readFits(fits::MemFileManager& manager, int hdu = fits::DEFAULT_HDU);
    static Schema readFits(fits::Fits& fitsfile);

    static Schema fromFitsMetadata(daf::base::PropertyList& header, bool stripMetadata = true);

    friend std::ostream& operator<<(std::ostream& os, Schema const& schema);

    daf::base::Citizen& getCitizen() { return *_impl; }

private:
    friend class detail::Access;
    friend class SubSchema;

    void _edit();

    std::shared_ptr<Impl> _impl;
    std::shared_ptr<AliasMap> _aliases;
};

class SubSchema final {
    typedef detail::SchemaImpl Impl;

public:
    std::string join(std::string const& a, std::string const& b) const;
    std::string join(std::string const& a, std::string const& b, std::string const& c) const {
        return join(join(a, b), c);
    }
    std::string join(std::string const& a, std::string const& b, std::string const& c,
                     std::string const& d) const {
        return join(join(a, b), join(c, d));
    }

    template <typename T>
    SchemaItem<T> find(std::string const& name) const;

    template <typename F>
    void findAndApply(std::string const& name, F&& func) const {
        _impl->findAndApply(_aliases->apply(join(_name, name)), std::forward<F>(func));
    }

    template <typename F>
    void apply(F&& func) const {
        _impl->findAndApply(_aliases->apply(_name), std::forward<F>(func));
    }

    SubSchema operator[](std::string const& name) const;

    std::string const& getPrefix() const { return _name; }

    std::set<std::string> getNames(bool topOnly = false) const;

    template <typename T>
    operator Key<T>() const {
        return _impl->find<T>(_aliases->apply(_name)).key;
    }

    template <typename T>
    operator Field<T>() const {
        return _impl->find<T>(_aliases->apply(_name)).field;
    }

private:
    friend class Schema;

    SubSchema(std::shared_ptr<Impl> impl, std::shared_ptr<AliasMap> aliases, std::string const& name);

    std::shared_ptr<Impl> _impl;
    std::shared_ptr<AliasMap> _aliases;
    std::string _name;
};

inline SubSchema Schema::operator[](std::string const& name) const {
    return SubSchema(_impl, _aliases, name);
}
}  // namespace table
}  // namespace afw
}  // namespace lsst

namespace std {
template <>
struct hash<lsst::afw::table::Schema> {
    using argument_type = lsst::afw::table::Schema;
    using result_type = size_t;
    size_t operator()(argument_type const& obj) const noexcept { return obj.hash_value(); }
};
}  // namespace std

#endif  // !AFW_TABLE_Schema_h_INCLUDED