Access.h

Go to the documentation of this file.

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

#include <cstring>

#include "ndarray/Manager.h"
#include "lsst/afw/table/FieldBase.h"
#include "lsst/afw/table/Schema.h"
#include "lsst/afw/table/detail/SchemaImpl.h"

namespace lsst {
namespace afw {
namespace table {

class BaseRecord;
class BaseTable;

namespace detail {

class Access final {
public:
    template <typename T>
    static Key<typename Key<T>::Element> extractElement(KeyBase<T> const &kb, int n) {
        if (!static_cast<Key<T> const &>(kb).isValid()) {
            throw LSST_EXCEPT(
                    pex::exceptions::LogicError,
                    (boost::format(
                             "Cannot extract subfield key from invalid key of type '%s' "
                             "(most often this is caused by failing to setup centroid or shape slots)") %
                     Key<T>::getTypeString())
                            .str());
        }
        return Key<typename Key<T>::Element>(static_cast<Key<T> const &>(kb).getOffset() +
                                             n * sizeof(typename Key<T>::Element));
    }

    template <typename T>
    static Key<Array<T> > extractRange(KeyBase<Array<T> > const &kb, int begin, int end) {
        if (!static_cast<Key<Array<T> > const &>(kb).isValid()) {
            throw LSST_EXCEPT(pex::exceptions::LogicError,
                              (boost::format("Cannot extract subfield key from invalid key of type '%s' ") %
                               Key<T>::getTypeString())
                                      .str());
        }
        return Key<Array<T> >(static_cast<Key<Array<T> > const &>(kb).getOffset() +
                                      begin * sizeof(typename Key<T>::Element),
                              end - begin);
    }

    template <typename T>
    static Key<T> makeKey(int offset) {
        return Key<T>(offset);
    }

    template <typename T>
    static Key<T> makeKey(Field<T> const &field, int offset) {
        return Key<T>(offset, field);
    }

    static Key<Flag> makeKey(int offset, int bit) { return Key<Flag>(offset, bit); }

    static Key<std::string> makeKeyString(int offset, int size) { return Key<std::string>(offset, size); }

    template <typename T>
    static Key<Array<T>> makeKeyArray(int offset, int size) {
        return Key<Array<T>>(offset, size);
    }

    static void padSchema(Schema &schema, int bytes) {
        schema._edit();
        schema._impl->_recordSize += bytes;
    }
};
}  // namespace detail
}  // namespace table
}  // namespace afw
}  // namespace lsst

#endif  // !AFW_TABLE_DETAIL_Access_h_INCLUDED