| /* -*-C++-*- |
| // @@@ 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 @@@ |
| ***************************************************************************** |
| * |
| * File: ElemDDLSGOptions.C |
| * Description: methods for class ElemDDLSGOption and any classes |
| * derived from class ElemDDLSGOption. |
| * |
| * Created: 4/22/08 |
| * Language: C++ |
| * |
| * |
| * |
| * |
| ***************************************************************************** |
| */ |
| |
| #include "ComDiags.h" |
| #include "ElemDDLSGOptions.h" |
| #include "ElemDDLSGOption.h" |
| #define SQLPARSERGLOBALS_CONTEXT_AND_DIAGS |
| #include "SqlParserGlobals.h" |
| #include "NAString.h" |
| |
| // ----------------------------------------------------------------------- |
| // methods for class ElemDDLSGOptions |
| // ----------------------------------------------------------------------- |
| |
| // |
| // constructors |
| // |
| |
| ElemDDLSGOptions::ElemDDLSGOptions(OperatorTypeEnum operType) |
| : ElemDDLNode(operType), |
| ieType_(SG_UNKNOWN), |
| cdType_(CD_UNKNOWN) |
| { |
| setChild(INDEX_SG_OPT_LIST, NULL); |
| |
| initializeDataMembers(); |
| } |
| |
| ElemDDLSGOptions::ElemDDLSGOptions() |
| : ElemDDLNode(ELM_SG_OPTS_DEFAULT_ELEM), |
| ieType_(SG_UNKNOWN), |
| cdType_(CD_UNKNOWN) |
| { |
| setChild(INDEX_SG_OPT_LIST, NULL); |
| |
| initializeDataMembers(); |
| } |
| |
| ElemDDLSGOptions::ElemDDLSGOptions(Int32 ieType, |
| ElemDDLNode * pSGOptList) |
| : ElemDDLNode(ELM_SG_OPTS_DEFAULT_ELEM) |
| { |
| setChild(INDEX_SG_OPT_LIST, pSGOptList); |
| |
| if (ieType == 1) |
| ieType_= SG_INTERNAL; |
| else if (ieType == 2) |
| ieType_ = SG_EXTERNAL; |
| else if (ieType == 3) |
| ieType_ = SG_INTERNAL_COMPUTED; |
| else |
| ieType_ = SG_UNKNOWN; |
| |
| initializeDataMembers(); |
| } |
| |
| // Virtual destructor |
| ElemDDLSGOptions::~ElemDDLSGOptions() |
| { |
| // delete all children |
| for (Int32 i = 0; i < getArity(); i++) |
| { |
| delete getChild(i); |
| } |
| } |
| |
| // cast virtual function |
| ElemDDLSGOptions * |
| ElemDDLSGOptions::castToElemDDLSGOptions() |
| { |
| return this; |
| } |
| |
| // |
| // accessors |
| // |
| |
| // get the degree of this node |
| Int32 |
| ElemDDLSGOptions::getArity() const |
| { |
| return MAX_ELEM_DDL_SG_OPTS_ARITY; |
| } |
| |
| ExprNode * |
| ElemDDLSGOptions::getChild(Lng32 index) |
| { |
| ComASSERT(index >= 0 AND index < getArity()); |
| return children_[index]; |
| } |
| |
| // |
| // mutators |
| // |
| |
| void |
| ElemDDLSGOptions::initializeDataMembers() |
| { |
| // |
| // Sequence generator options |
| // |
| |
| isStartValueSpec_ = FALSE; |
| isIncrementSpec_ = FALSE; |
| isMinValueSpec_ = FALSE; |
| isMaxValueSpec_ = FALSE; |
| isCycleSpec_ = FALSE; |
| isCacheSpec_ = FALSE; |
| isDatatypeSpec_ = FALSE; |
| isResetSpec_ = FALSE; |
| |
| isNoMinValue_ = FALSE; |
| isNoMaxValue_ = FALSE; |
| cycle_ = FALSE; |
| cache_ = 0; |
| isNoCache_ = FALSE; |
| reset_ = FALSE; |
| |
| startValue_ = 0; |
| increment_ = 0; |
| minValue_ = 0; |
| maxValue_ = 0; |
| |
| fsDataType_ = COM_UNKNOWN_FSDT; |
| |
| // |
| // Traverse the parse sub-tree containing the list of SG |
| // options. For each option found, set the corresponding |
| // data member in this class. Also check for duplicate clauses. |
| // |
| |
| if (getChild(INDEX_SG_OPT_LIST) NEQ NULL) |
| { |
| ElemDDLNode * pSGOptList = getChild(INDEX_SG_OPT_LIST) |
| ->castToElemDDLNode(); |
| numOptions_ = pSGOptList->entries(); |
| |
| for (CollIndex i = 0; i < pSGOptList->entries(); i++) |
| { |
| setSGOpt((*pSGOptList)[i]); |
| } |
| } |
| |
| } // ElemDDLSGOptions::initializeDataMembers() |
| |
| void |
| ElemDDLSGOptions::setChild(Lng32 index, ExprNode * pChildNode) |
| { |
| ComASSERT(index >= 0 AND index < getArity()); |
| if (pChildNode NEQ NULL) |
| { |
| ComASSERT(pChildNode->castToElemDDLNode() NEQ NULL); |
| children_[index] = pChildNode->castToElemDDLNode(); |
| } |
| else |
| { |
| children_[index] = NULL; |
| } |
| } |
| |
| // |
| // Set private data members corresponding to the SG options |
| // specified in a file option or load option phrases in a SG |
| // clause. This method also looks for duplicate phrases. |
| // |
| void |
| ElemDDLSGOptions::setSGOpt(ElemDDLNode * pSGOpt) |
| { |
| switch(pSGOpt->getOperatorType()) |
| { |
| |
| |
| case ELM_SG_OPT_START_VALUE_ELEM : |
| if (isStartValueSpec_) |
| { |
| // cout << "*** Error *** Duplicate options in sg option list. |
| if (ieType_ == SG_INTERNAL) |
| *SqlParser_Diags << DgSqlCode(-3427) |
| << DgString0("START WITH") |
| << DgString1("IDENTITY column"); |
| else |
| *SqlParser_Diags << DgSqlCode(-3427) |
| << DgString0("START WITH") |
| << DgString1("sequence generator"); |
| } |
| isStartValueSpec_ = TRUE; |
| startValue_ = |
| pSGOpt->castToElemDDLSGOptionStartValue()->getValue(); |
| break; |
| |
| case ELM_SG_OPT_INCREMENT_ELEM : |
| if (isIncrementSpec_) |
| { |
| // cout << "*** Error *** Duplicate options in sg option list. |
| if (ieType_ == SG_INTERNAL) |
| *SqlParser_Diags << DgSqlCode(-3427) |
| << DgString0("INCREMENT BY") |
| << DgString1("IDENTITY column"); |
| else |
| *SqlParser_Diags << DgSqlCode(-3427) |
| << DgString0("INCREMENT BY") |
| << DgString1("sequence generator"); |
| } |
| isIncrementSpec_ = TRUE; |
| increment_ = |
| pSGOpt->castToElemDDLSGOptionIncrement()->getValue(); |
| break; |
| |
| case ELM_SG_OPT_MIN_VALUE_ELEM : |
| if (isMinValueSpec_) |
| { |
| // cout << "*** Error *** Duplicate options in sg option list. |
| if (ieType_ == SG_INTERNAL) |
| *SqlParser_Diags << DgSqlCode(-3427) |
| << DgString0("MINVALUE") |
| << DgString1("IDENTITY column"); |
| else |
| *SqlParser_Diags << DgSqlCode(-3427) |
| << DgString0("MINVALUE") |
| << DgString1("sequence generator"); |
| } |
| isMinValueSpec_ = TRUE; |
| minValue_ = |
| pSGOpt->castToElemDDLSGOptionMinValue()->getValue(); |
| isNoMinValue_ = |
| pSGOpt->castToElemDDLSGOptionMinValue()->isNoMinValue(); |
| break; |
| |
| case ELM_SG_OPT_MAX_VALUE_ELEM : |
| if (isMaxValueSpec_) |
| { |
| // cout << "*** Error *** Duplicate options in sg option list. |
| if (ieType_ == SG_INTERNAL) |
| *SqlParser_Diags << DgSqlCode(-3427) |
| << DgString0("MAXVALUE") |
| << DgString1("IDENTITY column"); |
| else |
| *SqlParser_Diags << DgSqlCode(-3427) |
| << DgString0("MAXVALUE") |
| << DgString1("sequence generator"); |
| } |
| isMaxValueSpec_ = TRUE; |
| maxValue_ = |
| pSGOpt->castToElemDDLSGOptionMaxValue()->getValue(); |
| isNoMaxValue_ = |
| pSGOpt->castToElemDDLSGOptionMaxValue()->isNoMaxValue(); |
| break; |
| |
| case ELM_SG_OPT_CYCLE_OPTION_ELEM : |
| if (isCycleSpec_) |
| { |
| // cout << "*** Error *** Duplicate options in sg option list. |
| if (ieType_ == SG_INTERNAL) |
| *SqlParser_Diags << DgSqlCode(-3427) |
| << DgString0("CYCLE") |
| << DgString1("IDENTITY column"); |
| else |
| *SqlParser_Diags << DgSqlCode(-3427) |
| << DgString0("CYCLE") |
| << DgString1("sequence generator"); |
| } |
| isCycleSpec_ = TRUE; |
| cycle_ = |
| pSGOpt->castToElemDDLSGOptionCycleOption()->getValue(); |
| break; |
| |
| case ELM_SG_OPT_CACHE_OPTION_ELEM : |
| if (isCacheSpec_) |
| { |
| // cout << "*** Error *** Duplicate options in sg option list. |
| if (ieType_ == SG_INTERNAL) |
| *SqlParser_Diags << DgSqlCode(-3427) |
| << DgString0("CACHE") |
| << DgString1("IDENTITY column"); |
| else |
| *SqlParser_Diags << DgSqlCode(-3427) |
| << DgString0("CACHE") |
| << DgString1("sequence generator"); |
| } |
| isCacheSpec_ = TRUE; |
| cache_ = |
| pSGOpt->castToElemDDLSGOptionCacheOption()->getCacheSize(); |
| isNoCache_ = |
| pSGOpt->castToElemDDLSGOptionCacheOption()->isNoCache(); |
| break; |
| |
| case ELM_SG_OPT_DATATYPE_ELEM : |
| if (isDatatypeSpec_) |
| { |
| // cout << "*** Error *** Duplicate options in sg option list. |
| if (ieType_ == SG_INTERNAL) |
| *SqlParser_Diags << DgSqlCode(-3427) |
| << DgString0("DATATYPE") |
| << DgString1("IDENTITY column"); |
| else |
| *SqlParser_Diags << DgSqlCode(-3427) |
| << DgString0("DATATYPE") |
| << DgString1("sequence generator"); |
| } |
| isDatatypeSpec_ = TRUE; |
| fsDataType_ = |
| pSGOpt->castToElemDDLSGOptionDatatype()->getDatatype(); |
| break; |
| |
| case ELM_SG_OPT_RESET_OPTION_ELEM : |
| if (isResetSpec_) |
| { |
| // cout << "*** Error *** Duplicate options in sg option list. |
| if (ieType_ == SG_INTERNAL) |
| *SqlParser_Diags << DgSqlCode(-3427) |
| << DgString0("RESET") |
| << DgString1("IDENTITY column"); |
| else |
| *SqlParser_Diags << DgSqlCode(-3427) |
| << DgString0("RESET") |
| << DgString1("sequence generator"); |
| } |
| isResetSpec_ = TRUE; |
| reset_ = TRUE; |
| break; |
| |
| default : |
| ABORT("internal logic error"); |
| break; |
| } |
| } // ElemDDLSGOptions::setSGOpt() |
| |
| void ElemDDLSGOptions::setCDType(Int32 cdType) |
| { |
| if (cdType == 1) |
| cdType_= CD_GENERATED_BY_DEFAULT; |
| else if (cdType == 2) |
| cdType_ = CD_GENERATED_ALWAYS; |
| else |
| cdType_ = CD_UNKNOWN; |
| } |
| |
| // |
| // method for binding |
| // |
| |
| ExprNode * |
| ElemDDLSGOptions::bindNode(BindWA * /*pBindWA*/) |
| { |
| |
| markAsBound(); |
| return this; |
| } |
| |
| // queryType: 0, create sequence. 1, alter sequence. 2, IDENTITY col. |
| short ElemDDLSGOptions::validate(short queryType) |
| { |
| char queryTypeStr[40]; |
| |
| if (queryType == 0) |
| strcpy(queryTypeStr, "CREATE SEQUENCE"); |
| else if (queryType == 1) |
| strcpy(queryTypeStr, "ALTER SEQUENCE"); |
| else |
| strcpy(queryTypeStr, "IDENTITY column"); |
| |
| Int64 minValue = 0; |
| Int64 startValue = 0; |
| Int64 increment = 0; |
| Int64 maxValue = LONG_MAX - 1; |
| |
| NAString dtStr; |
| if (fsDataType_ != COM_UNKNOWN_FSDT) |
| { |
| switch (fsDataType_) |
| { |
| case COM_UNSIGNED_BIN16_FSDT: |
| maxValue = USHRT_MAX; |
| dtStr = COM_SMALLINT_UNSIGNED_SDT_LIT; |
| break; |
| case COM_UNSIGNED_BIN32_FSDT: |
| maxValue = UINT_MAX; |
| dtStr = COM_INTEGER_UNSIGNED_SDT_LIT; |
| break; |
| case COM_SIGNED_BIN64_FSDT: |
| maxValue = LONG_MAX - 1; |
| dtStr = COM_LARGEINT_SIGNED_SDT_LIT; |
| break; |
| default: |
| *CmpCommon::diags() << DgSqlCode(-1510); |
| return -1; |
| } |
| } |
| |
| if (queryType == 1) // alter |
| { |
| if ((isMinValueSpecified()|| isStartValueSpecified())) |
| { |
| *CmpCommon::diags() << DgSqlCode(-1592) |
| << (isMinValueSpecified() ? DgString0("MINVALUE") : DgString0("START WITH")) |
| << DgString1(queryTypeStr); |
| |
| return -1; |
| } |
| |
| minValue = getMinValue(); |
| startValue = getStartValue(); |
| increment = getIncrement(); |
| |
| if (isMaxValueSpecified() && (NOT isNoMaxValue())) |
| { |
| if ((fsDataType_ != COM_UNKNOWN_FSDT) && |
| (getMaxValue() > maxValue)) |
| { |
| *CmpCommon::diags() << DgSqlCode(-1576) |
| << DgString0("MAXVALUE") |
| << DgString1(dtStr); |
| |
| return -1; |
| } |
| } |
| |
| maxValue = getMaxValue(); |
| } // alter |
| else |
| { |
| if (isResetSpecified()) |
| { |
| *CmpCommon::diags() << DgSqlCode(-1592) |
| << DgString0("RESET") |
| << DgString1(queryTypeStr); |
| |
| return -1; |
| } |
| |
| minValue = ((isMinValueSpecified() && (NOT isNoMinValue())) ? |
| getMinValue() : 1LL); |
| startValue = (isStartValueSpecified() ? getStartValue() : minValue); |
| increment = (isIncrementSpecified() ? getIncrement() : 1LL); |
| } //else |
| |
| if (isMaxValueSpecified() && (NOT isNoMaxValue())) |
| { |
| if ((fsDataType_ != COM_UNKNOWN_FSDT) && |
| (getMaxValue() > maxValue)) |
| { |
| *CmpCommon::diags() << DgSqlCode(-1576) |
| << DgString0("MAXVALUE") |
| << DgString1(dtStr); |
| |
| return -1; |
| } |
| |
| maxValue = getMaxValue(); |
| } |
| |
| if (minValue == 0) |
| { |
| *CmpCommon::diags() << DgSqlCode(-1571) |
| << DgString0("MINVALUE") |
| << DgString1(queryTypeStr); |
| |
| return -1; |
| } |
| |
| if (minValue < 0) |
| { |
| *CmpCommon::diags() << DgSqlCode(-1572) |
| << DgString0("MINVALUE") |
| << DgString1(queryTypeStr); |
| |
| return -1; |
| } |
| |
| if (maxValue == 0) |
| { |
| *CmpCommon::diags() << DgSqlCode(-1571) |
| << DgString0("MAXVALUE") |
| << DgString1(queryTypeStr); |
| |
| return -1; |
| } |
| |
| if (maxValue < 0) |
| { |
| *CmpCommon::diags() << DgSqlCode(-1572) |
| << DgString0("MAXVALUE") |
| << DgString1(queryTypeStr); |
| |
| return -1; |
| } |
| |
| if (increment == 0) |
| { |
| *CmpCommon::diags() << DgSqlCode(-1571) |
| << DgString0("INCREMENT BY") |
| << DgString1(queryTypeStr); |
| |
| return -1; |
| } |
| |
| if (increment < 0) |
| { |
| *CmpCommon::diags() << DgSqlCode(-1572) |
| << DgString0("INCREMENT BY") |
| << DgString1(queryTypeStr); |
| return -1; |
| } |
| |
| if (startValue < 0) |
| { |
| *CmpCommon::diags() << DgSqlCode(-1572) |
| << DgString0("START WITH") |
| << DgString1(queryTypeStr); |
| |
| return -1; |
| } |
| |
| if (maxValue <= minValue) |
| { |
| *CmpCommon::diags() << DgSqlCode(-1570) |
| << DgString0(queryTypeStr); |
| return -1; |
| } |
| |
| if (startValue > maxValue) |
| { |
| *CmpCommon::diags() << DgSqlCode(-1573) |
| << DgString0(queryTypeStr); |
| return -1; |
| } |
| |
| if (startValue < minValue) |
| { |
| *CmpCommon::diags() << DgSqlCode(-1573) |
| << DgString0(queryTypeStr); |
| return -1; |
| } |
| |
| if (increment > (maxValue - minValue)) |
| { |
| *CmpCommon::diags() << DgSqlCode(-1575) |
| << DgString0(queryTypeStr); |
| return -1; |
| } |
| |
| Int64 cache = 0; |
| Int64 minVal = MAXOF(startValue, minValue); |
| Int64 rangeOfVals = (maxValue-minVal)/increment + 1; |
| |
| if (isCacheSpecified()) |
| cache = getCache(); |
| else |
| cache = MINOF(rangeOfVals, 25); |
| |
| if (NOT isNoCache()) |
| { |
| if ((cache <= 1) || |
| (cache > rangeOfVals)) |
| { |
| *CmpCommon::diags() << DgSqlCode(-1577) |
| << DgString0(queryTypeStr); |
| return -1; |
| } |
| } |
| |
| cache = MINOF(rangeOfVals, cache); |
| |
| setStartValue(startValue); |
| setIncrement(increment); |
| setMinValue(minValue); |
| setMaxValue(maxValue); |
| if (NOT isCacheSpecified()) |
| setCache(cache); |
| |
| return 0; |
| } |
| |
| short ElemDDLSGOptions::genSGA(SequenceGeneratorAttributes &sga) |
| { |
| sga.setSGStartValue(getStartValue()); |
| sga.setSGIncrement(getIncrement()); |
| sga.setSGMinValue(getMinValue()); |
| sga.setSGMaxValue(getMaxValue()); |
| |
| sga.setSGCache(getCache()); |
| sga.setSGCycleOption(isCycle()); |
| |
| sga.setSGFSDataType(getFSDataType()); |
| |
| sga.setSGResetOption(isReset()); |
| |
| return 0; |
| } |
| |
| short ElemDDLSGOptions::importSGA(const SequenceGeneratorAttributes *sga) |
| { |
| initializeDataMembers(); |
| |
| setFSDataType(sga->getSGFSDataType()); |
| setStartValue(sga->getSGStartValue()); |
| setIncrement(sga->getSGIncrement()); |
| setMinValue(sga->getSGMinValue()); |
| setMaxValue(sga->getSGMaxValue()); |
| |
| setCache(sga->getSGCache()); |
| setCycle(sga->getSGCycleOption()); |
| |
| setReset(sga->getSGResetOption()); |
| |
| return 0; |
| } |
| |
| short ElemDDLSGOptions::importSGO(const ElemDDLSGOptions *sgo) |
| { |
| if (sgo->isStartValueSpecified()) |
| { |
| setStartValueSpec(TRUE); |
| setStartValue(sgo->getStartValue()); |
| } |
| |
| if (sgo->isIncrementSpecified()) |
| { |
| setIncrementSpec(TRUE); |
| setIncrement(sgo->getIncrement()); |
| } |
| |
| if (sgo->isMinValueSpecified()) |
| { |
| setMinValueSpec(TRUE); |
| |
| if (sgo->isNoMinValue()) |
| setNoMinValue(TRUE); |
| else |
| setMinValue(sgo->getMinValue()); |
| } |
| |
| if (sgo->isMaxValueSpecified()) |
| { |
| setMaxValueSpec(TRUE); |
| |
| if (sgo->isNoMaxValue()) |
| setNoMaxValue(TRUE); |
| else |
| setMaxValue(sgo->getMaxValue()); |
| } |
| |
| if (sgo->isCacheSpecified()) |
| { |
| setCacheSpec(TRUE); |
| setCache(sgo->getCache()); |
| } |
| |
| if (sgo->isCycleSpecified()) |
| { |
| setCycleSpec(TRUE); |
| setCycle(sgo->isCycle()); |
| } |
| |
| if (sgo->isResetSpecified()) |
| { |
| setResetSpec(); |
| setReset(sgo->isReset()); |
| } |
| |
| return 0; |
| } |
| |
| // |
| // methods for tracing |
| // |
| |
| NATraceList |
| ElemDDLSGOptions::getDetailInfo() const |
| { |
| NAString detailText; |
| NATraceList detailTextList; |
| |
| detailTextList.append("Sequence Generator Options:"); |
| detailText = " SG Type: "; |
| |
| if (isInternalSG()) |
| detailText = "INTERNAL "; |
| else if (isExternalSG()) |
| detailText = "EXTERNAL "; |
| else |
| detailText = "UNKNOWN "; |
| detailTextList.append(detailText); |
| |
| detailText = " Start Value specified? "; |
| detailText += YesNo(isStartValueSpecified()); |
| detailTextList.append(detailText); |
| |
| detailText = " Start Value: "; |
| detailText += Int64ToNAString(getStartValue()); |
| detailTextList.append(detailText); |
| |
| detailText = " Increment specified? "; |
| detailText += YesNo(isIncrementSpecified()); |
| detailTextList.append(detailText); |
| |
| detailText = " Increment: "; |
| detailText += Int64ToNAString(getIncrement()); |
| detailTextList.append(detailText); |
| |
| detailText = " MaxValue specified? "; |
| detailText += YesNo(isMaxValueSpecified()); |
| detailTextList.append(detailText); |
| |
| if (isNoMaxValue()) |
| { |
| detailText = " Max Value: NO MAXVAL "; |
| detailTextList.append(detailText); |
| } |
| else |
| { |
| detailText = " Max Value: "; |
| detailText += Int64ToNAString(getMaxValue()); |
| detailTextList.append(detailText); |
| } |
| |
| detailText = " MinValue specified? "; |
| detailText += YesNo(isMinValueSpecified()); |
| detailTextList.append(detailText); |
| |
| if (isNoMinValue()) |
| { |
| detailText = " Min Value: NO MINVAL "; |
| detailTextList.append(detailText); |
| } |
| else |
| { |
| detailText = " Min Value: "; |
| detailText += Int64ToNAString(getMinValue()); |
| detailTextList.append(detailText); |
| } |
| |
| detailText = " Cycle specified? "; |
| detailText += YesNo(isCycleSpecified()); |
| detailTextList.append(detailText); |
| |
| if (isNoCycle()) |
| { |
| detailText = " Cycle Option: NO CYCLE "; |
| detailTextList.append(detailText); |
| } |
| else |
| { |
| detailText = " Cycle Option: CYCLE "; |
| detailTextList.append(detailText); |
| } |
| |
| detailText = " Cache specified? "; |
| detailText += YesNo(isCacheSpecified()); |
| detailTextList.append(detailText); |
| |
| if (isNoCache()) |
| { |
| detailText = " Cache Option: NO CACHE "; |
| detailTextList.append(detailText); |
| } |
| else |
| { |
| detailText = " Cache Option: CACHE "; |
| detailTextList.append(detailText); |
| } |
| |
| return detailTextList; |
| } |
| |
| const NAString |
| ElemDDLSGOptions::getText() const |
| { |
| return "ElemDDLSGOptions"; |
| } |
| |
| // method for building text |
| // virtual |
| NAString ElemDDLSGOptions::getSyntax() const |
| { |
| ElemDDLSGOptions *ncThis = (ElemDDLSGOptions*)this; |
| |
| |
| NAString syntax = "Sequence Generator Options: "; |
| |
| if (NULL != ncThis->getChild(INDEX_SG_OPT_LIST)) |
| { |
| ElemDDLNode * pSGOptList = |
| ncThis->getChild(INDEX_SG_OPT_LIST)->castToElemDDLNode(); |
| |
| for (CollIndex i = 0; i < pSGOptList->entries(); i++) |
| { |
| syntax += (*pSGOptList)[i]->getSyntax(); |
| syntax += " "; |
| } |
| } |
| return syntax; |
| } |
| |
| // |
| // End of File |
| // |
