SchemaImpl.h

Go to the documentation of this file.

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

#include <vector>
#include <algorithm>
#include <map>
#include <set>

#include "boost/variant.hpp"
#include "boost/mpl/transform.hpp"
#include "boost/type_traits/remove_const.hpp"
#include "boost/type_traits/remove_reference.hpp"

#include "lsst/daf/base/Citizen.h"

namespace lsst { namespace afw { namespace table {

class Schema;
class SubSchema;

template <typename T>
struct SchemaItem {
#ifndef SWIG  // see comment block in tableLib.i; workaround to avoid dangling references
    Key<T> key;
    Field<T> field;
#endif 
    SchemaItem(Key<T> const & key_, Field<T> const & field_) : key(key_), field(field_) {}
};

namespace detail {

#ifndef SWIG

class Access;

class SchemaImpl : public daf::base::Citizen {
private:

    struct MakeItem {
        template <typename T>
        struct apply {
            typedef SchemaItem<T> type;
        };
    };

public:

    static int const DEFAULT_VERSION = 1;

    typedef boost::mpl::transform<FieldTypes,MakeItem>::type ItemTypes;
    typedef boost::make_variant_over< ItemTypes >::type ItemVariant;
    typedef std::vector<ItemVariant> ItemContainer;
    typedef std::map<std::string,int> NameMap;
    typedef std::map<int,int> OffsetMap;
    typedef std::map<std::pair<int,int>,int> FlagMap;

    int getRecordSize() const { return _recordSize; }

    int getFieldCount() const { return _names.size(); }

    int getFlagFieldCount() const { return _flags.size(); }

    int getNonFlagFieldCount() const { return _offsets.size(); }

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

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

    SchemaItem<Flag> find(Key<Flag> const & key) const;

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

    std::set<std::string> getNames(bool topOnly, std::string const & prefix) const;

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

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

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

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

    ItemContainer const & getItems() const { return _items; }

    explicit SchemaImpl() : 
        daf::base::Citizen(typeid(this)), 
        _recordSize(0), _lastFlagField(-1), _lastFlagBit(-1), _items(), _version(DEFAULT_VERSION)
    {}

    template <typename F>
    struct VisitorWrapper : public boost::static_visitor<> {

        template <typename T>
        void operator()(SchemaItem<T> const & x) const { _func(x); };
    
        void operator()(ItemVariant const & v) const {
            boost::apply_visitor(*this, v);
        }

        explicit VisitorWrapper(F func) : _func(func) {}

    private:
        F _func;
    };

    int getVersion() const { return _version; }

    void setVersion(int version) { _version = version; }


private:

    friend class detail::Access;

    int _recordSize;      // Size of a record in bytes.
    int _lastFlagField;   // Offset of the last flag field in bytes.
    int _lastFlagBit;     // Bit of the last flag field.
    ItemContainer _items; // Vector of variants of SchemaItem<T>.
    NameMap _names;       // Field name to vector-index map.
    OffsetMap _offsets;   // Offset to vector-index map for regular fields.
    FlagMap _flags;       // Offset to vector-index map for flags.
    int _version;         // temporary flag for version 0/1 tables
};

#endif

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

#endif // !AFW_TABLE_DETAIL_SchemaImpl_h_INCLUDED