From 0bbbdf71684a61b37a62bea0c103016f40c540cd Mon Sep 17 00:00:00 2001 From: Christian Zimmermann Date: Thu, 4 Jan 2018 11:43:45 +0100 Subject: [PATCH] static polymorphism in Block* + remove unused code --- src/block/bbase_def.h | 20 +------ src/block/block.h | 114 +++++++++++++++++++++++++----------- src/multi_array_operation.h | 33 +++++------ 3 files changed, 96 insertions(+), 71 deletions(-) diff --git a/src/block/bbase_def.h b/src/block/bbase_def.h index 63f0ece..667dfe6 100644 --- a/src/block/bbase_def.h +++ b/src/block/bbase_def.h @@ -10,11 +10,11 @@ namespace MultiArrayHelper class BlockBinaryOp; - template + template class BlockBase; - template + template class MutableBlockBase; @@ -26,22 +26,6 @@ namespace MultiArrayHelper class MBlock; - template - class BlockValue; - - - template - class MBlockValue; - - - template - class SplitBlock; - - - template - class MSplitBlock; - - template class BlockResult; diff --git a/src/block/block.h b/src/block/block.h index f097a27..a558e28 100644 --- a/src/block/block.h +++ b/src/block/block.h @@ -46,18 +46,32 @@ namespace MultiArrayHelper // EVERYTHING IN HERE MUST N O T BE VITUAL !! - template + template class BlockBase { public: - DEFAULT_MEMBERS(BlockBase); - BlockBase(size_t size); + const BlockClass& THIS() const { return static_cast(*this); } + BlockClass& THIS() { return static_cast(*this); } + static BlockType sType() { return BlockClass::sType(); } + size_t size() const; bool init() const; - protected: + BlockType type() const { return THIS().type(); } + const T& operator[](size_t pos) const { return THIS()[pos]; } + BlockClass& set(size_t npos) { return THIS().set(npos); } + size_t stepSize() const { return THIS().stepSize(); } + + private: + + friend BlockClass; + friend MutableBlockBase; + + DEFAULT_MEMBERS(BlockBase); + BlockBase(size_t size); + size_t mSize = 0; bool mInit = false; }; @@ -93,20 +107,32 @@ namespace MultiArrayHelper } - template - class MutableBlockBase : public BlockBase + template + class MutableBlockBase : public BlockBase { public: + typedef BlockBase BB; + + T& operator[](size_t pos) { return BB::THIS()[pos]; } + + private: + + friend BlockClass; + DEFAULT_MEMBERS(MutableBlockBase); MutableBlockBase(size_t size); }; template - class Block : public BlockBase + class Block : public BlockBase > { public: + typedef BlockBase > BB; + + static BlockType sType() { return BlockType::BLOCK; } + DEFAULT_MEMBERS(Block); Block(const T* data, size_t begPos, size_t size, size_t stepSize); @@ -122,13 +148,16 @@ namespace MultiArrayHelper }; template - class BlockArray : public BlockBase + class BlockArray : public BlockBase > { + typedef BlockBase > BB; + + static BlockType sType() { return BlockType::ARRAY; } + DEFAULT_MEMBERS(BlockArray); - template - BlockArray(size_t stepSize, const Args&... args); + BlockArray(const BlockClass& block, size_t size, size_t stepSize); BlockType type() const; BlockClass& operator[](size_t pos); @@ -136,15 +165,20 @@ namespace MultiArrayHelper size_t stepSize() const; protected: - BlockClass mBlock; + const BlockClass& mBlock; size_t mStepSize; // total stepSize !! }; template - class MBlock : public MutableBlockBase + class MBlock : public MutableBlockBase > { public: + + typedef BlockBase > BB; + + static BlockType sType() { return BlockType::BLOCK; } + DEFAULT_MEMBERS(MBlock); MBlock(T* data, size_t begPos, size_t size, size_t stepSize); @@ -164,12 +198,14 @@ namespace MultiArrayHelper }; template - class BlockResult : public MutableBlockBase + class BlockResult : public MutableBlockBase > { public: - typedef BlockBase BB; + typedef BlockBase > BB; using BB::init; + + static BlockType sType() { return BlockType::RESULT; } BlockResult(); BlockResult(const BlockResult& in); @@ -196,6 +232,7 @@ namespace MultiArrayHelper protected: T* mResPtr = nullptr; + T* mBegPtr = nullptr; }; } // end namespace MultiArrayHelper @@ -261,17 +298,17 @@ namespace MultiArrayHelper * BlockBase * *****************/ - template - BlockBase::BlockBase(size_t size) : mSize(size), mInit(size != 0) {} + template + BlockBase::BlockBase(size_t size) : mSize(size), mInit(size != 0) {} - template - size_t BlockBase::size() const + template + size_t BlockBase::size() const { return mSize; } - template - bool BlockBase::init() const + template + bool BlockBase::init() const { return mInit; } @@ -280,8 +317,8 @@ namespace MultiArrayHelper * MutableBlockBase * ************************/ - template - MutableBlockBase::MutableBlockBase(size_t size) : BlockBase(size) {} + template + MutableBlockBase::MutableBlockBase(size_t size) : BlockBase(size) {} /************* @@ -291,7 +328,7 @@ namespace MultiArrayHelper template Block::Block(const T* data, size_t begPos, size_t size, size_t stepSize) : - BlockBase(size), + BlockBase(size), mData(data), mBegPtr(data + begPos), mStepSize(stepSize) {} @@ -329,9 +366,9 @@ namespace MultiArrayHelper ******************/ template - template - BlockArray::BlockArray(size_t stepSize, const Args&... args) : - mBlock(args...), mStepSize(stepSize) {} + BlockArray::BlockArray(const BlockClass& block, size_t size, size_t stepSize) : + BlockBase >(size), + mBlock(block), mStepSize(stepSize) {} template BlockType BlockArray::type() const @@ -366,7 +403,7 @@ namespace MultiArrayHelper template MBlock::MBlock(T* data, size_t begPos, size_t size, size_t stepSize) : - MutableBlockBase(size), + MutableBlockBase(size), mData(data), mBegPtr(data + begPos), mStepSize(stepSize) {} @@ -375,7 +412,7 @@ namespace MultiArrayHelper template MBlock& MBlock::operator=(const BlockClass& in) { - for(size_t i = 0; i != BlockBase::mSize; ++i){ + for(size_t i = 0; i != BB::mSize; ++i){ (*this)[i] = in[i]; } return *this; @@ -420,10 +457,10 @@ namespace MultiArrayHelper *******************/ template - BlockResult::BlockResult() : MutableBlockBase() {} + BlockResult::BlockResult() : MutableBlockBase() {} template - BlockResult::BlockResult(const BlockResult& in) : MutableBlockBase(in.size()) + BlockResult::BlockResult(const BlockResult& in) : MutableBlockBase(in.size()) { if(BB::mInit){ mResPtr = new T[BB::mSize]; @@ -431,17 +468,20 @@ namespace MultiArrayHelper for(size_t i = 0; i != BB::mSize; ++i){ mResPtr[i] = in.mResPtr[i]; } + mBegPtr = mResPtr; } template - BlockResult::BlockResult(BlockResult&& in) : MutableBlockBase(in.size()) + BlockResult::BlockResult(BlockResult&& in) : MutableBlockBase(in.size()) { if(BB::mInit){ mResPtr = in.mResPtr; + mBegPtr = mResPtr; } in.mSize = 0; in.mInit = false; in.mResPtr = nullptr; + in.mBegPtr = nullptr; } template @@ -455,6 +495,7 @@ namespace MultiArrayHelper for(size_t i = 0; i != BB::mSize; ++i){ mResPtr[i] = in.mResPtr[i]; } + mBegPtr = mResPtr; return *this; } @@ -465,6 +506,7 @@ namespace MultiArrayHelper BB::mInit = BB::mInit and BB::mSize != 0; if(BB::mInit){ mResPtr = in.mResPtr; + mBegPtr = mResPtr; } in.mSize = 0; in.mInit = false; @@ -475,7 +517,7 @@ namespace MultiArrayHelper template template BlockResult::BlockResult(size_t size, const ArgTypes&... args) : - MutableBlockBase(size) + MutableBlockBase(size) { if(BB::mInit){ mResPtr = new T[BB::mSize](args...); @@ -483,6 +525,7 @@ namespace MultiArrayHelper for(size_t i = 0; i != BB::mSize; ++i){ mResPtr[i] = static_cast( 0 ); } + mBegPtr = mResPtr; } template @@ -490,6 +533,7 @@ namespace MultiArrayHelper { delete[] mResPtr; mResPtr = nullptr; + mBegPtr = nullptr; BB::mInit = false; BB::mSize = 0; } @@ -515,18 +559,19 @@ namespace MultiArrayHelper template const T& BlockResult::operator[](size_t i) const { - return mResPtr[i]; + return mBegPtr[i]; } template T& BlockResult::operator[](size_t i) { - return mResPtr[i]; + return mBegPtr[i]; } template BlockResult& BlockResult::set(size_t npos) { + mBegPtr = mResPtr + npos; return *this; } @@ -552,6 +597,7 @@ namespace MultiArrayHelper for(size_t i = 0; i != BB::mSize; ++i){ mResPtr[i] = static_cast( 0 ); } + mBegPtr = mResPtr; return *this; } diff --git a/src/multi_array_operation.h b/src/multi_array_operation.h index c18234b..712de4b 100644 --- a/src/multi_array_operation.h +++ b/src/multi_array_operation.h @@ -99,7 +99,8 @@ namespace MultiArrayTools typedef OperationBase OB; typedef ContainerRange CRange; typedef typename MultiRange::IndexType IndexType; - + typedef MBlock bType; + OperationMaster(MutableMultiArrayBase& ma, const OpClass& second, std::shared_ptr& index); @@ -121,7 +122,7 @@ namespace MultiArrayTools MutableMultiArrayBase& mArrayRef; std::shared_ptr mIndex; IndexInfo mIInfo; - mutable MBlock mBlock; + mutable bType mBlock; }; @@ -136,6 +137,7 @@ namespace MultiArrayTools typedef OperationTemplate > OT; typedef ContainerRange CRange; typedef typename CRange::IndexType IndexType; + typedef Block bType; ConstOperationRoot(const MultiArrayBase& ma, const std::shared_ptr&... indices); @@ -154,7 +156,7 @@ namespace MultiArrayTools MultiArrayBase const& mArrayRef; std::shared_ptr mIndex; IndexInfo mIInfo; - mutable Block mBlock; + mutable bType mBlock; }; template @@ -168,7 +170,8 @@ namespace MultiArrayTools typedef OperationTemplate > OT; typedef ContainerRange CRange; typedef typename CRange::IndexType IndexType; - + typedef MBlock bType; + OperationRoot(MutableMultiArrayBase& ma, const std::shared_ptr&... indices); @@ -179,8 +182,6 @@ namespace MultiArrayTools MBlock& get(); OperationRoot& set(const IndexInfo* blockIndex); - OperationRoot& set(std::shared_ptr blockIndex); - std::vector block(const IndexInfo* blockIndex, bool init = false) const; const OperationRoot& block() const; @@ -193,8 +194,7 @@ namespace MultiArrayTools MutableMultiArrayBase& mArrayRef; std::shared_ptr mIndex; IndexInfo mIInfo; - mutable MBlock mBlock; - std::shared_ptr mBlockIndex; // predefine to save time + mutable bType mBlock; const IndexInfo* mBlockII; // predefine to save time }; @@ -208,6 +208,7 @@ namespace MultiArrayTools typedef OperationBase OB; typedef OperationTemplate > OT; typedef OpFunction F; + typedef BlockResult bType; Operation(const Ops&... ops); @@ -218,7 +219,7 @@ namespace MultiArrayTools protected: std::tuple mOps; - mutable BlockResult mRes; + mutable bType mRes; }; template @@ -228,6 +229,7 @@ namespace MultiArrayTools typedef T value_type; typedef OperationTemplate > OT; + typedef BlockResult bType; Contraction(const Op& op, std::shared_ptr ind); @@ -240,7 +242,8 @@ namespace MultiArrayTools const Op& mOp; std::shared_ptr mInd; - mutable BlockResult mRes; + //mutable BlockArray mInBlock; + mutable bType mRes; }; } @@ -499,7 +502,7 @@ namespace MultiArrayTools const std::shared_ptr&... indices) : //OperationTemplate >(this), mArrayRef(ma), mIndex( mkIndex( ma, indices... ) ), mIInfo(*mIndex), - mBlockIndex(nullptr), mBlockII(nullptr) + mBlockII(nullptr) {} template @@ -539,14 +542,6 @@ namespace MultiArrayTools return mBlock; } - template - OperationRoot& - OperationRoot::set(std::shared_ptr blockIndex) - { - mBlockIndex = blockIndex; - return *this; - } - template OperationRoot& OperationRoot::set(const IndexInfo* blockIndex)