/*
 * 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_DURATIONS_DATES_TIMES_DURATIONS_DATES_TIMES_H
#define ZORBA_RUNTIME_DURATIONS_DATES_TIMES_DURATIONS_DATES_TIMES_H


#include "common/shared_types.h"



#include "runtime/base/narybase.h"


namespace zorba {

/**
 * fn:years-from-duration
 * Author: Zorba Team
 */
class YearsFromDurationIterator : public NaryBaseIterator<YearsFromDurationIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(YearsFromDurationIterator);

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

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

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

  virtual ~YearsFromDurationIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:months-from-duration
 * Author: Zorba Team
 */
class MonthsFromDurationIterator : public NaryBaseIterator<MonthsFromDurationIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(MonthsFromDurationIterator);

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

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

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

  virtual ~MonthsFromDurationIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:days-from-duration
 * Author: Zorba Team
 */
class DaysFromDurationIterator : public NaryBaseIterator<DaysFromDurationIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(DaysFromDurationIterator);

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

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

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

  virtual ~DaysFromDurationIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:hours-from-duration
 * Author: Zorba Team
 */
class HoursFromDurationIterator : public NaryBaseIterator<HoursFromDurationIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(HoursFromDurationIterator);

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

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

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

  virtual ~HoursFromDurationIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:minutes-from-duration
 * Author: Zorba Team
 */
class MinutesFromDurationIterator : public NaryBaseIterator<MinutesFromDurationIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(MinutesFromDurationIterator);

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

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

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

  virtual ~MinutesFromDurationIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:seconds-from-duration
 * Author: Zorba Team
 */
class SecondsFromDurationIterator : public NaryBaseIterator<SecondsFromDurationIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(SecondsFromDurationIterator);

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

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

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

  virtual ~SecondsFromDurationIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:year-from-dateTime
 * Author: Zorba Team
 */
class YearFromDatetimeIterator : public NaryBaseIterator<YearFromDatetimeIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(YearFromDatetimeIterator);

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

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

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

  virtual ~YearFromDatetimeIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:month-from-dateTime
 * Author: Zorba Team
 */
class MonthFromDatetimeIterator : public NaryBaseIterator<MonthFromDatetimeIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(MonthFromDatetimeIterator);

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

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

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

  virtual ~MonthFromDatetimeIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:day-from-dateTime
 * Author: Zorba Team
 */
class DayFromDatetimeIterator : public NaryBaseIterator<DayFromDatetimeIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(DayFromDatetimeIterator);

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

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

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

  virtual ~DayFromDatetimeIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:hours-from-dateTime
 * Author: Zorba Team
 */
class HoursFromDatetimeIterator : public NaryBaseIterator<HoursFromDatetimeIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(HoursFromDatetimeIterator);

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

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

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

  virtual ~HoursFromDatetimeIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:minutes-from-dateTime
 * Author: Zorba Team
 */
class MinutesFromDatetimeIterator : public NaryBaseIterator<MinutesFromDatetimeIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(MinutesFromDatetimeIterator);

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

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

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

  virtual ~MinutesFromDatetimeIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:seconds-from-dateTime
 * Author: Zorba Team
 */
class SecondsFromDatetimeIterator : public NaryBaseIterator<SecondsFromDatetimeIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(SecondsFromDatetimeIterator);

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

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

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

  virtual ~SecondsFromDatetimeIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:timezone-from-dateTime
 * Author: Zorba Team
 */
class TimezoneFromDatetimeIterator : public NaryBaseIterator<TimezoneFromDatetimeIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(TimezoneFromDatetimeIterator);

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

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

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

  virtual ~TimezoneFromDatetimeIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:year-from-date
 * Author: Zorba Team
 */
class YearFromDateIterator : public NaryBaseIterator<YearFromDateIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(YearFromDateIterator);

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

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

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

  virtual ~YearFromDateIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:month-from-date
 * Author: Zorba Team
 */
class MonthFromDateIterator : public NaryBaseIterator<MonthFromDateIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(MonthFromDateIterator);

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

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

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

  virtual ~MonthFromDateIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:day-from-date
 * Author: Zorba Team
 */
class DayFromDateIterator : public NaryBaseIterator<DayFromDateIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(DayFromDateIterator);

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

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

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

  virtual ~DayFromDateIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:timezone-from-date
 * Author: Zorba Team
 */
class TimezoneFromDateIterator : public NaryBaseIterator<TimezoneFromDateIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(TimezoneFromDateIterator);

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

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

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

  virtual ~TimezoneFromDateIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:hours-from-time
 * Author: Zorba Team
 */
class HoursFromTimeIterator : public NaryBaseIterator<HoursFromTimeIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(HoursFromTimeIterator);

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

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

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

  virtual ~HoursFromTimeIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:minutes-from-time
 * Author: Zorba Team
 */
class MinutesFromTimeIterator : public NaryBaseIterator<MinutesFromTimeIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(MinutesFromTimeIterator);

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

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

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

  virtual ~MinutesFromTimeIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:seconds-from-time
 * Author: Zorba Team
 */
class SecondsFromTimeIterator : public NaryBaseIterator<SecondsFromTimeIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(SecondsFromTimeIterator);

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

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

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

  virtual ~SecondsFromTimeIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


/**
 * fn:timezone-from-time
 * Author: Zorba Team
 */
class TimezoneFromTimeIterator : public NaryBaseIterator<TimezoneFromTimeIterator, PlanIteratorState>
{ 
public:
  SERIALIZABLE_CLASS(TimezoneFromTimeIterator);

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

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

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

  virtual ~TimezoneFromTimeIterator();

  zstring getNameAsString() const;

  void accept(PlanIterVisitor& v) const;

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


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