2018-02-16 18:17:22 +01:00
|
|
|
|
|
|
|
#ifndef __slice_h__
|
|
|
|
#define __slice_h__
|
|
|
|
|
|
|
|
#include "multi_array_base.h"
|
|
|
|
|
|
|
|
namespace MultiArrayTools
|
|
|
|
{
|
|
|
|
|
|
|
|
template <typename T, class... SRanges>
|
|
|
|
class Slice : public MutableMultiArrayBase<T,SRanges...>
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
|
|
|
typedef ContainerRange<T,SRanges...> CRange;
|
|
|
|
typedef MultiArrayBase<T,SRanges...> MAB;
|
2018-03-05 00:04:50 +01:00
|
|
|
typedef typename CRange::IndexType IType;
|
2018-02-16 18:17:22 +01:00
|
|
|
|
|
|
|
DEFAULT_MEMBERS(Slice);
|
|
|
|
|
2018-03-05 00:04:50 +01:00
|
|
|
// RITypes = Range XOR Index depending on whether const XOR opern
|
|
|
|
template <class... RITypes>
|
|
|
|
Slice(MutableMultiArrayBase<T,typename RITypes::RangeType...>& ma,
|
|
|
|
const std::shared_ptr<RITypes>&... ris);
|
2018-02-16 18:17:22 +01:00
|
|
|
|
2018-03-05 00:04:50 +01:00
|
|
|
virtual const T& operator[](const IType& i) const override;
|
|
|
|
virtual T& operator[](const IType& i) override;
|
|
|
|
virtual const T& at(const typename IType::MetaType& meta) const override;
|
|
|
|
virtual T& at(const typename IType::MetaType& meta) override;
|
2018-02-16 18:17:22 +01:00
|
|
|
|
|
|
|
virtual const T* data() const override;
|
|
|
|
virtual T* data() override;
|
|
|
|
|
|
|
|
virtual bool isSlice() const override;
|
|
|
|
|
2018-03-05 00:04:50 +01:00
|
|
|
virtual auto begin() const -> IType override;
|
|
|
|
virtual auto end() const -> IType override;
|
2018-02-16 18:17:22 +01:00
|
|
|
|
|
|
|
private:
|
|
|
|
T* mData;
|
|
|
|
};
|
|
|
|
|
|
|
|
} // end namespace MultiArrayTools
|
|
|
|
|
|
|
|
/* ========================= *
|
|
|
|
* --- TEMPLATE CODE --- *
|
|
|
|
* ========================= */
|
|
|
|
|
|
|
|
namespace MultiArrayTools
|
|
|
|
{
|
|
|
|
|
|
|
|
namespace
|
|
|
|
{
|
|
|
|
|
2018-03-05 00:04:50 +01:00
|
|
|
//size_t sum(size_t arg)
|
|
|
|
//{
|
|
|
|
// return arg;
|
|
|
|
//}
|
|
|
|
|
|
|
|
template <typename... SizeTypes>
|
|
|
|
size_t sum(size_t arg, SizeTypes... args)
|
|
|
|
{
|
|
|
|
return arg + sum(args...);
|
|
|
|
}
|
|
|
|
|
2018-02-16 18:17:22 +01:00
|
|
|
template <bool ISINDEX>
|
|
|
|
struct XX
|
|
|
|
{
|
|
|
|
template <class RI>
|
|
|
|
static auto ri_to_tuple(const std::shared_ptr<RI>& ri)
|
|
|
|
-> std::tuple<RI>
|
|
|
|
{
|
|
|
|
return std::make_tuple(ri);
|
|
|
|
}
|
2018-03-05 00:04:50 +01:00
|
|
|
|
|
|
|
template <class RI>
|
|
|
|
static size_t ri_to_start_pos(const std::shared_ptr<RI>& ri)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2018-02-16 18:17:22 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
template <>
|
|
|
|
struct XX<true>
|
|
|
|
{
|
|
|
|
template <class RI>
|
|
|
|
static auto ri_to_tuple(const std::shared_ptr<RI>& ri)
|
|
|
|
-> std::tuple<>
|
|
|
|
{
|
|
|
|
return std::make_tuple();
|
|
|
|
}
|
2018-03-05 00:04:50 +01:00
|
|
|
|
|
|
|
template <class RI>
|
|
|
|
static size_t ri_to_start_pos(const std::shared_ptr<RI>& ri)
|
|
|
|
{
|
|
|
|
return ri->pos();
|
|
|
|
}
|
|
|
|
|
2018-02-16 18:17:22 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
template <class... RITypes>
|
|
|
|
auto mkSliceRange(const std::shared_ptr<RITypes>&... ris)
|
2018-03-05 00:04:50 +01:00
|
|
|
-> decltype(std::tuple_cat(XX<RITypes::ISINDEX>::ri_to_tuple(ris)...))
|
2018-02-16 18:17:22 +01:00
|
|
|
{
|
|
|
|
return std::tuple_cat(XX<RITypes::ISINDEX>::ri_to_tuple(ris)...);
|
|
|
|
}
|
|
|
|
|
2018-03-05 00:04:50 +01:00
|
|
|
template <class... RITypes>
|
|
|
|
size_t mkStartPos(const std::shared_ptr<RITypes>&... ris)
|
|
|
|
{
|
|
|
|
return sum(ri_to_start_pos(ris)...);
|
|
|
|
}
|
|
|
|
|
2018-02-16 18:17:22 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*************
|
|
|
|
* Slice *
|
|
|
|
*************/
|
2018-03-05 00:04:50 +01:00
|
|
|
|
2018-02-16 18:17:22 +01:00
|
|
|
template <typename T, class... SRanges>
|
2018-03-05 00:04:50 +01:00
|
|
|
template <class... RITypes>
|
|
|
|
Slice<T,SRanges...>::Slice(MutableMultiArrayBase<T,typename RITypes::RangeType...>& ma,
|
|
|
|
const std::shared_ptr<RITypes>&... ris) :
|
2018-02-16 18:17:22 +01:00
|
|
|
MutableMultiArrayBase<T,SRanges...>( mkSliceRange(ris...) ),
|
2018-03-05 00:04:50 +01:00
|
|
|
mData(ma.data() + mkStartPos(ris...))
|
|
|
|
{
|
|
|
|
MAB::mProtoI.format( mBlockSizes(mkSliceBlocks(ris...)) );
|
|
|
|
}
|
|
|
|
|
2018-02-16 18:17:22 +01:00
|
|
|
template <typename T, class... SRanges>
|
2018-03-05 00:04:50 +01:00
|
|
|
const T& Slice<T,SRanges...>::operator[](const IType& i) const
|
2018-02-16 18:17:22 +01:00
|
|
|
{
|
|
|
|
assert(i.sliceMode()); // -> compare objects !!!!!
|
2018-03-05 00:04:50 +01:00
|
|
|
assert(i.container() == reinterpret_cast<std::intptr_t>(this));
|
2018-02-16 18:17:22 +01:00
|
|
|
return mData[ i.pos() ];
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... SRanges>
|
2018-03-05 00:04:50 +01:00
|
|
|
T& Slice<T,SRanges...>::operator[](const IType& i)
|
2018-02-16 18:17:22 +01:00
|
|
|
{
|
|
|
|
assert(i.sliceMode());
|
2018-03-05 00:04:50 +01:00
|
|
|
assert(i.container() == reinterpret_cast<std::intptr_t>(this));
|
2018-02-16 18:17:22 +01:00
|
|
|
return mData[ i.pos() ];
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... SRanges>
|
2018-03-05 00:04:50 +01:00
|
|
|
const T& Slice<T,SRanges...>::at(const typename IType::MetaType& meta) const
|
2018-02-16 18:17:22 +01:00
|
|
|
{
|
|
|
|
return mData[ begin().at(meta).pos() ];
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... SRanges>
|
2018-03-05 00:04:50 +01:00
|
|
|
T& Slice<T,SRanges...>::at(const typename IType::MetaType& meta)
|
2018-02-16 18:17:22 +01:00
|
|
|
{
|
|
|
|
return mData[ begin().at(meta).pos() ];
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... SRanges>
|
|
|
|
const T* Slice<T,SRanges...>::data() const
|
|
|
|
{
|
|
|
|
return mData;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... SRanges>
|
|
|
|
T* Slice<T,SRanges...>::data()
|
|
|
|
{
|
|
|
|
return mData;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... SRanges>
|
|
|
|
bool Slice<T,SRanges...>::isSlice() const
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... SRanges>
|
2018-03-05 00:04:50 +01:00
|
|
|
auto Slice<T,SRanges...>::begin() const -> Slice<T,SRanges...>::IType
|
2018-02-16 18:17:22 +01:00
|
|
|
{
|
2018-03-05 00:04:50 +01:00
|
|
|
IType i = MAB::mProtoI;
|
|
|
|
i = 0;
|
|
|
|
//i = mStartPos;
|
2018-02-16 18:17:22 +01:00
|
|
|
return i.setData(data());
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class... SRanges>
|
2018-03-05 00:04:50 +01:00
|
|
|
auto Slice<T,SRanges...>::end() const -> Slice<T,SRanges...>::IType
|
2018-02-16 18:17:22 +01:00
|
|
|
{
|
2018-03-05 00:04:50 +01:00
|
|
|
IType i = MAB::mProtoI;
|
|
|
|
i = i.max(); // CHECK !!!
|
|
|
|
//i = std::get<sizeof...(SRanges)>(mBlockSizes);
|
2018-02-16 18:17:22 +01:00
|
|
|
return i.setData(data());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
} // end namespace MultiArrayTools
|
|
|
|
|
|
|
|
#endif
|