ArrayBase.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_ArrayBase_h_INCLUDED
#define NDARRAY_ArrayBase_h_INCLUDED
 
#include <boost/iterator/counting_iterator.hpp>
 
#include "ndarray/ExpressionBase.h"
#include "ndarray/Vector.h"
#include "ndarray/detail/Core.h"
#include "ndarray/detail/NestedIterator.h"
#include "ndarray/detail/StridedIterator.h"
#include "ndarray/detail/ArrayAccess.h"
#include "ndarray/detail/ViewBuilder.h"
#include "ndarray/ArrayTraits.h"
 
namespace ndarray {
 
template <typename Derived>
class ArrayBase : public ExpressionBase<Derived> {
protected:
    typedef ExpressionTraits<Derived> Traits;
    typedef typename Traits::Core Core;
    typedef typename Traits::CorePtr CorePtr;
public:
    typedef typename Traits::Element Element;
    typedef typename Traits::Iterator Iterator;
    typedef typename Traits::Reference Reference;
    typedef typename Traits::Value Value;
    typedef typename Traits::ND ND;
    typedef typename Traits::RMC RMC;
    typedef Vector<Size,ND::value> Index;
    typedef Vector<Offset,ND::value> Strides;
    typedef ArrayRef<Element,ND::value,-RMC::value> FullTranspose;
    typedef ArrayRef<Element,ND::value,0> Transpose;
    typedef Array<Element,ND::value,RMC::value> Shallow;
    typedef ArrayRef<Element,ND::value,RMC::value> Deep;
 
    Reference operator[](Size n) const {
        return Traits::makeReference(
            this->_data + n * this->
            #ifndef _MSC_VER
            template
            #endif
            getStride<0>(),
            this->_core
        );
    }
 
    Element & operator[](Index const & i) const {
        return *(this->_data + this->_core->
            #ifndef _MSC_VER
            template
            #endif
            computeOffset(i));
    }
 
    Iterator begin() const {
        return Traits::makeIterator(
            this->_data,
            this->_core,
            this->
                #ifndef _MSC_VER
                template
                #endif
                getStride<0>()
        );
    }
 
    Iterator end() const {
        return Traits::makeIterator(
            this->_data + this->
                #ifndef _MSC_VER
                template
                #endif
                getSize<0>() * this->
                    #ifndef _MSC_VER
                    template
                    #endif
                    getStride<0>(), 
            this->_core,
            this->
                #ifndef _MSC_VER
                template
                #endif
                getStride<0>()
        );
    }
 
    Element * getData() const { return _data; }
    
    bool isEmpty() const { return _data == 0; }
 
    Manager::Ptr getManager() const { return this->_core->getManager(); }
 
    template <int P> Size getSize() const {
        return detail::getDimension<P>(*this->_core).getSize();
    }
 
    template <int P> Offset getStride() const {
        return detail::getDimension<P>(*this->_core).getStride();
    }
 
    Index getShape() const { Index r; this->_core->fillShape(r); return r; }
 
    Strides getStrides() const { Strides r; this->_core->fillStrides(r); return r; }
 
    Size getNumElements() const { return this->_core->getNumElements(); }
 
    FullTranspose transpose() const {
        Index shape = getShape();
        Strides strides = getStrides();
        for (int n=0; n < ND::value / 2; ++n) {
            std::swap(shape[n], shape[ND::value-n-1]);
            std::swap(strides[n], strides[ND::value-n-1]);
        }
        return FullTranspose(
            getData(),
            Core::create(shape, strides, getManager())
        );
    }
 
    Transpose transpose(Index const & order) const {
        Index newShape;
        Strides newStrides;
        Index oldShape = getShape();
        Strides oldStrides = getStrides();
        for (int n=0; n < ND::value; ++n) {
            newShape[n] = oldShape[order[n]];
            newStrides[n] = oldStrides[order[n]];
        }
        return Transpose(
            getData(), 
            Core::create(newShape, newStrides, getManager())
        );
    }
 
    Shallow const shallow() const { return Shallow(this->getSelf()); }
 
    Deep const deep() const { return Deep(this->getSelf()); }
 
    template <typename View_>
    struct ResultOf {
        typedef Element Element_;
        typedef typename detail::ViewTraits<ND::value, RMC::value, typename View_::Sequence>::ND ND_;
        typedef typename detail::ViewTraits<ND::value, RMC::value, typename View_::Sequence>::RMC RMC_;
        typedef ArrayRef<Element_,ND_::value,RMC_::value> Type;
        typedef Array<Element_,ND_::value,RMC_::value> Value;
    };
 
    template <typename Seq>
    typename ResultOf< View<Seq> >::Type
    operator[](View<Seq> const & def) const {
        return detail::buildView(this->getSelf(), def._seq);
    }
 
protected:
    template <typename T_, int N_, int C_> friend class Array;
    template <typename T_, int N_, int C_> friend class ArrayRef;
    template <typename T_, int N_, int C_> friend struct ArrayTraits;
    template <typename T_, int N_, int C_> friend class detail::NestedIterator;
    template <typename Derived_> friend class ArrayBase;
    template <typename Array_> friend class detail::ArrayAccess;
 
    Element * _data;
    CorePtr _core;
 
    void operator=(ArrayBase const & other) {
        _data = other._data;
        _core = other._core;
    }
 
    template <typename Other>
    ArrayBase(ArrayBase<Other> const & other) : _data(other._data), _core(other._core) {}
 
    ArrayBase(Element * data, CorePtr const & core) : _data(data), _core(core) {}
};
 
} // namespace ndarray
 
#endif // !NDARRAY_ArrayBase_h_INCLUDED