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, std::size_t 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));
    }
    static Key<typename Key<T>::Element> extractElement(KeyBase<T> const &kb, std::size_t n) {…}

    template <typename T>
    static Key<Array<T> > extractRange(KeyBase<Array<T> > const &kb, std::size_t begin, std::size_t 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);
    }
    static Key<Array<T> > extractRange(KeyBase<Array<T> > const &kb, std::size_t begin, std::size_t end) {…}

    template <typename T>
    static Key<T> makeKey(std::size_t offset) {
        return Key<T>(offset);
    }
    static Key<T> makeKey(std::size_t offset) {…}

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

    static Key<Flag> makeKey(std::size_t offset, std::size_t bit) { return Key<Flag>(offset, bit); }

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

    template <typename T>
    static Key<Array<T>> makeKeyArray(std::size_t offset, std::size_t size) {
        return Key<Array<T>>(offset, size);
    }
    static Key<Array<T>> makeKeyArray(std::size_t offset, std::size_t size) {…}

    static void padSchema(Schema &schema, std::size_t bytes) {
        schema._edit();
        schema._impl->_recordSize += bytes;
    }
    static void padSchema(Schema &schema, std::size_t bytes) {…}
};
class Access final {…};
}  // namespace detail
}  // namespace table
}  // namespace afw
}  // namespace lsst
 
#endif  // !AFW_TABLE_DETAIL_Access_h_INCLUDED