chizeta/cnorxz
chizeta/cnorxz
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

fix: gcc 9 more pedantic in this case: int vs uint template arg

Browse source
This commit is contained in:
Christian Zimmermann 2019-07-05 17:40:26 +02:00
parent 472abec3fd
commit a2d67ef78c
9 changed files with 83 additions and 82 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/include/conversions.h
View file

@ -22,13 +22,13 @@ namespace MultiArrayTools
}; };
template <> template <>
struct OrigSize<-1> struct OrigSize<MUI>
{ {
template <typename C, typename T> template <typename C, typename T>
struct FromTo struct FromTo
{ {
static void check() {} static void check() {}
static constexpr size_t SIZE = -1; static constexpr size_t SIZE = MUI;
}; };
}; };
} }

18
src/include/ranges/anonymous_range.h
View file

@ -14,12 +14,12 @@
namespace MultiArrayTools namespace MultiArrayTools
{ {
typedef GenSingleIndex<size_t,SpaceType::ANON,-1> AnonymousIndex; typedef GenSingleIndex<size_t,SpaceType::ANON,MUI> AnonymousIndex;
//template <class R> //template <class R>
//using SIZET = size_t; //using SIZET = size_t;
typedef GenSingleRange<size_t,SpaceType::ANON,-1> AnonymousRange; typedef GenSingleRange<size_t,SpaceType::ANON,MUI> AnonymousRange;
// NOT THREAD SAVE!! // NOT THREAD SAVE!!
class AnonymousRangeFactory : public RangeFactoryBase class AnonymousRangeFactory : public RangeFactoryBase
@ -53,18 +53,18 @@ namespace MultiArrayTools
}; };
template <> template <>
class GenSingleRange<size_t,SpaceType::ANON,-1> : public RangeInterface<AnonymousIndex> class GenSingleRange<size_t,SpaceType::ANON,MUI> : public RangeInterface<AnonymousIndex>
{ {
public: public:
static constexpr bool defaultable = true; static constexpr bool defaultable = true;
static constexpr size_t ISSTATIC = 0; static constexpr size_t ISSTATIC = 0;
static constexpr size_t SIZE = -1; static constexpr size_t SIZE = MUI;
static constexpr bool HASMETACONT = false; static constexpr bool HASMETACONT = false;
typedef RangeBase RB; typedef RangeBase RB;
typedef typename RangeInterface<AnonymousIndex>::IndexType IndexType; typedef typename RangeInterface<AnonymousIndex>::IndexType IndexType;
typedef GenSingleRange<size_t,SpaceType::ANON,-1> RangeType; typedef GenSingleRange<size_t,SpaceType::ANON,MUI> RangeType;
typedef size_t MetaType; typedef size_t MetaType;
typedef AnonymousRangeFactory FType; typedef AnonymousRangeFactory FType;
@ -209,7 +209,7 @@ namespace MultiArrayTools
***********************/ ***********************/
template <class... RangeTypes> template <class... RangeTypes>
GenSingleRange<size_t,SpaceType::ANON,-1>::GenSingleRange(const std::tuple<std::shared_ptr<RangeTypes>...>& origs) : GenSingleRange<size_t,SpaceType::ANON,MUI>::GenSingleRange(const std::tuple<std::shared_ptr<RangeTypes>...>& origs) :
RangeInterface<AnonymousIndex>() RangeInterface<AnonymousIndex>()
{ {
RPackNum<sizeof...(RangeTypes)-1>::RangesToVec( origs, mOrig ); RPackNum<sizeof...(RangeTypes)-1>::RangesToVec( origs, mOrig );
@ -220,7 +220,7 @@ namespace MultiArrayTools
} }
template <class... RangeTypes> template <class... RangeTypes>
GenSingleRange<size_t,SpaceType::ANON,-1>::GenSingleRange(std::shared_ptr<RangeTypes>... origs) : GenSingleRange<size_t,SpaceType::ANON,MUI>::GenSingleRange(std::shared_ptr<RangeTypes>... origs) :
RangeInterface<AnonymousIndex>() RangeInterface<AnonymousIndex>()
{ {
auto rst = std::make_tuple(origs...); auto rst = std::make_tuple(origs...);
@ -232,13 +232,13 @@ namespace MultiArrayTools
} }
template <class Range> template <class Range>
std::shared_ptr<Range> GenSingleRange<size_t,SpaceType::ANON,-1>::fullsub(size_t num) const std::shared_ptr<Range> GenSingleRange<size_t,SpaceType::ANON,MUI>::fullsub(size_t num) const
{ {
return std::dynamic_pointer_cast<Range>( mOrig.at(num) ); return std::dynamic_pointer_cast<Range>( mOrig.at(num) );
} }
template <class... Ranges> template <class... Ranges>
std::shared_ptr<MultiRange<Ranges...> > GenSingleRange<size_t,SpaceType::ANON,-1>::scast(SIZET<Ranges>... sizes) const std::shared_ptr<MultiRange<Ranges...> > GenSingleRange<size_t,SpaceType::ANON,MUI>::scast(SIZET<Ranges>... sizes) const
{ {
std::tuple<std::shared_ptr<Ranges>...> rtp; std::tuple<std::shared_ptr<Ranges>...> rtp;
RPackNum<sizeof...(Ranges)-1>::resolveRangeType(mOrig, rtp, 0, sizes...); RPackNum<sizeof...(Ranges)-1>::resolveRangeType(mOrig, rtp, 0, sizes...);

26
src/include/ranges/range_types/classic_range.h
View file

@ -12,14 +12,14 @@
namespace MultiArrayTools namespace MultiArrayTools
{ {
typedef GenSingleIndex<size_t,SpaceType::NONE,-1> ClassicIndex; typedef GenSingleIndex<size_t,SpaceType::NONE,MUI> ClassicIndex;
template <> template <>
class GenSingleRangeFactory<size_t,SpaceType::NONE,-1> : public RangeFactoryBase class GenSingleRangeFactory<size_t,SpaceType::NONE,MUI> : public RangeFactoryBase
{ {
public: public:
typedef GenSingleRange<size_t,SpaceType::NONE,-1> oType; typedef GenSingleRange<size_t,SpaceType::NONE,MUI> oType;
GenSingleRangeFactory(size_t size = 0); GenSingleRangeFactory(size_t size = 0);
std::shared_ptr<RangeBase> create(); std::shared_ptr<RangeBase> create();
@ -27,14 +27,14 @@ namespace MultiArrayTools
}; };
template <> template <>
class GenSingleRange<size_t,SpaceType::NONE,-1> : public RangeInterface<ClassicIndex> class GenSingleRange<size_t,SpaceType::NONE,MUI> : public RangeInterface<ClassicIndex>
{ {
public: public:
typedef RangeBase RB; typedef RangeBase RB;
typedef typename RangeInterface<GenSingleIndex<size_t,SpaceType::NONE,-1> >::IndexType IndexType; typedef typename RangeInterface<GenSingleIndex<size_t,SpaceType::NONE,MUI> >::IndexType IndexType;
typedef GenSingleRange<size_t,SpaceType::NONE,-1> RangeType; typedef GenSingleRange<size_t,SpaceType::NONE,MUI> RangeType;
typedef size_t MetaType; typedef size_t MetaType;
typedef GenSingleRangeFactory<size_t,SpaceType::NONE,-1> FType; typedef GenSingleRangeFactory<size_t,SpaceType::NONE,MUI> FType;
virtual size_t size() const final; virtual size_t size() const final;
virtual size_t dim() const final; virtual size_t dim() const final;
@ -55,15 +55,15 @@ namespace MultiArrayTools
virtual IndexType end() const final; virtual IndexType end() const final;
//virtual std::shared_ptr<VIWB> index() const final; //virtual std::shared_ptr<VIWB> index() const final;
friend GenSingleRangeFactory<size_t,SpaceType::NONE,-1>; friend GenSingleRangeFactory<size_t,SpaceType::NONE,MUI>;
static constexpr bool defaultable = true; static constexpr bool defaultable = true;
static constexpr size_t ISSTATIC = 0; static constexpr size_t ISSTATIC = 0;
static constexpr size_t SIZE = -1; static constexpr size_t SIZE = MUI;
static constexpr bool HASMETACONT = false; static constexpr bool HASMETACONT = false;
static GenSingleRangeFactory<size_t,SpaceType::NONE,-1> factory(size_t size = 0) static GenSingleRangeFactory<size_t,SpaceType::NONE,MUI> factory(size_t size = 0)
{ return GenSingleRangeFactory<size_t,SpaceType::NONE,-1>(size); } { return GenSingleRangeFactory<size_t,SpaceType::NONE,MUI>(size); }
protected: protected:
@ -75,8 +75,8 @@ namespace MultiArrayTools
GenSingleRange(size_t size); GenSingleRange(size_t size);
}; };
typedef GenSingleRange<size_t,SpaceType::NONE,-1> ClassicRange; typedef GenSingleRange<size_t,SpaceType::NONE,MUI> ClassicRange;
typedef GenSingleRangeFactory<size_t,SpaceType::NONE,-1> ClassicRF; typedef GenSingleRangeFactory<size_t,SpaceType::NONE,MUI> ClassicRF;
} }

26
src/include/ranges/range_types/space_range.h
View file

@ -11,14 +11,14 @@ include_range_type(PSPACE,3) // Periodic 1dim space
namespace MultiArrayTools namespace MultiArrayTools
{ {
// Periodic 1dim space // Periodic 1dim space
typedef GenSingleIndex<int,SpaceType::PSPACE,-1> XSpaceIndex; typedef GenSingleIndex<int,SpaceType::PSPACE,MUI> XSpaceIndex;
template <> template <>
class GenSingleRangeFactory<int,SpaceType::PSPACE,-1> : public RangeFactoryBase class GenSingleRangeFactory<int,SpaceType::PSPACE,MUI> : public RangeFactoryBase
{ {
public: public:
typedef GenSingleRange<int,SpaceType::PSPACE,-1> oType; typedef GenSingleRange<int,SpaceType::PSPACE,MUI> oType;
GenSingleRangeFactory(size_t size = 0); GenSingleRangeFactory(size_t size = 0);
std::shared_ptr<RangeBase> create(); std::shared_ptr<RangeBase> create();
@ -26,14 +26,14 @@ namespace MultiArrayTools
}; };
template <> template <>
class GenSingleRange<int,SpaceType::PSPACE,-1> : public RangeInterface<XSpaceIndex> class GenSingleRange<int,SpaceType::PSPACE,MUI> : public RangeInterface<XSpaceIndex>
{ {
public: public:
typedef RangeBase RB; typedef RangeBase RB;
typedef typename RangeInterface<GenSingleIndex<int,SpaceType::PSPACE,-1> >::IndexType IndexType; typedef typename RangeInterface<GenSingleIndex<int,SpaceType::PSPACE,MUI> >::IndexType IndexType;
typedef GenSingleRange<int,SpaceType::PSPACE,-1> RangeType; typedef GenSingleRange<int,SpaceType::PSPACE,MUI> RangeType;
typedef int MetaType; typedef int MetaType;
typedef GenSingleRangeFactory<int,SpaceType::PSPACE,-1> FType; typedef GenSingleRangeFactory<int,SpaceType::PSPACE,MUI> FType;
virtual size_t size() const final; virtual size_t size() const final;
virtual size_t dim() const final; virtual size_t dim() const final;
@ -53,15 +53,15 @@ namespace MultiArrayTools
virtual IndexType begin() const final; virtual IndexType begin() const final;
virtual IndexType end() const final; virtual IndexType end() const final;
friend GenSingleRangeFactory<int,SpaceType::PSPACE,-1>; friend GenSingleRangeFactory<int,SpaceType::PSPACE,MUI>;
static constexpr bool defaultable = true; static constexpr bool defaultable = true;
static constexpr size_t ISSTATIC = 0; static constexpr size_t ISSTATIC = 0;
static constexpr size_t SIZE = -1; static constexpr size_t SIZE = MUI;
static constexpr bool HASMETACONT = false; static constexpr bool HASMETACONT = false;
static GenSingleRangeFactory<int,SpaceType::PSPACE,-1> factory(size_t size = 0) static GenSingleRangeFactory<int,SpaceType::PSPACE,MUI> factory(size_t size = 0)
{ return GenSingleRangeFactory<int,SpaceType::PSPACE,-1>(size); } { return GenSingleRangeFactory<int,SpaceType::PSPACE,MUI>(size); }
protected: protected:
@ -73,8 +73,8 @@ namespace MultiArrayTools
GenSingleRange(size_t size); GenSingleRange(size_t size);
}; };
typedef GenSingleRange<int,SpaceType::PSPACE,-1> PSpaceRange; typedef GenSingleRange<int,SpaceType::PSPACE,MUI> PSpaceRange;
typedef GenSingleRangeFactory<int,SpaceType::PSPACE,-1> PSpaceRF; typedef GenSingleRangeFactory<int,SpaceType::PSPACE,MUI> PSpaceRF;
std::shared_ptr<PSpaceRF> mkPSPACE(const char* dp, size_t size); std::shared_ptr<PSpaceRF> mkPSPACE(const char* dp, size_t size);

1
src/include/ranges/rbase_def.h
View file

@ -15,6 +15,7 @@
#endif #endif
#include "allocator.h" #include "allocator.h"
#define MUI static_cast<size_t>(-1)
namespace MultiArrayTools namespace MultiArrayTools
{ {

12
src/include/ranges/single_range.h
View file

@ -204,10 +204,10 @@ namespace MultiArrayTools
}; };
template <> template <>
struct CheckStatic<-1> struct CheckStatic<MUI>
{ {
static constexpr size_t ISSTATIC = false; static constexpr size_t ISSTATIC = false;
static constexpr size_t SIZE = -1; static constexpr size_t SIZE = MUI;
}; };
template <SpaceType TYPE> template <SpaceType TYPE>
@ -283,13 +283,13 @@ namespace MultiArrayTools
}; };
template <typename U, SpaceType TYPE> template <typename U, SpaceType TYPE>
using SingleRange = GenSingleRange<U,TYPE,-1>; using SingleRange = GenSingleRange<U,TYPE,MUI>;
template <typename U, SpaceType TYPE> template <typename U, SpaceType TYPE>
using SingleIndex = GenSingleIndex<U,TYPE,-1>; using SingleIndex = GenSingleIndex<U,TYPE,MUI>;
template <typename U, SpaceType TYPE> template <typename U, SpaceType TYPE>
using SingleRangeFactory = GenSingleRangeFactory<U,TYPE,-1>; using SingleRangeFactory = GenSingleRangeFactory<U,TYPE,MUI>;
} }
@ -556,7 +556,7 @@ namespace MultiArrayTools
} }
template <> template <>
inline size_t getStatSizeOrDyn<-1>(size_t size) inline size_t getStatSizeOrDyn<MUI>(size_t size)
{ {
return size; return size;
} }

2
src/lib/ranges/anonymous_range.cc
View file

@ -253,7 +253,7 @@ namespace MultiArrayTools
return mOrig; return mOrig;
} }
GenSingleRange<size_t,SpaceType::ANON,-1>::GenSingleRange(const vector<std::shared_ptr<RangeBase>>& origs) : GenSingleRange<size_t,SpaceType::ANON,MUI>::GenSingleRange(const vector<std::shared_ptr<RangeBase>>& origs) :
RangeInterface<AnonymousIndex>(), RangeInterface<AnonymousIndex>(),
mOrig(origs) mOrig(origs)
{ {

38
src/lib/ranges/range_types/classic_range.cc
View file

@ -8,16 +8,16 @@ namespace MultiArrayTools
* GenSingleRange * * GenSingleRange *
********************/ ********************/
GenSingleRangeFactory<size_t,SpaceType::NONE,-1>::GenSingleRangeFactory(size_t size) GenSingleRangeFactory<size_t,SpaceType::NONE,MUI>::GenSingleRangeFactory(size_t size)
{ {
// Quasi Singleton // Quasi Singleton
if(not mProd){ if(not mProd){
mProd = std::shared_ptr<oType>( new GenSingleRange<size_t,SpaceType::NONE,-1>(size) ); mProd = std::shared_ptr<oType>( new GenSingleRange<size_t,SpaceType::NONE,MUI>(size) );
setSelf(); setSelf();
} }
} }
std::shared_ptr<RangeBase> GenSingleRangeFactory<size_t,SpaceType::NONE,-1>::create() std::shared_ptr<RangeBase> GenSingleRangeFactory<size_t,SpaceType::NONE,MUI>::create()
{ {
return mProd; return mProd;
} }
@ -26,55 +26,55 @@ namespace MultiArrayTools
* GenSingleRange * * GenSingleRange *
********************/ ********************/
GenSingleRange<size_t,SpaceType::NONE,-1>::GenSingleRange(size_t size) : mSize(size) {} GenSingleRange<size_t,SpaceType::NONE,MUI>::GenSingleRange(size_t size) : mSize(size) {}
size_t GenSingleRange<size_t,SpaceType::NONE,-1>::get(size_t pos) const size_t GenSingleRange<size_t,SpaceType::NONE,MUI>::get(size_t pos) const
{ {
return pos; return pos;
} }
size_t GenSingleRange<size_t,SpaceType::NONE,-1>::getMeta(size_t metaPos) const size_t GenSingleRange<size_t,SpaceType::NONE,MUI>::getMeta(size_t metaPos) const
{ {
return metaPos; return metaPos;
} }
size_t GenSingleRange<size_t,SpaceType::NONE,-1>::size() const size_t GenSingleRange<size_t,SpaceType::NONE,MUI>::size() const
{ {
return mSize; return mSize;
} }
size_t GenSingleRange<size_t,SpaceType::NONE,-1>::dim() const size_t GenSingleRange<size_t,SpaceType::NONE,MUI>::dim() const
{ {
return 1; return 1;
} }
SpaceType GenSingleRange<size_t,SpaceType::NONE,-1>::spaceType() const SpaceType GenSingleRange<size_t,SpaceType::NONE,MUI>::spaceType() const
{ {
return SpaceType::NONE; return SpaceType::NONE;
} }
vector<size_t> GenSingleRange<size_t,SpaceType::NONE,-1>::typeNum() const vector<size_t> GenSingleRange<size_t,SpaceType::NONE,MUI>::typeNum() const
{ {
return {NumTypeMap<size_t>::num}; return {NumTypeMap<size_t>::num};
} }
size_t GenSingleRange<size_t,SpaceType::NONE,-1>::cmeta(char* target, size_t pos) const size_t GenSingleRange<size_t,SpaceType::NONE,MUI>::cmeta(char* target, size_t pos) const
{ {
*reinterpret_cast<size_t*>(target) = pos; *reinterpret_cast<size_t*>(target) = pos;
return sizeof(size_t); return sizeof(size_t);
} }
size_t GenSingleRange<size_t,SpaceType::NONE,-1>::cmetaSize() const size_t GenSingleRange<size_t,SpaceType::NONE,MUI>::cmetaSize() const
{ {
return sizeof(size_t); return sizeof(size_t);
} }
std::string GenSingleRange<size_t,SpaceType::NONE,-1>::stringMeta(size_t pos) const std::string GenSingleRange<size_t,SpaceType::NONE,MUI>::stringMeta(size_t pos) const
{ {
return std::to_string(get(pos)); return std::to_string(get(pos));
} }
vector<char> GenSingleRange<size_t,SpaceType::NONE,-1>::data() const vector<char> GenSingleRange<size_t,SpaceType::NONE,MUI>::data() const
{ {
DataHeader h = dataHeader(); DataHeader h = dataHeader();
vector<char> out; vector<char> out;
@ -86,7 +86,7 @@ namespace MultiArrayTools
return out; return out;
} }
DataHeader GenSingleRange<size_t,SpaceType::NONE,-1>::dataHeader() const DataHeader GenSingleRange<size_t,SpaceType::NONE,MUI>::dataHeader() const
{ {
DataHeader h; DataHeader h;
h.spaceType = static_cast<int>( SpaceType::NONE ); h.spaceType = static_cast<int>( SpaceType::NONE );
@ -96,17 +96,17 @@ namespace MultiArrayTools
} }
typename GenSingleRange<size_t,SpaceType::NONE,-1>::IndexType GenSingleRange<size_t,SpaceType::NONE,-1>::begin() const typename GenSingleRange<size_t,SpaceType::NONE,MUI>::IndexType GenSingleRange<size_t,SpaceType::NONE,MUI>::begin() const
{ {
GenSingleIndex<size_t,SpaceType::NONE,-1> i( std::dynamic_pointer_cast<GenSingleRange<size_t,SpaceType::NONE,-1> > GenSingleIndex<size_t,SpaceType::NONE,MUI> i( std::dynamic_pointer_cast<GenSingleRange<size_t,SpaceType::NONE,MUI> >
( std::shared_ptr<RangeBase>( RB::mThis ) ) ); ( std::shared_ptr<RangeBase>( RB::mThis ) ) );
i = 0; i = 0;
return i; return i;
} }
typename GenSingleRange<size_t,SpaceType::NONE,-1>::IndexType GenSingleRange<size_t,SpaceType::NONE,-1>::end() const typename GenSingleRange<size_t,SpaceType::NONE,MUI>::IndexType GenSingleRange<size_t,SpaceType::NONE,MUI>::end() const
{ {
GenSingleIndex<size_t,SpaceType::NONE,-1> i( std::dynamic_pointer_cast<GenSingleRange<size_t,SpaceType::NONE,-1> > GenSingleIndex<size_t,SpaceType::NONE,MUI> i( std::dynamic_pointer_cast<GenSingleRange<size_t,SpaceType::NONE,MUI> >
( std::shared_ptr<RangeBase>( RB::mThis ) ) ); ( std::shared_ptr<RangeBase>( RB::mThis ) ) );
i = size(); i = size();
return i; return i;

38
src/lib/ranges/range_types/space_range.cc
View file

@ -14,16 +14,16 @@ namespace MultiArrayTools
* GenSingleRange * * GenSingleRange *
********************/ ********************/
GenSingleRangeFactory<int,SpaceType::PSPACE,-1>::GenSingleRangeFactory(size_t size) GenSingleRangeFactory<int,SpaceType::PSPACE,MUI>::GenSingleRangeFactory(size_t size)
{ {
// Quasi Singleton // Quasi Singleton
if(not mProd){ if(not mProd){
mProd = std::shared_ptr<oType>( new GenSingleRange<int,SpaceType::PSPACE,-1>(size) ); mProd = std::shared_ptr<oType>( new GenSingleRange<int,SpaceType::PSPACE,MUI>(size) );
setSelf(); setSelf();
} }
} }
std::shared_ptr<RangeBase> GenSingleRangeFactory<int,SpaceType::PSPACE,-1>::create() std::shared_ptr<RangeBase> GenSingleRangeFactory<int,SpaceType::PSPACE,MUI>::create()
{ {
return mProd; return mProd;
} }
@ -32,55 +32,55 @@ namespace MultiArrayTools
* GenSingleRange * * GenSingleRange *
********************/ ********************/
GenSingleRange<int,SpaceType::PSPACE,-1>::GenSingleRange(size_t size) : mSize(size) { } GenSingleRange<int,SpaceType::PSPACE,MUI>::GenSingleRange(size_t size) : mSize(size) { }
int GenSingleRange<int,SpaceType::PSPACE,-1>::get(size_t pos) const int GenSingleRange<int,SpaceType::PSPACE,MUI>::get(size_t pos) const
{ {
return pos > mSize / 2 ? pos - mSize : pos; return pos > mSize / 2 ? pos - mSize : pos;
} }
size_t GenSingleRange<int,SpaceType::PSPACE,-1>::getMeta(int metaPos) const size_t GenSingleRange<int,SpaceType::PSPACE,MUI>::getMeta(int metaPos) const
{ {
return metaPos < 0 ? metaPos + mSize : metaPos; return metaPos < 0 ? metaPos + mSize : metaPos;
} }
size_t GenSingleRange<int,SpaceType::PSPACE,-1>::size() const size_t GenSingleRange<int,SpaceType::PSPACE,MUI>::size() const
{ {
return mSize; return mSize;
} }
size_t GenSingleRange<int,SpaceType::PSPACE,-1>::dim() const size_t GenSingleRange<int,SpaceType::PSPACE,MUI>::dim() const
{ {
return 1; return 1;
} }
SpaceType GenSingleRange<int,SpaceType::PSPACE,-1>::spaceType() const SpaceType GenSingleRange<int,SpaceType::PSPACE,MUI>::spaceType() const
{ {
return SpaceType::PSPACE; return SpaceType::PSPACE;
} }
vector<size_t> GenSingleRange<int,SpaceType::PSPACE,-1>::typeNum() const vector<size_t> GenSingleRange<int,SpaceType::PSPACE,MUI>::typeNum() const
{ {
return {NumTypeMap<int>::num}; return {NumTypeMap<int>::num};
} }
size_t GenSingleRange<int,SpaceType::PSPACE,-1>::cmeta(char* target, size_t pos) const size_t GenSingleRange<int,SpaceType::PSPACE,MUI>::cmeta(char* target, size_t pos) const
{ {
*reinterpret_cast<int*>(target) = get(pos); *reinterpret_cast<int*>(target) = get(pos);
return sizeof(int); return sizeof(int);
} }
size_t GenSingleRange<int,SpaceType::PSPACE,-1>::cmetaSize() const size_t GenSingleRange<int,SpaceType::PSPACE,MUI>::cmetaSize() const
{ {
return sizeof(int); return sizeof(int);
} }
std::string GenSingleRange<int,SpaceType::PSPACE,-1>::stringMeta(size_t pos) const std::string GenSingleRange<int,SpaceType::PSPACE,MUI>::stringMeta(size_t pos) const
{ {
return std::to_string(get(pos)); return std::to_string(get(pos));
} }
vector<char> GenSingleRange<int,SpaceType::PSPACE,-1>::data() const vector<char> GenSingleRange<int,SpaceType::PSPACE,MUI>::data() const
{ {
DataHeader h = dataHeader(); DataHeader h = dataHeader();
vector<char> out; vector<char> out;
@ -92,7 +92,7 @@ namespace MultiArrayTools
return out; return out;
} }
DataHeader GenSingleRange<int,SpaceType::PSPACE,-1>::dataHeader() const DataHeader GenSingleRange<int,SpaceType::PSPACE,MUI>::dataHeader() const
{ {
DataHeader h; DataHeader h;
h.spaceType = static_cast<int>( SpaceType::PSPACE ); h.spaceType = static_cast<int>( SpaceType::PSPACE );
@ -101,17 +101,17 @@ namespace MultiArrayTools
return h; return h;
} }
typename GenSingleRange<int,SpaceType::PSPACE,-1>::IndexType GenSingleRange<int,SpaceType::PSPACE,-1>::begin() const typename GenSingleRange<int,SpaceType::PSPACE,MUI>::IndexType GenSingleRange<int,SpaceType::PSPACE,MUI>::begin() const
{ {
GenSingleIndex<int,SpaceType::PSPACE,-1> i( std::dynamic_pointer_cast<GenSingleRange<int,SpaceType::PSPACE,-1> > GenSingleIndex<int,SpaceType::PSPACE,MUI> i( std::dynamic_pointer_cast<GenSingleRange<int,SpaceType::PSPACE,MUI> >
( std::shared_ptr<RangeBase>( RB::mThis ) ) ); ( std::shared_ptr<RangeBase>( RB::mThis ) ) );
i = 0; i = 0;
return i; return i;
} }
typename GenSingleRange<int,SpaceType::PSPACE,-1>::IndexType GenSingleRange<int,SpaceType::PSPACE,-1>::end() const typename GenSingleRange<int,SpaceType::PSPACE,MUI>::IndexType GenSingleRange<int,SpaceType::PSPACE,MUI>::end() const
{ {
GenSingleIndex<int,SpaceType::PSPACE,-1> i( std::dynamic_pointer_cast<GenSingleRange<int,SpaceType::PSPACE,-1> > GenSingleIndex<int,SpaceType::PSPACE,MUI> i( std::dynamic_pointer_cast<GenSingleRange<int,SpaceType::PSPACE,MUI> >
( std::shared_ptr<RangeBase>( RB::mThis ) ) ); ( std::shared_ptr<RangeBase>( RB::mThis ) ) );
i = size(); i = size();
return i; return i;