Core.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_DETAIL_Core_h_INCLUDED
#define NDARRAY_DETAIL_Core_h_INCLUDED
 
#include <boost/intrusive_ptr.hpp>
#include <boost/mpl/int.hpp>
#include "ndarray/Vector.h"
#include "ndarray/Manager.h"
 
namespace ndarray {
namespace detail {
 
template <int N>
class Core : public Core<N-1> {
public:
    typedef boost::mpl::int_<N> ND;                    
    typedef Core<N-1> Super;                           
    typedef boost::intrusive_ptr<Core> Ptr;            
    typedef boost::intrusive_ptr<Core const> ConstPtr; 
 
    template <int M>
    static Ptr create(
        Vector<Size,M> const & shape,
        Vector<Offset,M> const & strides, 
        Manager::Ptr const & manager = Manager::Ptr()
    ) {
        return Ptr(new Core(shape, strides, manager), false);
    }        
 
    template <int M>
    static Ptr create(
        Vector<Size,M> const & shape,
        DataOrderEnum order,
        Manager::Ptr const & manager = Manager::Ptr()
    ) {
        if (order == ROW_MAJOR) {
            return Ptr(new Core(shape, manager), false);
        } else {
            return Ptr(new Core(shape, 1, manager), false);
        }
    }
 
    static Ptr create(
        Manager::Ptr const & manager = Manager::Ptr()
    ) {
        return Ptr(new Core(manager), false);
    }
 
    Ptr copy() const { return Ptr(new Core(*this)); }
 
    Size getSize() const { return _size; }
 
    Offset getStride() const { return _stride; }
 
    void setSize(Size size) { _size = size; }
 
    void setStride(Offset stride) { _stride = stride; }
 
    template <int M>
    Offset computeOffset(Vector<Size,M> const & index) const {
        return index[M-N] * this->getStride() + Super::computeOffset(index);
    }
 
    template <int M>
    void fillShape(Vector<Size,M> & shape) const {
        shape[M-N] = this->getSize();
        Super::fillShape(shape);
    }
 
    template <int M>
    void fillStrides(Vector<Offset,M> & strides) const {
        strides[M-N] = this->getStride();
        Super::fillStrides(strides);
    }
 
    Size getNumElements() const {
        return getSize() * Super::getNumElements();
    }
    
protected:
 
    // Explicit strides
    template <int M>
    Core (
        Vector<Size,M> const & shape,
        Vector<Offset,M> const & strides, 
        Manager::Ptr const & manager
    ) : Super(shape, strides, manager), _size(shape[M-N]), _stride(strides[M-N]) {}
 
    // Row-major strides
    template <int M>
    Core (
        Vector<Size,M> const & shape,
        Manager::Ptr const & manager
    ) : Super(shape, manager), _size(shape[M-N]), _stride(Super::getStride() * Super::getSize()) {}
 
    // Column-major strides
    template <int M>
    Core (
        Vector<Size,M> const & shape,
        Offset stride,
        Manager::Ptr const & manager
    ) : Super(shape, stride * shape[M-N], manager), _size(shape[M-N]), _stride(stride) {}
 
    // Zero shape and strides
    Core (
        Manager::Ptr const & manager
    ) : Super(manager), _size(0), _stride(0) {}
 
    Core(Core const & other) : Super(other), _size(other._size), _stride(other._stride) {}
 
private:
    Size _size;
    Offset _stride;
};
 
template <>
class Core<0> {
public:
    typedef boost::mpl::int_<0> ND;
    typedef boost::intrusive_ptr<Core> Ptr;
    typedef boost::intrusive_ptr<Core const> ConstPtr;
 
    friend inline void intrusive_ptr_add_ref(Core const * core) {
        ++core->_rc;
    }
 
    friend inline void intrusive_ptr_release(Core const * core) {
        if ((--core->_rc)==0) delete core;
    }
 
    Ptr copy() const { return Ptr(new Core(*this)); }
 
    Size getSize() const { return 1; }
    Offset getStride() const { return 1; }
 
    template <int M>
    Offset computeOffset(Vector<Size,M> const & index) const { return 0; }
 
    Manager::Ptr getManager() const { return _manager; }
 
    void setManager(Manager::Ptr const & manager) { _manager = manager; }
 
    template <int M>
    void fillShape(Vector<Size,M> const & shape) const {}
 
    template <int M>
    void fillStrides(Vector<Offset,M> const & strides) const {}
 
    Size getNumElements() const { return 1; }
 
    int getRC() const { return _rc; }
 
    bool isUnique() const { return (_rc == 1) && (_manager->getRC() == 1) && _manager->isUnique(); }
 
protected:
 
    virtual ~Core() {}
 
    template <int M>
    Core(
        Vector<Size,M> const & shape,
        Vector<Offset,M> const & strides, 
        Manager::Ptr const & manager
    ) : _manager(manager), _rc(1) {}
 
    template <int M>
    Core(
        Vector<Size,M> const & shape,
        Manager::Ptr const & manager
    ) : _manager(manager), _rc(1) {}
 
    template <int M>
    Core(
        Vector<Size,M> const & shape,
        Offset stride,
        Manager::Ptr const & manager
    ) : _manager(manager), _rc(1) {}
 
    Core(
        Manager::Ptr const & manager
    ) : _manager(manager), _rc(1) {}
 
    Core(Core const & other) : _manager(other._manager), _rc(1) {}
 
private:
    Manager::Ptr _manager;
    mutable int _rc;
};
 
 
template <int P, int N>
inline Core<N-P> const & 
getDimension(Core<N> const & core) { return core; }
 
template <int P, int N>
inline typename Core<N-P>::Ptr 
getDimension(typename Core<N>::Ptr const & core) { return core; }
 
} // namespace detail
} // namespace ndarray
 
#endif // !NDARRAY_DETAIL_Core_h_INCLUDED