ViewBuilder.h

Go to the documentation of this file.

// -*- c++ -*-
/* 
 * LSST Data Management System
 * Copyright 2008, 2009, 2010, 2011 LSST Corporation.
 * 
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the LSST License Statement and 
 * the GNU General Public License along with this program.  If not, 
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */
#ifndef NDARRAY_DETAIL_ViewBuilder_h_INCLUDED
#define NDARRAY_DETAIL_ViewBuilder_h_INCLUDED

#include "ndarray/views.h"
#include <boost/fusion/include/push_back.hpp>
#include <boost/fusion/include/pop_back.hpp>
#include <boost/fusion/include/front.hpp>
#include <boost/fusion/include/back.hpp>
#include <boost/fusion/include/vector.hpp>
#include <boost/fusion/include/reverse_view.hpp>
#include <boost/fusion/include/mpl.hpp>
#include <boost/fusion/include/at.hpp>
#include <boost/fusion/include/at_c.hpp>
#include <boost/fusion/tuple.hpp>
#include <boost/mpl/count.hpp>
#include <boost/mpl/size.hpp>
#include <boost/mpl/fold.hpp>

namespace ndarray {
namespace detail {

template <typename T, int M, int N>
struct CoreTransformer {
    T * _data;
    typename Core<M>::ConstPtr _input;
    typename Core<N>::Ptr _output;
    
    CoreTransformer(
        T * data,
        typename Core<M>::ConstPtr const & input,
        typename Core<N>::Ptr const & output
    ) : _data(data), _input(input), _output(output) {}
    
    template <int M1, int N1>
    CoreTransformer(CoreTransformer<T,M1,N1> const & other) : 
        _data(other._data), _input(other._input), _output(other._output) {}
};

template <int N, int C, int I>
struct Dimensions {
    typedef boost::mpl::int_<N> ND;  // Number of dimensions in output array
    typedef boost::mpl::int_<C> RMC; // Number of contiguous dimensions in output array, from end.
    typedef boost::mpl::int_<I> IDX; // Current dimension of input array being processed.
    typedef boost::mpl::int_<N-I> N_I; 
};

template <typename Index> struct IndexTraits;

template <>
struct IndexTraits<ndarray::index::Slice> {

    template <typename D> 
    struct Append {
        typedef Dimensions< 
            D::ND::value, 
            ((D::RMC::value < D::N_I::value) ? D::RMC::value : (D::N_I::value - 1)),
            (D::IDX::value + 1)
        > Type;
    };

    template <typename T, int M, int N> struct TransformCoreResult {
        typedef CoreTransformer<T,M-1,N-1> Type;
    };

    template <typename T, int M, int N>
    static CoreTransformer<T,M-1,N-1> transformCore(
        ndarray::index::Slice const & index, CoreTransformer<T,M,N> & t
    ) {
        NDARRAY_ASSERT(index.step > 0);
        NDARRAY_ASSERT(index.start <= index.stop);
        NDARRAY_ASSERT(index.start >= 0);
        NDARRAY_ASSERT(index.stop <= t._input->getSize());
        t._data += index.start * t._input->getStride();
        t._output->setSize(index.computeSize());
        t._output->setStride(t._input->getStride() * index.step);
        return t;
    }

};

template <>
struct IndexTraits<ndarray::index::Range> {

    template <typename D> 
    struct Append {
        typedef Dimensions< 
            D::ND::value, 
            ((D::RMC::value < D::N_I::value) ? D::RMC::value : D::N_I::value),
            (D::IDX::value + 1)
        > Type;
    };

    template <typename T, int M, int N> struct TransformCoreResult {
        typedef CoreTransformer<T,M-1,N-1> Type;
    };

    template <typename T, int M, int N>
    static CoreTransformer<T,M-1,N-1> transformCore(
        ndarray::index::Range const & index, CoreTransformer<T,M,N> & t
    ) {
        NDARRAY_ASSERT(index.start <= index.stop);
        NDARRAY_ASSERT(index.start >= 0);
        NDARRAY_ASSERT(index.stop <= t._input->getSize());
        t._data += index.start * t._input->getStride();
        t._output->setSize(index.stop - index.start);
        t._output->setStride(t._input->getStride());
        return t;
    }
};

template <>
struct IndexTraits<ndarray::index::Full> {

    template <typename D> 
    struct Append {
        typedef Dimensions< 
            D::ND::value, 
            D::RMC::value,
            (D::IDX::value + 1)
        > Type;
    };

    template <typename T, int M, int N> struct TransformCoreResult {
        typedef CoreTransformer<T,M-1,N-1> Type;
    };

    template <typename T, int M, int N>
    static CoreTransformer<T,M-1,N-1> transformCore(
        ndarray::index::Full const &, CoreTransformer<T,M,N> & t
    ) {
        t._output->setSize(t._input->getSize());
        t._output->setStride(t._input->getStride());
        return t;
    }
};

template <>
struct IndexTraits<ndarray::index::Scalar> {

    template <typename D> 
    struct Append {
        typedef Dimensions< 
            (D::ND::value - 1),
            ((D::RMC::value < (D::N_I::value - 1)) ? D::RMC::value : (D::N_I::value - 1)),
            (D::IDX::value + 1)
        > Type;
    };

    template <typename T, int M, int N> struct TransformCoreResult {
        typedef CoreTransformer<T,M-1,N> Type;
    };

    template <typename T, int M, int N>
    static CoreTransformer<T,M-1,N> transformCore(
        ndarray::index::Scalar const & index, CoreTransformer<T,M,N> & t
    ) {
        NDARRAY_ASSERT(index.n >= 0);
        NDARRAY_ASSERT(index.n < t._input->getSize());
        t._data += index.n * t._input->getStride();
        return t;
    }
};

template <typename T, int M, int N, typename Index>
typename IndexTraits<Index>::template TransformCoreResult<T,M,N>::Type
transformCore(Index const & index, CoreTransformer<T,M,N> & t) {
    return IndexTraits<Index>::transformCore(index, t);
}

struct AppendIndex {

    template <typename State, typename Index>
    struct apply {
        typedef typename IndexTraits<Index>::template Append<State>::Type type;
    };

};

template <int N, int C, typename Seq_, bool isColumnMajor = (C < 0)>
struct ViewTraits;

template <int N, int C, typename Seq_>
struct ViewTraits<N,C,Seq_,false> {

    typedef typename boost::mpl::fold< Seq_, Dimensions<N,C,0>, AppendIndex >::type Dims;
    
    typedef typename Dims::ND ND;
    typedef typename Dims::RMC RMC;

};

template <int N, int C, typename Seq_>
struct ViewTraits<N,C,Seq_,true> {

    typedef typename boost::mpl::fold< 
        boost::fusion::reverse_view< typename boost::fusion::result_of::as_vector<Seq_>::type >, 
        Dimensions<N,-C,0>, AppendIndex
    >::type Dims;
    
    typedef typename Dims::ND ND;
    typedef typename boost::mpl::negate<typename Dims::RMC>::type RMC;

};

template <int N, typename Seq_, bool IsNormalized=(boost::mpl::template size<Seq_>::type::value==N)>
struct ViewNormalizer {

    typedef typename boost::fusion::result_of::push_back<Seq_ const,index::Full>::type Next;

    typedef typename ViewNormalizer<N,Next>::Output Output;

    static Output apply(Seq_ const & input) {
        return ViewNormalizer<N,Next>::apply(
            boost::fusion::push_back(input, index::Full())
        );
    }
};

template <int N, typename Seq_>
struct ViewNormalizer<N,Seq_,true> {
    typedef typename boost::fusion::result_of::as_vector<Seq_>::type Output;
    static Output apply(Seq_ const & input) { return boost::fusion::as_vector(input); }
};

template <typename Array_, typename InSeq>
struct ViewBuilder {
    typedef ExpressionTraits<Array_> Traits;
    typedef typename Traits::Element Element;
    typedef typename Traits::ND InputND;
    typedef typename Traits::RMC InputRMC;
    typedef typename Traits::Core InputCore;
    typedef boost::mpl::bool_<(InputRMC::value < 0)> IsColumnMajor;

    typedef ViewNormalizer<InputND::value,InSeq> Normalizer;
    typedef typename ViewNormalizer<InputND::value,InSeq>::Output NormSeq;
    typedef ViewTraits<InputND::value,InputRMC::value,NormSeq> OutputTraits;

    typedef typename OutputTraits::ND OutputND;
    typedef typename OutputTraits::RMC OutputRMC;

    typedef ArrayRef<Element,OutputND::value,OutputRMC::value> OutputArray;
    typedef Core<OutputND::value> OutputCore;

    static OutputArray apply(Array_ const & array, InSeq const & seq) {
        CoreTransformer<Element,InputND::value,OutputND::value> initial(
            array.getData(), 
            ArrayAccess< Array_>::getCore(array),
            OutputCore::create(array.getManager())
        );
        NormSeq normSeq = Normalizer::apply(seq);
        std::pair<Element*,typename OutputCore::Ptr> final = process(normSeq, initial);
        return ArrayAccess< OutputArray >::construct(final.first, final.second);
    }

    template <int M, int N>
    static std::pair<Element*,typename OutputCore::Ptr>
    process(NormSeq const & seq, CoreTransformer<Element,M,N> t) {
        return process(seq, transformCore(boost::fusion::at_c<(InputND::value-M)>(seq), t));
    }

    static std::pair<Element*,typename OutputCore::Ptr>
    process(NormSeq const & seq, CoreTransformer<Element,0,0> t) {
        return std::make_pair(t._data, boost::static_pointer_cast<OutputCore>(t._output));
    }
    
};

template <typename Array_, typename Seq_>
typename ViewBuilder<Array_, Seq_>::OutputArray
buildView(Array_ const & array, Seq_ const & seq) {
    return ViewBuilder<Array_,Seq_>::apply(array, seq);
};

} // namespace detail

} // namespace ndarray

#endif // !NDARRAY_DETAIL_ViewBuilder_h_INCLUDED