FieldBase.h

Go to the documentation of this file.

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

#include <cstring>
#include <iostream>

#include "boost/mpl/vector.hpp"
#include "boost/preprocessor/punctuation/paren.hpp"
#include "Eigen/Core"

#include "lsst/base.h"
#include "lsst/pex/exceptions.h"
#include "ndarray.h"
#include "lsst/afw/table/misc.h"
#include "lsst/afw/table/KeyBase.h"
#include "lsst/afw/table/types.h"

namespace lsst {
namespace afw {
namespace table {

namespace detail {

class TableImpl;

inline int indexCovariance(int i, int j) { return (i < j) ? (i + j * (j + 1) / 2) : (j + i * (i + 1) / 2); }

inline int computeCovariancePackedSize(int size) { return size * (size + 1) / 2; }

}  // namespace detail

template <typename T>
struct FieldBase {
    typedef T Value;                  
    typedef T &Reference;             
    typedef T const &ConstReference;  
    typedef T Element;                

    int getElementCount() const noexcept { return 1; }

    static std::string getTypeString();

    // Only the first of these constructors is valid for this specializations, but
    // it's convenient to be able to instantiate both, since the other is used
    // by other specializations.
    FieldBase() = default;
    FieldBase(int) {
        throw LSST_EXCEPT(lsst::pex::exceptions::LogicError,
                          "Constructor disabled (this Field type is not sized).");
    }
    FieldBase(FieldBase const &) noexcept = default;
    FieldBase(FieldBase &&) noexcept = default;
    FieldBase &operator=(FieldBase const &) noexcept = default;
    FieldBase &operator=(FieldBase &&) noexcept = default;
    ~FieldBase() noexcept = default;

protected:
    static FieldBase makeDefault() noexcept { return FieldBase(); }

    void stream(std::ostream &os) const {}

    Reference getReference(Element *p, ndarray::Manager::Ptr const &) const { return *p; }

    ConstReference getConstReference(Element const *p, ndarray::Manager::Ptr const &) const { return *p; }

    Value getValue(Element const *p, ndarray::Manager::Ptr const &) const { return *p; }

    void setValue(Element *p, ndarray::Manager::Ptr const &, Value v) const { *p = v; }
};

template <typename U>
struct FieldBase<Array<U> > {
    typedef ndarray::Array<U const, 1, 1> Value;  

    typedef ndarray::ArrayRef<U, 1, 1> Reference;

    typedef ndarray::ArrayRef<U const, 1, 1> ConstReference;

    typedef U Element;  

    FieldBase(int size = 0) : _size(size) {
        if (size < 0)
            throw LSST_EXCEPT(lsst::pex::exceptions::LogicError,
                              "A non-negative size must be provided when constructing an array field.");
    }

    FieldBase(FieldBase const &) noexcept = default;
    FieldBase(FieldBase &&) noexcept = default;
    FieldBase &operator=(FieldBase const &) noexcept = default;
    FieldBase &operator=(FieldBase &&) noexcept = default;
    ~FieldBase() noexcept = default;

    static std::string getTypeString();

    int getElementCount() const noexcept { return _size; }

    int getSize() const noexcept { return _size; }

    bool isVariableLength() const noexcept { return _size == 0; }

protected:
    static FieldBase makeDefault() noexcept { return FieldBase(0); }

    void stream(std::ostream &os) const { os << ", size=" << _size; }

    Reference getReference(Element *p, ndarray::Manager::Ptr const &m) const {
        if (isVariableLength()) {
            return reinterpret_cast<ndarray::Array<Element, 1, 1> *>(p)->deep();
        }
        return ndarray::external(p, ndarray::makeVector(_size), ndarray::ROW_MAJOR, m);
    }

    ConstReference getConstReference(Element const *p, ndarray::Manager::Ptr const &m) const {
        if (isVariableLength()) {
            return reinterpret_cast<ndarray::Array<Element, 1, 1> const *>(p)->deep();
        }
        return ndarray::external(p, ndarray::makeVector(_size), ndarray::ROW_MAJOR, m);
    }

    Value getValue(Element const *p, ndarray::Manager::Ptr const &m) const {
        if (isVariableLength()) {
            return *reinterpret_cast<ndarray::Array<Element, 1, 1> const *>(p);
        }
        return ndarray::external(p, ndarray::makeVector(_size), ndarray::ROW_MAJOR, m);
    }

    void setValue(Element *p, ndarray::Manager::Ptr const &,
                  ndarray::Array<Element, 1, 1> const &value) const {
        if (isVariableLength()) {
            *reinterpret_cast<ndarray::Array<Element, 1, 1> *>(p) = value;
        } else {
            setValueDeep(p, value);
        }
    }

    template <typename Derived>
    void setValue(Element *p, ndarray::Manager::Ptr const &,
                  ndarray::ExpressionBase<Derived> const &value) const {
        if (isVariableLength()) {
            throw LSST_EXCEPT(
                    lsst::pex::exceptions::LogicError,
                    "Assignment to a variable-length array must use a non-const array of the correct type.");
        }
        setValueDeep(p, value);
    }

private:
    template <typename Derived>
    void setValueDeep(Element *p, ndarray::ExpressionBase<Derived> const &value) const {
        if (value.template getSize<0>() != static_cast<std::size_t>(_size)) {
            throw LSST_EXCEPT(lsst::pex::exceptions::LengthError,
                              "Incorrect size in array field assignment.");
        }
        for (int i = 0; i < _size; ++i) p[i] = value[i];
    }

    int _size;
};

template <>
struct FieldBase<std::string> {
    typedef std::string Value;  

    typedef char *Reference;

    typedef char const *ConstReference;

    typedef char Element;  

    FieldBase(int size = -1);

    FieldBase(FieldBase const &) noexcept = default;
    FieldBase(FieldBase &&) noexcept = default;
    FieldBase &operator=(FieldBase const &) noexcept = default;
    FieldBase &operator=(FieldBase &&) noexcept = default;
    ~FieldBase() noexcept = default;

    static std::string getTypeString();

    int getElementCount() const noexcept { return _size; }

    int getSize() const noexcept { return _size; }

    bool isVariableLength() const noexcept { return _size == 0; }

protected:
    static FieldBase makeDefault() noexcept { return FieldBase(0); }

    void stream(std::ostream &os) const { os << ", size=" << _size; }

    Reference getReference(Element *p, ndarray::Manager::Ptr const &m) const {
        if (isVariableLength()) {
            // Can't be done until C++17, which allows read/write access to std::string's internal buffer
            throw LSST_EXCEPT(lsst::pex::exceptions::LogicError,
                              "non-const operator[] not supported for variable-length strings");
        } else {
            return p;
        }
    }

    ConstReference getConstReference(Element const *p, ndarray::Manager::Ptr const &m) const {
        if (isVariableLength()) {
            return reinterpret_cast<std::string const *>(p)->data();
        } else {
            return p;
        }
    }

    Value getValue(Element const *p, ndarray::Manager::Ptr const &m) const;

    void setValue(Element *p, ndarray::Manager::Ptr const &, std::string const &value) const;

private:
    int _size;
};
}  // namespace table
}  // namespace afw
}  // namespace lsst

#endif  // !AFW_TABLE_FieldBase_h_INCLUDED