DecimalDatatypeValidator.cpp
上传用户:zhuqijet
上传日期:2013-06-25
资源大小:10074k
文件大小:23k
源码类别:

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2001-2003 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 2001, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  56. /*
  57.  * $Log: DecimalDatatypeValidator.cpp,v $
  58.  * Revision 1.11  2003/05/18 14:02:07  knoaman
  59.  * Memory manager implementation: pass per instance manager.
  60.  *
  61.  * Revision 1.10  2003/05/16 06:01:57  knoaman
  62.  * Partial implementation of the configurable memory manager.
  63.  *
  64.  * Revision 1.9  2003/05/15 18:53:26  knoaman
  65.  * Partial implementation of the configurable memory manager.
  66.  *
  67.  * Revision 1.8  2003/03/01 20:59:06  peiyongz
  68.  * TotalDigits value must be a positiveInteger
  69.  *
  70.  * Revision 1.7  2003/02/25 17:24:37  peiyongz
  71.  * Schema Errata: E2-44 totalDigits/fractDigits
  72.  *
  73.  * Revision 1.6  2003/01/30 21:56:22  tng
  74.  * Performance: call getRawData instead of toString
  75.  *
  76.  * Revision 1.5  2002/12/18 14:17:55  gareth
  77.  * Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
  78.  *
  79.  * Revision 1.4  2002/11/04 14:53:28  tng
  80.  * C++ Namespace Support.
  81.  *
  82.  * Revision 1.3  2002/09/24 19:44:40  tng
  83.  * Performance: use XMLString::equals instead of XMLString::compareString
  84.  *
  85.  * Revision 1.2  2002/04/01 20:17:46  peiyongz
  86.  * Bug#7551: Exceptions are caught by value, rather than by reference
  87.  *
  88.  * Revision 1.1.1.1  2002/02/01 22:22:41  peiyongz
  89.  * sane_include
  90.  *
  91.  * Revision 1.19  2001/10/09 20:53:22  peiyongz
  92.  * Optimization: save get***() to temp var
  93.  *
  94.  * Revision 1.18  2001/10/02 18:59:29  peiyongz
  95.  * Invalid_Facet_Tag to display the tag name
  96.  *
  97.  * Revision 1.17  2001/10/01 21:04:40  peiyongz
  98.  * DTV Reorganization:fix to memory leak in compare() method.
  99.  *
  100.  * Revision 1.16  2001/10/01 16:16:38  peiyongz
  101.  * DTV Reorganization:derived from AbstractNumericValidator
  102.  *
  103.  * Revision 1.15  2001/09/20 13:11:42  knoaman
  104.  * Regx  + misc. fixes
  105.  *
  106.  * Revision 1.14  2001/08/22 18:28:01  peiyongz
  107.  * Memory leak: delete the bufffer allocated by ::toString()
  108.  *
  109.  * Revision 1.13  2001/08/21 18:42:53  peiyongz
  110.  * Bugzilla# 2816: cleanUp() declared with external linkage and called
  111.  *                          before defined as inline
  112.  *
  113.  * Revision 1.12  2001/08/15 18:08:44  peiyongz
  114.  * Fix to potential leakage in strEnumeration
  115.  *
  116.  * Revision 1.11  2001/07/17 21:30:12  peiyongz
  117.  * bug fix: numBase->getMinInclusive()->toString()
  118.  *
  119.  * Revision 1.10  2001/06/20 17:56:32  peiyongz
  120.  * support for "fixed" option on constrainning facets
  121.  *
  122.  * Revision 1.8  2001/05/29 19:49:34  tng
  123.  * Schema: Constraint Checking Fix in datatypeValidators.  By Pei Yong Zhang.
  124.  *
  125.  * Revision 1.7  2001/05/28 21:11:18  tng
  126.  * Schema: Various DatatypeValidator fix.  By Pei Yong Zhang
  127.  *
  128.  * Revision 1.6  2001/05/18 20:18:02  tng
  129.  * Schema: More exception messages in XMLBigDecimal/XMLBigInteger/DecimalDatatypeValidator.  By Pei Yong Zhang.
  130.  *
  131.  * Revision 1.5  2001/05/18 13:36:45  tng
  132.  * Schema: Catch RegularExpression exception and NumberFormatException
  133.  *
  134.  * Revision 1.4  2001/05/18 13:23:46  tng
  135.  * Schema: Exception messages in DatatypeValidator.  By Pei Yong Zhang.
  136.  *
  137.  * Revision 1.3  2001/05/11 17:17:23  tng
  138.  * Schema: DatatypeValidator fixes.  By Pei Yong Zhang.
  139.  *
  140.  * Revision 1.2  2001/05/11 13:27:28  tng
  141.  * Copyright update.
  142.  *
  143.  * Revision 1.1  2001/05/10 20:51:29  tng
  144.  * Schema: Add DecimalDatatypeValidator and XMLBigDecimal, XMLBigInteger.  By Pei Yong Zhang.
  145.  *
  146.  */
  147. // ---------------------------------------------------------------------------
  148. //  Includes
  149. // ---------------------------------------------------------------------------
  150. #include <xercesc/validators/datatype/DecimalDatatypeValidator.hpp>
  151. #include <xercesc/validators/schema/SchemaSymbols.hpp>
  152. #include <xercesc/validators/datatype/InvalidDatatypeFacetException.hpp>
  153. #include <xercesc/validators/datatype/InvalidDatatypeValueException.hpp>
  154. #include <xercesc/util/NumberFormatException.hpp>
  155. #include <xercesc/util/XMLBigDecimal.hpp>
  156. XERCES_CPP_NAMESPACE_BEGIN
  157. static const int BUF_LEN = 64;
  158. static XMLCh value1[BUF_LEN+1];
  159. static XMLCh value2[BUF_LEN+1];
  160. // ---------------------------------------------------------------------------
  161. //  Constructors and Destructor
  162. // ---------------------------------------------------------------------------
  163. DecimalDatatypeValidator::DecimalDatatypeValidator(MemoryManager* const manager)
  164. :AbstractNumericValidator(0, 0, 0, DatatypeValidator::Decimal, manager)
  165. , fTotalDigits(0)
  166. , fFractionDigits(0)
  167. {}
  168. DecimalDatatypeValidator::DecimalDatatypeValidator(
  169.                           DatatypeValidator*            const baseValidator
  170.                         , RefHashTableOf<KVStringPair>* const facets
  171.                         , RefArrayVectorOf<XMLCh>*           const enums
  172.                         , const int                           finalSet
  173.                         , MemoryManager* const manager)
  174. :AbstractNumericValidator(baseValidator, facets, finalSet, DatatypeValidator::Decimal, manager)
  175. , fTotalDigits(0)
  176. , fFractionDigits(0)
  177. {
  178.     init(enums);
  179. }
  180. DecimalDatatypeValidator::~DecimalDatatypeValidator()
  181. {}
  182. // -----------------------------------------------------------------------
  183. // Compare methods
  184. // -----------------------------------------------------------------------
  185. int DecimalDatatypeValidator::compare(const XMLCh* const lValue
  186.                                     , const XMLCh* const rValue)
  187. {
  188.     XMLBigDecimal lObj(lValue, fMemoryManager);
  189.     XMLBigDecimal rObj(rValue, fMemoryManager);
  190.     return compareValues(&lObj, &rObj);
  191. }
  192. DatatypeValidator* DecimalDatatypeValidator::newInstance
  193. (
  194.       RefHashTableOf<KVStringPair>* const facets
  195.     , RefArrayVectorOf<XMLCh>* const      enums
  196.     , const int                           finalSet
  197.     , MemoryManager* const                manager
  198. )
  199. {
  200.     return (DatatypeValidator*) new (manager) DecimalDatatypeValidator(this, facets, enums, finalSet, manager);
  201. }
  202. // -----------------------------------------------------------------------
  203. // ctor provided to be used by derived classes
  204. // -----------------------------------------------------------------------
  205. DecimalDatatypeValidator::DecimalDatatypeValidator(DatatypeValidator*            const baseValidator
  206.                                                  , RefHashTableOf<KVStringPair>* const facets
  207.                                                  , const int                           finalSet
  208.                                                  , const ValidatorType                 type
  209.                                                  , MemoryManager* const                manager)
  210. :AbstractNumericValidator(baseValidator, facets, finalSet, type, manager)
  211. , fTotalDigits(0)
  212. , fFractionDigits(0)
  213. {
  214.     //do not invoke init here !!!
  215. }
  216. void DecimalDatatypeValidator::assignAdditionalFacet(const XMLCh* const key
  217.                                                    , const XMLCh* const value)
  218. {
  219.     if (XMLString::equals(key, SchemaSymbols::fgELT_TOTALDIGITS))
  220.     {
  221.         int val;
  222.         try
  223.         {
  224.             val = XMLString::parseInt(value);
  225.         }
  226.         catch (NumberFormatException&)
  227.         {
  228.             ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_TotalDigit, value);
  229.         }
  230.         // check 4.3.11.c0 must: totalDigits > 0
  231.         if ( val <= 0 )
  232.             ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_PosInt_TotalDigit, value);
  233.         setTotalDigits(val);
  234.         setFacetsDefined(DatatypeValidator::FACET_TOTALDIGITS);
  235.     }
  236.     else if (XMLString::equals(key, SchemaSymbols::fgELT_FRACTIONDIGITS))
  237.     {
  238.         int val;
  239.         try
  240.         {
  241.             val = XMLString::parseInt(value);
  242.         }
  243.         catch (NumberFormatException&)
  244.         {
  245.             ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_FractDigit, value);
  246.         }
  247.         // check 4.3.12.c0 must: fractionDigits > 0
  248.         if ( val < 0 )
  249.             ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_NonNeg_FractDigit, value);
  250.         setFractionDigits(val);
  251.         setFacetsDefined(DatatypeValidator::FACET_FRACTIONDIGITS);
  252.     }
  253.     else
  254.     {
  255.         ThrowXML1(InvalidDatatypeFacetException
  256.                 , XMLExcepts::FACET_Invalid_Tag
  257.                 , key);
  258.     }
  259. }
  260. void DecimalDatatypeValidator::inheritAdditionalFacet()
  261. {
  262.     DecimalDatatypeValidator *numBase = (DecimalDatatypeValidator*) getBaseValidator();
  263.     if (!numBase)
  264.         return;
  265.     int thisFacetsDefined = getFacetsDefined();
  266.     int baseFacetsDefined = numBase->getFacetsDefined();
  267.     // inherit totalDigits
  268.     if ((( baseFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
  269.         (( thisFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) == 0) )
  270.     {
  271.         setTotalDigits(numBase->fTotalDigits);
  272.         setFacetsDefined(DatatypeValidator::FACET_TOTALDIGITS);
  273.     }
  274.     // inherit fractionDigits
  275.     if ((( baseFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
  276.         (( thisFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) == 0) )
  277.     {
  278.         setFractionDigits(numBase->fFractionDigits);
  279.         setFacetsDefined(DatatypeValidator::FACET_FRACTIONDIGITS);
  280.     }
  281. }
  282. void DecimalDatatypeValidator::checkAdditionalFacetConstraints() const
  283. {
  284.     int thisFacetsDefined = getFacetsDefined();
  285.     // check 4.3.12.c1 must: fractionDigits <= totalDigits
  286.     if ( ((thisFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
  287.          ((thisFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0) )
  288.     {
  289.         if ( fFractionDigits > fTotalDigits )
  290.         {
  291.             XMLString::binToText(getFractionDigits(), value1, BUF_LEN, 10);
  292.             XMLString::binToText(getTotalDigits(), value2, BUF_LEN, 10);
  293.             ThrowXML2(InvalidDatatypeFacetException
  294.                                  , XMLExcepts::FACET_TotDigit_FractDigit
  295.                                  , value2
  296.                                  , value1);
  297.         }
  298.     }
  299. }
  300. void DecimalDatatypeValidator::checkAdditionalFacetConstraintsBase() const
  301. {
  302.     DecimalDatatypeValidator *numBase = (DecimalDatatypeValidator*) getBaseValidator();
  303.     if (!numBase)
  304.         return;
  305.     int thisFacetsDefined = getFacetsDefined();
  306.     int baseFacetsDefined = numBase->getFacetsDefined();
  307.     // check 4.3.11.c1 error: totalDigits > base.totalDigits
  308.     // totalDigits != base.totalDigits if (base.fixed)
  309.     if (( thisFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0)
  310.     {
  311.         if ( (( baseFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
  312.             ( fTotalDigits > numBase->fTotalDigits ))
  313.         {
  314.             XMLString::binToText(fTotalDigits, value1, BUF_LEN, 10);
  315.             XMLString::binToText(numBase->fTotalDigits, value2, BUF_LEN, 10);
  316.             ThrowXML2(InvalidDatatypeFacetException
  317.                                  , XMLExcepts::FACET_totalDigit_base_totalDigit
  318.                                  , value1
  319.                                  , value2);
  320.         }
  321.         if ( (( baseFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
  322.             (( numBase->getFixed() & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
  323.             ( fTotalDigits != numBase->fTotalDigits ))
  324.         {
  325.             XMLString::binToText(fTotalDigits, value1, BUF_LEN, 10);
  326.             XMLString::binToText(numBase->fTotalDigits, value2, BUF_LEN, 10);
  327.             ThrowXML2(InvalidDatatypeFacetException
  328.                                  , XMLExcepts::FACET_totalDigit_base_fixed
  329.                                  , value1
  330.                                  , value2);
  331.         }
  332.     }
  333.     if (( thisFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0)
  334.     {
  335.         // check question error: fractionDigits > base.fractionDigits ???
  336.         if ( (( baseFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
  337.             ( fFractionDigits > numBase->fFractionDigits ))
  338.         {
  339.             XMLString::binToText(fFractionDigits, value1, BUF_LEN, 10);
  340.             XMLString::binToText(numBase->fFractionDigits, value2, BUF_LEN, 10);
  341.             ThrowXML2(InvalidDatatypeFacetException
  342.                                  , XMLExcepts::FACET_fractDigit_base_fractDigit
  343.                                  , value1
  344.                                  , value2);
  345.                         }
  346.         // check question error: fractionDigits > base.totalDigits ???
  347.         if ( (( baseFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
  348.             ( fFractionDigits > numBase->fTotalDigits ))
  349.         {
  350.             XMLString::binToText(fFractionDigits, value1, BUF_LEN, 10);
  351.             XMLString::binToText(numBase->fTotalDigits, value2, BUF_LEN, 10);
  352.             ThrowXML2(InvalidDatatypeFacetException
  353.                                  , XMLExcepts::FACET_fractDigit_base_totalDigit
  354.                                  , value1
  355.                                  , value2);
  356.         }
  357.         // fractionDigits != base.fractionDigits if (base.fixed)
  358.         if ( (( baseFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
  359.             (( numBase->getFixed() & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
  360.             ( fFractionDigits != numBase->fFractionDigits ))
  361.         {
  362.             XMLString::binToText(fFractionDigits, value1, BUF_LEN, 10);
  363.             XMLString::binToText(numBase->fFractionDigits, value2, BUF_LEN, 10);
  364.             ThrowXML2(InvalidDatatypeFacetException
  365.                                  , XMLExcepts::FACET_fractDigit_base_fixed
  366.                                  , value1
  367.                                  , value2);
  368.         }
  369.     }
  370. }
  371. int  DecimalDatatypeValidator::compareValues(const XMLNumber* const lValue
  372.                                            , const XMLNumber* const rValue)
  373. {
  374.     return XMLBigDecimal::compareValues((XMLBigDecimal*) lValue, (XMLBigDecimal*) rValue);
  375. }
  376. void  DecimalDatatypeValidator::setMaxInclusive(const XMLCh* const value)
  377. {
  378.     fMaxInclusive = new (fMemoryManager) XMLBigDecimal(value, fMemoryManager);
  379. }
  380. void  DecimalDatatypeValidator::setMaxExclusive(const XMLCh* const value)
  381. {
  382.     fMaxExclusive = new (fMemoryManager) XMLBigDecimal(value, fMemoryManager);
  383. }
  384. void  DecimalDatatypeValidator::setMinInclusive(const XMLCh* const value)
  385. {
  386.     fMinInclusive = new (fMemoryManager) XMLBigDecimal(value, fMemoryManager);
  387. }
  388. void  DecimalDatatypeValidator::setMinExclusive(const XMLCh* const value)
  389. {
  390.     fMinExclusive = new (fMemoryManager) XMLBigDecimal(value, fMemoryManager);
  391. }
  392. void DecimalDatatypeValidator::setEnumeration()
  393. {
  394.     // check 4.3.5.c0 must: enumeration values from the value space of base
  395.     //
  396.     // 1. shall be from base value space
  397.     // 2. shall be from current value space as well ( shall go through boundsCheck() )
  398.     //
  399.     if (!fStrEnumeration)
  400.         return;
  401.     int i = 0;
  402.     int enumLength = fStrEnumeration->size();
  403.     DecimalDatatypeValidator *numBase = (DecimalDatatypeValidator*) getBaseValidator();
  404.     if (numBase)
  405.     {
  406.         try
  407.         {
  408.             for ( i = 0; i < enumLength; i++)
  409.             {
  410.                 numBase->checkContent(fStrEnumeration->elementAt(i), false);
  411.             }
  412.         }
  413.         catch (XMLException&)
  414.         {
  415.             ThrowXML1(InvalidDatatypeFacetException
  416.                     , XMLExcepts::FACET_enum_base
  417.                     , fStrEnumeration->elementAt(i));
  418.         }
  419.     }
  420.     // We put the this->checkContent in a separate loop
  421.     // to not block original message with in that method.
  422.     //
  423.     for ( i = 0; i < enumLength; i++)
  424.     {
  425.         checkContent(fStrEnumeration->elementAt(i), false);
  426.     }
  427.     fEnumeration = new (fMemoryManager) RefVectorOf<XMLNumber>(enumLength, true, fMemoryManager);
  428.     fEnumerationInherited = false;
  429.     for ( i = 0; i < enumLength; i++)
  430.     {
  431.         fEnumeration->insertElementAt(new (fMemoryManager) XMLBigDecimal(fStrEnumeration->elementAt(i), fMemoryManager), i);
  432.     }
  433. }
  434. // -----------------------------------------------------------------------
  435. // Abstract interface from AbstractNumericValidator
  436. // -----------------------------------------------------------------------
  437. void DecimalDatatypeValidator::checkContent( const XMLCh* const content, bool asBase)
  438. {
  439.     //validate against base validator if any
  440.     DecimalDatatypeValidator *pBase = (DecimalDatatypeValidator*) this->getBaseValidator();
  441.     if (pBase)
  442.         pBase->checkContent(content, true);
  443.     int thisFacetsDefined = getFacetsDefined();
  444.     // we check pattern first
  445.     if ( (thisFacetsDefined & DatatypeValidator::FACET_PATTERN ) != 0 )
  446.     {
  447.         // lazy construction
  448.         if (getRegex() ==0) {
  449.             try {
  450.                 setRegex(new (fMemoryManager) RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption, fMemoryManager));
  451.             }
  452.             catch (XMLException &e)
  453.             {
  454.                 ThrowXML1(InvalidDatatypeValueException, XMLExcepts::RethrowError, e.getMessage());
  455.             }
  456.         }
  457.         if (getRegex()->matches(content) ==false)
  458.         {
  459.             ThrowXML2(InvalidDatatypeValueException
  460.                     , XMLExcepts::VALUE_NotMatch_Pattern
  461.                     , content
  462.                     , getPattern());
  463.         }
  464.     }
  465.     // if this is a base validator, we only need to check pattern facet
  466.     // all other facet were inherited by the derived type
  467.     if (asBase)
  468.         return;
  469.     try {
  470.         XMLBigDecimal theValue(content, fMemoryManager);
  471.         XMLBigDecimal *theData = &theValue;
  472.         if (getEnumeration())
  473.         {
  474.             int i=0;
  475.             int enumLength = getEnumeration()->size();
  476.             for ( ; i < enumLength; i++)
  477.             {
  478.                 if (compareValues(theData, (XMLBigDecimal*) getEnumeration()->elementAt(i)) ==0 )
  479.                     break;
  480.             }
  481.             if (i == enumLength)
  482.                 ThrowXML1(InvalidDatatypeValueException, XMLExcepts::VALUE_NotIn_Enumeration, content);
  483.         }
  484.         boundsCheck(theData);
  485.         if ( (thisFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0 )
  486.         {
  487.             if ( theData->getScale() > fFractionDigits )
  488.             {                
  489.                 XMLString::binToText(theData->getScale(), value1, BUF_LEN, 10);
  490.                 XMLString::binToText(fFractionDigits, value2, BUF_LEN, 10);
  491.                 ThrowXML3(InvalidDatatypeFacetException
  492.                                  , XMLExcepts::VALUE_exceed_fractDigit
  493.                                  , theData->getRawData()
  494.                                  , value1
  495.                                  , value2);
  496.             }
  497.         }
  498.         if ( (thisFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0 )
  499.         {
  500.             if ( theData->getTotalDigit() > fTotalDigits )
  501.             {                
  502.                 XMLString::binToText(theData->getTotalDigit(), value1, BUF_LEN, 10);
  503.                 XMLString::binToText(fTotalDigits, value2, BUF_LEN, 10);
  504.                 ThrowXML3(InvalidDatatypeFacetException
  505.                                  , XMLExcepts::VALUE_exceed_totalDigit
  506.                                  , theData->getRawData()
  507.                                  , value1
  508.                                  , value2);
  509.             }
  510.             /***
  511.              E2-44 totalDigits
  512.              ... by restricting it to numbers that are expressible as i