views.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_views_h_INCLUDED
#define NDARRAY_views_h_INCLUDED

#include <boost/fusion/include/push_back.hpp>
#include <boost/fusion/include/vector.hpp>
#include <boost/fusion/include/make_vector.hpp>
#include <boost/fusion/include/mpl.hpp>

namespace ndarray {
namespace index {

struct Slice {
    int start;
    int stop;
    int step;

    Slice(int start_, int stop_, int step_) : start(start_), stop(stop_), step(step_) {}

    int computeSize() const { return (step > 1) ? (stop - start + 1) / step : stop - start; }
};

struct Range {
    int start;
    int stop;

    Range(int start_, int stop_) : start(start_), stop(stop_) {}
};

struct Full {};

struct Scalar {
    int n;

    explicit Scalar(int n_) : n(n_) {}
};

} // namespace index

template <typename Seq_ = boost::fusion::vector<> >
struct View {
    typedef Seq_ Sequence; 
    Sequence _seq; 

    explicit View(Sequence seq) : _seq(seq) {}

    template <typename OtherSequence>
    explicit View(OtherSequence const & other) : _seq(other) {}

    template <typename OtherSequence>
    View(View<OtherSequence> const & other) : _seq(other._seq) {}

    typedef View<typename boost::fusion::result_of::push_back<Sequence const,index::Full>::type> Full;

    typedef View<typename boost::fusion::result_of::push_back<Sequence const,index::Range>::type> Range;

    typedef View<typename boost::fusion::result_of::push_back<Sequence const,index::Slice>::type> Slice;

    typedef View<typename boost::fusion::result_of::push_back<Sequence const,index::Scalar>::type> Scalar;

    Full operator()() const { return Full(boost::fusion::push_back(_seq, index::Full())); }
    
    Range operator()(int start, int stop) const {
        return Range(boost::fusion::push_back(_seq, index::Range(start, stop)));
    }

    Slice operator()(int start, int stop, int step) const {
        return Slice(boost::fusion::push_back(_seq, index::Slice(start, stop, step)));
    }

    Scalar operator()(int n) const {
        return Scalar(boost::fusion::push_back(_seq, index::Scalar(n)));
    }
};


inline View< boost::fusion::vector1<index::Full> > view() {
    return View< boost::fusion::vector1<index::Full> >(
        boost::fusion::make_vector(index::Full())
    );
}

inline View< boost::fusion::vector1<index::Range> > view(int start, int stop) {
    return View< boost::fusion::vector1<index::Range> >(
        boost::fusion::make_vector(index::Range(start, stop))
    );
}

inline View< boost::fusion::vector1<index::Slice> > view(int start, int stop, int step) {
    return View< boost::fusion::vector1<index::Slice> >(
        boost::fusion::make_vector(index::Slice(start, stop, step))
    );
}

inline View< boost::fusion::vector1<index::Scalar> > view(int n) {
    return View< boost::fusion::vector1<index::Scalar> >(
        boost::fusion::make_vector(index::Scalar(n))
    );
}

template <typename Sequence>
inline View<Sequence> view(Sequence const & sequence) {
    return View<Sequence>(sequence);
}


} // namespace ndarray

#endif // !NDARRAY_views_h_INCLUDED