Markos Zaharioudakis has proposed merging lp:~zorba-coders/zorba/no-batching into lp:zorba.
Commit message: Removed the Batcher class from the runtime (saves 10% off the size of the zorba library) Requested reviews: Markos Zaharioudakis (markos-za) For more details, see: https://code.launchpad.net/~zorba-coders/zorba/no-batching/+merge/166118 Removed the Batcher class from the runtime (saves 10% off the size of the zorba library) -- https://code.launchpad.net/~zorba-coders/zorba/no-batching/+merge/166118 Your team Zorba Coders is subscribed to branch lp:zorba.
=== modified file 'include/zorba/config.h.cmake' --- include/zorba/config.h.cmake 2013-02-07 17:24:36 +0000 +++ include/zorba/config.h.cmake 2013-05-28 18:20:34 +0000 @@ -194,8 +194,6 @@ #cmakedefine ZORBA_DEBUG_STRING // Zorba runtime configuration parameters -#define ZORBA_BATCHING_TYPE ${ZORBA_BATCHING_TYPE} -#define ZORBA_BATCHING_BATCHSIZE ${ZORBA_BATCHING_BATCHSIZE} #define ZORBA_FLOAT_POINT_PRECISION ${ZORBA_FLOAT_POINT_PRECISION} // Zorba threading mechanism === modified file 'src/runtime/base/binarybase.h' --- src/runtime/base/binarybase.h 2013-02-07 17:24:36 +0000 +++ src/runtime/base/binarybase.h 2013-05-28 18:20:34 +0000 @@ -31,7 +31,7 @@ data members. ********************************************************************************/ template <class IterType, class StateType> -class BinaryBaseIterator : public Batcher<IterType> +class BinaryBaseIterator : public PlanIterator { protected: PlanIter_t theChild0; @@ -39,10 +39,10 @@ public: SERIALIZABLE_ABSTRACT_CLASS(BinaryBaseIterator) - SERIALIZABLE_CLASS_CONSTRUCTOR2(BinaryBaseIterator, Batcher<IterType>) + SERIALIZABLE_CLASS_CONSTRUCTOR2(BinaryBaseIterator, PlanIterator) void serialize(::zorba::serialization::Archiver& ar) { - serialize_baseclass(ar, (Batcher<IterType>*)this); + serialize_baseclass(ar, (PlanIterator*)this); ar & theChild0; ar & theChild1; } @@ -54,7 +54,7 @@ PlanIter_t& child0, PlanIter_t& child1) : - Batcher<IterType>(sctx, loc), + PlanIterator(sctx, loc), theChild0(child0), theChild1(child1) { === modified file 'src/runtime/base/narybase.h' --- src/runtime/base/narybase.h 2013-02-07 17:24:36 +0000 +++ src/runtime/base/narybase.h 2013-05-28 18:20:34 +0000 @@ -34,17 +34,17 @@ data members. ********************************************************************************/ template <class IterType, class StateType> -class NaryBaseIterator : public Batcher<IterType> +class NaryBaseIterator : public PlanIterator { protected: std::vector<PlanIter_t> theChildren; public: SERIALIZABLE_ABSTRACT_CLASS(NaryBaseIterator) - SERIALIZABLE_CLASS_CONSTRUCTOR2(NaryBaseIterator, Batcher<IterType>) + SERIALIZABLE_CLASS_CONSTRUCTOR2(NaryBaseIterator, PlanIterator) void serialize(::zorba::serialization::Archiver& ar) { - serialize_baseclass(ar, (Batcher<IterType>*)this); + serialize_baseclass(ar, (PlanIterator*)this); ar & theChildren; } @@ -80,18 +80,17 @@ NaryBaseIterator<IterType, StateType>::NaryBaseIterator( static_context* sctx, const QueryLoc& loc, - std::vector<PlanIter_t>& aChildren) + std::vector<PlanIter_t>& children) : - Batcher<IterType>(sctx, loc), - theChildren(aChildren) + PlanIterator(sctx, loc), + theChildren(children) { #ifndef NDEBUG - std::vector<PlanIter_t>::const_iterator lEnd = aChildren.end(); - for(std::vector<PlanIter_t>::const_iterator lIter = aChildren.begin(); - lIter != lEnd; - ++lIter) + std::vector<PlanIter_t>::const_iterator end = children.end(); + std::vector<PlanIter_t>::const_iterator ite = children.begin(); + for(; ite != end; ++ite) { - assert(*lIter != 0); + assert(*ite != 0); } #endif } @@ -114,11 +113,11 @@ { uint32_t size = 0; - std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin(); - std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end(); - for (; lIter != lEnd; ++lIter ) + std::vector<PlanIter_t>::const_iterator ite = theChildren.begin(); + std::vector<PlanIter_t>::const_iterator end = theChildren.end(); + for (; ite != end; ++ite) { - size += (*lIter)->getStateSizeOfSubtree(); + size += (*ite)->getStateSizeOfSubtree(); } return this->getStateSize() + size; @@ -126,47 +125,44 @@ template <class IterType, class StateType> -void -NaryBaseIterator<IterType, StateType>::openImpl( +void NaryBaseIterator<IterType, StateType>::openImpl( PlanState& planState, uint32_t& offset) { StateTraitsImpl<StateType>::createState(planState, this->theStateOffset, offset); StateTraitsImpl<StateType>::initState(planState, this->theStateOffset); - std::vector<PlanIter_t>::iterator lIter = theChildren.begin(); - std::vector<PlanIter_t>::iterator lEnd = theChildren.end(); - for ( ; lIter != lEnd; ++lIter ) + std::vector<PlanIter_t>::iterator ite = theChildren.begin(); + std::vector<PlanIter_t>::iterator end = theChildren.end(); + for (; ite != end; ++ite) { - (*lIter)->open(planState, offset); + (*ite)->open(planState, offset); } } template <class IterType, class StateType> -void -NaryBaseIterator<IterType, StateType>::resetImpl(PlanState& planState) const +void NaryBaseIterator<IterType, StateType>::resetImpl(PlanState& planState) const { StateTraitsImpl<StateType>::reset(planState, this->theStateOffset); - std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin(); - std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end(); - for ( ; lIter != lEnd; ++lIter ) + std::vector<PlanIter_t>::const_iterator ite = theChildren.begin(); + std::vector<PlanIter_t>::const_iterator end = theChildren.end(); + for (; ite != end; ++ite) { - (*lIter)->reset(planState); + (*ite)->reset(planState); } } template <class IterType, class StateType> -void -NaryBaseIterator<IterType, StateType>::closeImpl(PlanState& planState) +void NaryBaseIterator<IterType, StateType>::closeImpl(PlanState& planState) { - std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin(); - std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end(); - for ( ; lIter != lEnd; ++lIter ) + std::vector<PlanIter_t>::const_iterator ite = theChildren.begin(); + std::vector<PlanIter_t>::const_iterator end = theChildren.end(); + for (; ite != end; ++ite) { - (*lIter)->close(planState); + (*ite)->close(planState); } StateTraitsImpl<StateType>::destroyState(planState, this->theStateOffset); === modified file 'src/runtime/base/noarybase.h' --- src/runtime/base/noarybase.h 2013-02-07 17:24:36 +0000 +++ src/runtime/base/noarybase.h 2013-05-28 18:20:34 +0000 @@ -31,22 +31,22 @@ data members. ********************************************************************************/ template <class IterType, class StateType> -class NoaryBaseIterator : public Batcher<IterType> +class NoaryBaseIterator : public PlanIterator { public: SERIALIZABLE_TEMPLATE_ABSTRACT_CLASS(NoaryBaseIterator); - SERIALIZABLE_CLASS_CONSTRUCTOR2(NoaryBaseIterator, Batcher<IterType>); + SERIALIZABLE_CLASS_CONSTRUCTOR2(NoaryBaseIterator, PlanIterator); void serialize(::zorba::serialization::Archiver& ar) { - serialize_baseclass(ar, (Batcher<IterType>*)this); + serialize_baseclass(ar, (PlanIterator*)this); } public: NoaryBaseIterator(static_context* sctx, const QueryLoc& loc) : - Batcher<IterType>(sctx, loc) + PlanIterator(sctx, loc) { } === modified file 'src/runtime/base/plan_iterator.h' --- src/runtime/base/plan_iterator.h 2013-05-24 22:52:47 +0000 +++ src/runtime/base/plan_iterator.h 2013-05-28 18:20:34 +0000 @@ -32,11 +32,6 @@ #include "zorbaserialization/serialize_zorba_types.h" -#if ZORBA_BATCHING_TYPE == 1 -#include "store/api/item.h" -#endif - - // Info: Forcing inlining a function in g++: // store::Item_t next() __attribute__((always_inline)) {...} @@ -169,6 +164,7 @@ uint32_t theDuffsLine; public: +<<<<<<< TREE #if ZORBA_BATCHING_TYPE == 1 public: bool theIsDone; @@ -176,6 +172,8 @@ store::Item_t * theCurrItem; store::Item_t theBatch[ZORBA_BATCHING_BATCHSIZE]; #endif +======= +>>>>>>> MERGE-SOURCE #ifndef NDEBUG bool theIsOpened; #endif @@ -184,11 +182,14 @@ PlanIteratorState() : theDuffsLine(DUFFS_ALLOCATE_RESOURCES) +<<<<<<< TREE #if ZORBA_BATCHING_TYPE == 1 , theIsDone(false) , theEndItem(NULL) , theCurrItem(NULL) #endif +======= +>>>>>>> MERGE-SOURCE #ifndef NDEBUG , theIsOpened(false) #endif @@ -213,7 +214,14 @@ * Each subclass implementation of this method must call the init() method of * their parent class explicitly in order to guarantee proper initialization. */ +<<<<<<< TREE void init(PlanState& s) { reset(s); } +======= + void init(PlanState&) + { + theDuffsLine = DUFFS_ALLOCATE_RESOURCES; + } +>>>>>>> MERGE-SOURCE /** * Reset the current state object. @@ -230,11 +238,14 @@ void reset(PlanState&) { theDuffsLine = DUFFS_ALLOCATE_RESOURCES; +<<<<<<< TREE #if ZORBA_BATCHING_TYPE == 1 theIsDone = false; theEndItem = NULL; theCurrItem = NULL; #endif +======= +>>>>>>> MERGE-SOURCE } }; @@ -319,7 +330,17 @@ void serialize(::zorba::serialization::Archiver& ar); public: +<<<<<<< TREE PlanIterator(static_context* sctx, const QueryLoc& loc); +======= + PlanIterator(static_context* sctx, const QueryLoc& aLoc) + : + theStateOffset(0), + loc(aLoc), + theSctx(sctx) + { + } +>>>>>>> MERGE-SOURCE PlanIterator(const PlanIterator& it); @@ -359,7 +380,19 @@ * Begin the execution of the iterator. Initializes information required for * the plan state and constructs the state object. */ - virtual void open(PlanState& planState, uint32_t& offset) = 0; + void open(PlanState& planState, uint32_t& offset) + { + openImpl(planState, offset); +#ifndef NDEBUG + // do this after openImpl because the state is created there + PlanIteratorState* state = + StateTraitsImpl<PlanIteratorState>::getState(planState, theStateOffset); + ZORBA_ASSERT(!state->theIsOpened); // don't call open twice + state->theIsOpened = true; +#endif + } + + virtual void openImpl(PlanState& planState, uint32_t& offset) = 0; /** * Restarts the iterator so that the next 'produceNext' call will start @@ -367,7 +400,17 @@ * * @param planState */ - virtual void reset(PlanState& planState) const = 0; + void reset(PlanState& planState) const + { +#ifndef NDEBUG + PlanIteratorState* state = + StateTraitsImpl<PlanIteratorState>::getState(planState, theStateOffset); + ZORBA_ASSERT(state->theIsOpened); +#endif + resetImpl(planState); + } + + virtual void resetImpl(PlanState& planState) const = 0; /** * Finish the execution of the iterator. Releases all resources and destroys @@ -376,6 +419,7 @@ * * @param planState */ +<<<<<<< TREE virtual void close(PlanState& planState) = 0; /** @@ -410,7 +454,11 @@ store::Item_t& result, const PlanIterator* iter, PlanState& planState) +======= + void close(PlanState& planState) +>>>>>>> MERGE-SOURCE { +<<<<<<< TREE PlanIteratorState* state = StateTraitsImpl<PlanIteratorState>::getState(planState, iter->getStateOffset()); @@ -434,10 +482,19 @@ result.transfer(*state->theCurrItem); ++state->theCurrItem; return true; +======= +#ifndef NDEBUG + PlanIteratorState* state = + StateTraitsImpl<PlanIteratorState>::getState(planState, theStateOffset); + closeImpl(planState); + state->theIsOpened = false; +#else + closeImpl(planState); +#endif +>>>>>>> MERGE-SOURCE } - -#else // ZORBA_BATCHING_TYPE + virtual void closeImpl(PlanState& planState) = 0; /** * Produce the next item and return it to the caller. Implicitly, the first @@ -446,7 +503,17 @@ * * @param stateBLock */ - virtual bool produceNext(store::Item_t& handle, PlanState& planState) const = 0; + bool produceNext(store::Item_t& result, PlanState& planState) const + { +#ifndef NDEBUG + PlanIteratorState* state = + StateTraitsImpl<PlanIteratorState>::getState(planState, theStateOffset); + ZORBA_ASSERT(state->theIsOpened); +#endif + return nextImpl(result, planState); + } + + virtual bool nextImpl(store::Item_t& result, PlanState& planState) const = 0; /** * Static Method: Makes the given iterator produce its next result and returns @@ -472,6 +539,7 @@ return iter->produceNext(result, planState); } #endif +<<<<<<< TREE #endif // ZORBA_BATCHING_TYPE }; @@ -593,6 +661,8 @@ inline void resetImpl(PlanState& planState) const; inline void closeImpl(PlanState& planState); +======= +>>>>>>> MERGE-SOURCE }; #ifndef NDEBUG === modified file 'src/runtime/base/unarybase.h' --- src/runtime/base/unarybase.h 2013-02-07 17:24:36 +0000 +++ src/runtime/base/unarybase.h 2013-05-28 18:20:34 +0000 @@ -31,17 +31,17 @@ data members. ********************************************************************************/ template <class IterType, class StateType> -class UnaryBaseIterator : public Batcher<IterType> +class UnaryBaseIterator : public PlanIterator { protected: PlanIter_t theChild; public: SERIALIZABLE_ABSTRACT_CLASS(UnaryBaseIterator) - SERIALIZABLE_CLASS_CONSTRUCTOR2(UnaryBaseIterator, Batcher<IterType>) + SERIALIZABLE_CLASS_CONSTRUCTOR2(UnaryBaseIterator, PlanIterator) void serialize(::zorba::serialization::Archiver& ar) { - serialize_baseclass(ar, (Batcher<IterType>*)this); + serialize_baseclass(ar, (PlanIterator*)this); ar & theChild; } @@ -51,7 +51,7 @@ const QueryLoc& loc, const PlanIter_t& child) : - Batcher<IterType>(sctx, loc), + PlanIterator(sctx, loc), theChild(child) { #ifndef NDEBUG === modified file 'src/runtime/core/flwor_iterator.cpp' --- src/runtime/core/flwor_iterator.cpp 2013-03-15 08:22:41 +0000 +++ src/runtime/core/flwor_iterator.cpp 2013-05-28 18:20:34 +0000 @@ -881,7 +881,7 @@ MaterializeClause* materializeClause, PlanIter_t& aReturnClause) : - Batcher<FLWORIterator>(sctx, loc), + PlanIterator(sctx, loc), theForLetClauses(aForLetClauses), theNumBindings(aForLetClauses.size()), theWhereClause(aWhereClause), @@ -934,7 +934,7 @@ ********************************************************************************/ void FLWORIterator::serialize(::zorba::serialization::Archiver& ar) { - serialize_baseclass(ar, (Batcher<FLWORIterator>*)this); + serialize_baseclass(ar, (PlanIterator*)this); ar & theForLetClauses; theNumBindings = theForLetClauses.size(); ar & theWhereClause; //can be null === modified file 'src/runtime/core/flwor_iterator.h' --- src/runtime/core/flwor_iterator.h 2013-03-04 21:00:58 +0000 +++ src/runtime/core/flwor_iterator.h 2013-05-28 18:20:34 +0000 @@ -437,7 +437,7 @@ - Data Members: ********************************************************************************/ -class FLWORIterator : public Batcher<FLWORIterator> +class FLWORIterator : public PlanIterator { private: std::vector<ForLetClause> theForLetClauses; @@ -450,7 +450,7 @@ public: SERIALIZABLE_CLASS(FLWORIterator); - SERIALIZABLE_CLASS_CONSTRUCTOR2(FLWORIterator, Batcher<FLWORIterator>); + SERIALIZABLE_CLASS_CONSTRUCTOR2(FLWORIterator, PlanIterator); void serialize(::zorba::serialization::Archiver& ar); public: === modified file 'src/runtime/core/gflwor/groupby_iterator.cpp' --- src/runtime/core/gflwor/groupby_iterator.cpp 2013-02-07 17:24:36 +0000 +++ src/runtime/core/gflwor/groupby_iterator.cpp 2013-05-28 18:20:34 +0000 @@ -128,7 +128,7 @@ std::vector<GroupingSpec> aGroupingSpecs, std::vector<NonGroupingSpec> aNonGroupingSpecs) : - Batcher<GroupByIterator>(sctx, aLoc), + PlanIterator(sctx, aLoc), theTupleIter(aTupleIterator), theGroupingSpecs(aGroupingSpecs), theNonGroupingSpecs(aNonGroupingSpecs) @@ -149,7 +149,7 @@ ********************************************************************************/ void GroupByIterator::serialize(::zorba::serialization::Archiver& ar) { - serialize_baseclass(ar, (Batcher<GroupByIterator>*)this); + serialize_baseclass(ar, (PlanIterator*)this); ar & theTupleIter; ar & theGroupingSpecs; ar & theNonGroupingSpecs; === modified file 'src/runtime/core/gflwor/groupby_iterator.h' --- src/runtime/core/gflwor/groupby_iterator.h 2013-02-07 17:24:36 +0000 +++ src/runtime/core/gflwor/groupby_iterator.h 2013-05-28 18:20:34 +0000 @@ -61,7 +61,7 @@ /***************************************************************************//** ********************************************************************************/ -class GroupByIterator : public Batcher<GroupByIterator> +class GroupByIterator : public PlanIterator { private: PlanIter_t theTupleIter; @@ -70,7 +70,7 @@ public: SERIALIZABLE_CLASS(GroupByIterator) - SERIALIZABLE_CLASS_CONSTRUCTOR2(GroupByIterator, Batcher<GroupByIterator>) + SERIALIZABLE_CLASS_CONSTRUCTOR2(GroupByIterator, PlanIterator) void serialize(::zorba::serialization::Archiver& ar); public: === modified file 'src/runtime/core/gflwor/orderby_iterator.cpp' --- src/runtime/core/gflwor/orderby_iterator.cpp 2013-02-26 04:12:43 +0000 +++ src/runtime/core/gflwor/orderby_iterator.cpp 2013-05-28 18:20:34 +0000 @@ -189,7 +189,7 @@ std::vector<std::vector<PlanIter_t> >& outputForVarsRefs, std::vector<std::vector<PlanIter_t> >& outputLetVarsRefs) : - Batcher<OrderByIterator>(sctx, aLoc), + PlanIterator(sctx, aLoc), theStable(stable), theOrderSpecs(orderSpecs), theTupleIter(tupleIterator), @@ -208,7 +208,7 @@ void OrderByIterator::serialize(::zorba::serialization::Archiver& ar) { - serialize_baseclass(ar, (Batcher<OrderByIterator>*)this); + serialize_baseclass(ar, (PlanIterator*)this); ar & theStable; ar & theOrderSpecs; ar & theTupleIter; === modified file 'src/runtime/core/gflwor/orderby_iterator.h' --- src/runtime/core/gflwor/orderby_iterator.h 2013-02-26 04:12:43 +0000 +++ src/runtime/core/gflwor/orderby_iterator.h 2013-05-28 18:20:34 +0000 @@ -179,7 +179,7 @@ /******************************************************************************* ********************************************************************************/ -class OrderByIterator : public Batcher<OrderByIterator> +class OrderByIterator : public PlanIterator { private: bool theStable; @@ -194,7 +194,7 @@ public: SERIALIZABLE_CLASS(OrderByIterator) - SERIALIZABLE_CLASS_CONSTRUCTOR2(OrderByIterator, Batcher<OrderByIterator>) + SERIALIZABLE_CLASS_CONSTRUCTOR2(OrderByIterator, PlanIterator) void serialize(::zorba::serialization::Archiver& ar); public: === modified file 'src/runtime/core/gflwor/window_iterator.cpp' --- src/runtime/core/gflwor/window_iterator.cpp 2013-04-24 18:01:51 +0000 +++ src/runtime/core/gflwor/window_iterator.cpp 2013-05-28 18:20:34 +0000 @@ -620,7 +620,7 @@ bool lazyEval, ulong maxNeededHistory) : - Batcher<WindowIterator>(sctx, loc), + PlanIterator(sctx, loc), theWindowType(windowType), theTupleIter(tupleIter), theInputIter(domainIter), @@ -651,7 +651,7 @@ ********************************************************************************/ void WindowIterator::serialize(::zorba::serialization::Archiver& ar) { - serialize_baseclass(ar, (Batcher<WindowIterator>*)this); + serialize_baseclass(ar, (PlanIterator*)this); SERIALIZE_ENUM(WindowType, theWindowType); ar & theTupleIter; ar & theInputIter; === modified file 'src/runtime/core/gflwor/window_iterator.h' --- src/runtime/core/gflwor/window_iterator.h 2013-04-24 18:01:51 +0000 +++ src/runtime/core/gflwor/window_iterator.h 2013-05-28 18:20:34 +0000 @@ -312,7 +312,7 @@ buffer the domain sequence. theMaxNeededHistory : This is relevant only if a lazy temp sequence is used. ********************************************************************************/ -class WindowIterator : public Batcher<WindowIterator> +class WindowIterator : public PlanIterator { public: static const ulong MAX_HISTORY; @@ -344,9 +344,15 @@ WindowIterator(::zorba::serialization::Archiver& ar) : +<<<<<<< TREE Batcher<WindowIterator>(ar), theStartClause(ar) { } +======= + PlanIterator(ar), + theStartClause(ar) + {} +>>>>>>> MERGE-SOURCE void serialize(::zorba::serialization::Archiver& ar); === modified file 'src/runtime/core/item_iterator.cpp' --- src/runtime/core/item_iterator.cpp 2013-03-05 00:45:43 +0000 +++ src/runtime/core/item_iterator.cpp 2013-05-28 18:20:34 +0000 @@ -85,7 +85,7 @@ PlanIter_t& aElseIter, bool aIsBooleanIter) : - Batcher<IfThenElseIterator>(sctx, loc), + PlanIterator(sctx, loc), theCondIter(aCondIter), theThenIter(aThenIter), theElseIter(aElseIter), @@ -96,7 +96,7 @@ void IfThenElseIterator::serialize(::zorba::serialization::Archiver& ar) { - serialize_baseclass(ar, (Batcher<IfThenElseIterator>*)this); + serialize_baseclass(ar, (PlanIterator*)this); ar & theCondIter; ar & theThenIter; ar & theElseIter; @@ -165,7 +165,7 @@ } -void IfThenElseIterator::closeImpl(PlanState& planState) const +void IfThenElseIterator::closeImpl(PlanState& planState) { theCondIter->close(planState); theThenIter->close(planState); === modified file 'src/runtime/core/item_iterator.h' --- src/runtime/core/item_iterator.h 2013-03-05 00:45:43 +0000 +++ src/runtime/core/item_iterator.h 2013-05-28 18:20:34 +0000 @@ -82,17 +82,17 @@ }; -class IfThenElseIterator : public Batcher<IfThenElseIterator> +class IfThenElseIterator : public PlanIterator { private: PlanIter_t theCondIter; PlanIter_t theThenIter; PlanIter_t theElseIter; - bool theIsBooleanIter; + bool theIsBooleanIter; public: SERIALIZABLE_CLASS(IfThenElseIterator) - SERIALIZABLE_CLASS_CONSTRUCTOR2(IfThenElseIterator, Batcher<IfThenElseIterator>) + SERIALIZABLE_CLASS_CONSTRUCTOR2(IfThenElseIterator, PlanIterator) void serialize(::zorba::serialization::Archiver& ar); public: @@ -127,7 +127,7 @@ void resetImpl(PlanState& planState) const; - void closeImpl(PlanState& planState) const; + void closeImpl(PlanState& planState); }; === modified file 'src/runtime/update/update.cpp' --- src/runtime/update/update.cpp 2013-02-07 17:24:36 +0000 +++ src/runtime/update/update.cpp 2013-05-28 18:20:34 +0000 @@ -751,7 +751,7 @@ PlanIter_t aApplyIter, PlanIter_t aReturnIter) : - Batcher<TransformIterator>(sctx, aLoc), + PlanIterator(sctx, aLoc), theCopyClauses(aCopyClauses), theModifyIter(aModifyIter), thePulHolderIter(aPulHolderIter), @@ -768,7 +768,7 @@ void TransformIterator::serialize(::zorba::serialization::Archiver& ar) { - serialize_baseclass(ar, (Batcher<TransformIterator>*)this); + serialize_baseclass(ar, (PlanIterator*)this); ar & theCopyClauses; ar & theModifyIter; ar & thePulHolderIter; @@ -926,8 +926,7 @@ } -void -TransformIterator::resetImpl(PlanState& planState) const +void TransformIterator::resetImpl(PlanState& planState) const { StateTraitsImpl<PlanIteratorState>::reset(planState, theStateOffset); @@ -945,8 +944,7 @@ } -void -TransformIterator::closeImpl(PlanState& planState) const +void TransformIterator::closeImpl(PlanState& planState) { CopyClause::const_iter_t lIter = theCopyClauses.begin(); CopyClause::const_iter_t lEnd = theCopyClauses.end(); === modified file 'src/runtime/update/update.h' --- src/runtime/update/update.h 2013-02-07 17:24:36 +0000 +++ src/runtime/update/update.h 2013-05-28 18:20:34 +0000 @@ -175,7 +175,7 @@ }; -class TransformIterator : public Batcher<TransformIterator> +class TransformIterator : public PlanIterator { private: std::vector<CopyClause> theCopyClauses; @@ -186,7 +186,7 @@ public: SERIALIZABLE_CLASS(TransformIterator) - SERIALIZABLE_CLASS_CONSTRUCTOR2(TransformIterator, Batcher<TransformIterator>) + SERIALIZABLE_CLASS_CONSTRUCTOR2(TransformIterator, PlanIterator) void serialize(::zorba::serialization::Archiver& ar); public: @@ -213,7 +213,7 @@ void resetImpl(PlanState& planState) const; - void closeImpl(PlanState& planState) const; + void closeImpl(PlanState& planState); };
-- Mailing list: https://launchpad.net/~zorba-coders Post to : zorba-coders@lists.launchpad.net Unsubscribe : https://launchpad.net/~zorba-coders More help : https://help.launchpad.net/ListHelp