Core.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_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<int,M> const & shape,
        Vector<int,M> const & strides, 
        Manager::Ptr const & manager = Manager::Ptr()
    ) {
        return Ptr(new Core(shape, strides, manager), false);
    }        

    template <int M>
    static Ptr create(
        Vector<int,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)); }

    int getSize() const { return _size; }

    int getStride() const { return _stride; }

    void setSize(int size) { _size = size; }

    void setStride(int stride) { _stride = stride; }

    template <int M>
    int computeOffset(Vector<int,M> const & index) const {
        return index[M-N] * this->getStride() + Super::computeOffset(index);
    }

    template <int M>
    void fillShape(Vector<int,M> & shape) const {
        shape[M-N] = this->getSize();
        Super::fillShape(shape);
    }

    template <int M>
    void fillStrides(Vector<int,M> & strides) const {
        strides[M-N] = this->getStride();
        Super::fillStrides(strides);
    }

    int getNumElements() const {
        return getSize() * Super::getNumElements();
    }
    
protected:

    // Explicit strides
    template <int M>
    Core (
        Vector<int,M> const & shape,
        Vector<int,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<int,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<int,M> const & shape,
        int 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:
    int _size;
    int _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)); }

    int getSize() const { return 1; }
    int getStride() const { return 1; }

    template <int M>
    int computeOffset(Vector<int,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<int,M> const & shape) const {}

    template <int M>
    void fillStrides(Vector<int,M> const & strides) const {}

    int 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<int,M> const & shape,
        Vector<int,M> const & strides, 
        Manager::Ptr const & manager
    ) : _manager(manager), _rc(1) {}

    template <int M>
    Core(
        Vector<int,M> const & shape,
        Manager::Ptr const & manager
    ) : _manager(manager), _rc(1) {}

    template <int M>
    Core(
        Vector<int,M> const & shape,
        int 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