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/geom.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 { return 1; }

    static std::string getTypeString();

#ifndef SWIG_BUG_3465431_FIXED
    // SWIG uses this template to define the interface for the other specializations.
    // We can add other methods to full specializations using %extend, but we can't add
    // constructors that way.
    FieldBase() {}
    FieldBase(int) {
        throw LSST_EXCEPT(
            lsst::pex::exceptions::LogicError,
            "Constructor disabled (it only appears to exist as a workaround for a SWIG bug)."
        );
    }
#endif

protected:

    static FieldBase makeDefault() { 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."
        );
    }

    static std::string getTypeString();

    int getElementCount() const { return _size; }

    int getSize() const { return _size; }

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

protected:

    static FieldBase makeDefault() { 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);

    static std::string getTypeString();

    int getElementCount() const { return _size; }

    int getSize() const { return _size; }

protected:

    static FieldBase makeDefault() { return FieldBase(0); }

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

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

    ConstReference getConstReference(Element const * p, ndarray::Manager::Ptr const & m) const {
        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 lsst::afw::table

#endif // !AFW_TABLE_FieldBase_h_INCLUDED