/**********************************************************************
// @@@ 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_MAPTABLE_H
#define GEN_MAPTABLE_H

/* -*-C++-*-
 *****************************************************************************
 *
 * File:         GenMaptable.h
 * Description:  The map table. Used to keep track of value ids and
 *               their address where this value will be found at runtime.
 *               
 *               
 * Created:      4/15/95
 * Language:     C++
 *
 *
 *
 *
 *****************************************************************************
 */

#include "AllItemExpr.h"
#include "ItemExprList.h"
#include "exp_attrs.h"

/////////////////////////////////////////////////////////////////
// class MapInfo
//   Contains information about a value id, its type attributes
//   and its buffer attributes. 
//   
//   Type attributes for a value id contain datatype, length
//   etc. See exp_attrs.h for detail on type attributes.
//
//   Buffer attributes for a value id define where that
//   value will be available at runtime. See Executor Internal
//   spec and/or files ex_queue.h and sql_tupp.h in executor
//   directory.
/////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////
// Important note :
// The design of MapInfo and MapTable cannot
// be declared as a stack variables. They will always be created
// from the dynamic memory ( i.e. new ). So the CollHeap* in
// NABasicObject can be used for furthur memory allocation.
//
/////////////////////////////////////////////////////////////////


class MapInfo // : public NABasicObject
{
  ValueId value_id;
  Attributes * attr_; // contains type and buffer attributes.
  ULng32 flags;

  enum {CODE_GENERATED = 0x0001, MARKED = 0x0002};

public:
  // MapInfo(const ValueId & value_id_, Attributes * attr);

  MapInfo() 
  {
    init();
  }

  void init()
  {
    flags = 0;

#ifdef _DEBUG
    // Initialize the attribute pointer to repeating sequence of 1011.
    // Make it eye-catching and if we ever try dereferencing
    // an odd pointer, it'll crash.
    attr_ = (Attributes *) 0xBBBBBBBB;
#endif
  }

  // ~MapInfo() {}
  
  inline ValueId getValueId(){return value_id;};
  
  inline Attributes * getAttr(){return attr_;};

  // returns 1, if code has been generated for this value id.
  inline ULng32 isCodeGenerated()
  {
    return flags & CODE_GENERATED;
  }

  // remembers that code has been generated.
  inline void codeGenerated(){flags |= CODE_GENERATED;};
  inline void resetCodeGenerated() { flags &= ~CODE_GENERATED; };

  inline void setMark(){flags |= MARKED;};
  inline void clearMark(){flags &= ~MARKED;};
  inline ULng32 marked() { return flags & MARKED; };

  short isOffsetAssigned();

  // Set the value id and attributes for this map info.
  void set( const ValueId & valueId, Attributes * attr, CollHeap * heap );

};


class MapInfoContainer
{
#define MICAsize 8  // Map Info Container Array size

public:
  MapInfoContainer(CollHeap * heap)
  {
    mapInfoArray_ = (MapInfo*)(new(heap) char[sizeof(MapInfo) * MICAsize]);
    for (Int32 i = 0; i < MICAsize; i++)
      {
	mapInfoArray_[i].init();
      }

    next_ = NULL;
  }

  MapInfoContainer * next_;
  MapInfo * mapInfoArray_;
};

/////////////////////////////////////////////////////////////////////
// class MapTable
//
// Any value id that is to be used in an expression is added to
// 'the map table' and is retrieved when code is being generated
// for the expression which uses that value id. With each value
// id, 'the map table' stores its type and buffer attributes (see,
// class MapInfo).
//
// 'the map table' is really a list of class MapTable's. To
// retrieve attributes of a value id, the list of map tables is
// searched until it is found. Attributes are retrieved by calling
// getMapInfo. An assertion is raised if it is not found.
//
// There are also times when we need to know if a value is available
// in a given map table. In this case, we don't want to raise an
// assertion. This could happen when values are being added to the
// map table. In this case, getMapInfoAsIs is called
//
// Value ids are normally added to the last map table in the list
// by calling addMapInfo. However, if it is to be added to a particular
// map table, then addMapInfoToThis should be called.
//
/////////////////////////////////////////////////////////////////////

class MapTable : public NABasicObject
{
  // ---------------------------------------------------------------------
  // The map table contains the following:
  // 1. an array of value id bitmaps
  // 2. an array of integers showing the number of value ids in each bitmap.
  // 3. an array of pointers to map info.
  // 4. a cache for the < value id, pointer to map info> tuple last accessed.
  // 5. some helpful counters
  //
  // The value id bitmap is shown as follows:
  //
  // value id:   0   1   2   3   4   5    ...    31
  //           -------------------------------------
  //           |   |   |   |   |   |   |  ...  |   |
  //           -------------------------------------
  //      bit:   0   1   2   3   4   5    ...    31
  //
  // Example:
  // Suppose we have the value ids { 57, 60, 61, 64, 91 } in this map table:
  //  value id bitmap array = < 0x0, 0x4c, 0x8000 0010, 0x0 >
  //          integer array = < 0,   3,    2,           0   >
  // map info pointer array = < 0x4def2380, 0x4def26f0, ... >
  // correspond to value id = < 57,         60,         ... >
  //                  cache = < 57, 0x4def2380 >
  //        total value ids = 5
  // ---------------------------------------------------------------------

private:
  friend class Generator;

  // ---------------------------------------------------------------------
  // The unit here is an unsigned integer (assume it is a 32-bit integer).
  // If we use a different unit, then change the defines below.
  // NOTE: Do NOT use a signed data type!
  // For explanation, see the comments in getIndexIntoMapInfoPtrArray()
  // function.
  // ---------------------------------------------------------------------
  typedef UInt32 MTBitmapUnit;  // prefix MT stands for map table
  #define bitsPerUnit	      32
  #define bitsPerUnitMinus1   31

  // ---------------------------------------------------------------------
  // Bitmap for value ids in the map table.
  // ---------------------------------------------------------------------
  #define initMTBAsize 8              // initial map table bitmap array size
  Int32            vidBitMapArraySize_; // size of value id bitmap array
  MTBitmapUnit * vidBitMapArray_;     // array of value id bitmaps
  short        * vidsInBitMapArray_;  // array of number of value ids in bitmap
  Int32            totalVids_;          // total number of value ids in map table
                                      // it is the sum of vidsInBitMapArray_

  // ---------------------------------------------------------------------
  // Map infos in the map table.
  // ---------------------------------------------------------------------
  #define initMTMIPAsize 8            // initial map table map info array size
  #define mapInfoPtrArrayStepSize 8   // increase the map info array size by 8
  Int32        mapInfoPtrArraySize_;    // size of map info array ptr
  MapInfo ** mapInfoPtrArray_;        // array of map infos ptrs

  // ---------------------------------------------------------------------
  // List of MapInfoContainer's
  // ---------------------------------------------------------------------
  MapInfoContainer * firstMapInfoContainer_;
  MapInfoContainer * lastMapInfoContainer_;

  // ---------------------------------------------------------------------
  // Next map table.
  // ---------------------------------------------------------------------
  MapTable * next_;

  // ---------------------------------------------------------------------
  // Previous map table.
  // ---------------------------------------------------------------------
  MapTable * prev_;
  
  // ---------------------------------------------------------------------
  // getBits()
  //
  // Get the bits that we are interested in.
  // ---------------------------------------------------------------------
  inline MTBitmapUnit getBits( const CollIndex valueId, const Int32 whichMap );

  // ---------------------------------------------------------------------
  // getIndexIntoMapInfoPtrArray()
  //
  // Get the index into the map info array.
  // Inputs: whichMap -- the bitmap the value id is in
  //         inBits   -- the relevant bits that we're interested in
  // ---------------------------------------------------------------------
  Int32 getIndexIntoMapInfoPtrArray( const Int32    whichMap, 
                                          MTBitmapUnit inBits    ) const;

public:


  void setAllAtp(short Atp);
  void resetCodeGen();

  void shiftAtpIndex(short shiftIndex);

#ifdef _DEBUG
  // for debugging
  void print();
  void printToFile(FILE *f = stdout);
#endif

protected:
  // ---------------------------------------------------------------------
  // Constructor.
  // ---------------------------------------------------------------------
  MapTable() :
       vidBitMapArraySize_(0)
    , totalVids_( 0 )
    , mapInfoPtrArraySize_(0)
    , next_( NULL )
    , prev_( NULL )
    , firstMapInfoContainer_(0)
    , lastMapInfoContainer_(0)
  {
  }
  
  // ---------------------------------------------------------------------
  // Destructor.
  // ---------------------------------------------------------------------
  ~MapTable() 
  {
    if (vidBitMapArraySize_ > 0)
      NADELETEBASIC(vidBitMapArray_, collHeap());
    if (mapInfoPtrArraySize_ > 0)
      NADELETEBASIC(mapInfoPtrArray_, collHeap());
    
    MapInfoContainer * curr = firstMapInfoContainer_;
    while (curr)
      {
	MapInfoContainer * next = curr->next_;
	NADELETEBASIC(curr->mapInfoArray_, collHeap());
	NADELETEBASIC(curr, collHeap());
	curr = next;
      }
  }

  // adds to 'this' map table
  MapInfo * addMapInfoToThis(const ValueId &value_id,
			     Attributes * attr);
  
  // searches for value_id in the list of map tables
  // starting at 'this'. Returns MapInfo, if found.
  // Raises assertion, if not found.
  MapInfo * getMapInfoFromThis(const ValueId & value_id);

  MapTable* &next() {return next_;};
  MapTable* &prev() {return prev_;};

  Int32 getTotalVids() { return totalVids_;};
};


// ---------------------------------------------------------------------
// getBits()
//
// Get the bits that we are interested in.
// ---------------------------------------------------------------------

MapTable::MTBitmapUnit MapTable::getBits( const CollIndex valueId, const Int32 whichMap )
{
  // Get the bitmap and right shift away the bits that we don't care about.
  
#ifdef _DEBUG
  
  MTBitmapUnit bitmap = *(vidBitMapArray_ + whichMap);
  MTBitmapUnit bits   = bitmap >> (bitsPerUnitMinus1 - (valueId % bitsPerUnit));
  return bits;
  
#else
  
  return ( *(vidBitMapArray_ + whichMap) 
           >> (bitsPerUnitMinus1 - (valueId % bitsPerUnit))
	   );
  
#endif
}

#endif /* GEN_MAPTABLE_H */