2017-02-16 11:20:40 +01:00
|
|
|
// -*- C++ -*-
|
|
|
|
|
|
|
|
#ifndef __single_range_h__
|
|
|
|
#define __single_range_h__
|
|
|
|
|
|
|
|
#include <cstdlib>
|
|
|
|
#include <vector>
|
2017-06-01 13:19:27 +02:00
|
|
|
#include <memory>
|
2017-02-16 11:20:40 +01:00
|
|
|
|
|
|
|
#include "base_def.h"
|
|
|
|
#include "index_base.h"
|
|
|
|
#include "range_base.h"
|
|
|
|
|
|
|
|
namespace MultiArrayTools
|
|
|
|
{
|
|
|
|
|
2017-08-04 11:27:47 +02:00
|
|
|
template <typename U, RangeType TYPE>
|
2017-12-10 18:41:53 +01:00
|
|
|
class SingleIndex : public IndexInterface<SingleIndex<U,TYPE>,U>
|
2017-02-16 11:20:40 +01:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
2017-12-11 18:49:43 +01:00
|
|
|
typedef IndexInterface<SingleIndex<U,TYPE>,U> IB;
|
2017-08-04 14:57:19 +02:00
|
|
|
typedef U MetaType;
|
2017-08-11 15:26:10 +02:00
|
|
|
typedef SingleRange<U,TYPE> RangeType;
|
2017-08-04 11:27:47 +02:00
|
|
|
|
2017-08-11 16:45:03 +02:00
|
|
|
//DEFAULT_MEMBERS_X(SingleIndex);
|
2017-08-04 11:27:47 +02:00
|
|
|
|
2017-07-26 18:38:11 +02:00
|
|
|
SingleIndex(const std::shared_ptr<SingleRange<U,TYPE> >& range);
|
2017-08-28 18:28:43 +02:00
|
|
|
|
2017-12-11 18:49:43 +01:00
|
|
|
private:
|
|
|
|
|
|
|
|
friend IB;
|
|
|
|
|
|
|
|
// ==== >>>>> STATIC POLYMORPHISM <<<<< ====
|
|
|
|
|
|
|
|
static IndexType S_type(SingleIndex* i)
|
|
|
|
{
|
|
|
|
return IndexType::SINGLE;
|
|
|
|
}
|
2017-08-11 16:45:03 +02:00
|
|
|
|
2017-12-11 18:49:43 +01:00
|
|
|
static SingleIndex& S_ass_op(SingleIndex* i, size_t pos)
|
|
|
|
{
|
|
|
|
i->mPos = pos;
|
|
|
|
return *i;
|
|
|
|
}
|
|
|
|
|
|
|
|
static SingleIndex& S_pp_op(SingleIndex* i)
|
|
|
|
{
|
|
|
|
++i->mPos;
|
|
|
|
return *i;
|
|
|
|
}
|
|
|
|
|
|
|
|
static SingleIndex& S_mm_op(SingleIndex* i)
|
|
|
|
{
|
|
|
|
--i->mPos;
|
|
|
|
return *i;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int S_pp(SingleIndex* i, intptr_t idxPtrNum)
|
|
|
|
{
|
|
|
|
++(*i);
|
|
|
|
return 1;
|
|
|
|
}
|
2017-02-17 18:10:03 +01:00
|
|
|
|
2017-12-11 18:49:43 +01:00
|
|
|
static int S_mm(SingleIndex* i, intptr_t idxPtrNum)
|
|
|
|
{
|
|
|
|
--(*i);
|
|
|
|
return 1;
|
|
|
|
}
|
2017-08-30 17:56:38 +02:00
|
|
|
|
2017-12-11 18:49:43 +01:00
|
|
|
static U S_meta(SingleIndex* i)
|
|
|
|
{
|
|
|
|
return std::dynamic_pointer_cast<SingleRange<U,TYPE> const>( i->mRangePtr )->get( i->pos() );
|
|
|
|
}
|
|
|
|
|
|
|
|
static SingleIndex& S_at(SingleIndex* i, const U& metaPos)
|
|
|
|
{
|
|
|
|
operator=( std::dynamic_pointer_cast<SingleRange<U,TYPE> const>( i->mRangePtr )->getMeta( metaPos ) );
|
|
|
|
return *i;
|
|
|
|
}
|
2017-03-03 17:51:42 +01:00
|
|
|
|
2017-12-11 18:49:43 +01:00
|
|
|
static size_t S_dim(SingleIndex* i) // = 1
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool S_last(SingleIndex* i)
|
|
|
|
{
|
|
|
|
return i->mPos == i->mMax - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool S_first(SingleIndex* i)
|
|
|
|
{
|
|
|
|
return i->mPos == 0;
|
|
|
|
}
|
2017-08-25 22:03:20 +02:00
|
|
|
|
2017-12-10 18:41:53 +01:00
|
|
|
template <size_t N>
|
2017-12-11 18:49:43 +01:00
|
|
|
static void S_getPtr(SingleIndex* i) {}
|
2017-12-10 18:41:53 +01:00
|
|
|
|
2017-12-11 18:49:43 +01:00
|
|
|
static std::shared_ptr<VIWB> S_getVPtr(SingleIndex* i, size_t n)
|
|
|
|
{
|
|
|
|
return std::shared_ptr<VIWB>();
|
|
|
|
}
|
2017-12-10 18:41:53 +01:00
|
|
|
|
2017-12-11 18:49:43 +01:00
|
|
|
static size_t S_getStepSize(SingleIndex* i, size_t n)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
2017-08-28 18:28:43 +02:00
|
|
|
|
2017-12-11 18:49:43 +01:00
|
|
|
static std::string S_id(SingleIndex* i) { return std::string("sin") + std::to_string(IB::mId); }
|
2017-02-16 11:20:40 +01:00
|
|
|
};
|
|
|
|
|
2017-07-28 11:33:31 +02:00
|
|
|
template <typename U, RangeType TYPE>
|
|
|
|
class SingleRangeFactory : public RangeFactoryBase
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
|
|
|
typedef SingleRange<U,TYPE> oType;
|
|
|
|
|
|
|
|
SingleRangeFactory() = delete;
|
|
|
|
SingleRangeFactory(const std::vector<U>& space);
|
|
|
|
std::shared_ptr<RangeBase> create();
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2017-02-16 11:20:40 +01:00
|
|
|
template <typename U, RangeType TYPE>
|
2017-08-04 11:27:47 +02:00
|
|
|
class SingleRange : public RangeInterface<SingleIndex<U,TYPE> >
|
2017-02-16 11:20:40 +01:00
|
|
|
{
|
|
|
|
public:
|
2017-08-04 11:27:47 +02:00
|
|
|
typedef RangeBase RB;
|
|
|
|
typedef typename RangeInterface<SingleIndex<U,TYPE> >::IndexType IndexType;
|
2017-02-17 18:10:03 +01:00
|
|
|
|
2017-02-16 16:06:23 +01:00
|
|
|
virtual size_t size() const override;
|
2017-08-04 11:27:47 +02:00
|
|
|
virtual size_t dim() const override;
|
|
|
|
|
2017-02-16 11:20:40 +01:00
|
|
|
const U& get(size_t pos) const;
|
2017-03-03 17:51:42 +01:00
|
|
|
size_t getMeta(const U& metaPos) const;
|
2017-02-20 17:18:53 +01:00
|
|
|
|
2017-08-04 14:57:19 +02:00
|
|
|
virtual IndexType begin() const override;
|
|
|
|
virtual IndexType end() const override;
|
2017-12-10 18:41:53 +01:00
|
|
|
virtual std::shared_ptr<VIWB> index() const override;
|
2017-07-28 14:02:44 +02:00
|
|
|
|
2017-07-26 18:38:11 +02:00
|
|
|
friend SingleRangeFactory<U,TYPE>;
|
2017-02-16 11:20:40 +01:00
|
|
|
|
|
|
|
protected:
|
2017-07-26 18:38:11 +02:00
|
|
|
|
|
|
|
SingleRange() = delete;
|
|
|
|
SingleRange(const SingleRange& in) = delete;
|
2017-06-01 13:19:27 +02:00
|
|
|
|
|
|
|
SingleRange(const std::vector<U>& space);
|
|
|
|
|
2017-02-16 11:20:40 +01:00
|
|
|
std::vector<U> mSpace;
|
|
|
|
};
|
2017-03-14 23:00:41 +01:00
|
|
|
|
2017-11-20 21:35:25 +01:00
|
|
|
}
|
2017-03-30 14:41:57 +02:00
|
|
|
|
2017-11-20 21:35:25 +01:00
|
|
|
/* ========================= *
|
|
|
|
* --- TEMPLATE CODE --- *
|
|
|
|
* ========================= */
|
2017-03-14 23:00:41 +01:00
|
|
|
|
2017-11-20 21:35:25 +01:00
|
|
|
namespace MultiArrayTools
|
|
|
|
{
|
|
|
|
/******************
|
|
|
|
* SingleIndex *
|
|
|
|
******************/
|
|
|
|
|
|
|
|
template <typename U, RangeType TYPE>
|
|
|
|
SingleIndex<U,TYPE>::SingleIndex(const std::shared_ptr<SingleRange<U,TYPE> >& range) :
|
2017-12-11 18:49:43 +01:00
|
|
|
IndexInterface<SingleIndex<U,TYPE>,U>(range, 0) {}
|
2017-11-20 21:35:25 +01:00
|
|
|
|
|
|
|
/********************
|
|
|
|
* SingleRange *
|
|
|
|
********************/
|
2017-03-14 23:00:41 +01:00
|
|
|
|
2017-11-20 21:35:25 +01:00
|
|
|
template <typename U, RangeType TYPE>
|
|
|
|
SingleRangeFactory<U,TYPE>::SingleRangeFactory(const std::vector<U>& space)
|
2017-03-14 23:00:41 +01:00
|
|
|
{
|
2017-11-20 21:35:25 +01:00
|
|
|
mProd = std::shared_ptr<oType>( new SingleRange<U,TYPE>( space ) );
|
|
|
|
}
|
2017-03-14 23:00:41 +01:00
|
|
|
|
2017-11-20 21:35:25 +01:00
|
|
|
template <typename U, RangeType TYPE>
|
|
|
|
std::shared_ptr<RangeBase> SingleRangeFactory<U,TYPE>::create()
|
|
|
|
{
|
|
|
|
setSelf();
|
|
|
|
return mProd;
|
|
|
|
}
|
|
|
|
|
|
|
|
/********************
|
|
|
|
* SingleRange *
|
|
|
|
********************/
|
2017-03-15 22:54:48 +01:00
|
|
|
|
2017-11-20 21:35:25 +01:00
|
|
|
template <typename U, RangeType TYPE>
|
|
|
|
SingleRange<U,TYPE>::SingleRange(const std::vector<U>& space) : RangeInterface<SingleIndex<U,TYPE> >(),
|
|
|
|
mSpace(space) {}
|
|
|
|
|
|
|
|
template <typename U, RangeType TYPE>
|
|
|
|
const U& SingleRange<U,TYPE>::get(size_t pos) const
|
2017-03-14 23:00:41 +01:00
|
|
|
{
|
2017-11-20 21:35:25 +01:00
|
|
|
return mSpace[pos];
|
|
|
|
}
|
2017-03-14 23:00:41 +01:00
|
|
|
|
2017-11-20 21:35:25 +01:00
|
|
|
template <typename U, RangeType TYPE>
|
|
|
|
size_t SingleRange<U,TYPE>::getMeta(const U& metaPos) const
|
|
|
|
{
|
|
|
|
size_t cnt = 0;
|
|
|
|
for(auto& x: mSpace){
|
|
|
|
if(x == metaPos){
|
|
|
|
return cnt;
|
|
|
|
}
|
|
|
|
++cnt;
|
|
|
|
}
|
|
|
|
return cnt;
|
|
|
|
}
|
2017-03-14 23:00:41 +01:00
|
|
|
|
2017-11-20 21:35:25 +01:00
|
|
|
template <typename U, RangeType TYPE>
|
|
|
|
size_t SingleRange<U,TYPE>::size() const
|
|
|
|
{
|
|
|
|
return mSpace.size();
|
|
|
|
}
|
2017-03-14 23:00:41 +01:00
|
|
|
|
2017-11-20 21:35:25 +01:00
|
|
|
template <typename U, RangeType TYPE>
|
|
|
|
size_t SingleRange<U,TYPE>::dim() const
|
2017-03-14 23:00:41 +01:00
|
|
|
{
|
2017-11-20 21:35:25 +01:00
|
|
|
return 1;
|
|
|
|
}
|
2017-03-14 23:00:41 +01:00
|
|
|
|
2017-11-20 21:35:25 +01:00
|
|
|
template <typename U, RangeType TYPE>
|
|
|
|
typename SingleRange<U,TYPE>::IndexType SingleRange<U,TYPE>::begin() const
|
|
|
|
{
|
|
|
|
SingleIndex<U,TYPE> i( std::dynamic_pointer_cast<SingleRange<U,TYPE> >
|
|
|
|
( std::shared_ptr<RangeBase>( RB::mThis ) ) );
|
|
|
|
i = 0;
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename U, RangeType TYPE>
|
|
|
|
typename SingleRange<U,TYPE>::IndexType SingleRange<U,TYPE>::end() const
|
|
|
|
{
|
|
|
|
SingleIndex<U,TYPE> i( std::dynamic_pointer_cast<SingleRange<U,TYPE> >
|
|
|
|
( std::shared_ptr<RangeBase>( RB::mThis ) ) );
|
|
|
|
i = size();
|
|
|
|
return i;
|
|
|
|
}
|
2017-03-14 23:00:41 +01:00
|
|
|
|
2017-11-20 21:35:25 +01:00
|
|
|
// put this in the interface class !!!
|
|
|
|
template <typename U, RangeType TYPE>
|
2017-12-10 18:41:53 +01:00
|
|
|
std::shared_ptr<VIWB> SingleRange<U,TYPE>::index() const
|
2017-11-20 21:35:25 +01:00
|
|
|
{
|
2017-12-10 18:41:53 +01:00
|
|
|
return std::make_shared<VIWB>
|
|
|
|
( std::make_shared<SingleIndex<U,TYPE> >
|
2017-12-11 18:49:43 +01:00
|
|
|
( std::dynamic_pointer_cast<SingleRange<U,TYPE> >
|
|
|
|
( std::shared_ptr<RangeBase>( RB::mThis ) ) ) );
|
2017-11-20 21:35:25 +01:00
|
|
|
}
|
2017-02-16 11:20:40 +01:00
|
|
|
|
2017-11-20 21:35:25 +01:00
|
|
|
}
|
2017-02-16 11:20:40 +01:00
|
|
|
|
2017-12-04 18:29:18 +01:00
|
|
|
#include "range_types/header.h"
|
|
|
|
|
2017-02-16 11:20:40 +01:00
|
|
|
#endif
|