/**********************************************************************
// @@@ 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 ELEMDDLPARTITIONSYSTEM_H
#define ELEMDDLPARTITIONSYSTEM_H
/* -*-C++-*-
 *****************************************************************************
 *
 * File:         ElemDDLPartitionSystem.h
 * Description:  class representing a system partition element
 *               specified in a DDL statement
 *
 *
 * Created:      4/6/95
 * Language:     C++
 *
 *
 *
 *
 *****************************************************************************
 */


#include "NAString.h"
#include "ElemDDLNode.h"
#include "ElemDDLFileAttrMaxSize.h"
#include "ElemDDLFileAttrExtents.h"
#include "ElemDDLFileAttrMaxExtents.h"
#include "ElemDDLLocation.h"
#include "ElemDDLPartition.h"
#include "ItemConstValueArray.h"

// -----------------------------------------------------------------------
// contents of this file
// -----------------------------------------------------------------------
class ElemDDLPartitionSystem;

// -----------------------------------------------------------------------
// forward references
// -----------------------------------------------------------------------
class BindWA;

// -----------------------------------------------------------------------
// definition of class ElemDDLPartitionSystem
// -----------------------------------------------------------------------
class ElemDDLPartitionSystem : public ElemDDLPartition
{

public:

  // constructors
  ElemDDLPartitionSystem();
  ElemDDLPartitionSystem(ElemDDLPartition::optionEnum,
                         ElemDDLNode * pLocation,
                         ElemDDLNode * pPartitionSystemAttrList);
  ElemDDLPartitionSystem(OperatorTypeEnum operType,
                         ElemDDLPartition::optionEnum,
                         ElemDDLNode * pLocation,
                         ElemDDLNode * pPartitionSystemAttrList);

  // virtual destructor
  virtual ~ElemDDLPartitionSystem();

  // cast
  virtual ElemDDLPartitionSystem * castToElemDDLPartitionSystem();

  //
  // accessors
  //

  virtual Int32 getArity() const;
  virtual ExprNode * getChild(Lng32 index);

  inline const NAString & getGuardianLocation() const;

        // returns an empty string unless the parse node
        // is bound (the method bindNode is invoked).
        // After the parse node is bound, returns the
        // location of the primary partition in Guardian
        // physical device name format.  If the LOCATION
        // clause is not specified, a default location is
        // used.

  inline const NAString & getLocation() const;

        // returns the location name specified in the LOCATION
        // clause/phrase associating with the primary or
        // secondary partition; returns an empty string if the
        // LOCATION clause associating with the primary partition
        // does not appear.
  
  inline const NAString & getLocationName() const;

        // same as getLocation()

  inline const NAString & getPartitionName() const;

        // returns the partition name specified in the LOCATION clause.
        // returns an empty string if the LOCATION clause is not specified.

  inline ElemDDLLocation::locationNameTypeEnum getLocationNameType() const;

        // returns the type of the location name (e.g., an OSS
        // path name, a Guardian device name, an OSS environment
        // variable name, etc.)  If LOCATION clause does not
        // appear, the returned value has no meaning.

  inline ElemDDLNode * getLocationNode() const;

        // returns the pointer pointing to the parse node
        // representing the specified LOCATION clause. If the
        // LOCATION clause does not appear, returns NULL.

  inline ULng32 getMaxSize() const;
  inline ComUnits      getMaxSizeUnit() const;
  inline ULng32 getPriExt() const;
  inline ULng32 getSecExt() const;
  inline ULng32 getMaxExt() const;

  inline ElemDDLPartition::optionEnum getOption() const;

        // returns either ElemDDLPartition::ADD_OPTION or
        // ElemDDLPartition::DROP_OPTION depending on whether
        // ADD or DROP is specified.

  NAString getOptionAsNAString() const;

        // Same as getOption() except that this method returns
        // NAString("ADD") or NAString("DROP").

  inline NABoolean isMaxSizeSpecified() const;
  inline NABoolean isMaxSizeUnbounded() const;
  inline NABoolean isExtentSpecified() const;
  inline NABoolean isMaxExtentSpecified() const;

  //
  // mutators
  //

  virtual void setChild(Lng32 index, ExprNode * pChildNode);
  inline void setIsMaxSizeSpecified(NABoolean isMaxSizeSpecified);
  inline void setIsMaxSizeUnbounded(NABoolean isMaxSizeUnbounded);
  inline void setIsExtentSpecified(NABoolean isExtentSpecified);
  inline void setIsMaxExtentSpecified(NABoolean isMaxExtentSpecified);
  inline void setLocationName(const NAString &locationName);
  inline void setPartitionName(const NAString &partitionName);
  inline void setLocationNameType(ElemDDLLocation::locationNameTypeEnum
                                  locationNameType);
  inline void setMaxSize(ULng32 maxSize);
  inline void setMaxSizeUnit(ComUnits maxSizeUnit);
  inline void setPriExt(ULng32 priExt);
  inline void setSecExt(ULng32 secExt);
  inline void setMaxExt(ULng32 maxExt);

  //
  // method for binding
  //

  virtual ExprNode * bindNode(BindWA * pBindWA);

  //
  // methods for tracing
  //

  virtual const NAString displayLabel1() const;
  virtual const NAString displayLabel2() const;
  virtual const NAString displayLabel3() const;
  virtual NATraceList getDetailInfo() const;
  virtual const NAString getText() const;

  // method for building text
  virtual NAString getSyntax() const;


protected:

  //
  // pointer to child parse nodes
  //

  enum { INDEX_LOCATION = 0,
         INDEX_PARTITION_ATTR_LIST,
         MAX_ELEM_DDL_PARTITION_SYSTEM_ARITY };

  ElemDDLNode * children_[MAX_ELEM_DDL_PARTITION_SYSTEM_ARITY];


private:

  // ---------------------------------------------------------------------
  // private methods
  // ---------------------------------------------------------------------

  // accessor
  inline ElemDDLNode * getPartitionSystemAttrList() const;

  // mutators
  void initializeDataMembers();
  void setPartitionAttr(ElemDDLNode * pOptionNode);

  // ---------------------------------------------------------------------
  // private data members
  // ---------------------------------------------------------------------

  ElemDDLPartition::optionEnum option_;

  //
  // location
  //

  NAString locationName_;
  ElemDDLLocation::locationNameTypeEnum locationNameType_;

  // guardianLocation_ is empty until the parse node is
  // bound (the method bindNode() is invoked).  The method
  // bindNode() converts the specified location to a
  // Guardian physical device and then saves the computed
  // name in this data member.  If the LOCATION clause does
  // not appear, a default location name is selected.
  NAString guardianLocation_;

  NAString partitionName_;

  //
  // file attributes
  //

  // The flags is...Spec_ shows whether the corresponding partitionSystem
  // attributes were specified in the PARTITIONSYSTEM clause or not.  They
  // are used by the parser to look for duplicate clauses.

  // MAXSIZE
  NABoolean isMaxSizeSpec_;
  NABoolean isMaxSizeUnbounded_;
  ULng32 maxSize_;
  ComUnits maxSizeUnit_;

  // EXTENT
  NABoolean isExtentSpec_;
  ULng32 priExt_;
  ULng32 secExt_;

  // MAXEXTENT
  NABoolean isMaxExtentSpec_;
  ULng32 maxExt_;

}; // class ElemDDLPartitionSystem

// -----------------------------------------------------------------------
// definitions of inline methods for class ElemDDLPartitionSystem
// -----------------------------------------------------------------------

//
// accessors
//

inline const NAString &
ElemDDLPartitionSystem::getGuardianLocation() const
{
  return guardianLocation_;
}

inline const NAString &
ElemDDLPartitionSystem::getLocation() const
{
  return locationName_;
}

// same as getLocation()
inline const NAString &
ElemDDLPartitionSystem::getLocationName() const
{
  return locationName_;
}

inline const NAString &
ElemDDLPartitionSystem::getPartitionName() const
{
  return partitionName_;
}

inline ElemDDLLocation::locationNameTypeEnum
ElemDDLPartitionSystem::getLocationNameType() const
{
  return locationNameType_;
}

inline ElemDDLNode *
ElemDDLPartitionSystem::getLocationNode() const
{
  return children_[INDEX_LOCATION];
}

inline ULng32
ElemDDLPartitionSystem::getMaxSize() const
{
  return maxSize_;
}

inline ComUnits
ElemDDLPartitionSystem::getMaxSizeUnit() const
{
  return maxSizeUnit_;
}

inline ULng32
ElemDDLPartitionSystem::getPriExt() const
{
  return priExt_;
}

inline ULng32
ElemDDLPartitionSystem::getSecExt() const
{
  return secExt_;
}

inline ULng32
ElemDDLPartitionSystem::getMaxExt() const
{
  return maxExt_;
}

// is ADD or DELETE option?
inline ElemDDLPartition::optionEnum
ElemDDLPartitionSystem::getOption() const
{
  return option_;
}

inline ElemDDLNode *
ElemDDLPartitionSystem::getPartitionSystemAttrList() const
{
  return children_[INDEX_PARTITION_ATTR_LIST];
}

inline NABoolean
ElemDDLPartitionSystem::isMaxSizeSpecified() const
{
  return isMaxSizeSpec_;
}

inline NABoolean
ElemDDLPartitionSystem::isExtentSpecified() const
{
  return isExtentSpec_;
}

inline NABoolean
ElemDDLPartitionSystem::isMaxExtentSpecified() const
{
  return isMaxExtentSpec_;
}

inline NABoolean
ElemDDLPartitionSystem::isMaxSizeUnbounded() const
{
  return isMaxSizeUnbounded_;
}

//
// mutators
//

inline void
ElemDDLPartitionSystem::setIsMaxSizeSpecified(NABoolean isMaxSizeSpecified)
{
  isMaxSizeSpec_ = isMaxSizeSpecified;
}

inline void
ElemDDLPartitionSystem::setIsMaxSizeUnbounded(NABoolean isMaxSizeUnbounded)
{
  isMaxSizeUnbounded_ = isMaxSizeUnbounded;
}

inline void
ElemDDLPartitionSystem::setIsExtentSpecified(NABoolean isExtentSpecified)
{
  isExtentSpec_ = isExtentSpecified;
}

inline void
ElemDDLPartitionSystem::setIsMaxExtentSpecified(NABoolean isMaxExtentSpecified)
{
  isMaxExtentSpec_ = isMaxExtentSpecified;
}

inline void
ElemDDLPartitionSystem::setLocationName(const NAString & locationName)
{
  locationName_ = locationName;
}
  
inline void
ElemDDLPartitionSystem::setPartitionName(const NAString & partitionName)
{
  partitionName_ = partitionName;
}

inline void
ElemDDLPartitionSystem::setLocationNameType(
     ElemDDLLocation::locationNameTypeEnum locationNameType)
{
  locationNameType_ = locationNameType;
}
  
inline void
ElemDDLPartitionSystem::setMaxSize(ULng32 maxSize)
{
  maxSize_ = maxSize;
}

inline void
ElemDDLPartitionSystem::setMaxSizeUnit(ComUnits maxSizeUnit)
{
  maxSizeUnit_ = maxSizeUnit;
}

inline void
ElemDDLPartitionSystem::setPriExt(ULng32 priExt)
{
  priExt_ = priExt;
}

inline void
ElemDDLPartitionSystem::setSecExt(ULng32 secExt)
{
  secExt_ = secExt;
}

inline void
ElemDDLPartitionSystem::setMaxExt(ULng32 maxExt)
{
  maxExt_ = maxExt;
}

#endif // ELEMDDLPARTITIONSYSTEM_H