/**********************************************************************
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you 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.
//
// @@@ END COPYRIGHT @@@
**********************************************************************/
#ifndef GEN_FRAGMENT_DIR_H
#define GEN_FRAGMENT_DIR_H
/* -*-C++-*-
 *****************************************************************************
 *
 * File:         GenFragmentDir.h
 * Description:  Fragment directory for a generated statement. A fragment
 *               is a part of a plan executed in one process. Plans that use
 *               ESPs have multiple fragments. This file also defines
 *		 a directory describing the needed resources for each ESP.
 *               
 * Created:      12/4/95
 * Language:     C++
 *
 *
 *
 *
 *****************************************************************************
 */

// -----------------------------------------------------------------------

#include "Collections.h"

// -----------------------------------------------------------------------
// Contents of this file
// -----------------------------------------------------------------------
class FragmentDirEntry;
class FragmentDir;

// -----------------------------------------------------------------------
// forward references
// -----------------------------------------------------------------------
class PartitioningFunction;

// -----------------------------------------------------------------------
// Entry of a fragment directory, containing info on the generated
// fragment (offsets, lengths, ...). Note that this class itself (not
// a pointer to it) is used as a collection member in class FragmentDir.
// -----------------------------------------------------------------------
class FragmentDirEntry : public NABasicObject
{
  // class FragmentDir is the only class that can use this object, since
  // it has no public accessor functions (could have made this a local
  // struct but some C++ compilers have a problem with that)
  friend class FragmentDir;

public:
  // public default constructor needed in order to create arrays of entries
  FragmentDirEntry() ;

  // comparison operator to make collection template happy
  inline NABoolean operator == (const FragmentDirEntry &other) const
                                        { return space_ == other.space_; }

private:
  Int32                        type_;
  Space                      *space_;
  CollIndex                  parentIndex_;
  char                       *topNode_;
  Lng32                       numESPs_;
  const PartitioningFunction *partFunc_;
  Lng32                       partInputDataLength_;
  NABoolean                  needsTransaction_;
  // a flag used only during codegen.
  NABoolean                  containsPushedDownOperators_;
  unsigned short             numBMOs_;
  double                     BMOsMemoryUsage_;

  // level of esp layer relative to root node. First esp layer is 1.
  Lng32                       espLevel_;
  NABoolean                  soloFragment_;
};

// -----------------------------------------------------------------------
// A global array containing the information for all fragments of a
// plan.
// -----------------------------------------------------------------------
class FragmentDir : public NABasicObject
{
public:

  enum FragmentTypeEnum { MASTER = 1,
			  DP2    = 2,
			  ESP    = 3,
			  EXPLAIN = 4};

  // default constructor
  FragmentDir(CollHeap * Heap);

  // destructor deletes all space objects that were used
  ~FragmentDir();

  // how many entries does the directory have
  inline CollIndex entries() const          { return entries_->entries(); }

  // create a new fragment as child of the current one and return its id
  CollIndex pushFragment(
       FragmentTypeEnum           type,
       Lng32                       numESPs = 0,
       const PartitioningFunction *partFunc = NULL,
       Lng32                       partInputDataLength = 0);

  // leave a created fragment and return to its parent fragment
  // (must call setTopObj() before doing this), return parent fragment id
  CollIndex popFragment();

  // removes the last fragment from the fragment dir.
  void removeFragment();

  // The top level index maintenance nodes belong in the master/esp 
  // even though they are generated in update (dp2 fragment). Thus, 
  // we must be able to switch back to the parent fragment temporarily.
  // See GenRelUpdate.C for usage example...
  //
  CollIndex setCurrentId(CollIndex currentId) {
    CollIndex oldId = currentFragmentId_;
    currentFragmentId_= currentId;
    return(oldId);
  }

  // get the "Space" object for the current fragment or for any fragment
  inline Space *getCurrentSpace() const
                           { return (*entries_)[currentFragmentId_]->space_; }
  inline Space *getSpace(CollIndex ix) const {return (*entries_)[ix]->space_;}

  // set the pointer to the generated top object for the current fragment
  inline void setTopObj(char *obj)
                          { (*entries_)[currentFragmentId_]->topNode_ = obj; }
  // Warning: know what you are doing when using this, it's not always valid!
  // This method is put here based on the code change on R2 path, it is 
  // needed for gui executor display.
  inline char * getTopObj(CollIndex ix)  { return (*entries_)[ix]->topNode_; }

  // set the pointer to the generated top object for the current fragment
  inline void setTopObj(CollIndex fragIndex, char *obj)
                          { (*entries_)[fragIndex]->topNode_ = obj; }

  // get the type of a fragment
  inline FragmentTypeEnum getType(CollIndex ix) const
                         { return (FragmentTypeEnum) (*entries_)[ix]->type_; }

  // get the generated length for a given fragment (use this proc only
  // for obtaining fragment length, since it rounds up the length indicated
  // by the Space object to the nearest multiple of 8)
  Lng32 getFragmentLength(CollIndex ix) const;

  // get the parent id of a fragment
  inline CollIndex getParentId() const 
                     { return (*entries_)[currentFragmentId_]->parentIndex_; }
  inline CollIndex getParentId(CollIndex ix) const
                                     { return (*entries_)[ix]->parentIndex_; }

  // get the id of the current fragment
  inline CollIndex getCurrentId() const { return currentFragmentId_; }

  // get a pointer to the top node of a fragment
  inline char * getTopNode(CollIndex ix) const
                                         { return (*entries_)[ix]->topNode_; }

  inline Lng32 getNumESPs(CollIndex ix) const
                                         { return (*entries_)[ix]->numESPs_; }

  inline Lng32 getEspLevel(CollIndex ix) const
                                         { return (*entries_)[ix]->espLevel_; }
  inline void setEspLevel(CollIndex ix, Lng32 level)
  { (*entries_)[ix]->espLevel_ = level; }

  inline const PartitioningFunction *
  getPartitioningFunction(CollIndex ix) const
                                        { return (*entries_)[ix]->partFunc_; }

  inline Lng32 getPartInputDataLength(CollIndex ix) const
                             { return (*entries_)[ix]->partInputDataLength_; }
  inline void setPartInputDataLength(CollIndex ix, Lng32 l)
                                { (*entries_)[ix]->partInputDataLength_ = l; }

  inline NABoolean getNeedsTransaction(CollIndex ix) const
                                { return (*entries_)[ix]->needsTransaction_; }
  inline void setNeedsTransaction(CollIndex ix, NABoolean n = TRUE)
                                   { (*entries_)[ix]->needsTransaction_ = n; }

  inline NABoolean getContainsPushedDownOperators(CollIndex ix) const
                                { return (*entries_)[ix]->containsPushedDownOperators_; }
  inline void setContainsPushedDownOperators(CollIndex ix, NABoolean n = TRUE)
                                   { (*entries_)[ix]->containsPushedDownOperators_= n; }

  inline NABoolean getSoloFragment(CollIndex ix) const
                                { return (*entries_)[ix]->soloFragment_; }
  inline void setSoloFragment(CollIndex ix, NABoolean n = TRUE)
                                   { (*entries_)[ix]->soloFragment_ = n; }

  void setAllEspFragmentsNeedTransaction();

  // get the generated length of all fragments together
  Lng32 getTotalLength() const;

  inline void setNumBMOs(CollIndex ix, unsigned short num)
  { (*entries_)[ix]->numBMOs_ = num; }
  inline unsigned short getNumBMOs()
  { return (*entries_)[currentFragmentId_]->numBMOs_ ; }
  inline unsigned short getNumBMOs(CollIndex ix)
  { return (*entries_)[ix]->numBMOs_ ; }

  inline void setBMOsMemoryUsage(CollIndex ix, double memInMB)
  { (*entries_)[ix]->BMOsMemoryUsage_ = memInMB; }
  inline double getBMOsMemoryUsage()
  { return (*entries_)[currentFragmentId_]->BMOsMemoryUsage_; }
  inline double getBMOsMemoryUsage(CollIndex ix)
  { return (*entries_)[ix]->BMOsMemoryUsage_; }

  NABoolean containsESPLayer();

private:
  CollHeap * heap_;
  NAArray<FragmentDirEntry*> * entries_;
  CollIndex currentFragmentId_;
  NABoolean allEspFragmentsNeedTransaction_;
};

#endif /* GEN_FRAGMENT_DIR_H */