/*
 * Copyright 2006-2012 The FLWOR Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
// ******************************************
// *                                        *
// * THIS IS A GENERATED FILE. DO NOT EDIT! *
// * SEE .xml FILE WITH SAME NAME           *
// *                                        *
// ******************************************

#ifndef ZORBA_RUNTIME_NODES_NODE_POSITION_H
#define ZORBA_RUNTIME_NODES_NODE_POSITION_H


#include "common/shared_types.h"



#include "runtime/base/narybase.h"


namespace zorba {

/**
 * 
 * Author: Federico Cavalieri
 */
class NodePositionIterator : public NaryBaseIterator<NodePositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(NodePositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(NodePositionIterator,
    NaryBaseIterator<NodePositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  NodePositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<NodePositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~NodePositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class IsAncestorPositionIterator : public NaryBaseIterator<IsAncestorPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(IsAncestorPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsAncestorPositionIterator,
    NaryBaseIterator<IsAncestorPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  IsAncestorPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<IsAncestorPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~IsAncestorPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class IsFollowingSiblingPositionIterator : public NaryBaseIterator<IsFollowingSiblingPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(IsFollowingSiblingPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsFollowingSiblingPositionIterator,
    NaryBaseIterator<IsFollowingSiblingPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  IsFollowingSiblingPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<IsFollowingSiblingPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~IsFollowingSiblingPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class IsFollowingPositionIterator : public NaryBaseIterator<IsFollowingPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(IsFollowingPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsFollowingPositionIterator,
    NaryBaseIterator<IsFollowingPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  IsFollowingPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<IsFollowingPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~IsFollowingPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class IsInSubtreeOfPositionIterator : public NaryBaseIterator<IsInSubtreeOfPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(IsInSubtreeOfPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsInSubtreeOfPositionIterator,
    NaryBaseIterator<IsInSubtreeOfPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  IsInSubtreeOfPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<IsInSubtreeOfPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~IsInSubtreeOfPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class IsDescendantPositionIterator : public NaryBaseIterator<IsDescendantPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(IsDescendantPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsDescendantPositionIterator,
    NaryBaseIterator<IsDescendantPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  IsDescendantPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<IsDescendantPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~IsDescendantPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class IsPrecedingSiblingPositionIterator : public NaryBaseIterator<IsPrecedingSiblingPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(IsPrecedingSiblingPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsPrecedingSiblingPositionIterator,
    NaryBaseIterator<IsPrecedingSiblingPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  IsPrecedingSiblingPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<IsPrecedingSiblingPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~IsPrecedingSiblingPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class IsPrecedingPositionIterator : public NaryBaseIterator<IsPrecedingPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(IsPrecedingPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsPrecedingPositionIterator,
    NaryBaseIterator<IsPrecedingPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  IsPrecedingPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<IsPrecedingPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~IsPrecedingPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class IsChildPositionIterator : public NaryBaseIterator<IsChildPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(IsChildPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsChildPositionIterator,
    NaryBaseIterator<IsChildPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  IsChildPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<IsChildPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~IsChildPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class IsAttributeOfPositionIterator : public NaryBaseIterator<IsAttributeOfPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(IsAttributeOfPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsAttributeOfPositionIterator,
    NaryBaseIterator<IsAttributeOfPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  IsAttributeOfPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<IsAttributeOfPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~IsAttributeOfPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class IsParentPositionIterator : public NaryBaseIterator<IsParentPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(IsParentPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsParentPositionIterator,
    NaryBaseIterator<IsParentPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  IsParentPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<IsParentPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~IsParentPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class IsPrecedingInDocumentOrderPositionIterator : public NaryBaseIterator<IsPrecedingInDocumentOrderPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(IsPrecedingInDocumentOrderPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsPrecedingInDocumentOrderPositionIterator,
    NaryBaseIterator<IsPrecedingInDocumentOrderPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  IsPrecedingInDocumentOrderPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<IsPrecedingInDocumentOrderPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~IsPrecedingInDocumentOrderPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class IsFollowingInDocumentOrderPositionIterator : public NaryBaseIterator<IsFollowingInDocumentOrderPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(IsFollowingInDocumentOrderPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsFollowingInDocumentOrderPositionIterator,
    NaryBaseIterator<IsFollowingInDocumentOrderPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  IsFollowingInDocumentOrderPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<IsFollowingInDocumentOrderPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~IsFollowingInDocumentOrderPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class LevelPositionIterator : public NaryBaseIterator<LevelPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(LevelPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(LevelPositionIterator,
    NaryBaseIterator<LevelPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  LevelPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<LevelPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~LevelPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class IsAttributePositionIterator : public NaryBaseIterator<IsAttributePositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(IsAttributePositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsAttributePositionIterator,
    NaryBaseIterator<IsAttributePositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  IsAttributePositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<IsAttributePositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~IsAttributePositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class IsCommentPositionIterator : public NaryBaseIterator<IsCommentPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(IsCommentPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsCommentPositionIterator,
    NaryBaseIterator<IsCommentPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  IsCommentPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<IsCommentPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~IsCommentPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class IsDocumentPositionIterator : public NaryBaseIterator<IsDocumentPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(IsDocumentPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsDocumentPositionIterator,
    NaryBaseIterator<IsDocumentPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  IsDocumentPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<IsDocumentPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~IsDocumentPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class IsElementPositionIterator : public NaryBaseIterator<IsElementPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(IsElementPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsElementPositionIterator,
    NaryBaseIterator<IsElementPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  IsElementPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<IsElementPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~IsElementPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class IsProcessingInstructionPositionIterator : public NaryBaseIterator<IsProcessingInstructionPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(IsProcessingInstructionPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsProcessingInstructionPositionIterator,
    NaryBaseIterator<IsProcessingInstructionPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  IsProcessingInstructionPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<IsProcessingInstructionPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~IsProcessingInstructionPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class IsTextPositionIterator : public NaryBaseIterator<IsTextPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(IsTextPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsTextPositionIterator,
    NaryBaseIterator<IsTextPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  IsTextPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<IsTextPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~IsTextPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class IsSiblingPositionIterator : public NaryBaseIterator<IsSiblingPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(IsSiblingPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsSiblingPositionIterator,
    NaryBaseIterator<IsSiblingPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  IsSiblingPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<IsSiblingPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~IsSiblingPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class InSameTreePositionIterator : public NaryBaseIterator<InSameTreePositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(InSameTreePositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(InSameTreePositionIterator,
    NaryBaseIterator<InSameTreePositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  InSameTreePositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<InSameTreePositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~InSameTreePositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class InCollectionPositionIterator : public NaryBaseIterator<InCollectionPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(InCollectionPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(InCollectionPositionIterator,
    NaryBaseIterator<InCollectionPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  InCollectionPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<InCollectionPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~InCollectionPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


/**
 * 
 * Author: Federico Cavalieri
 */
class InSameCollectionPositionIterator : public NaryBaseIterator<InSameCollectionPositionIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(InSameCollectionPositionIterator);

  SERIALIZABLE_CLASS_CONSTRUCTOR2T(InSameCollectionPositionIterator,
    NaryBaseIterator<InSameCollectionPositionIterator, PlanIteratorState>);

  void serialize( ::zorba::serialization::Archiver& ar);

  InSameCollectionPositionIterator(
    static_context* sctx,
    const QueryLoc& loc,
    std::vector<PlanIter_t>& children)
    : 
    NaryBaseIterator<InSameCollectionPositionIterator, PlanIteratorState>(sctx, loc, children)
  {}

  virtual ~InSameCollectionPositionIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
};


}
#endif
/*
 * Local variables:
 * mode: c++
 * End:
 */ 
