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-07-26 18:38:11 +02:00
|
|
|
class SingleIndex : public IndexInterface<U>
|
2017-02-16 11:20:40 +01:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
2017-08-04 11:27:47 +02:00
|
|
|
typedef IndexBase 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
|
|
|
|
|
|
|
virtual IndexType type() const override;
|
2017-08-11 16:45:03 +02:00
|
|
|
|
2017-02-17 18:10:03 +01:00
|
|
|
virtual SingleIndex& operator=(size_t pos) override;
|
|
|
|
virtual SingleIndex& operator++() override;
|
|
|
|
virtual SingleIndex& operator--() override;
|
|
|
|
|
2017-08-04 14:57:19 +02:00
|
|
|
virtual U meta() const override;
|
|
|
|
virtual SingleIndex& at(const U& metaPos) override;
|
2017-03-03 17:51:42 +01:00
|
|
|
|
2017-02-16 11:20:40 +01:00
|
|
|
virtual size_t dim() const override; // = 1
|
2017-07-26 18:38:11 +02:00
|
|
|
virtual bool last() const override;
|
|
|
|
virtual bool first() const override;
|
2017-08-25 22:03:20 +02:00
|
|
|
|
2017-08-28 18:28:43 +02:00
|
|
|
virtual std::shared_ptr<const IndexBase> getPtr(size_t n) const override;
|
|
|
|
|
2017-08-25 22:03:20 +02:00
|
|
|
virtual std::string id() const override { 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-07-28 14:02:44 +02:00
|
|
|
virtual std::shared_ptr<IndexBase> index() const override;
|
|
|
|
|
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-07-28 14:02:44 +02:00
|
|
|
/*
|
2017-03-14 23:00:41 +01:00
|
|
|
// specializaions
|
|
|
|
|
|
|
|
template <>
|
|
|
|
class SingleRange<int,RangeType::SPACE> : public RangeBase<SingleIndex<int,RangeType::SPACE> >
|
|
|
|
{
|
|
|
|
public:
|
2017-03-15 22:54:48 +01:00
|
|
|
typedef typename RangeBase<SingleIndex<int,RangeType::SPACE> >::IndexType IndexType;
|
2017-03-30 14:41:57 +02:00
|
|
|
|
|
|
|
static SingleRange<int,RangeType::SPACE> oType() { return SingleRange<int,RangeType::SPACE>(); }
|
2017-03-14 23:00:41 +01:00
|
|
|
|
|
|
|
virtual size_t size() const override;
|
|
|
|
|
|
|
|
int get(size_t pos) const;
|
|
|
|
size_t getMeta(int metaPos) const;
|
|
|
|
|
|
|
|
virtual MultiRangeType type() const override;
|
|
|
|
|
|
|
|
SingleIndex<int,RangeType::SPACE> begin() const override;
|
|
|
|
SingleIndex<int,RangeType::SPACE> end() const override;
|
|
|
|
|
|
|
|
protected:
|
2017-06-01 13:19:27 +02:00
|
|
|
|
|
|
|
SingleRange(size_t ext);
|
|
|
|
|
2017-03-21 23:31:50 +01:00
|
|
|
size_t mExt;
|
2017-03-14 23:00:41 +01:00
|
|
|
};
|
|
|
|
|
2017-03-24 15:05:02 +01:00
|
|
|
template <>
|
2017-03-27 19:29:51 +02:00
|
|
|
class SingleRange<size_t,RangeType::DISTANCE> : public RangeBase<SingleIndex<size_t,RangeType::DISTANCE> >
|
2017-03-24 15:05:02 +01:00
|
|
|
{
|
|
|
|
public:
|
2017-03-27 19:29:51 +02:00
|
|
|
typedef typename RangeBase<SingleIndex<size_t,RangeType::DISTANCE> >::IndexType IndexType;
|
2017-03-30 14:41:57 +02:00
|
|
|
|
|
|
|
static SingleRange<size_t,RangeType::DISTANCE> oType() { return SingleRange<size_t,RangeType::DISTANCE>(); }
|
2017-03-24 15:05:02 +01:00
|
|
|
|
|
|
|
virtual size_t size() const override;
|
|
|
|
|
|
|
|
size_t get(size_t pos) const;
|
|
|
|
size_t getMeta(size_t metaPos) const;
|
|
|
|
|
|
|
|
virtual MultiRangeType type() const override;
|
|
|
|
|
2017-03-27 19:29:51 +02:00
|
|
|
SingleIndex<size_t,RangeType::DISTANCE> begin() const override;
|
|
|
|
SingleIndex<size_t,RangeType::DISTANCE> end() const override;
|
2017-03-24 15:05:02 +01:00
|
|
|
|
|
|
|
protected:
|
2017-06-01 13:19:27 +02:00
|
|
|
|
|
|
|
SingleRange(size_t ext);
|
|
|
|
|
2017-03-24 15:05:02 +01:00
|
|
|
size_t mExt;
|
|
|
|
};
|
|
|
|
|
2017-03-14 23:00:41 +01:00
|
|
|
template <>
|
|
|
|
class SingleRange<size_t,RangeType::ENSEMBLE> : public RangeBase<SingleIndex<size_t,RangeType::ENSEMBLE> >
|
|
|
|
{
|
|
|
|
public:
|
2017-03-15 22:54:48 +01:00
|
|
|
typedef typename RangeBase<SingleIndex<size_t,RangeType::ENSEMBLE> >::IndexType IndexType;
|
2017-03-30 14:41:57 +02:00
|
|
|
|
|
|
|
static SingleRange<size_t,RangeType::ENSEMBLE> oType() { return SingleRange<size_t,RangeType::ENSEMBLE>(); }
|
2017-03-14 23:00:41 +01:00
|
|
|
|
|
|
|
virtual size_t size() const override;
|
|
|
|
|
|
|
|
size_t get(size_t pos) const;
|
|
|
|
size_t getMeta(size_t metaPos) const;
|
|
|
|
|
|
|
|
virtual MultiRangeType type() const override;
|
|
|
|
|
|
|
|
SingleIndex<size_t,RangeType::ENSEMBLE> begin() const override;
|
|
|
|
SingleIndex<size_t,RangeType::ENSEMBLE> end() const override;
|
|
|
|
|
|
|
|
protected:
|
2017-06-01 13:19:27 +02:00
|
|
|
|
|
|
|
SingleRange(size_t num);
|
|
|
|
|
2017-03-14 23:00:41 +01:00
|
|
|
size_t mNum;
|
|
|
|
};
|
|
|
|
|
|
|
|
enum class VET
|
|
|
|
{
|
|
|
|
VALUE = 0,
|
|
|
|
ERROR = 1
|
|
|
|
};
|
|
|
|
|
2017-03-15 22:54:48 +01:00
|
|
|
std::ostream& operator<<(std::ostream& os, VET vet);
|
|
|
|
|
2017-03-14 23:00:41 +01:00
|
|
|
template <>
|
|
|
|
class SingleRange<VET,RangeType::VALUE_ERROR> : public RangeBase<SingleIndex<VET,RangeType::VALUE_ERROR> >
|
|
|
|
{
|
|
|
|
public:
|
2017-03-15 22:54:48 +01:00
|
|
|
typedef typename RangeBase<SingleIndex<VET,RangeType::VALUE_ERROR> >::IndexType IndexType;
|
2017-03-14 23:00:41 +01:00
|
|
|
|
2017-03-30 14:41:57 +02:00
|
|
|
static SingleRange<VET,RangeType::VALUE_ERROR> oType()
|
|
|
|
{ return SingleRange<VET,RangeType::VALUE_ERROR>(); }
|
|
|
|
|
2017-03-14 23:00:41 +01:00
|
|
|
virtual size_t size() const override;
|
|
|
|
|
|
|
|
VET get(size_t pos) const;
|
|
|
|
size_t getMeta(VET metaPos) const;
|
|
|
|
|
|
|
|
virtual MultiRangeType type() const override;
|
|
|
|
|
|
|
|
SingleIndex<VET,RangeType::VALUE_ERROR> begin() const override;
|
|
|
|
SingleIndex<VET,RangeType::VALUE_ERROR> end() const override;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <>
|
|
|
|
class SingleRange<size_t,RangeType::LORENTZ> : public RangeBase<SingleIndex<size_t,RangeType::LORENTZ> >
|
|
|
|
{
|
|
|
|
public:
|
2017-03-15 22:54:48 +01:00
|
|
|
typedef typename RangeBase<SingleIndex<size_t,RangeType::LORENTZ> >::IndexType IndexType;
|
2017-03-14 23:00:41 +01:00
|
|
|
|
2017-03-30 14:41:57 +02:00
|
|
|
static SingleRange<size_t,RangeType::LORENTZ> oType() { return SingleRange<size_t,RangeType::LORENTZ>(); }
|
|
|
|
|
2017-03-14 23:00:41 +01:00
|
|
|
virtual size_t size() const override;
|
|
|
|
|
|
|
|
size_t get(size_t pos) const;
|
|
|
|
size_t getMeta(size_t metaPos) const;
|
|
|
|
|
|
|
|
virtual MultiRangeType type() const override;
|
|
|
|
|
|
|
|
SingleIndex<size_t,RangeType::LORENTZ> begin() const override;
|
|
|
|
SingleIndex<size_t,RangeType::LORENTZ> end() const override;
|
|
|
|
};
|
2017-07-28 14:02:44 +02:00
|
|
|
*/
|
2017-02-16 11:20:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
#include "single_range.cc"
|
|
|
|
|
|
|
|
#endif
|