~zorba-coders/zorba/trunk

/*
 * Copyright 2006-2008 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.
 */
#pragma once
#ifndef ZORBA_RUNTIME_BOOLEAN
#define ZORBA_RUNTIME_BOOLEAN

#include "common/shared_types.h"

#include "types/typeconstants.h"
#include "types/typemanager.h"

#include "compiler/expression/expr_consts.h"

#include "runtime/base/unarybase.h"
#include "runtime/base/binarybase.h"
#include "runtime/base/narybase.h"

#include "system/globalenv.h"


namespace zorba
{

class RuntimeCB; // TODO we should have a shared_runtime_types.h
class GenericCast;


/*******************************************************************************
  15.1.1 fn:boolean
  fn:boolean($arg as item()*) as xs:boolean

  Computes the effective boolean value of the sequence $arg.
********************************************************************************/
class FnBooleanIterator : public UnaryBaseIterator<FnBooleanIterator, PlanIteratorState>
{
private:
  bool theNegate;

public:
  SERIALIZABLE_CLASS(FnBooleanIterator);
  SERIALIZABLE_CLASS_CONSTRUCTOR2T(
  FnBooleanIterator,
  UnaryBaseIterator<FnBooleanIterator, PlanIteratorState>);
  void serialize(::zorba::serialization::Archiver& ar);

public:
  FnBooleanIterator(
      static_context* sctx,
      const QueryLoc& loc,
      PlanIter_t& aIter,
      bool aNegate = false );

  void accept(PlanIterVisitor& v) const;

  zstring getNameAsString() const;

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

public:
  /**
   * Static function which computes the effective boolean value of a passed iterator.
   *
   * @param loc location of the iterator which invokes this function
   * @param planState
   * @param iterator
   * @param negate optinal parameter which negates the effective boolean value (default == false)
   * @return effective boolean value
   */
  static bool effectiveBooleanValue(
      const QueryLoc& loc,
      PlanState& planState,
      const PlanIterator* ,
      bool negate = false);
};


/*******************************************************************************

********************************************************************************/
class OrIterator : public NaryBaseIterator<OrIterator, PlanIteratorState>
{
public:
  SERIALIZABLE_CLASS(OrIterator);
  SERIALIZABLE_CLASS_CONSTRUCTOR2T(
  OrIterator,
  NaryBaseIterator<OrIterator, PlanIteratorState>);
  void serialize(::zorba::serialization::Archiver& ar);

public:
  OrIterator(
      static_context* sctx,
      const QueryLoc& loc,
      std::vector<PlanIter_t>& inChildren);

  void accept(PlanIterVisitor& v) const;

  zstring getNameAsString() const;

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


/*******************************************************************************

********************************************************************************/
class AndIterator : public NaryBaseIterator<AndIterator, PlanIteratorState>
{
public:
  SERIALIZABLE_CLASS(AndIterator);
  SERIALIZABLE_CLASS_CONSTRUCTOR2T(
  AndIterator,
  NaryBaseIterator<AndIterator, PlanIteratorState>);
  void serialize(::zorba::serialization::Archiver& ar);

public:
  AndIterator(
      static_context* sctx,
      const QueryLoc& loc,
      std::vector<PlanIter_t>& inChildren);

  void accept(PlanIterVisitor& v) const;

  zstring getNameAsString() const;

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


/*******************************************************************************
  Iterator for general and value comparisons
********************************************************************************/
class CompareIterator : public BinaryBaseIterator<CompareIterator, PlanIteratorState>
{
private:
  CompareConsts::CompareType  theCompType;
  bool                        theIsGeneralComparison;
  TypeManager               * theTypeManager;
  long                        theTimezone;
  XQPCollator               * theCollation;

public:
  SERIALIZABLE_CLASS(CompareIterator);
  CompareIterator(::zorba::serialization::Archiver& ar);
  void serialize(::zorba::serialization::Archiver& ar);

public:
  CompareIterator (
      static_context* sctx,
      const QueryLoc& loc,
      PlanIter_t theChild0,
      PlanIter_t theChild1,
      CompareConsts::CompareType aCompType);

  void accept(PlanIterVisitor& v) const;

  void openImpl(PlanState& planState, uint32_t& offset);

  zstring getNameAsString() const;

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

public:
  static bool valueComparison(
      const QueryLoc& loc,
      store::Item_t& aItem0,
      store::Item_t& aItem1,
      CompareConsts::CompareType aCompType,
      const TypeManager* typemgr,
      long timezone,
      XQPCollator* aCollation);

  static bool valueEqual(
      const QueryLoc& loc,
      store::Item_t& aItem0,
      store::Item_t& aItem1,
      const TypeManager* typemgr,
      long timezone,
      XQPCollator* aCollation,
      bool raiseError);

  static long valueCompare(
      const QueryLoc& loc,
      store::Item_t& aItem0,
      store::Item_t& aItem1,
      const TypeManager* typemgr,
      long timezone,
      XQPCollator* aCollation);

  static bool generalComparison(
      const QueryLoc& loc,
      store::Item_t& aItem0,
      store::Item_t& aItem_1,
      CompareConsts::CompareType aCompType,
      const TypeManager* typemgr,
      long timezone,
      XQPCollator*   aCollation);

  static bool generalEqual(
      const QueryLoc& loc,
      store::Item_t& aItem0,
      store::Item_t& aItem1,
      const TypeManager* typemgr,
      long timezone,
      XQPCollator* aCollation);

  static long generalCompare(
      const QueryLoc& loc,
      store::Item_t& aItem0,
      store::Item_t& aItem1,
      const TypeManager* typemgr,
      long timezone,
      XQPCollator* aCollation);

  static bool equal(
      const QueryLoc& loc,
      const store::Item_t& aItem0,
      const store::Item_t& aItem1,
      const TypeManager* typemgr,
      long timezone,
      XQPCollator* aCollation,
      bool raiseError);

  static long compare(
      const QueryLoc& loc,
      const store::Item_t& aItem0,
      const store::Item_t& aItem1,
      const TypeManager* typemgr,
      long timezone,
      XQPCollator* aCollation);

private:
  static bool valueCasting(
      const QueryLoc& loc,
      const TypeManager* typemgr,
      store::Item_t& aItem0,
      store::Item_t& aItem1,
      store::Item_t& castItem0,
      store::Item_t& castItem1,
      bool raiseError);

  static void generalCasting(
      const QueryLoc& loc,
      const TypeManager* typemgr,
      store::Item_t& aItem0,
      store::Item_t& aItem1,
      store::Item_t& castItem0,
      store::Item_t& castItem1);
};


/*******************************************************************************

********************************************************************************/
template <store::SchemaTypeCode ATC>
class TypedValueCompareIterator : public NaryBaseIterator<TypedValueCompareIterator<ATC>,
                                                          PlanIteratorState>
{
  CompareConsts::CompareType  theCompType;
  long                        theTimezone;
  XQPCollator               * theCollation;

public:
  SERIALIZABLE_TEMPLATE_CLASS(TypedValueCompareIterator);
  SERIALIZABLE_CLASS_CONSTRUCTOR2T(
  TypedValueCompareIterator,
  NaryBaseIterator<TypedValueCompareIterator<ATC>, PlanIteratorState>);
  void serialize(::zorba::serialization::Archiver& ar);

public:
  TypedValueCompareIterator(
        static_context* sctx,
        const QueryLoc& loc,
        std::vector<PlanIter_t>& children,
        CompareConsts::CompareType aCompType)
    :
    NaryBaseIterator<TypedValueCompareIterator<ATC>, PlanIteratorState>(sctx, loc, children),
    theCompType(aCompType),
    theTimezone(0),
    theCollation(NULL)
  {
  }

  ~TypedValueCompareIterator () {}

  void accept(PlanIterVisitor& v) const;

  void openImpl(PlanState& planState, uint32_t& offset);

  zstring getNameAsString() const;

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


/*******************************************************************************
  Atomic Values Equivalence Iterator

  http://www.w3.org/TR/xquery-11/#dt-equivalence-two-atomic-values
********************************************************************************/
class AtomicValuesEquivalenceIterator : 
public BinaryBaseIterator<AtomicValuesEquivalenceIterator, PlanIteratorState>
{
private:
  TypeManager               * theTypeManager;
  long                        theTimezone;
  XQPCollator               * theCollation;

public:
  SERIALIZABLE_CLASS(AtomicValuesEquivalenceIterator);
  AtomicValuesEquivalenceIterator(::zorba::serialization::Archiver& ar);
  void serialize(::zorba::serialization::Archiver& ar);

public:
  AtomicValuesEquivalenceIterator(
      static_context* sctx,
      const QueryLoc& loc,
      PlanIter_t theChild0,
      PlanIter_t theChild1);

  void accept(PlanIterVisitor& v) const;

  void openImpl(PlanState& planState, uint32_t& offset);

  zstring getNameAsString() const;

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

};

}

#endif

/*
 * Local variables:
 * mode: c++
 * End:
 */
/* vim:set et sw=2 ts=2: */