开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 词法分析 > 查看源码
AbstractNumericFacetValidator.cpp
资源名称：xerces-c-src_2_3_0.zip　[点击查看]
上传用户：zhuqijet
上传日期：2013-06-25
资源大小：10074k
文件大小：31k
源码类别：

词法分析

开发平台：

Visual C++

AbstractNumericFacetValidator.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2001 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.  */
  57. /*
  58.  * $Id: AbstractNumericFacetValidator.cpp,v 1.12 2003/05/15 18:53:26 knoaman Exp $
  59.  * $Log: AbstractNumericFacetValidator.cpp,v $
  60.  * Revision 1.12  2003/05/15 18:53:26  knoaman
  61.  * Partial implementation of the configurable memory manager.
  62.  *
  63.  * Revision 1.11  2003/02/03 16:34:35  peiyongz
  64.  * fix to misplaced derived and base value in error message.
  65.  *
  66.  * Revision 1.10  2003/02/02 23:55:40  peiyongz
  67.  * getFormattedString() added to return original and converted value.
  68.  *
  69.  * Revision 1.9  2003/01/30 21:56:22  tng
  70.  * Performance: call getRawData instead of toString
  71.  *
  72.  * Revision 1.8  2003/01/25 16:33:25  peiyongz
  73.  * wrong error code.
  74.  *
  75.  * Revision 1.7  2002/12/18 14:17:55  gareth
  76.  * Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
  77.  *
  78.  * Revision 1.6  2002/11/26 22:19:15  peiyongz
  79.  * Schema Errata E2-16 maxExclusive
  80.  *
  81.  * Revision 1.5  2002/11/04 14:53:27  tng
  82.  * C++ Namespace Support.
  83.  *
  84.  * Revision 1.4  2002/09/24 19:44:40  tng
  85.  * Performance: use XMLString::equals instead of XMLString::compareString
  86.  *
  87.  * Revision 1.3  2002/04/01 20:17:46  peiyongz
  88.  * Bug#7551: Exceptions are caught by value, rather than by reference
  89.  *
  90.  * Revision 1.2  2002/02/14 15:17:31  peiyongz
  91.  * getEnumString()
  92.  *
  93.  * Revision 1.1.1.1  2002/02/01 22:22:39  peiyongz
  94.  * sane_include
  95.  *
  96.  * Revision 1.6  2001/12/13 16:48:29  peiyongz
  97.  * Avoid dangling pointer
  98.  *
  99.  * Revision 1.5  2001/12/10 22:13:21  peiyongz
  100.  * swap checking to avoid "dangling pointer" reported by BoundsChecker
  101.  *
  102.  * Revision 1.4  2001/11/12 20:37:57  peiyongz
  103.  * SchemaDateTimeException defined
  104.  *
  105.  * Revision 1.3  2001/10/16 16:29:34  tng
  106.  * Schema: Fix Typo
  107.  *
  108.  * Revision 1.2  2001/10/09 21:17:41  peiyongz
  109.  * . macro to simplify code
  110.  * .save get***() to temp vars.
  111.  *
  112.  * Revision 1.1  2001/10/01 16:13:56  peiyongz
  113.  * DTV Reorganization:new classes: AbstractNumericFactValidator/ AbstractNumericValidator
  114.  *
  115.  */
  117. // ---------------------------------------------------------------------------
  118. //  Includes
  119. // ---------------------------------------------------------------------------
  120. #include <xercesc/validators/datatype/AbstractNumericFacetValidator.hpp>
  121. #include <xercesc/validators/datatype/InvalidDatatypeFacetException.hpp>
  122. #include <xercesc/util/NumberFormatException.hpp>
  124. XERCES_CPP_NAMESPACE_BEGIN
  126. const int AbstractNumericFacetValidator::INDETERMINATE = 2;
  128. #define  REPORT_FACET_ERROR(val1, val2, except_code)    
  129.   ThrowXML2(InvalidDatatypeFacetException               
  130.           , except_code                                 
  131.           , val1->getFormattedString()                  
  132.           , val2->getFormattedString());
  134. #define  FROM_BASE_VALUE_SPACE(val, facetFlag, except_code)   
  135.   if ((thisFacetsDefined & facetFlag) != 0)                   
  136. {                                                             
  137.     try                                                       
  138. {                                                             
  139.         numBase->checkContent(val->getRawData(), false);      
  140. }                                                             
  141.     catch ( XMLException& )                                   
  142. {                                                             
  143.         ThrowXML1(InvalidDatatypeFacetException               
  144.                 , except_code                                 
  145.                 , val->getRawData());                         
  146. }                                                             
  147. }
  150. // ---------------------------------------------------------------------------
  151. //  Constructors and Destructor
  152. // ---------------------------------------------------------------------------
  153. AbstractNumericFacetValidator::~AbstractNumericFacetValidator()
  154. {
  155.     if (!fMaxInclusiveInherited && fMaxInclusive)
  156.         delete fMaxInclusive;
  158.     if (!fMaxExclusiveInherited && fMaxExclusive)
  159.         delete fMaxExclusive;
  161.     if (!fMinInclusiveInherited && fMinInclusive)
  162.         delete fMinInclusive;
  164.     if (!fMinExclusiveInherited && fMinExclusive)
  165.         delete fMinExclusive;
  167.     //~RefVectorOf will delete all adopted elements
  168.     if (!fEnumerationInherited &&  fEnumeration)
  169.         delete fEnumeration;
  171.     if (!fEnumerationInherited &&  fStrEnumeration)
  172.         delete fStrEnumeration;
  173. }
  175. AbstractNumericFacetValidator::AbstractNumericFacetValidator(
  176.                           DatatypeValidator*            const baseValidator
  177.                         , RefHashTableOf<KVStringPair>* const facets
  178.                         , const int                           finalSet
  179.                         , const ValidatorType                 type
  180.                         , MemoryManager* const                manager)
  181. :DatatypeValidator(baseValidator, facets, finalSet, type, manager)
  182. , fMaxInclusiveInherited(false)
  183. , fMaxExclusiveInherited(false)
  184. , fMinInclusiveInherited(false)
  185. , fMinExclusiveInherited(false)
  186. , fEnumerationInherited(false)
  187. , fMaxInclusive(0)
  188. , fMaxExclusive(0)
  189. , fMinInclusive(0)
  190. , fMinExclusive(0)
  191. , fEnumeration(0)
  192. , fStrEnumeration(0)
  193. {
  194.     //do not invoke init() here !!!
  195. }
  197. //
  198. //  P1. Enumeration
  199. //
  200. void AbstractNumericFacetValidator::init(RefArrayVectorOf<XMLCh>* const enums)
  201. {
  203.     fStrEnumeration = enums; // save the literal value
  204.                          // which is needed for getEnumString()
  206.     if (enums)
  207.     {
  208.         setFacetsDefined(DatatypeValidator::FACET_ENUMERATION);
  209.     }
  211.     assignFacet();
  212.     inspectFacet();
  213.     inspectFacetBase();
  214.     inheritFacet();
  215. }
  217. //
  218. //   Assign facets
  219. //        assign common facets
  220. //        assign additional facet
  221. //
  222. void AbstractNumericFacetValidator::assignFacet()
  223. {
  225.     RefHashTableOf<KVStringPair>* facets = getFacets();
  227.     if (!facets)     // no facets defined
  228.         return;
  230.     XMLCh* key;
  231.     XMLCh* value;
  233.     RefHashTableOfEnumerator<KVStringPair> e(facets);
  235.     while (e.hasMoreElements())
  236.     {
  237.         KVStringPair pair = e.nextElement();
  238.         key = pair.getKey();
  239.         value = pair.getValue();
  241.         if (XMLString::equals(key, SchemaSymbols::fgELT_PATTERN))
  242.         {
  243.             setPattern(value);
  244.             if (getPattern())
  245.                 setFacetsDefined(DatatypeValidator::FACET_PATTERN);
  246.             // do not construct regex until needed
  247.         }
  248.         else if (XMLString::equals(key, SchemaSymbols::fgELT_MAXINCLUSIVE))
  249.         {
  250.             try
  251.             {
  252.                 setMaxInclusive(value);
  253.             }
  254.             catch (NumberFormatException&)
  255.             {
  256.                 ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MaxIncl, value);
  257.             }
  258.             setFacetsDefined(DatatypeValidator::FACET_MAXINCLUSIVE);
  259.         }
  260.         else if (XMLString::equals(key, SchemaSymbols::fgELT_MAXEXCLUSIVE))
  261.         {
  262.             try
  263.             {
  264.                 setMaxExclusive(value);
  265.             }
  266.             catch (NumberFormatException&)
  267.             {
  268.                 ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MaxExcl, value);
  269.             }
  270.             setFacetsDefined(DatatypeValidator::FACET_MAXEXCLUSIVE);
  271.         }
  272.         else if (XMLString::equals(key, SchemaSymbols::fgELT_MININCLUSIVE))
  273.         {
  274.             try
  275.             {
  276.                 setMinInclusive(value);
  277.             }
  278.             catch (NumberFormatException&)
  279.             {
  280.                 ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MinIncl, value);
  281.             }
  282.             setFacetsDefined(DatatypeValidator::FACET_MININCLUSIVE);
  283.         }
  284.         else if (XMLString::equals(key, SchemaSymbols::fgELT_MINEXCLUSIVE))
  285.         {
  286.             try
  287.             {
  288.                 setMinExclusive(value);
  289.             }
  290.             catch (NumberFormatException&)
  291.             {
  292.                 ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MinExcl, value);
  293.             }
  294.             setFacetsDefined(DatatypeValidator::FACET_MINEXCLUSIVE);
  295.         }
  296.         else if (XMLString::equals(key, SchemaSymbols::fgATT_FIXED))
  297.         {
  298.             unsigned int val;
  299.             bool         retStatus;
  300.             try
  301.             {
  302.                 retStatus = XMLString::textToBin(value, val);
  303.             }
  304.             catch (RuntimeException&)
  305.             {
  306.                 ThrowXML(InvalidDatatypeFacetException, XMLExcepts::FACET_internalError_fixed);
  307.             }
  309.             if (!retStatus)
  310.             {
  311.                 ThrowXML(InvalidDatatypeFacetException, XMLExcepts::FACET_internalError_fixed);
  312.             }
  314.             setFixed(val);
  315.             //no setFacetsDefined here
  317.         }
  318.         else
  319.         {
  320.             assignAdditionalFacet(key, value);
  321.         }
  323.     }//while
  325. }// end of assigneFacet()
  327. //
  328. // Check facet among self
  329. //         check common facets
  330. //         check Additional Facet Constraint
  331. //
  332. void AbstractNumericFacetValidator::inspectFacet()
  333. {
  335.     int thisFacetsDefined = getFacetsDefined();
  336.     XMLNumber *thisMaxInclusive = getMaxInclusive();
  337.     XMLNumber *thisMaxExclusive = getMaxExclusive();
  338.     XMLNumber *thisMinInclusive = getMinInclusive();
  339.     XMLNumber *thisMinExclusive = getMinExclusive();
  341.     if (!thisFacetsDefined)
  342.         return;
  344.     // non co-existence checking
  345.     // check 4.3.8.c1 error: maxInclusive + maxExclusive
  346.     if (((thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
  347.         ((thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) )
  348.         ThrowXML(InvalidDatatypeFacetException, XMLExcepts::FACET_max_Incl_Excl);
  350.     // non co-existence checking
  351.     // check 4.3.9.c1 error: minInclusive + minExclusive
  352.     if (((thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) &&
  353.         ((thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0) )
  354.         ThrowXML(InvalidDatatypeFacetException, XMLExcepts::FACET_min_Incl_Excl);
  356.     //
  357.     // minExclusive < minInclusive <= maxInclusive < maxExclusive
  358.     //
  359.     // check 4.3.7.c1 must: minInclusive <= maxInclusive
  360.     if (((thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
  361.         ((thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0) )
  362.     {
  363.         int result = compareValues(thisMinInclusive, thisMaxInclusive);
  364.         if ( result == 1 || result == INDETERMINATE )
  365.         {
  366.             REPORT_FACET_ERROR(thisMinInclusive
  367.                              , thisMaxInclusive
  368.                              , XMLExcepts::FACET_maxIncl_minIncl)
  369.         }
  370.     }
  372.     // check 4.3.8.c2 must: minExclusive <= maxExclusive
  373.     if ( ((thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
  374.         ((thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) )
  375.     {
  376.         int result = compareValues(getMinExclusive(), getMaxExclusive());
  377.         if ( result == 1 || result == INDETERMINATE )
  378.         {
  379.             REPORT_FACET_ERROR(thisMinExclusive
  380.                              , thisMaxExclusive
  381.                              , XMLExcepts::FACET_maxExcl_minExcl)
  382.         }
  383.     }
  385.     // check 4.3.9.c2 must: minExclusive < maxInclusive
  386.     if ( ((thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
  387.         ((thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) )
  388.     {
  389.         int result = compareValues(getMinExclusive(), getMaxInclusive());
  390.         if ( result != -1 )
  391.         {
  392.             REPORT_FACET_ERROR(thisMinExclusive
  393.                              , thisMaxInclusive
  394.                              , XMLExcepts::FACET_maxIncl_minExcl)
  395.         }
  396.     }
  398.     // check 4.3.10.c1 must: minInclusive < maxExclusive
  399.     if ( ((thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
  400.         ((thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0) )
  401.     {
  402.         int result = compareValues(getMinInclusive(), getMaxExclusive());
  403.         if ( result != -1)
  404.         {
  405.             REPORT_FACET_ERROR(thisMinInclusive
  406.                              , thisMaxExclusive
  407.                              , XMLExcepts::FACET_maxExcl_minIncl)
  408.         }
  409.     }
  411.     checkAdditionalFacetConstraints();
  413. }// end of inspectFacet()
  415. //
  416. //  Check vs base
  417. //         check common facets
  418. //         check enumeration
  419. //         check Additional Facet Constraint
  420. //
  421. void AbstractNumericFacetValidator::inspectFacetBase()
  422. {
  424.     AbstractNumericFacetValidator* numBase = (AbstractNumericFacetValidator*) getBaseValidator();
  425.     int thisFacetsDefined = getFacetsDefined();
  427.     if ( (!thisFacetsDefined && !fEnumeration) ||
  428.          !numBase           )
  429.         return;
  431.     int baseFacetsDefined = numBase->getFacetsDefined();
  433.     XMLNumber *thisMaxInclusive = getMaxInclusive();
  434.     XMLNumber *thisMaxExclusive = getMaxExclusive();
  435.     XMLNumber *thisMinInclusive = getMinInclusive();
  436.     XMLNumber *thisMinExclusive = getMinExclusive();
  438.     XMLNumber *baseMaxInclusive = numBase->getMaxInclusive();
  439.     XMLNumber *baseMaxExclusive = numBase->getMaxExclusive();
  440.     XMLNumber *baseMinInclusive = numBase->getMinInclusive();
  441.     XMLNumber *baseMinExclusive = numBase->getMinExclusive();
  442.     int       baseFixed = numBase->getFixed();
  444.                 //                                     this
  445.                 //                 minExclusive                          maxExclusive
  446.                 //                    minInclusive                  maxInclusive
  447.                 //
  448.                 //                                     base
  449.                 //  minExclusive                                                          maxExclusive
  450.                 //      minInclusive                                                   maxInclusive
  451.                 //
  453.     // check 4.3.7.c2 error:
  454.     // maxInclusive > base.maxInclusive && maxInclusive != base.maxInclusive if (base.fixed)
  455.     // maxInclusive >= base.maxExclusive
  456.     // maxInclusive < base.minInclusive
  457.     // maxInclusive <= base.minExclusive
  459.     if ((thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
  460.     {
  461.         if ((baseFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
  462.         {
  463.             int result = compareValues(thisMaxInclusive, baseMaxInclusive);
  465.             if (((baseFixed & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
  466.                  (result != 0 ))
  467.             {
  468.                 REPORT_FACET_ERROR(thisMaxInclusive
  469.                                  , baseMaxInclusive
  470.                                  , XMLExcepts::FACET_maxIncl_base_fixed)
  471.             }
  473.             if (result == 1 || result == INDETERMINATE)
  474.             {
  475.                 REPORT_FACET_ERROR(thisMaxInclusive
  476.                                  , baseMaxInclusive
  477.                                  , XMLExcepts::FACET_maxIncl_base_maxIncl)
  478.             }
  480.         }
  482.         if ((baseFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
  483.         {
  484.             int result = compareValues(thisMaxInclusive, baseMaxExclusive);
  485.             if (result != -1 )
  486.             {
  487.                 REPORT_FACET_ERROR(thisMaxInclusive
  488.                                  , baseMaxExclusive
  489.                                  , XMLExcepts::FACET_maxIncl_base_maxExcl)
  490.             }
  491.         }
  494.         if ((baseFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
  495.         {
  496.             int result = compareValues(thisMaxInclusive, baseMinInclusive);
  497.             if (result == -1 || result == INDETERMINATE)
  498.             {
  499.                 REPORT_FACET_ERROR(thisMaxInclusive
  500.                                  , baseMinInclusive
  501.                                  , XMLExcepts::FACET_maxIncl_base_minIncl)
  502.             }
  503.         }
  505.         if ((baseFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
  506.         {
  507.             int result = compareValues(thisMaxInclusive, baseMinExclusive);
  508.             if (result != 1 )
  509.             {
  510.                 REPORT_FACET_ERROR(thisMaxInclusive
  511.                                  , baseMinExclusive
  512.                                  , XMLExcepts::FACET_maxIncl_base_minExcl)
  513.             }
  514.         }
  516.     }
  518.     // check 4.3.8.c3 error:
  519.     // maxExclusive > base.maxExclusive  && maxExclusive != base.maxExclusive if (base.fixed)
  520.     // maxExclusive > base.maxInclusive
  521.     // maxExclusive <= base.minInclusive
  522.     // maxExclusive <= base.minExclusive
  524.     if ((thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
  525.     {
  526.         if (( baseFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
  527.         {
  528.             int result = compareValues(thisMaxExclusive, baseMaxExclusive);
  530.             if (((baseFixed & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
  531.                  (result != 0 ))
  532.             {
  533.                 REPORT_FACET_ERROR(thisMaxExclusive
  534.                                  , baseMaxExclusive
  535.                                  , XMLExcepts::FACET_maxExcl_base_fixed)
  536.              }
  538.             if (result == 1 || result == INDETERMINATE)
  539.             {
  540.                 REPORT_FACET_ERROR(thisMaxExclusive
  541.                                  , baseMaxExclusive
  542.                                  , XMLExcepts::FACET_maxExcl_base_maxExcl)
  543.             }
  545.             /**
  546.              * Schema Errata
  547.              * E2-16 maxExclusive
  548.              *
  549.              *   derived type's maxExclusive must either be
  550.              *   1) equal to base' maxExclusive or
  551.              *   2) from the base type value space
  552.              *
  553.              */
  554.             if (result != 0)
  555.             {
  556.                 FROM_BASE_VALUE_SPACE(thisMaxExclusive
  557.                         , DatatypeValidator::FACET_MAXEXCLUSIVE
  558.                         , XMLExcepts::FACET_maxExcl_notFromBase)
  559.             }
  560.         }
  561.         else  // base has no maxExclusive
  562.         {
  563.             FROM_BASE_VALUE_SPACE(thisMaxExclusive
  564.                         , DatatypeValidator::FACET_MAXEXCLUSIVE
  565.                         , XMLExcepts::FACET_maxExcl_notFromBase)
  566.         }
  568.         if (( baseFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
  569.         {
  570.             int result = compareValues(thisMaxExclusive, baseMaxInclusive);
  571.             if (result == 1 || result == INDETERMINATE)
  572.             {
  573.                 REPORT_FACET_ERROR(thisMaxExclusive
  574.                                  , baseMaxInclusive
  575.                                  , XMLExcepts::FACET_maxExcl_base_maxIncl)
  576.             }
  577.         }
  579.         if (( baseFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
  580.         {
  581.             int result = compareValues(thisMaxExclusive, baseMinExclusive);
  582.             if (result != 1)
  583.             {
  584.                 REPORT_FACET_ERROR(thisMaxExclusive
  585.                                  , baseMinExclusive
  586.                                  , XMLExcepts::FACET_maxExcl_base_minExcl)
  587.             }
  588.         }
  590.         if (( baseFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
  591.         {
  592.             int result = compareValues(thisMaxExclusive, baseMinInclusive);
  593.             if (result != 1)
  594.             {
  595.                 REPORT_FACET_ERROR(thisMaxExclusive
  596.                                  , baseMinInclusive
  597.                                  , XMLExcepts::FACET_maxExcl_base_minIncl)
  598.             }
  599.         }
  600.     }
  602.     // check 4.3.9.c3 error:
  603.     // minExclusive < base.minExclusive     minExclusive != base.minExclusive if (base.fixed)
  604.     // minExclusive > base.maxInclusive ??? minExclusive >= base.maxInclusive
  605.     // minExclusive < base.minInclusive
  606.     // minExclusive >= base.maxExclusive
  608.     if ((thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
  609.     {
  610.         if (( baseFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
  611.         {
  612.             int result = compareValues(thisMinExclusive, baseMinExclusive);
  614.             if (((baseFixed & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) &&
  615.                  (result != 0 ))
  616.             {
  617.                 REPORT_FACET_ERROR(thisMinExclusive
  618.                                  , baseMinExclusive
  619.                                  , XMLExcepts::FACET_minExcl_base_fixed)
  620.             }
  622.             if (result == -1 || result == INDETERMINATE)
  623.             {
  624.                 REPORT_FACET_ERROR(thisMinExclusive
  625.                                  , baseMinExclusive
  626.                                  , XMLExcepts::FACET_minExcl_base_minExcl)
  627.             }
  629.             /**
  630.              * Schema Errata
  631.              * E2-16 maxExclusive
  632.              *
  633.              *   derived type's minExclusive must either be
  634.              *   1) equal to base' minxExclusive or
  635.              *   2) from the base type value space
  636.              *
  637.              *  Note: deduced from, not explicitly expressed in the Errata
  638.              */
  639.             if (result != 0)
  640.             {
  641.                 FROM_BASE_VALUE_SPACE(thisMinExclusive
  642.                         , DatatypeValidator::FACET_MINEXCLUSIVE
  643.                         , XMLExcepts::FACET_minExcl_notFromBase)
  644.             }
  645.         }
  646.         else // base has no minExclusive
  647.         {
  649.             FROM_BASE_VALUE_SPACE(thisMinExclusive
  650.                         , DatatypeValidator::FACET_MINEXCLUSIVE
  651.                         , XMLExcepts::FACET_minExcl_notFromBase)
  652.         }
  654.         if (( baseFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
  655.         {
  656.             int result = compareValues(thisMinExclusive, baseMaxInclusive);
  657.             if (result == 1 || result == INDETERMINATE)
  658.             {
  659.                 REPORT_FACET_ERROR(thisMinExclusive
  660.                                  , baseMaxInclusive
  662.                                  , XMLExcepts::FACET_minExcl_base_maxIncl)
  663.             }
  664.         }
  666.         if (( baseFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
  667.         {
  668.             int result = compareValues(thisMinExclusive, baseMinInclusive);
  669.             if (result == -1 || result == INDETERMINATE)
  670.             {
  671.                 REPORT_FACET_ERROR(thisMinExclusive
  672.                                  , baseMinInclusive
  673.                                  , XMLExcepts::FACET_minExcl_base_minIncl)
  674.             }
  675.         }
  677.         if (( baseFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
  678.         {
  679.             int result = compareValues(thisMinExclusive, baseMaxExclusive);
  680.             if (result != -1)
  681.             {
  682.                 REPORT_FACET_ERROR(thisMinExclusive
  683.                                  , baseMaxExclusive
  684.                                  , XMLExcepts::FACET_minExcl_base_maxExcl)
  685.             }
  686.         }
  688.     }
  690.     // check 4.3.10.c2 error:
  691.     // minInclusive < base.minInclusive   minInclusive != base.minInclusive if (base.fixed)
  692.     // minInclusive > base.maxInclusive
  693.     // minInclusive <= base.minExclusive
  694.     // minInclusive >= base.maxExclusive
  697.     if ((thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
  698.     {
  699.         if ((baseFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
  700.         {
  701.             int result = compareValues(thisMinInclusive, baseMinInclusive);
  703.             if (((baseFixed & DatatypeValidator::FACET_MININCLUSIVE) != 0) &&
  704.                  (result != 0 ))
  705.             {
  706.                 REPORT_FACET_ERROR(thisMinInclusive
  707.                                  , baseMinInclusive
  708.                                  , XMLExcepts::FACET_minIncl_base_fixed)
  709.             }
  711.             if (result == -1 || result == INDETERMINATE)
  712.             {
  713.                 REPORT_FACET_ERROR(thisMinInclusive
  714.                                  , baseMinInclusive
  715.                                  , XMLExcepts::FACET_minIncl_base_minIncl)
  716.             }
  717.         }
  719.         if (( baseFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
  720.         {
  721.             int result = compareValues(thisMinInclusive, baseMaxInclusive);
  722.             if (result == 1 || result == INDETERMINATE)
  723.             {
  724.                 REPORT_FACET_ERROR(thisMinInclusive
  725.                                  , baseMaxInclusive
  726.                                  , XMLExcepts::FACET_minIncl_base_maxIncl)
  727.             }
  728.         }
  730.         if (( baseFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
  731.         {
  732.             int result = compareValues(thisMinInclusive, baseMinExclusive);
  733.             if (result != 1)
  734.             {
  735.                 REPORT_FACET_ERROR(thisMinInclusive
  736.                                  , baseMinExclusive
  737.                                  , XMLExcepts::FACET_minIncl_base_minExcl)
  738.             }
  739.         }
  741.         if (( baseFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
  742.         {
  743.             int result = compareValues(thisMinInclusive, baseMaxExclusive);
  744.             if (result != -1)
  745.             {
  746.                 REPORT_FACET_ERROR(thisMinInclusive
  747.                                  , baseMaxExclusive
  748.                                  , XMLExcepts::FACET_minIncl_base_maxExcl)
  749.             }
  750.         }
  752.     }
  754.     checkAdditionalFacetConstraintsBase();
  756.     // check 4.3.5.c0 must: enumeration values from the value space of base
  757.     //
  758.     // In fact, the values in the enumeration shall go through validation
  759.     // of this class as well.
  760.     // this->checkContent(value, false);
  761.     //
  762.     if ( ((thisFacetsDefined & DatatypeValidator::FACET_ENUMERATION) != 0) &&
  763.         ( fStrEnumeration ))
  764.     {
  765.         setEnumeration();
  766.     }
  768.     //
  769.     // maxInclusive, maxExclusive, minInclusive and minExclusive
  770.     // shall come from the base's value space as well
  771.     //
  773.     FROM_BASE_VALUE_SPACE(thisMaxInclusive
  774.                         , DatatypeValidator::FACET_MAXINCLUSIVE
  775.                         , XMLExcepts::FACET_maxIncl_notFromBase)
  777.     FROM_BASE_VALUE_SPACE(thisMinInclusive
  778.                         , DatatypeValidator::FACET_MININCLUSIVE
  779.                         , XMLExcepts::FACET_minIncl_notFromBase)
  781. } //end of inspectFacetBase
  783. //
  784. //  Inherit facet from base
  785. //    a. inherit common facets
  786. //    b. inherit additional facet
  787. //
  788. void AbstractNumericFacetValidator::inheritFacet()
  789. {
  791.     AbstractNumericFacetValidator* numBase = (AbstractNumericFacetValidator*) getBaseValidator();
  792.     if (!numBase)
  793.         return;
  795.     int thisFacetsDefined = getFacetsDefined();
  796.     int baseFacetsDefined = numBase->getFacetsDefined();
  798.     // inherit enumeration
  799.     if ((( baseFacetsDefined & DatatypeValidator::FACET_ENUMERATION) != 0) &&
  800.         (( thisFacetsDefined & DatatypeValidator::FACET_ENUMERATION) == 0))
  801.     {
  802.         fEnumeration = numBase->fEnumeration;
  803.         fEnumerationInherited = true;
  804.         setFacetsDefined(DatatypeValidator::FACET_ENUMERATION);
  805.     }
  807.     // inherit maxInclusive
  808.     if ((( baseFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
  809.         (( thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) == 0) &&
  810.         (( thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) == 0) )
  811.     {
  812.         fMaxInclusive = numBase->getMaxInclusive();
  813.         fMaxInclusiveInherited = true;
  814.         setFacetsDefined(DatatypeValidator::FACET_MAXINCLUSIVE);
  815.     }
  817.     // inherit maxExclusive
  818.     if ((( baseFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
  819.         (( thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) == 0) &&
  820.         (( thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) == 0) )
  821.     {
  822.         fMaxExclusive = numBase->getMaxExclusive();
  823.         fMaxExclusiveInherited = true;
  824.         setFacetsDefined(DatatypeValidator::FACET_MAXEXCLUSIVE);
  825.     }
  827.     // inherit minExclusive
  828.     if ((( baseFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0) &&
  829.         (( thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) == 0) &&
  830.         (( thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) == 0) )
  831.     {
  832.         fMinInclusive = numBase->getMinInclusive();
  833.         fMinInclusiveInherited = true;
  834.         setFacetsDefined(DatatypeValidator::FACET_MININCLUSIVE);
  835.     }
  837.     // inherit minExclusive
  838.     if ((( baseFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) &&
  839.         (( thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) == 0) &&
  840.         (( thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) == 0) )
  841.     {
  842.         fMinExclusive = numBase->getMinExclusive();
  843.         fMinExclusiveInherited = true;
  844.         setFacetsDefined(DatatypeValidator::FACET_MINEXCLUSIVE);
  845.     }
  847.     inheritAdditionalFacet();
  849.     // inherit "fixed" option
  850.     setFixed(getFixed() | numBase->getFixed());
  852. }
  854. const RefArrayVectorOf<XMLCh>* AbstractNumericFacetValidator::getEnumString() const
  855. {
  856. return (fEnumerationInherited? getBaseValidator()->getEnumString() : fStrEnumeration );
  857. }
  859. XERCES_CPP_NAMESPACE_END
  861. /**
  862.   * End of file AbstractNumericFacetValidator::cpp
  863.   */