Schema.h

Go to the documentation of this file.

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

#include <vector>

#include "boost/shared_ptr.hpp"
#include "boost/ref.hpp"

#include "ndarray.h"
#include "lsst/base.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 {
    typedef detail::SchemaImpl Impl;
public:

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

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

    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;

    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<typename boost::unwrap_reference<F>::type &> visitor(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); }

    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;

    PTR(AliasMap) getAliasMap() const { return _aliases; }

    void setAliasMap(PTR(AliasMap) aliases);

    void disconnectAliases();

    Schema();

    explicit Schema(int version);

    Schema(Schema const & other);

    explicit Schema(daf::base::PropertyList & metadata, bool stripMetadata);

    explicit Schema(daf::base::PropertyList const & metadata);

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

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

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

    void setVersion(int version) { _edit();_impl->setVersion(version); }

private:

    friend class detail::Access;
    friend class SubSchema;

    void _edit();

    PTR(Impl) _impl;
    PTR(AliasMap) _aliases;
};

class SubSchema {
    typedef detail::SchemaImpl Impl;
public:
    
    template <typename T>
    SchemaItem<T> find(std::string const & name) const;

    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(PTR(Impl) impl, PTR(AliasMap) aliases, std::string const & name);

    PTR(Impl) _impl;
    PTR(AliasMap) _aliases;
    std::string _name;
};

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

}}} // namespace lsst::afw::table

#endif // !AFW_TABLE_Schema_h_INCLUDED