simplify index/range framework -> no native major index system (planned to implement separate class)
This commit is contained in:
Christian Zimmermann
parent
30d8e5e5b2
commit
c13c51bd51
6 changed files with 175 additions and 418 deletions
|
|
@ -3,114 +3,40 @@
|
|||
|
||||
namespace MultiArrayTools
|
||||
{
|
||||
/************************
|
||||
* IndefinitIndexBase *
|
||||
************************/
|
||||
/*****************
|
||||
* IndexBase *
|
||||
*****************/
|
||||
|
||||
IndexBase::IndexBase(const std::shared_ptr<RangeBase>& range,
|
||||
size_t pos) : mRangePtr(range),
|
||||
mPos(pos) {}
|
||||
|
||||
size_t IndefinitIndexBase::pos() const
|
||||
bool IndexBase::operator==(const IndexBase& in) const
|
||||
{
|
||||
//assert(not virt());
|
||||
return static_cast<size_t>( mPos );
|
||||
return in.mPos == mPos and in.mRangePtr.get() == mRangePtr.get();
|
||||
}
|
||||
|
||||
bool IndexBase::operator!=(const IndexBase& in) const
|
||||
{
|
||||
return in.mPos != mPos or in.mRangePtr.get() != mRangePtr.get();
|
||||
}
|
||||
|
||||
size_t IndexBase::pos() const
|
||||
{
|
||||
return mPos;
|
||||
}
|
||||
|
||||
bool IndefinitIndexBase::operator==(const IndefinitIndexBase& in) const
|
||||
operator IndexBase::size_t() const
|
||||
{
|
||||
return rangeType() == in.rangeType() and pos() == in.pos();
|
||||
return mPos;
|
||||
}
|
||||
|
||||
bool IndefinitIndexBase::operator!=(const IndefinitIndexBase& in) const
|
||||
{
|
||||
return rangeType() != in.rangeType() or pos() != in.pos();
|
||||
}
|
||||
|
||||
IndefinitIndexBase& IndefinitIndexBase::setPos(size_t pos, IndefinitIndexBase* ctrlPtr)
|
||||
{
|
||||
mPos = pos;
|
||||
for(auto mm: mMajor){
|
||||
if(mm.first == ctrlPtr){
|
||||
continue;
|
||||
}
|
||||
mm.first->setPos(mm.first->pos() % mm.second + mm.second * pos, this);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
/**********************
|
||||
* IndexInterface *
|
||||
**********************/
|
||||
|
||||
IndefinitIndexBase& IndefinitIndexBase::setPosRel(int relPos, IndefinitIndexBase* ctrlPtr)
|
||||
{
|
||||
mPos += relPos;
|
||||
for(auto mm: mMajor){
|
||||
if(mm.first == ctrlPtr){
|
||||
continue;
|
||||
}
|
||||
mm.first->setPosRel(mm.second * relPos, this);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
IndefinitIndexBase& IndefinitIndexBase::toFirst(IndefinitIndexBase* ctrlPtr)
|
||||
{
|
||||
mPos = 0;
|
||||
for(auto mm: mMajor){
|
||||
if(mm.first == ctrlPtr){
|
||||
continue;
|
||||
}
|
||||
mm.first->setPos(mm.first->pos() % mm.second, this);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
template <typename MetaType>
|
||||
IndexInterface::IndexInterface(const RangeBase& range, size_t pos) :
|
||||
IndexBase(range, pos) {}
|
||||
|
||||
IndefinitIndexBase& IndefinitIndexBase::toLast(IndefinitIndexBase* ctrlPtr)
|
||||
{
|
||||
mPos = max() - 1;
|
||||
for(auto mm: mMajor){
|
||||
if(mm.first == ctrlPtr){
|
||||
continue;
|
||||
}
|
||||
mm.first->setPos(mm.first->pos() % mm.second + mm.second * mPos, this);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
int IndefinitIndexBase::outOfRange() const
|
||||
{
|
||||
if(mPos < 0){
|
||||
return mPos;
|
||||
}
|
||||
else if(mPos >= static_cast<int>( max() ) ){
|
||||
return mPos - max() + 1;
|
||||
}
|
||||
else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
bool IndefinitIndexBase::atEdge() const
|
||||
{
|
||||
return static_cast<size_t>( mPos ) == max();
|
||||
}
|
||||
|
||||
bool IndefinitIndexBase::master() const
|
||||
{
|
||||
return mMajor.size() == 0;
|
||||
}
|
||||
|
||||
IndefinitIndexBase& IndefinitIndexBase::subOrd(IndefinitIndexBase* major)
|
||||
{
|
||||
mMajor[major] = major->giveSubStepSize(this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/**************
|
||||
* IndexBase *
|
||||
**************/
|
||||
|
||||
template <class Index>
|
||||
IndexBase<Index>::IndexBase(std::shared_ptr<const RangeBase<Index> >& rangePtr) : mRangePtr(rangePtr) {}
|
||||
|
||||
template <class Index>
|
||||
size_t IndexBase<Index>::max() const
|
||||
{
|
||||
//assert(not virt());
|
||||
return mRange->size();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,67 +14,48 @@
|
|||
namespace MultiArrayTools
|
||||
{
|
||||
|
||||
class IndefinitIndexBase
|
||||
class IndexBase
|
||||
{
|
||||
public:
|
||||
DEFAULT_MEMBERS(IndefinitIndexBase);
|
||||
virtual ~IndefinitIndexBase() = default;
|
||||
DEFAULT_MEMBERS(IndexBase);
|
||||
IndexBase(const RangeBase& range, size_t pos);
|
||||
virtual ~IndexBase() = default;
|
||||
|
||||
virtual IndefinitIndexBase& operator=(size_t pos) = 0;
|
||||
virtual IndefinitIndexBase& operator++() = 0;
|
||||
virtual IndefinitIndexBase& operator--() = 0;
|
||||
virtual IndefinitIndexBase& operator+=(int n) = 0;
|
||||
virtual IndefinitIndexBase& operator-=(int n) = 0;
|
||||
virtual IndexBase& operator=(size_t pos) = 0;
|
||||
virtual IndexBase& operator++() = 0;
|
||||
virtual IndexBase& operator--() = 0;
|
||||
virtual IndexBase& operator+=(int n) = 0;
|
||||
virtual IndexBase& operator-=(int n) = 0;
|
||||
|
||||
bool operator==(const IndefinitIndexBase& in) const;
|
||||
bool operator!=(const IndefinitIndexBase& in) const;
|
||||
bool operator==(const IndexBase& in) const;
|
||||
bool operator!=(const IndexBase& in) const;
|
||||
|
||||
virtual size_t dim() const = 0;
|
||||
virtual size_t pos() const;
|
||||
virtual size_t max() const;
|
||||
|
||||
virtual bool last() const = 0;
|
||||
virtual bool first() const = 0;
|
||||
|
||||
virtual MultiRangeType rangeType() const = 0;
|
||||
|
||||
virtual IndefinitIndexBase& setPos(size_t pos, IndefinitIndexBase* ctrlPtr = nullptr);
|
||||
virtual IndefinitIndexBase& setPosRel(int relPos, IndefinitIndexBase* ctrlPtr = nullptr);
|
||||
|
||||
virtual IndefinitIndexBase& toFirst(IndefinitIndexBase* ctrlPtr = nullptr);
|
||||
virtual IndefinitIndexBase& toLast(IndefinitIndexBase* ctrlPtr = nullptr);
|
||||
|
||||
virtual size_t max() const = 0;
|
||||
virtual int outOfRange() const;
|
||||
virtual bool atEdge() const;
|
||||
virtual bool master() const;
|
||||
|
||||
virtual IndefinitIndexBase& subOrd(IndefinitIndexBase* major);
|
||||
virtual size_t giveSubStepSize(IndefinitIndexBase* subIndex) = 0;
|
||||
virtual operator size_t() const;
|
||||
|
||||
protected:
|
||||
|
||||
int mPos;
|
||||
std::map<IndefinitIndexBase*,size_t> mMajor;
|
||||
std::shared_ptr<RangeBase> mRangePtr;
|
||||
size_t mPos;
|
||||
};
|
||||
|
||||
template <class Index>
|
||||
class IndexBase : public IndefinitIndexBase
|
||||
|
||||
template <typename MetaType>
|
||||
class IndexInterface : public IndexBase
|
||||
{
|
||||
public:
|
||||
|
||||
typedef IndefinitIndexBase IIB;
|
||||
IndexInterface(const RangeBase& range, size_t pos);
|
||||
|
||||
DEFAULT_MEMBERS(IndexBase);
|
||||
IndexBase(std::shared_ptr<const RangeBase<Index> >& rangePtr);
|
||||
|
||||
//virtual size_t pos() const override; // = mPos; implement !!!
|
||||
virtual size_t max() const override;
|
||||
virtual void copyPos(const Index& in) = 0;
|
||||
|
||||
protected:
|
||||
|
||||
// translate index into position
|
||||
virtual size_t evaluate(const Index& in) const = 0;
|
||||
std::shared_ptr<const RangeBase<Index> > mRangePtr;
|
||||
MetaType& meta() = 0;
|
||||
const MetaType& meta() const = 0;
|
||||
};
|
||||
|
||||
|
||||
}
|
||||
|
||||
#include "index_base.cc"
|
||||
|
|
|
|||
|
|
@ -362,62 +362,106 @@ namespace MultiArrayTools
|
|||
|
||||
};
|
||||
|
||||
template <size_t N>
|
||||
struct SubIndexConstruct
|
||||
{
|
||||
template <class MRange, class... Indices>
|
||||
void construct(std::tuple<std::shared_ptr<Indices>...>& ip,
|
||||
const MRange& range)
|
||||
{
|
||||
typedef decltype(range.template get<N>()) SubIndexType;
|
||||
typedef decltype(std::get<N>(ip).get()) wTypeFromIndexPack;
|
||||
|
||||
static_assert(is_same<SubIndexType,SubIndexType>::value,
|
||||
"inconsiśtent types");
|
||||
|
||||
std::get<N>(ip).swap( std::make_shared<SubIndexType> ( range.template get<N>() ) );
|
||||
SubIndexConstruct<N-1>::construct(ip, range);
|
||||
}
|
||||
|
||||
template <class... Indices>
|
||||
void copy(std::tuple<std::shared_ptr<Indices>...>& ip,
|
||||
const MultiIndex<Indices...>& ind)
|
||||
{
|
||||
typedef decltype(ind.template get<N>()) SubIndexType;
|
||||
std::get<N>(ip).swap( std::make_shared<SubIndexType>( ind.template get<N>() ) );
|
||||
SubIndexConstruct<N-1>::copy(ip, ind);
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct SubIndexConstruct<0>
|
||||
{
|
||||
template <class MRange, class... Indices>
|
||||
void construct(std::tuple<std::shared_ptr<Indices>...>& ip,
|
||||
const MRange& range)
|
||||
{
|
||||
typedef decltype(range.template get<0>()) SubIndexType;
|
||||
typedef decltype(std::get<0>(ip).get()) wTypeFromIndexPack;
|
||||
|
||||
static_assert(std::is_same<SubIndexType,SubIndexType>::value,
|
||||
"inconsiśtent types");
|
||||
|
||||
std::get<0>(ip).swap( std::make_shared<SubIndexType> ( range.template get<0>() ) );
|
||||
}
|
||||
|
||||
template <class... Indices>
|
||||
void copy(std::tuple<std::shared_ptr<Indices>...>& ip,
|
||||
const MultiIndex<Indices...>& ind)
|
||||
{
|
||||
typedef decltype(ind.template get<0>()) SubIndexType;
|
||||
std::get<0>(ip).swap( std::make_shared<SubIndexType>( ind.template get<0>() ) );
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
template <size_t N>
|
||||
struct PosGetter
|
||||
{
|
||||
template <class... Indices>
|
||||
size_t makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup)
|
||||
{
|
||||
return std::get<N>(iPtrTup)->pos() +
|
||||
PosGetter<N-1>::makePos(iPtrTup) * std::get<N-1>(iPtrTup)->max();
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct PosGetter<0>
|
||||
{
|
||||
template <class... Indices>
|
||||
size_t makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup)
|
||||
{
|
||||
return std::get<0>(iPtrTup)->pos();
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
template <class... Indices>
|
||||
MultiIndex<Indices...>::MultiIndex(const MultiIndex<Indices...>& in) :
|
||||
IndexBase<MultiIndex<Indices...> >(in),
|
||||
mIPack(in.mIPack)
|
||||
IndexInterface<std::tuple<decltype(Indices().meta())...> >(in)
|
||||
{
|
||||
// THAT's the point:
|
||||
IndexSubOrder<sizeof...(Indices)-1>::subOrd(mIPack, this);
|
||||
IIB::mPos = evaluate(*this);
|
||||
SubIndexConstruct<sizeof...(Indices)-1>::copy(mIPack, in);
|
||||
mPos = PosGetter<sizeof...(Indices)-1>::makePos(mIPack);
|
||||
}
|
||||
|
||||
|
||||
template <class... Indices>
|
||||
MultiIndex<Indices...>& MultiIndex<Indices...>::operator=(const MultiIndex<Indices...>& in)
|
||||
{
|
||||
IndexBase<MultiIndex<Indices...> >::operator=(in);
|
||||
mIPack = in.mIPack;
|
||||
|
||||
// THAT's the point:
|
||||
IndexSubOrder<sizeof...(Indices)-1>::subOrd(mIPack, this);
|
||||
IIB::mPos = evaluate(*this);
|
||||
IndexI::operator=(in);
|
||||
SubIndexConstruct<sizeof...(Indices)-1>::copy(mIPack, in);
|
||||
mPos = PosGetter<sizeof...(Indices)-1>::makePos(mIPack);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class... Indices>
|
||||
MultiIndex<Indices...>::MultiIndex(RangeBase<MultiIndex<Indices...> > const* range) :
|
||||
IndexBase<MultiIndex<Indices...> >(range),
|
||||
mIPack()
|
||||
template <class MRange>
|
||||
MultiIndex<Indices...>::MultiIndex(const std::shared_ptr<MRange>& range) :
|
||||
IndexInterface<std::tuple<decltype(Indices().meta())...> >(range, 0)
|
||||
{
|
||||
operator=(IB::mRange->begin());
|
||||
IIB::mPos = evaluate(*this);
|
||||
}
|
||||
|
||||
template <class... Indices>
|
||||
MultiIndex<Indices...>::MultiIndex(RangeBase<MultiIndex<Indices...> > const* range,
|
||||
Indices&&... inds) : IndexBase<MultiIndex<Indices...> >(range),
|
||||
mIPack(std::make_tuple(inds...))
|
||||
{
|
||||
IndexSubOrder<sizeof...(Indices)-1>::subOrd(mIPack, this);
|
||||
IIB::mPos = evaluate(*this);
|
||||
}
|
||||
|
||||
template <class... Indices>
|
||||
MultiIndex<Indices...>::MultiIndex(RangeBase<MultiIndex<Indices...> > const* range,
|
||||
const IndexPack& ipack) : IndexBase<MultiIndex<Indices...> >(range),
|
||||
mIPack(ipack)
|
||||
{
|
||||
IndexSubOrder<sizeof...(Indices)-1>::subOrd(mIPack, this);
|
||||
IIB::mPos = evaluate(*this);
|
||||
}
|
||||
|
||||
template <class... Indices>
|
||||
MultiIndex<Indices...>::MultiIndex(std::vector<std::shared_ptr<IndefinitIndexBase> >& indexList)
|
||||
{
|
||||
mIPack = IndexPackSetter<sizeof...(Indices)-1>::setFromPointerList(mIPack, indexList);
|
||||
IndexSubOrder<sizeof...(Indices)-1>::subOrd(mIPack, this);
|
||||
SubIndexConstruct<sizeof...(Indices)-1>::construct(mIPack, *range);
|
||||
mPos = PosGetter<sizeof...(Indices)-1>::makePos(mIPack);
|
||||
}
|
||||
|
||||
template <class... Indices>
|
||||
|
|
|
|||
|
|
@ -15,63 +15,41 @@ namespace MultiArrayTools
|
|||
{
|
||||
|
||||
template <class... Indices>
|
||||
class MultiIndex : public IndexBase<MultiIndex<Indices...> >
|
||||
class MultiIndex : public IndexInterface<std::tuple<decltype(Indices().meta())...> >
|
||||
{
|
||||
public:
|
||||
|
||||
typedef std::tuple<std::shared_ptr<Indices>...> IndexPack;
|
||||
typedef IndefinitIndexBase IIB;
|
||||
typedef IndexBase<MultiIndex<std::shared_ptr<Indices>...> > IB;
|
||||
typedef std::tuple<decltype(Indices().getMetaPos())...> MetaType;
|
||||
typedef std::tuple<decltype(Indices().meta())...> MetaType;
|
||||
typedef IndexInterface<MetaType> IndexI;
|
||||
|
||||
protected:
|
||||
|
||||
virtual bool linkLower(IndefinitIndexBase* toLink);
|
||||
virtual size_t evaluate(const MultiIndex& in) const override;
|
||||
|
||||
IndexPack mIPack;
|
||||
|
||||
public:
|
||||
|
||||
|
||||
MultiIndex() = default;
|
||||
// NO DEFAULT HERE !!!
|
||||
// ( have to subord sub-indices (mMajor) correctly, and not only copy their mMajor pointer to 'in'
|
||||
// which is not major any more in copies!! )
|
||||
MultiIndex(const MultiIndex& in);
|
||||
MultiIndex& operator=(const MultiIndex& in);
|
||||
|
||||
MultiIndex(RangeBase<MultiIndex<std::shared_ptr<Indices>...> > const* range);
|
||||
|
||||
MultiIndex(RangeBase<MultiIndex<std::shared_ptr<Indices>...> > const* range,
|
||||
Indices&&... inds);
|
||||
|
||||
MultiIndex(RangeBase<MultiIndex<std::shared_ptr<Indices>...> > const* range,
|
||||
const IndexPack& ipack);
|
||||
|
||||
MultiIndex(std::vector<std::shared_ptr<IndefinitIndexBase> >& indexList);
|
||||
template <class MRange>
|
||||
MultiIndex(const std::shared_ptr<MRange>& range);
|
||||
|
||||
virtual MultiIndex& operator++() override;
|
||||
virtual MultiIndex& operator--() override;
|
||||
virtual MultiIndex& operator+=(int n) override;
|
||||
virtual MultiIndex& operator-=(int n) override;
|
||||
|
||||
bool operator==(const MultiIndex& in);
|
||||
bool operator!=(const MultiIndex& in);
|
||||
|
||||
virtual MultiIndex& operator=(size_t pos) override;
|
||||
virtual MultiRangeType rangeType() const override;
|
||||
|
||||
template <size_t N>
|
||||
auto getIndex() -> decltype(*std::get<N>(mIPack))&;
|
||||
//typename std::tuple_element<N, std::tuple<std::shared_ptr<Indices>...> >::type& getIndex();
|
||||
|
||||
template <size_t N>
|
||||
auto getIndex() const -> decltype(*std::get<N>(mIPack))&;
|
||||
auto get() const -> decltype(*std::get<N>(mIPack))&;
|
||||
//typename std::tuple_element<N, std::tuple<std::shared_ptr<Indices>...> >::type const& getIndex() const;
|
||||
|
||||
IndefinitIndexBase& get(size_t n);
|
||||
const IndefinitIndexBase& get(size_t n) const;
|
||||
|
||||
MetaType getMetaPos() const;
|
||||
const IndexBase& get(size_t n) const;
|
||||
|
||||
virtual MetaType meta() const override;
|
||||
MultiIndex& atMeta(const MetaType& metaPos);
|
||||
|
||||
MultiIndex& operator()(Indices&&... inds);
|
||||
|
|
@ -79,7 +57,11 @@ namespace MultiArrayTools
|
|||
|
||||
// dimension of MultiRange; includes ALL degrees of freedom
|
||||
virtual size_t dim() const override;
|
||||
virtual size_t giveSubStepSize(IndefinitIndexBase* subIndex) override;
|
||||
|
||||
protected:
|
||||
|
||||
IndexPack mIPack;
|
||||
|
||||
};
|
||||
|
||||
/*****************************
|
||||
|
|
@ -88,33 +70,29 @@ namespace MultiArrayTools
|
|||
|
||||
|
||||
template <class... Ranges>
|
||||
class MultiRange : public RangeBase<MultiIndex<typename Ranges::IndexType...> >
|
||||
class MultiRange : public RangeInterface<MultiIndex<typename Ranges::IndexType...> >
|
||||
{
|
||||
public:
|
||||
|
||||
typedef std::tuple<std::shared_ptr<Ranges>...> SpaceType;
|
||||
typedef typename RangeBase<MultiIndex<typename Ranges::IndexType...> >::IndexType
|
||||
typedef typename RangeInterface<MultiIndex<typename Ranges::IndexType...> >::IndexType
|
||||
IndexType;
|
||||
|
||||
static const size_t dim = sizeof...(Ranges);
|
||||
|
||||
template <size_t N> // !!! return ref to range, not the corresp. shared ptr
|
||||
auto getRange() -> ;
|
||||
//typename std::tuple_element<N, std::tuple<std::shared_ptr<Ranges>...> >::type& getRange();
|
||||
|
||||
template <size_t N> // !!!
|
||||
auto getRange() const ->;
|
||||
auto get() const ->;
|
||||
//typename std::tuple_element<N, std::tuple<std::shared_ptr<Ranges>...> >::type const& getRange() const;
|
||||
|
||||
|
||||
size_t dim() const override;
|
||||
size_t size() const override;
|
||||
|
||||
const SpaceType& space() const;
|
||||
|
||||
virtual MultiRangeType type() const override;
|
||||
|
||||
virtual MultiIndex<typename Ranges::IndexType...> begin() const override;
|
||||
virtual MultiIndex<typename Ranges::IndexType...> end() const override;
|
||||
virtual typename IndexType begin() const override;
|
||||
virtual typename IndexType end() const override;
|
||||
|
||||
virtual std::shared_ptr<IndefinitIndexBase> indexInstance() const override;
|
||||
virtual std::shared_ptr<IndexBase> index() const override;
|
||||
|
||||
protected:
|
||||
|
||||
|
|
|
|||
|
|
@ -3,121 +3,9 @@
|
|||
|
||||
namespace MultiArrayTools
|
||||
{
|
||||
/*********************
|
||||
* MultiRangeType *
|
||||
*********************/
|
||||
|
||||
MultiRangeType::MultiRangeType(const RangeType& type) : mType(type), mMultiType(nullptr) {}
|
||||
|
||||
MultiRangeType::MultiRangeType(const std::vector<MultiRangeType>& multiType) :
|
||||
mType(RangeType::NIL),
|
||||
mMultiType(new std::vector<MultiRangeType>(multiType)) {}
|
||||
|
||||
MultiRangeType::~MultiRangeType()
|
||||
{
|
||||
delete mMultiType;
|
||||
}
|
||||
|
||||
|
||||
MultiRangeType& MultiRangeType::operator=(const RangeType& type)
|
||||
{
|
||||
setType(type);
|
||||
return *this;
|
||||
}
|
||||
|
||||
MultiRangeType& MultiRangeType::operator=(const std::vector<MultiRangeType>& multiType)
|
||||
{
|
||||
setMultiType(multiType);
|
||||
return *this;
|
||||
}
|
||||
|
||||
MultiRangeType& MultiRangeType::operator[](size_t num)
|
||||
{
|
||||
return mMultiType->at(num);
|
||||
}
|
||||
|
||||
const MultiRangeType& MultiRangeType::operator[](size_t num) const
|
||||
{
|
||||
return mMultiType->at(num);
|
||||
}
|
||||
|
||||
bool MultiRangeType::multi() const
|
||||
{
|
||||
return mMultiType != nullptr;
|
||||
}
|
||||
|
||||
bool MultiRangeType::operator==(const MultiRangeType& in) const
|
||||
{
|
||||
if(multi() xor in.multi()){
|
||||
return false;
|
||||
}
|
||||
if(multi()){
|
||||
return *mMultiType == *in.mMultiType;
|
||||
}
|
||||
else {
|
||||
return mType == in.mType;
|
||||
}
|
||||
}
|
||||
|
||||
bool MultiRangeType::operator!=(const MultiRangeType& in) const
|
||||
{
|
||||
if(multi() xor in.multi()){
|
||||
return true;
|
||||
}
|
||||
if(multi()){
|
||||
return *mMultiType != *in.mMultiType;
|
||||
}
|
||||
else {
|
||||
return mType != in.mType;
|
||||
}
|
||||
}
|
||||
|
||||
void MultiRangeType::setType(RangeType type)
|
||||
{
|
||||
mType = type;
|
||||
if(mMultiType != nullptr){
|
||||
delete mMultiType;
|
||||
}
|
||||
mMultiType = nullptr;
|
||||
}
|
||||
|
||||
void MultiRangeType::setMultiType(const std::vector<MultiRangeType>& multiType)
|
||||
{
|
||||
mMultiType = new std::vector<MultiRangeType>( multiType );
|
||||
mType = RangeType::NIL;
|
||||
}
|
||||
|
||||
|
||||
/******************
|
||||
* RangeBase *
|
||||
******************/
|
||||
|
||||
template <class Index>
|
||||
bool RangeBase<Index>::isSubRange() const
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
template <class Index>
|
||||
RangeBase<Index>* RangeBase<Index>::base()
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
/*********************
|
||||
* SubRangeBase *
|
||||
*********************/
|
||||
|
||||
template <class Index>
|
||||
bool SubRangeBase<Index>::isSubRange() const
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
template <class Index>
|
||||
RangeBase<Index>* SubRangeBase<Index>::base()
|
||||
{
|
||||
return mBase;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -25,92 +25,32 @@ namespace MultiArrayTools
|
|||
DISTANCE = 8
|
||||
};
|
||||
|
||||
class MultiRangeType
|
||||
class RangeBase
|
||||
{
|
||||
public:
|
||||
|
||||
DEFAULT_MEMBERS(MultiRangeType);
|
||||
|
||||
MultiRangeType(const RangeType& type);
|
||||
MultiRangeType(const std::vector<MultiRangeType>& multiType);
|
||||
|
||||
~MultiRangeType();
|
||||
|
||||
MultiRangeType& operator=(const RangeType& type);
|
||||
MultiRangeType& operator=(const std::vector<MultiRangeType>& multiType);
|
||||
|
||||
MultiRangeType& operator[](size_t num);
|
||||
const MultiRangeType& operator[](size_t num) const;
|
||||
|
||||
bool multi() const;
|
||||
|
||||
bool operator==(const MultiRangeType& in) const;
|
||||
bool operator!=(const MultiRangeType& in) const;
|
||||
|
||||
private:
|
||||
void setType(RangeType type);
|
||||
void setMultiType(const std::vector<MultiRangeType>& multiType);
|
||||
|
||||
RangeType mType;
|
||||
std::vector<MultiRangeType>* mMultiType;
|
||||
};
|
||||
|
||||
class IndefinitRangeBase
|
||||
{
|
||||
public:
|
||||
|
||||
virtual ~IndefinitRangeBase() = default;
|
||||
virtual ~RangeBase() = default;
|
||||
|
||||
virtual size_t size() const = 0;
|
||||
virtual bool isSubRange() const = 0;
|
||||
virtual MultiRangeType type() const = 0;
|
||||
virtual std::shared_ptr<IndefinitIndexBase> indexInstance() const = 0;
|
||||
|
||||
protected:
|
||||
// only constructable via Factory
|
||||
virtual size_t dim() const = 0;
|
||||
|
||||
virtual std::shared_ptr<IndexBase> index() const = 0;
|
||||
|
||||
protected:
|
||||
|
||||
IndefinitRangeBase() = default;
|
||||
IndefinitRangeBase(const IndefinitRangeBase& in) = delete;
|
||||
IndefinitRangeBase& operator=(const IndefinitRangeBase& in) = delete;
|
||||
};
|
||||
|
||||
|
||||
template <class Index>
|
||||
class RangeBase : public IndefinitRangeBase
|
||||
class RangeInterface : public RangeBase
|
||||
{
|
||||
public:
|
||||
|
||||
typedef Index IndexType;
|
||||
|
||||
virtual IndexType begin() const = 0;
|
||||
virtual IndexType end() const = 0;
|
||||
virtual RangeBase<Index>* base();
|
||||
virtual bool isSubRange() const override;
|
||||
|
||||
virtual std::shared_ptr<IndefinitIndexBase> indexInstance() const override;
|
||||
|
||||
protected:
|
||||
RangeBase() = default;
|
||||
RangeBase(const RangeBase& in) = delete;
|
||||
RangeBase& operator=(const RangeBase& in) = delete;
|
||||
virtual Index begin() = 0;
|
||||
virtual Index end() = 0;
|
||||
};
|
||||
|
||||
//template <class Range>
|
||||
//auto cross(const Range& r1, const Range& r2) -> /**/;
|
||||
|
||||
//template <class Range1, class Range2>
|
||||
//auto cross(const Range1& r1, const Range2& r2) -> /**/;
|
||||
|
||||
template <class Index>
|
||||
class SubRangeBase : public RangeBase<Index>
|
||||
{
|
||||
public:
|
||||
virtual bool isSubRange() const override;
|
||||
virtual RangeBase<Index>* base() override;
|
||||
protected:
|
||||
DEFAULT_MEMBERS(SubRangeBase);
|
||||
RangeBase<Index>* mBase;
|
||||
std::vector<bool> mOccupation;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#include "range_base.cc"
|
||||
|
|
|
|||
Loading…
Reference in a new issue