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 <algorithm>
#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 {
    using Impl = detail::SchemaImpl;
 
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;
 
    std::size_t getRecordSize() const { return _impl->getRecordSize(); }
 
    std::size_t getFieldCount() const { return _impl->getFieldCount(); }
 
    std::size_t getFlagFieldCount() const { return _impl->getFlagFieldCount(); }
 
    std::size_t 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 {
        for (auto const & item : _impl->getItems()) {
            std::visit(func, item);
        }
    }
    template <typename F>
    void forEach(F const & func) const {
        for (auto const & item : _impl->getItems()) {
            std::visit(func, item);
        }
    }
 
 
    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);
 
private:
    friend class detail::Access;
    friend class SubSchema;
 
    void _edit();
 
    std::shared_ptr<Impl> _impl;
    std::shared_ptr<AliasMap> _aliases;
};
 
class SubSchema final {
    using Impl = detail::SchemaImpl;
 
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