2017-07-27 14:48:41 +02:00
|
|
|
// -*- C++ -*-
|
|
|
|
|
|
|
|
#ifndef __container_range_h__
|
|
|
|
#define __container_range_h__
|
|
|
|
|
|
|
|
#include <cstdlib>
|
2017-07-28 14:02:44 +02:00
|
|
|
#include <tuple>
|
|
|
|
#include <memory>
|
|
|
|
|
2017-12-17 17:40:55 +01:00
|
|
|
#include "ranges/range_base.h"
|
|
|
|
#include "ranges/index_base.h"
|
2017-07-27 14:48:41 +02:00
|
|
|
|
2017-12-17 17:40:55 +01:00
|
|
|
#include "rpack_num.h"
|
2017-11-20 21:35:25 +01:00
|
|
|
|
2017-07-27 14:48:41 +02:00
|
|
|
namespace MultiArrayTools
|
|
|
|
{
|
2017-08-25 22:03:20 +02:00
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
class ContainerIndex : public IndexInterface<ContainerIndex<T,Indices...>,
|
|
|
|
std::tuple<typename Indices::MetaType...> >,
|
|
|
|
public std::iterator<std::random_access_iterator_tag,T>
|
2017-08-04 16:19:50 +02:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
typedef IndexInterface<ContainerIndex<T,Indices...>,
|
2017-12-11 18:49:43 +01:00
|
|
|
std::tuple<typename Indices::MetaType...> > IB;
|
2017-08-11 15:26:10 +02:00
|
|
|
typedef std::tuple<typename Indices::MetaType...> MetaType;
|
2017-08-04 16:19:50 +02:00
|
|
|
typedef std::tuple<std::shared_ptr<Indices>...> IndexPack;
|
2018-02-15 20:06:14 +01:00
|
|
|
typedef ContainerRange<T,typename Indices::RangeType...> RangeType;
|
2017-08-04 16:19:50 +02:00
|
|
|
|
2018-03-02 16:37:11 +01:00
|
|
|
static constexpr IndexType sType() { return IndexType::CONT; }
|
|
|
|
static constexpr size_t sDim() { return sizeof...(Indices); }
|
|
|
|
static constexpr size_t totalDim() { return mkTotalDim<Indices...>(); }
|
2018-02-16 18:17:22 +01:00
|
|
|
|
2018-07-28 15:27:11 +02:00
|
|
|
static constexpr SpaceType STYPE = SpaceType::ANY;
|
|
|
|
|
2017-12-11 18:49:43 +01:00
|
|
|
private:
|
2018-03-02 13:35:50 +01:00
|
|
|
|
|
|
|
ContainerIndex() = default;
|
|
|
|
|
2018-02-16 18:17:22 +01:00
|
|
|
bool mNonTrivialBlocks = false;
|
2017-08-04 16:19:50 +02:00
|
|
|
bool mExternControl = false;
|
|
|
|
IndexPack mIPack;
|
2017-08-30 19:41:49 +02:00
|
|
|
std::array<size_t,sizeof...(Indices)+1> mBlockSizes;
|
2018-08-20 17:50:04 +02:00
|
|
|
const T* mData = nullptr;
|
|
|
|
//const MultiArrayBase<T,typename Indices::RangeType...>* mMa = nullptr;
|
2018-03-05 00:04:50 +01:00
|
|
|
std::intptr_t mObjPtrNum;
|
2017-08-30 19:41:49 +02:00
|
|
|
|
2017-08-04 16:19:50 +02:00
|
|
|
public:
|
2017-12-17 14:16:37 +01:00
|
|
|
|
2018-03-02 13:35:50 +01:00
|
|
|
ContainerIndex(const ContainerIndex& in) = default;
|
|
|
|
ContainerIndex& operator=(const ContainerIndex& in) = default;
|
2017-12-11 18:49:43 +01:00
|
|
|
|
2017-08-04 16:19:50 +02:00
|
|
|
template <class MRange>
|
2018-03-05 00:04:50 +01:00
|
|
|
ContainerIndex(const std::shared_ptr<MRange>& range,
|
|
|
|
std::intptr_t objPtrNum);
|
2018-02-16 18:17:22 +01:00
|
|
|
|
|
|
|
template <class MRange>
|
|
|
|
ContainerIndex(const std::shared_ptr<MRange>& range,
|
2018-03-05 00:04:50 +01:00
|
|
|
std::intptr_t objPtrNum,
|
2018-02-16 18:17:22 +01:00
|
|
|
const std::array<size_t,sizeof...(Indices)+1>& blockSizes);
|
2018-03-02 13:35:50 +01:00
|
|
|
|
2017-12-11 18:49:43 +01:00
|
|
|
template <size_t N>
|
|
|
|
auto get() const -> decltype( *std::get<N>( mIPack ) )&;
|
|
|
|
|
2017-12-12 11:15:39 +01:00
|
|
|
template <size_t N>
|
|
|
|
auto getPtr() const -> decltype( std::get<N>( mIPack ) )&;
|
|
|
|
|
2018-09-16 18:53:28 +02:00
|
|
|
template <size_t N>
|
|
|
|
size_t getBlockSize() const { return std::get<N>(mBlockSizes); }
|
|
|
|
|
2018-01-05 13:56:16 +01:00
|
|
|
const IndexPack& pack() const { return mIPack; }
|
|
|
|
|
2017-12-11 18:49:43 +01:00
|
|
|
ContainerIndex& sync(); // recalculate 'IB::mPos' when externalControl == true
|
|
|
|
ContainerIndex& operator()(const std::shared_ptr<Indices>&... inds); // control via external indices
|
|
|
|
ContainerIndex& operator()(); // -> sync; just to shorten the code
|
2017-12-12 16:16:09 +01:00
|
|
|
|
2017-12-11 18:49:43 +01:00
|
|
|
// ==== >>>>> STATIC POLYMORPHISM <<<<< ====
|
|
|
|
|
2017-12-26 15:13:50 +01:00
|
|
|
IndexType type() const;
|
2017-12-11 18:49:43 +01:00
|
|
|
|
2017-12-17 14:16:37 +01:00
|
|
|
ContainerIndex& operator++();
|
|
|
|
ContainerIndex& operator--();
|
2017-08-30 17:56:38 +02:00
|
|
|
|
2017-12-17 14:16:37 +01:00
|
|
|
ContainerIndex& operator=(size_t pos);
|
2017-12-11 18:49:43 +01:00
|
|
|
|
2017-12-17 14:16:37 +01:00
|
|
|
int pp(std::intptr_t idxPtrNum);
|
|
|
|
int mm(std::intptr_t idxPtrNum);
|
2018-07-22 16:16:24 +02:00
|
|
|
|
|
|
|
std::string stringMeta() const;
|
2018-02-16 18:17:22 +01:00
|
|
|
MetaType meta() const;
|
2017-12-17 14:16:37 +01:00
|
|
|
ContainerIndex& at(const MetaType& metaPos);
|
2017-12-11 18:49:43 +01:00
|
|
|
|
2018-02-16 18:17:22 +01:00
|
|
|
size_t dim() const;
|
|
|
|
bool first() const;
|
|
|
|
bool last() const;
|
|
|
|
bool sliceMode() const;
|
|
|
|
|
2017-12-17 14:16:37 +01:00
|
|
|
std::shared_ptr<RangeType> range();
|
2017-08-04 16:19:50 +02:00
|
|
|
|
2017-08-07 17:11:03 +02:00
|
|
|
template <size_t N>
|
2017-12-17 14:16:37 +01:00
|
|
|
auto getPtr() -> decltype( std::get<N>( mIPack ) )&;
|
2017-08-28 18:28:43 +02:00
|
|
|
|
2017-12-17 14:16:37 +01:00
|
|
|
size_t getStepSize(size_t n);
|
2017-12-24 18:14:07 +01:00
|
|
|
|
2018-01-14 22:41:35 +01:00
|
|
|
std::string id() const;
|
2017-12-17 14:16:37 +01:00
|
|
|
void print(size_t offset);
|
2018-01-09 17:24:10 +01:00
|
|
|
|
2018-01-13 18:07:52 +01:00
|
|
|
template <class Exprs>
|
2018-02-12 00:11:24 +01:00
|
|
|
auto ifor(Exprs exs) const
|
2018-01-13 18:07:52 +01:00
|
|
|
-> decltype(RPackNum<sizeof...(Indices)-1>::mkFor(mIPack, exs));
|
2018-01-15 14:56:22 +01:00
|
|
|
|
|
|
|
template <class Exprs>
|
2018-02-12 00:11:24 +01:00
|
|
|
auto iforh(Exprs exs) const
|
2018-01-15 14:56:22 +01:00
|
|
|
-> decltype(RPackNum<sizeof...(Indices)-1>::mkForh(mIPack, exs));
|
|
|
|
|
2018-03-05 00:04:50 +01:00
|
|
|
std::intptr_t container() const;
|
|
|
|
ContainerIndex& format(const std::array<size_t,sizeof...(Indices)+1>& blocks);
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
// Iterator Stuff
|
|
|
|
|
|
|
|
ContainerIndex& setData(const T* data);
|
|
|
|
|
|
|
|
const T& operator*() const;
|
|
|
|
const T* operator->() const;
|
2018-09-08 18:46:04 +02:00
|
|
|
//T& operator*();
|
|
|
|
//T* operator->();
|
2018-02-15 20:06:14 +01:00
|
|
|
|
|
|
|
ContainerIndex operator++(int);
|
|
|
|
ContainerIndex operator--(int);
|
|
|
|
ContainerIndex& operator+=(int diff);
|
|
|
|
ContainerIndex& operator-=(int diff);
|
|
|
|
ContainerIndex operator+(int num) const;
|
|
|
|
ContainerIndex operator-(int num) const;
|
|
|
|
|
|
|
|
int operator-(const ContainerIndex& it) const;
|
|
|
|
const T& operator[](int num) const;
|
|
|
|
|
|
|
|
bool operator<(const ContainerIndex& it) const;
|
|
|
|
bool operator>(const ContainerIndex& it) const;
|
|
|
|
bool operator<=(const ContainerIndex& it) const;
|
|
|
|
bool operator>=(const ContainerIndex& it) const;
|
|
|
|
|
2017-08-04 16:19:50 +02:00
|
|
|
};
|
|
|
|
|
2018-03-01 18:16:12 +01:00
|
|
|
/*
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Ranges>
|
2017-07-27 14:48:41 +02:00
|
|
|
class ContainerRangeFactory : public RangeFactoryBase
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
typedef ContainerRange<T,Ranges...> oType;
|
2017-07-28 11:33:31 +02:00
|
|
|
|
2017-12-15 14:47:02 +01:00
|
|
|
ContainerRangeFactory();
|
2017-07-27 20:34:14 +02:00
|
|
|
ContainerRangeFactory(const std::shared_ptr<Ranges>&... rs);
|
2018-02-15 20:06:14 +01:00
|
|
|
ContainerRangeFactory(const typename ContainerRange<T,Ranges...>::SpaceType& space);
|
2017-07-27 20:34:14 +02:00
|
|
|
|
2017-07-27 14:48:41 +02:00
|
|
|
virtual std::shared_ptr<RangeBase> create() override;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
|
2018-03-01 18:16:12 +01:00
|
|
|
};*/
|
|
|
|
/*
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Ranges>
|
|
|
|
class ContainerRange : public RangeInterface<ContainerIndex<T,typename Ranges::IndexType...> >
|
2017-07-27 14:48:41 +02:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
2017-08-04 11:27:47 +02:00
|
|
|
typedef RangeBase RB;
|
2017-07-27 14:48:41 +02:00
|
|
|
typedef std::tuple<std::shared_ptr<Ranges>...> SpaceType;
|
2018-02-15 20:06:14 +01:00
|
|
|
typedef ContainerIndex<T,typename Ranges::IndexType...> IndexType;
|
2017-07-27 14:48:41 +02:00
|
|
|
|
|
|
|
protected:
|
|
|
|
ContainerRange() = default;
|
|
|
|
ContainerRange(const ContainerRange& in) = delete;
|
2017-08-04 16:19:50 +02:00
|
|
|
ContainerRange& operator=(const ContainerRange& in) = delete;
|
|
|
|
|
2017-07-27 20:34:14 +02:00
|
|
|
ContainerRange(const std::shared_ptr<Ranges>&... rs);
|
2017-07-27 14:48:41 +02:00
|
|
|
ContainerRange(const SpaceType& space);
|
|
|
|
|
|
|
|
SpaceType mSpace;
|
|
|
|
|
2017-08-04 16:19:50 +02:00
|
|
|
public:
|
|
|
|
static const size_t sdim = sizeof...(Ranges);
|
2017-07-27 14:48:41 +02:00
|
|
|
|
2017-08-04 16:19:50 +02:00
|
|
|
virtual size_t dim() const override;
|
|
|
|
virtual size_t size() const override;
|
2017-07-27 14:48:41 +02:00
|
|
|
|
2017-08-07 17:11:03 +02:00
|
|
|
template <size_t N>
|
|
|
|
auto get() const -> decltype( *std::get<N>( mSpace ) )&;
|
|
|
|
|
|
|
|
template <size_t N>
|
|
|
|
auto getPtr() const -> decltype( std::get<N>( mSpace ) )&;
|
2017-08-11 15:26:10 +02:00
|
|
|
|
|
|
|
const SpaceType& space() const;
|
2017-08-07 17:11:03 +02:00
|
|
|
|
2017-08-04 16:19:50 +02:00
|
|
|
virtual IndexType begin() const override;
|
|
|
|
virtual IndexType end() const override;
|
2017-07-27 14:48:41 +02:00
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
friend ContainerRangeFactory<T,Ranges...>;
|
2017-12-15 14:47:02 +01:00
|
|
|
|
2018-02-13 16:54:13 +01:00
|
|
|
static constexpr bool defaultable = false;
|
|
|
|
static constexpr size_t ISSTATIC = SubProp<Ranges...>::ISSTATIC;
|
|
|
|
static constexpr size_t SIZE = SubProp<Ranges...>::SIZE;
|
2017-07-27 14:48:41 +02:00
|
|
|
};
|
2018-03-01 18:16:12 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
//template <typename T, class... Ranges>
|
|
|
|
//using ContainerRange = MultiRange<Ranges...>;
|
|
|
|
|
2017-07-27 14:48:41 +02:00
|
|
|
} // end namespace MultiArrayTools
|
|
|
|
|
2017-11-20 21:35:25 +01:00
|
|
|
/* ========================= *
|
|
|
|
* --- TEMPLATE CODE --- *
|
|
|
|
* ========================= */
|
|
|
|
|
|
|
|
namespace MultiArrayTools
|
|
|
|
{
|
|
|
|
namespace
|
|
|
|
{
|
|
|
|
using namespace MultiArrayHelper;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**********************
|
|
|
|
* ContainerIndex *
|
|
|
|
**********************/
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
2017-11-20 21:35:25 +01:00
|
|
|
template <class MRange>
|
2018-03-05 00:04:50 +01:00
|
|
|
ContainerIndex<T,Indices...>::ContainerIndex(const std::shared_ptr<MRange>& range,
|
|
|
|
std::intptr_t objPtrNum) :
|
|
|
|
IndexInterface<ContainerIndex<T,Indices...>,std::tuple<typename Indices::MetaType...> >(range, 0),
|
|
|
|
mObjPtrNum(objPtrNum)
|
2017-11-20 21:35:25 +01:00
|
|
|
{
|
2017-12-17 17:40:55 +01:00
|
|
|
RPackNum<sizeof...(Indices)-1>::construct(mIPack, *range);
|
2017-11-20 21:35:25 +01:00
|
|
|
std::get<sizeof...(Indices)>(mBlockSizes) = 1;
|
2017-12-17 17:40:55 +01:00
|
|
|
RPackNum<sizeof...(Indices)-1>::initBlockSizes(mBlockSizes, mIPack);
|
2018-02-16 18:17:22 +01:00
|
|
|
IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack, mBlockSizes);
|
2017-11-20 21:35:25 +01:00
|
|
|
}
|
|
|
|
|
2018-02-16 18:17:22 +01:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
template <class MRange>
|
|
|
|
ContainerIndex<T,Indices...>::ContainerIndex(const std::shared_ptr<MRange>& range,
|
2018-03-05 00:04:50 +01:00
|
|
|
std::intptr_t objPtrNum,
|
2018-02-16 18:17:22 +01:00
|
|
|
const std::array<size_t,sizeof...(Indices)+1>& blockSizes) :
|
2018-03-05 00:04:50 +01:00
|
|
|
IndexInterface<ContainerIndex<T,Indices...>,std::tuple<typename Indices::MetaType...> >(range, 0),
|
|
|
|
mObjPtrNum(objPtrNum)
|
2018-02-16 18:17:22 +01:00
|
|
|
{
|
|
|
|
RPackNum<sizeof...(Indices)-1>::construct(mIPack, *range);
|
|
|
|
mBlockSizes = blockSizes;
|
|
|
|
IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack, mBlockSizes);
|
|
|
|
mNonTrivialBlocks = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::sync()
|
2017-11-20 21:35:25 +01:00
|
|
|
{
|
|
|
|
if(mExternControl){
|
2017-12-17 17:40:55 +01:00
|
|
|
IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
|
2017-11-20 21:35:25 +01:00
|
|
|
//VCHECK(id());
|
|
|
|
//VCHECK(sizeof...(Indices));
|
|
|
|
//assert(IB::mPos < IB::max());
|
|
|
|
}
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
2017-11-20 21:35:25 +01:00
|
|
|
template <size_t N>
|
2018-02-15 20:06:14 +01:00
|
|
|
auto ContainerIndex<T,Indices...>::get() const -> decltype( *std::get<N>( mIPack ) )&
|
2017-11-20 21:35:25 +01:00
|
|
|
{
|
|
|
|
return *std::get<N>( mIPack );
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
2017-12-12 11:15:39 +01:00
|
|
|
template <size_t N>
|
2018-02-15 20:06:14 +01:00
|
|
|
auto ContainerIndex<T,Indices...>::getPtr() const -> decltype( std::get<N>( mIPack ) )&
|
2017-12-12 11:15:39 +01:00
|
|
|
{
|
|
|
|
return std::get<N>( mIPack );
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator()(const std::shared_ptr<Indices>&... inds)
|
2017-11-20 21:35:25 +01:00
|
|
|
{
|
2017-12-17 17:40:55 +01:00
|
|
|
RPackNum<sizeof...(Indices)-1>::swapIndices(mIPack, inds...);
|
2017-11-20 21:35:25 +01:00
|
|
|
mExternControl = true;
|
|
|
|
return sync();
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator()()
|
2017-11-20 21:35:25 +01:00
|
|
|
{
|
|
|
|
return sync();
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
IndexType ContainerIndex<T,Indices...>::type() const { return IndexType::CONT; }
|
2017-12-17 14:16:37 +01:00
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator++()
|
2017-12-17 14:16:37 +01:00
|
|
|
{
|
|
|
|
if(mExternControl){
|
2017-12-17 17:40:55 +01:00
|
|
|
IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
|
2017-12-17 14:16:37 +01:00
|
|
|
}
|
2017-12-17 17:40:55 +01:00
|
|
|
RPackNum<sizeof...(Indices)-1>::pp( mIPack );
|
2017-12-17 14:16:37 +01:00
|
|
|
++IB::mPos;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator--()
|
2017-12-17 14:16:37 +01:00
|
|
|
{
|
|
|
|
if(mExternControl){
|
2017-12-17 17:40:55 +01:00
|
|
|
IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
|
2017-12-17 14:16:37 +01:00
|
|
|
}
|
2017-12-17 17:40:55 +01:00
|
|
|
RPackNum<sizeof...(Indices)-1>::mm( mIPack );
|
2017-12-17 14:16:37 +01:00
|
|
|
--IB::mPos;
|
|
|
|
return *this;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator=(size_t pos)
|
2017-12-17 14:16:37 +01:00
|
|
|
{
|
|
|
|
IB::mPos = pos;
|
2017-12-17 17:40:55 +01:00
|
|
|
RPackNum<sizeof...(Indices)-1>::setIndexPack(mIPack, pos);
|
2017-12-17 14:16:37 +01:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
int ContainerIndex<T,Indices...>::pp(std::intptr_t idxPtrNum)
|
2017-12-17 14:16:37 +01:00
|
|
|
{
|
2017-12-17 17:40:55 +01:00
|
|
|
int tmp = RPackNum<sizeof...(Indices)-1>::pp(mIPack, mBlockSizes, idxPtrNum);
|
2017-12-17 14:16:37 +01:00
|
|
|
IB::mPos += tmp;
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
int ContainerIndex<T,Indices...>::mm(std::intptr_t idxPtrNum)
|
2017-12-17 14:16:37 +01:00
|
|
|
{
|
2017-12-17 17:40:55 +01:00
|
|
|
int tmp = RPackNum<sizeof...(Indices)-1>::mm(mIPack, mBlockSizes, idxPtrNum);
|
2017-12-17 14:16:37 +01:00
|
|
|
IB::mPos -= tmp;
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
2018-07-22 16:16:24 +02:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
std::string ContainerIndex<T,Indices...>::stringMeta() const
|
|
|
|
{
|
|
|
|
return std::dynamic_pointer_cast<RangeType>( IB::mRangePtr )->stringMeta(IB::mPos);
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
2018-02-16 18:17:22 +01:00
|
|
|
typename ContainerIndex<T,Indices...>::MetaType ContainerIndex<T,Indices...>::meta() const
|
2017-12-17 14:16:37 +01:00
|
|
|
{
|
|
|
|
MetaType metaTuple;
|
2017-12-17 17:40:55 +01:00
|
|
|
RPackNum<sizeof...(Indices)-1>::getMetaPos(metaTuple, mIPack);
|
2017-12-17 14:16:37 +01:00
|
|
|
return metaTuple;
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::at(const MetaType& metaPos)
|
2017-12-17 14:16:37 +01:00
|
|
|
{
|
2017-12-17 17:40:55 +01:00
|
|
|
RPackNum<sizeof...(Indices)-1>::setMeta(mIPack, metaPos);
|
2018-03-06 13:58:17 +01:00
|
|
|
IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack, mBlockSizes);
|
2017-12-17 14:16:37 +01:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
2018-02-16 18:17:22 +01:00
|
|
|
size_t ContainerIndex<T,Indices...>::dim() const
|
2017-12-17 14:16:37 +01:00
|
|
|
{
|
|
|
|
return sizeof...(Indices);
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
2018-02-16 18:17:22 +01:00
|
|
|
bool ContainerIndex<T,Indices...>::first() const
|
2017-12-17 14:16:37 +01:00
|
|
|
{
|
|
|
|
return IB::pos() == 0;
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
2018-02-16 18:17:22 +01:00
|
|
|
bool ContainerIndex<T,Indices...>::last() const
|
2017-12-17 14:16:37 +01:00
|
|
|
{
|
|
|
|
return IB::pos() == IB::mMax - 1;
|
|
|
|
}
|
|
|
|
|
2018-02-16 18:17:22 +01:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
bool ContainerIndex<T,Indices...>::sliceMode() const
|
|
|
|
{
|
|
|
|
return mNonTrivialBlocks;
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
std::shared_ptr<typename ContainerIndex<T,Indices...>::RangeType>
|
|
|
|
ContainerIndex<T,Indices...>::range()
|
2017-12-17 14:16:37 +01:00
|
|
|
{
|
|
|
|
return std::dynamic_pointer_cast<RangeType>( IB::mRangePtr );
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
2017-12-17 14:16:37 +01:00
|
|
|
template <size_t N>
|
2018-02-15 20:06:14 +01:00
|
|
|
auto ContainerIndex<T,Indices...>::getPtr() -> decltype( std::get<N>( mIPack ) )&
|
2017-12-17 14:16:37 +01:00
|
|
|
{
|
|
|
|
return std::get<N>( mIPack );
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
size_t ContainerIndex<T,Indices...>::getStepSize(size_t n)
|
2017-12-17 14:16:37 +01:00
|
|
|
{
|
|
|
|
if(n >= sizeof...(Indices)){
|
|
|
|
assert(0);
|
|
|
|
// throw !!
|
|
|
|
}
|
|
|
|
return mBlockSizes[n+1];
|
|
|
|
}
|
2017-12-24 18:14:07 +01:00
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
std::string ContainerIndex<T,Indices...>::id() const
|
2017-12-17 14:16:37 +01:00
|
|
|
{
|
|
|
|
return std::string("con") + std::to_string(IB::mId);
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
void ContainerIndex<T,Indices...>::print(size_t offset)
|
2017-12-17 14:16:37 +01:00
|
|
|
{
|
|
|
|
if(offset == 0){
|
|
|
|
std::cout << " === " << std::endl;
|
|
|
|
}
|
|
|
|
for(size_t j = 0; j != offset; ++j) { std::cout << "\t"; }
|
|
|
|
std::cout << id() << "[" << reinterpret_cast<std::intptr_t>(this) << "]"
|
|
|
|
<< "(" << IB::mRangePtr << "): " << meta() << std::endl;
|
2017-12-17 17:40:55 +01:00
|
|
|
RPackNum<sizeof...(Indices)-1>::printIndex(mIPack, offset+1);
|
2017-12-17 14:16:37 +01:00
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
2018-01-13 18:07:52 +01:00
|
|
|
template <class Exprs>
|
2018-02-15 20:06:14 +01:00
|
|
|
auto ContainerIndex<T,Indices...>::ifor(Exprs exs) const
|
2018-01-13 18:07:52 +01:00
|
|
|
-> decltype(RPackNum<sizeof...(Indices)-1>::mkFor(mIPack, exs))
|
2018-01-07 22:33:34 +01:00
|
|
|
{
|
2018-01-13 18:07:52 +01:00
|
|
|
return RPackNum<sizeof...(Indices)-1>::mkFor(mIPack, exs);
|
2018-01-07 22:33:34 +01:00
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
2018-01-15 14:56:22 +01:00
|
|
|
template <class Exprs>
|
2018-02-15 20:06:14 +01:00
|
|
|
auto ContainerIndex<T,Indices...>::iforh(Exprs exs) const
|
2018-01-15 14:56:22 +01:00
|
|
|
-> decltype(RPackNum<sizeof...(Indices)-1>::mkForh(mIPack, exs))
|
|
|
|
{
|
|
|
|
return RPackNum<sizeof...(Indices)-1>::mkForh(mIPack, exs);
|
|
|
|
}
|
2018-03-05 00:04:50 +01:00
|
|
|
|
|
|
|
template <typename T, class... Indices>
|
|
|
|
std::intptr_t ContainerIndex<T,Indices...>::container() const
|
|
|
|
{
|
|
|
|
return mObjPtrNum;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... Indices>
|
|
|
|
ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::
|
|
|
|
format(const std::array<size_t,sizeof...(Indices)+1>& blocks)
|
|
|
|
{
|
|
|
|
mBlockSizes = blocks;
|
|
|
|
return *this;
|
|
|
|
}
|
2017-12-17 14:16:37 +01:00
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::setData(const T* data)
|
|
|
|
{
|
|
|
|
mData = data;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... Indices>
|
|
|
|
const T& ContainerIndex<T,Indices...>::operator*() const
|
|
|
|
{
|
2018-08-20 17:50:04 +02:00
|
|
|
//return mMa[*this];
|
2018-02-15 20:06:14 +01:00
|
|
|
return mData[IB::mPos];
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... Indices>
|
|
|
|
const T* ContainerIndex<T,Indices...>::operator->() const
|
|
|
|
{
|
2018-08-20 17:50:04 +02:00
|
|
|
//return &mMa[*this];
|
2018-02-15 20:06:14 +01:00
|
|
|
return &mData[IB::mPos];
|
|
|
|
}
|
2018-09-08 18:46:04 +02:00
|
|
|
/*
|
|
|
|
template <typename T, class... Indices>
|
|
|
|
T& ContainerIndex<T,Indices...>::operator*()
|
|
|
|
{
|
|
|
|
//return mMa[*this];
|
|
|
|
return mData[IB::mPos];
|
|
|
|
}
|
2018-02-15 20:06:14 +01:00
|
|
|
|
2018-09-08 18:46:04 +02:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
T* ContainerIndex<T,Indices...>::operator->()
|
|
|
|
{
|
|
|
|
//return &mMa[*this];
|
|
|
|
return &mData[IB::mPos];
|
|
|
|
}
|
|
|
|
*/
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Indices>
|
|
|
|
ContainerIndex<T,Indices...> ContainerIndex<T,Indices...>::operator++(int)
|
|
|
|
{
|
|
|
|
auto tmp = *this;
|
|
|
|
++(*this);
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... Indices>
|
|
|
|
ContainerIndex<T,Indices...> ContainerIndex<T,Indices...>::operator--(int)
|
|
|
|
{
|
|
|
|
auto tmp = *this;
|
|
|
|
--(*this);
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... Indices>
|
|
|
|
ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator+=(int diff)
|
|
|
|
{
|
|
|
|
if(diff < 0){
|
|
|
|
for(int i = 0; i != diff; ++i){
|
|
|
|
(*this)--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
for(int i = 0; i != diff; ++i){
|
|
|
|
(*this)++;
|
|
|
|
}
|
|
|
|
}
|
2018-05-20 20:03:44 +02:00
|
|
|
return *this;
|
2018-02-15 20:06:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... Indices>
|
|
|
|
ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator-=(int diff)
|
|
|
|
{
|
|
|
|
if(diff < 0){
|
|
|
|
for(int i = 0; i != diff; ++i){
|
|
|
|
(*this)++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
for(int i = 0; i != diff; ++i){
|
|
|
|
(*this)--;
|
|
|
|
}
|
|
|
|
}
|
2018-05-20 20:03:44 +02:00
|
|
|
return *this;
|
2018-02-15 20:06:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... Indices>
|
|
|
|
ContainerIndex<T,Indices...> ContainerIndex<T,Indices...>::operator+(int num) const
|
|
|
|
{
|
|
|
|
auto tmp = *this;
|
|
|
|
return tmp += num;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... Indices>
|
|
|
|
ContainerIndex<T,Indices...> ContainerIndex<T,Indices...>::operator-(int num) const
|
|
|
|
{
|
|
|
|
auto tmp = *this;
|
|
|
|
return tmp -= num;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... Indices>
|
|
|
|
int ContainerIndex<T,Indices...>::operator-(const ContainerIndex<T,Indices...>& it) const
|
|
|
|
{
|
|
|
|
return static_cast<int>( IB::mPos ) - static_cast<int>( it.pos() );
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... Indices>
|
|
|
|
const T& ContainerIndex<T,Indices...>::operator[](int num) const
|
|
|
|
{
|
|
|
|
return mData[IB::mPos + num];
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... Indices>
|
|
|
|
bool ContainerIndex<T,Indices...>::operator<(const ContainerIndex<T,Indices...>& it) const
|
|
|
|
{
|
|
|
|
return IB::mPos < it.pos();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... Indices>
|
|
|
|
bool ContainerIndex<T,Indices...>::operator>(const ContainerIndex<T,Indices...>& it) const
|
|
|
|
{
|
|
|
|
return IB::mPos > it.pos();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... Indices>
|
|
|
|
bool ContainerIndex<T,Indices...>::operator<=(const ContainerIndex<T,Indices...>& it) const
|
|
|
|
{
|
|
|
|
return IB::mPos <= it.pos();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... Indices>
|
|
|
|
bool ContainerIndex<T,Indices...>::operator>=(const ContainerIndex<T,Indices...>& it) const
|
|
|
|
{
|
|
|
|
return IB::mPos >= it.pos();
|
|
|
|
}
|
|
|
|
|
2017-11-20 21:35:25 +01:00
|
|
|
/*****************************
|
|
|
|
* ContainerRangeFactory *
|
|
|
|
*****************************/
|
2018-03-01 18:16:12 +01:00
|
|
|
/*
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Ranges>
|
|
|
|
ContainerRangeFactory<T,Ranges...>::ContainerRangeFactory(const std::shared_ptr<Ranges>&... rs)
|
2017-11-20 21:35:25 +01:00
|
|
|
{
|
2018-02-15 20:06:14 +01:00
|
|
|
mProd = std::shared_ptr<ContainerRange<T,Ranges...> >( new ContainerRange<T,Ranges...>( rs... ) );
|
2017-11-20 21:35:25 +01:00
|
|
|
}
|
2017-12-15 14:47:02 +01:00
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Ranges>
|
|
|
|
ContainerRangeFactory<T,Ranges...>::
|
|
|
|
ContainerRangeFactory(const typename ContainerRange<T,Ranges...>::SpaceType& space)
|
2017-11-20 21:35:25 +01:00
|
|
|
{
|
2018-02-15 20:06:14 +01:00
|
|
|
mProd = std::shared_ptr<ContainerRange<T,Ranges...> >( new ContainerRange<T,Ranges...>( space ) );
|
2017-11-20 21:35:25 +01:00
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Ranges>
|
|
|
|
std::shared_ptr<RangeBase> ContainerRangeFactory<T,Ranges...>::create()
|
2017-11-20 21:35:25 +01:00
|
|
|
{
|
|
|
|
setSelf();
|
|
|
|
return mProd;
|
|
|
|
}
|
2018-03-01 18:16:12 +01:00
|
|
|
*/
|
2017-11-20 21:35:25 +01:00
|
|
|
/**********************
|
|
|
|
* ContainerRange *
|
|
|
|
**********************/
|
2018-03-01 18:16:12 +01:00
|
|
|
/*
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Ranges>
|
|
|
|
ContainerRange<T,Ranges...>::ContainerRange(const std::shared_ptr<Ranges>&... rs) :
|
2017-11-20 21:35:25 +01:00
|
|
|
mSpace( std::make_tuple( rs... ) ) {}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Ranges>
|
|
|
|
ContainerRange<T,Ranges...>::ContainerRange(const SpaceType& space) : mSpace( space ) {}
|
2017-11-20 21:35:25 +01:00
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Ranges>
|
|
|
|
size_t ContainerRange<T,Ranges...>::dim() const
|
2017-11-20 21:35:25 +01:00
|
|
|
{
|
|
|
|
return sizeof...(Ranges);
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Ranges>
|
|
|
|
size_t ContainerRange<T,Ranges...>::size() const
|
2017-11-20 21:35:25 +01:00
|
|
|
{
|
2017-12-17 17:40:55 +01:00
|
|
|
return RPackNum<sizeof...(Ranges)-1>::getSize(mSpace);
|
2017-11-20 21:35:25 +01:00
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Ranges>
|
2017-11-20 21:35:25 +01:00
|
|
|
template <size_t N>
|
2018-02-15 20:06:14 +01:00
|
|
|
auto ContainerRange<T,Ranges...>::get() const -> decltype( *std::get<N>( mSpace ) )&
|
2017-11-20 21:35:25 +01:00
|
|
|
{
|
|
|
|
return *std::get<N>( mSpace );
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Ranges>
|
2017-11-20 21:35:25 +01:00
|
|
|
template <size_t N>
|
2018-02-15 20:06:14 +01:00
|
|
|
auto ContainerRange<T,Ranges...>::getPtr() const -> decltype( std::get<N>( mSpace ) )&
|
2017-11-20 21:35:25 +01:00
|
|
|
{
|
|
|
|
return std::get<N>( mSpace );
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Ranges>
|
|
|
|
const typename ContainerRange<T,Ranges...>::SpaceType& ContainerRange<T,Ranges...>::space() const
|
2017-11-20 21:35:25 +01:00
|
|
|
{
|
|
|
|
return mSpace;
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Ranges>
|
|
|
|
typename ContainerRange<T,Ranges...>::IndexType ContainerRange<T,Ranges...>::begin() const
|
2017-11-20 21:35:25 +01:00
|
|
|
{
|
2018-02-15 20:06:14 +01:00
|
|
|
ContainerIndex<T,typename Ranges::IndexType...>
|
|
|
|
i( std::dynamic_pointer_cast<ContainerRange<T,Ranges...> >
|
2017-11-20 21:35:25 +01:00
|
|
|
( std::shared_ptr<RangeBase>( RB::mThis ) ) );
|
|
|
|
i = 0;
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
2018-02-15 20:06:14 +01:00
|
|
|
template <typename T, class... Ranges>
|
|
|
|
typename ContainerRange<T,Ranges...>::IndexType ContainerRange<T,Ranges...>::end() const
|
2017-11-20 21:35:25 +01:00
|
|
|
{
|
2018-02-15 20:06:14 +01:00
|
|
|
ContainerIndex<T,typename Ranges::IndexType...>
|
|
|
|
i( std::dynamic_pointer_cast<ContainerRange<T,Ranges...> >
|
2017-11-20 21:35:25 +01:00
|
|
|
( std::shared_ptr<RangeBase>( RB::mThis ) ) );
|
|
|
|
i = size();
|
|
|
|
return i;
|
|
|
|
}
|
2018-03-01 18:16:12 +01:00
|
|
|
*/
|
2017-11-20 21:35:25 +01:00
|
|
|
} // end namespace MultiArrayTools
|
|
|
|
|
2017-07-27 14:48:41 +02:00
|
|
|
|
|
|
|
#endif
|