// **********************************************************************
// @@@ 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 @@@
// **********************************************************************

// SwapSpace.h
//
// SwapSpace swaps data buffers to/from temporary storage.  It shares
// buffer management with its clients and encapsulates
// ScratchSpace::writeThru/readThru details.
//
#ifndef SWAPSPACE_H
#define SWAPSPACE_H

#include <limits.h>

#include <NABasicObject.h>
#include <SortError.h>
#include "Const.h"
#include "ExOverflow.h"
#include "Allocator.h"
#include "CommonStructs.h"

class ScratchSpace;
class ExSubtask;
class ExExeStmtGlobals;

namespace ExOverflow
{
  class SwapSpace : public NABasicObject
  {
    public:
      SwapSpace(Allocator& memory, const ExExeStmtGlobals* stmtGlobals,
                UInt16 scratchThresholdPct);
      ~SwapSpace(void);

      // Poll pending I/O operation
      IoStatus checkIO(bool* readCompleted = NULL);

      // Discard all data
      void discard(bool allDone);

      // Is SwapSpace empty?
      bool empty(void) const;

      // Fetch the next buffer.
      IoStatus fetchNextBuffer(void);

      // Return the last OS error or file system error
      Int16 getLastError(void);

      // Return the SQLCODE associated with the last error
      Int16 getLastSqlCode(void);

      // Get a pointer to the read buffer
      char* getReadBuffer(void) const;

      // True => read buffer is the first active buffer.
      bool haveFirstBuffer(void) const;

      // Is a SwapSpace I/O operation pending?
      bool isIoPending(void);

      // Promote the first buffer out of SwapSpace
      char* promoteBuffer(void);

      // Reposition read buffer offset to first active buffer
      IoStatus rewind(void);

      // Set NSK-only ScratchFileConnection I/O event handler
      void setIoEventHandler(ExSubtask* ioEventHandler);

      // Swap buffer out to temporary storage.
      IoStatus swapOut(char* buffer);

      void setScratchOverflowMode(ScratchOverflowMode ovMode)
          { ovMode_ = ovMode;}
      ScratchOverflowMode getScratchOverflowMode(void)
          { return ovMode_;}

    private:

      SwapSpace(void);                             // unimplemented
      SwapSpace(const SwapSpace& src);             // unimplemented
      SwapSpace& operator=(const SwapSpace& rhs);  // unimplemented

      enum  IoPending { NONE, READ, WRITE };

      // Poll to check whether a pending I/O operation has completed
      IoStatus checkIOPending(bool* readCompleted = NULL);

      // Read data from temporary storage into read buffer
      IoStatus fetch(void);

      // Initialize SwapSpace storage.
      void init(void);

      // Map ScratchSpace status to IoStatus
      IoStatus mapStatus(RESULT scratchStatus) const;

      // Reset SwapSpace state.  Close store_ files if closeFiles is true;
      // otherwise truncate the store_ files.
      void reset(bool allDone = false);

      bool atEOF_;                // No more swap buffers to read?
      ExSubtask* ioEventHandler_; // NSK-only I/O event handler task
      IoPending ioPending_;       // pending I/O state
      Allocator& memory_;         // memory allocator (not owned by this class)
      UInt32 numSwap_;            // number of swapped-out buffers in store_
      char* readBuffer_;          // swapped in data buffer
      bool readingFirstBuffer_;   // readBuffer_ is first active buffer?
      UInt16 scratchThresholdPct_;    // store_ attribute
      SortError sortError_;       // last store_ error
      const ExExeStmtGlobals* stmtGlobals_;    // for store_ attributes
      ScratchSpace* store_;       // temporary storage for swapped-out buffers
      ByteCount swapBufferSize_;  // swap buffer size in bytes
      char* swapOutBuffer_;       // swap out (pending write) buffer
      SpaceOffset swapEnd_;       // store_ offset for swapOutBuffer_
      SpaceOffset swapRead_;      // store_ offset for readBuffer_
      SpaceOffset swapStart_;     // store_ offset of first swapped-out buffer
      ScratchOverflowMode ovMode_; //overflow mode, SSD, HDD or HYBRID
  };

  inline
  bool
  SwapSpace::isIoPending(void)
  {
    return (ioPending_ != NONE);
  }

  // Test ioPending_ in-line so that the ioPending_ == NONE case is efficient
  inline
  IoStatus 
  SwapSpace::checkIO(bool* readCompleted)
  {
    if (readCompleted)
    {
      *readCompleted = false;
    }
    return (ioPending_ == NONE) ? OK : checkIOPending(readCompleted);
  }

  inline
  bool
  SwapSpace::empty(void) const
  {
    return ((numSwap_ == 0) && (ioPending_ == NONE));
  }

  inline
  char* 
  SwapSpace::getReadBuffer(void) const
  {
    return atEOF_ ? NULL : readBuffer_;
  }

  inline
  bool
  SwapSpace::haveFirstBuffer(void) const
  {
    return readingFirstBuffer_;
#if 0
    return ((numSwap_ > 0) && (swapRead_ == swapStart_)
            && (swapStart_ != swapEnd_));
#endif
  }
}

#endif