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
