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 "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 std::size_t indexCovariance(std::size_t i, std::size_t j) { return (i < j) ? (i + j * (j + 1) / 2) : (j + i * (i + 1) / 2); }
 
inline std::size_t computeCovariancePackedSize(std::size_t size) { return size * (size + 1) / 2; }
 
}  // namespace detail
 
template <typename T>
struct FieldBase {
    using Value = T;                  
    using Reference = T &;             
    using ConstReference = const T &;  
    using Element = T;                
 
    std::size_t 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(std::size_t) {
        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> > {
    using Value = ndarray::Array<const U, 1, 1>;  
 
    using Reference = ndarray::ArrayRef<U, 1, 1>;
 
    using ConstReference = ndarray::ArrayRef<const U, 1, 1>;
 
    using Element = U;  
 
    FieldBase(size_t size = 0) : _size(size) {
    }
 
    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();
 
    std::size_t getElementCount() const noexcept { return _size; }
 
    std::size_t 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 (std::size_t i = 0; i < _size; ++i) p[i] = value[i];
    }
 
    std::size_t _size;
};
 
template <>
struct FieldBase<std::string> {
    using Value = std::string;  
 
    using Reference = char *;
 
    using ConstReference = const char *;
 
    using Element = char;  
 
    FieldBase(std::size_t size=std::numeric_limits<size_t>::max());
 
    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();
 
    std::size_t getElementCount() const noexcept { return _size; }
 
    std::size_t 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:
    std::size_t _size;
};
}  // namespace table
}  // namespace afw
}  // namespace lsst
 
#endif  // !AFW_TABLE_FieldBase_h_INCLUDED