views.h

Go to the documentation of this file.

// -*- c++ -*-
/*
 * Copyright (c) 2010-2012, Jim Bosch
 * All rights reserved.
 *
 * ndarray is distributed under a simple BSD-like license;
 * see the LICENSE file that should be present in the root
 * of the source distribution, or alternately available at:
 * https://github.com/ndarray/ndarray
 */
#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>
 
#include "ndarray_fwd.h"
 
namespace ndarray {
namespace index {
 
struct Slice {
    Size start;
    Size stop;
    Offset step;
 
    Slice(Size start_, Size stop_, Offset step_) : start(start_), stop(stop_), step(step_) {}
 
    Size computeSize() const { return (step > 1) ? (stop - start + 1) / step : stop - start; }
};
 
struct Range {
    Size start;
    Size stop;
 
    Range(Size start_, Size stop_) : start(start_), stop(stop_) {}
};
 
struct Full {};
 
struct Scalar {
    Size n;
 
    explicit Scalar(Size 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()(Size start, Size stop) const {
        return Range(boost::fusion::push_back(_seq, index::Range(start, stop)));
    }
 
    Slice operator()(Size start, Size stop, Offset step) const {
        return Slice(boost::fusion::push_back(_seq, index::Slice(start, stop, step)));
    }
 
    Scalar operator()(Size 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(Size start, Size stop) {
    return View< boost::fusion::vector1<index::Range> >(
        boost::fusion::make_vector(index::Range(start, stop))
    );
}
 
inline View< boost::fusion::vector1<index::Slice> > view(Size start, Size stop, Offset 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(Size n) {
    return View< boost::fusion::vector1<index::Scalar> >(
        boost::fusion::make_vector(index::Scalar(n))
    );
}
 
 
} // namespace ndarray
 
#endif // !NDARRAY_views_h_INCLUDED