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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
AbstractNumericFacetValidator.cpp
资源名称：xerces-c-src1_6_0.tar.gz　[点击查看]
上传用户：huihehuasu
上传日期：2007-01-10
资源大小：6948k
文件大小：28k
源码类别：

xml/soap/webservice

开发平台：

C/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.4 2001/11/12 20:37:57 peiyongz Exp $
  59.  * $Log: AbstractNumericFacetValidator.cpp,v $
  60.  * Revision 1.4  2001/11/12 20:37:57  peiyongz
  61.  * SchemaDateTimeException defined
  62.  *
  63.  * Revision 1.3  2001/10/16 16:29:34  tng
  64.  * Schema: Fix Typo
  65.  *
  66.  * Revision 1.2  2001/10/09 21:17:41  peiyongz
  67.  * . macro to simplify code
  68.  * .save get***() to temp vars.
  69.  *
  70.  * Revision 1.1  2001/10/01 16:13:56  peiyongz
  71.  * DTV Reorganization:new classes: AbstractNumericFactValidator/ AbstractNumericValidator
  72.  *
  73.  */
  75. // ---------------------------------------------------------------------------
  76. //  Includes
  77. // ---------------------------------------------------------------------------
  78. #include <validators/datatype/AbstractNumericFacetValidator.hpp>
  79. #include <validators/schema/SchemaSymbols.hpp>
  80. #include <validators/datatype/InvalidDatatypeFacetException.hpp>
  81. #include <util/NumberFormatException.hpp>
  83. const int AbstractNumericFacetValidator::INDETERMINATE = 2;
  85. #define  REPORT_FACET_ERROR(val1, val2, except_code)    
  86.   XMLCh* value1 = (val1)->toString();                   
  87.   ArrayJanitor<XMLCh> jan1(value1);                     
  88.   XMLCh* value2 = (val2)->toString();                   
  89.   ArrayJanitor<XMLCh> jan2(value2);                     
  90.   ThrowXML2(InvalidDatatypeFacetException               
  91.           , except_code                                 
  92.           , value2                                      
  93.           , value1);
  96. #define  FROM_BASE_VALUE_SPACE(val, facetFlag, except_code)   
  97.   if ((thisFacetsDefined & facetFlag) != 0)                   
  98. {                                                             
  99.     XMLCh* value1 = (val)->toString();                        
  100.     ArrayJanitor<XMLCh> jan(value1);                          
  101.     try                                                       
  102. {                                                             
  103.         numBase->checkContent(value1, false);                 
  104. }                                                             
  105.     catch ( XMLException& )                                   
  106. {                                                             
  107.         ThrowXML1(InvalidDatatypeFacetException               
  108.                 , except_code                                 
  109.                 , value1);                                    
  110. }                                                             
  111. }
  114. // ---------------------------------------------------------------------------
  115. //  Constructors and Destructor
  116. // ---------------------------------------------------------------------------
  117. AbstractNumericFacetValidator::~AbstractNumericFacetValidator()
  118. {
  119.     if (fMaxInclusive && !fMaxInclusiveInherited)
  120.         delete fMaxInclusive;
  122.     if (fMaxExclusive && !fMaxExclusiveInherited)
  123.         delete fMaxExclusive;
  125.     if (fMinInclusive && !fMinInclusiveInherited)
  126.         delete fMinInclusive;
  128.     if (fMinExclusive && !fMinExclusiveInherited)
  129.         delete fMinExclusive;
  131.     //~RefVectorOf will delete all adopted elements
  132.     if (fEnumeration && !fEnumerationInherited)
  133.         delete fEnumeration;
  134. }
  136. AbstractNumericFacetValidator::AbstractNumericFacetValidator(
  137.                           DatatypeValidator*            const baseValidator
  138.                         , RefHashTableOf<KVStringPair>* const facets
  139.                         , const int                           finalSet
  140.                         , const ValidatorType                 type)
  141. :DatatypeValidator(baseValidator, facets, finalSet, type)
  142. , fMaxInclusiveInherited(false)
  143. , fMaxExclusiveInherited(false)
  144. , fMinInclusiveInherited(false)
  145. , fMinExclusiveInherited(false)
  146. , fEnumerationInherited(false)
  147. , fMaxInclusive(0)
  148. , fMaxExclusive(0)
  149. , fMinInclusive(0)
  150. , fMinExclusive(0)
  151. , fEnumeration(0)
  152. , fStrEnumeration(0)
  153. {
  154.     //do not invoke init() here !!!
  155. }
  157. //
  158. //  P1. Enumeration
  159. //
  160. void AbstractNumericFacetValidator::init(RefVectorOf<XMLCh>* const enums)
  161. {
  163.     fStrEnumeration = enums; // save the literal value
  164.     Janitor<RefVectorOf<XMLCh> >    janStrEnum(fStrEnumeration);
  166.     if (enums)
  167.     {
  168.         setFacetsDefined(DatatypeValidator::FACET_ENUMERATION);
  169.     }
  171.     assignFacet();
  172.     inspectFacet();
  173.     inspectFacetBase();
  174.     inheritFacet();
  175. }
  177. //
  178. //   Assign facets
  179. //        assign common facets
  180. //        assign additional facet
  181. //
  182. void AbstractNumericFacetValidator::assignFacet()
  183. {
  185.     RefHashTableOf<KVStringPair>* facets = getFacets();
  187.     if (!facets)     // no facets defined
  188.         return;
  190.     XMLCh* key;
  191.     XMLCh* value;
  193.     RefHashTableOfEnumerator<KVStringPair> e(facets);
  195.     while (e.hasMoreElements())
  196.     {
  197.         KVStringPair pair = e.nextElement();
  198.         key = pair.getKey();
  199.         value = pair.getValue();
  201.         if (XMLString::compareString(key, SchemaSymbols::fgELT_PATTERN) == 0)
  202.         {
  203.             setPattern(value);
  204.             if (getPattern())
  205.                 setFacetsDefined(DatatypeValidator::FACET_PATTERN);
  206.             // do not construct regex until needed
  207.         }
  208.         else if (XMLString::compareString(key, SchemaSymbols::fgELT_MAXINCLUSIVE)==0)
  209.         {
  210.             try
  211.             {
  212.                 setMaxInclusive(value);
  213.             }
  214.             catch (NumberFormatException)
  215.             {
  216.                 ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MaxIncl, value);
  217.             }
  218.             setFacetsDefined(DatatypeValidator::FACET_MAXINCLUSIVE);
  219.         }
  220.         else if (XMLString::compareString(key, SchemaSymbols::fgELT_MAXEXCLUSIVE)==0)
  221.         {
  222.             try
  223.             {
  224.                 setMaxExclusive(value);
  225.             }
  226.             catch (NumberFormatException)
  227.             {
  228.                 ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MaxExcl, value);
  229.             }
  230.             setFacetsDefined(DatatypeValidator::FACET_MAXEXCLUSIVE);
  231.         }
  232.         else if (XMLString::compareString(key, SchemaSymbols::fgELT_MININCLUSIVE)==0)
  233.         {
  234.             try
  235.             {
  236.                 setMinInclusive(value);
  237.             }
  238.             catch (NumberFormatException)
  239.             {
  240.                 ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MinIncl, value);
  241.             }
  242.             setFacetsDefined(DatatypeValidator::FACET_MININCLUSIVE);
  243.         }
  244.         else if (XMLString::compareString(key, SchemaSymbols::fgELT_MINEXCLUSIVE)==0)
  245.         {
  246.             try
  247.             {
  248.                 setMinExclusive(value);
  249.             }
  250.             catch (NumberFormatException)
  251.             {
  252.                 ThrowXML1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MinExcl, value);
  253.             }
  254.             setFacetsDefined(DatatypeValidator::FACET_MINEXCLUSIVE);
  255.         }
  256.         else if (XMLString::compareString(key, SchemaSymbols::fgATT_FIXED)==0)
  257.         {
  258.             unsigned int val;
  259.             bool         retStatus;
  260.             try
  261.             {
  262.                 retStatus = XMLString::textToBin(value, val);
  263.             }
  264.             catch (RuntimeException)
  265.             {
  266.                 ThrowXML(InvalidDatatypeFacetException, XMLExcepts::FACET_internalError_fixed);
  267.             }
  269.             if (!retStatus)
  270.             {
  271.                 ThrowXML(InvalidDatatypeFacetException, XMLExcepts::FACET_internalError_fixed);
  272.             }
  274.             setFixed(val);
  275.             //no setFacetsDefined here
  277.         }
  278.         else
  279.         {
  280.             assignAdditionalFacet(key, value);
  281.         }
  283.     }//while
  285. }// end of assigneFacet()
  287. //
  288. // Check facet among self
  289. //         check common facets
  290. //         check Additional Facet Constraint
  291. //
  292. void AbstractNumericFacetValidator::inspectFacet()
  293. {
  295.     int thisFacetsDefined = getFacetsDefined();
  296.     XMLNumber *thisMaxInclusive = getMaxInclusive();
  297.     XMLNumber *thisMaxExclusive = getMaxExclusive();
  298.     XMLNumber *thisMinInclusive = getMinInclusive();
  299.     XMLNumber *thisMinExclusive = getMinExclusive();
  301.     if (!thisFacetsDefined)
  302.         return;
  304.     // non co-existence checking
  305.     // check 4.3.8.c1 error: maxInclusive + maxExclusive
  306.     if (((thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
  307.         ((thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) )
  308.         ThrowXML(InvalidDatatypeFacetException, XMLExcepts::FACET_max_Incl_Excl);
  310.     // non co-existence checking
  311.     // check 4.3.9.c1 error: minInclusive + minExclusive
  312.     if (((thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) &&
  313.         ((thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0) )
  314.         ThrowXML(InvalidDatatypeFacetException, XMLExcepts::FACET_min_Incl_Excl);
  316.     //
  317.     // minExclusive < minInclusive <= maxInclusive < maxExclusive
  318.     //
  319.     // check 4.3.7.c1 must: minInclusive <= maxInclusive
  320.     if (((thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
  321.         ((thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0) )
  322.     {
  323.         int result = compareValues(thisMinInclusive, thisMaxInclusive);
  324.         if ( result == 1 || result == INDETERMINATE )
  325.         {
  326.             REPORT_FACET_ERROR(thisMinInclusive
  327.                              , thisMaxInclusive
  328.                              , XMLExcepts::FACET_maxIncl_minIncl)
  329.         }
  330.     }
  332.     // check 4.3.8.c2 must: minExclusive <= maxExclusive
  333.     if ( ((thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
  334.         ((thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) )
  335.     {
  336.         int result = compareValues(getMinExclusive(), getMaxExclusive());
  337.         if ( result == 1 || result == INDETERMINATE )
  338.         {
  339.             REPORT_FACET_ERROR(thisMinExclusive
  340.                              , thisMaxExclusive
  341.                              , XMLExcepts::FACET_maxExcl_minExcl)
  342.         }
  343.     }
  345.     // check 4.3.9.c2 must: minExclusive < maxInclusive
  346.     if ( ((thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
  347.         ((thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) )
  348.     {
  349.         int result = compareValues(getMinExclusive(), getMaxInclusive());
  350.         if ( result != -1 )
  351.         {
  352.             REPORT_FACET_ERROR(thisMinExclusive
  353.                              , thisMaxInclusive
  354.                              , XMLExcepts::FACET_maxIncl_minExcl)
  355.         }
  356.     }
  358.     // check 4.3.10.c1 must: minInclusive < maxExclusive
  359.     if ( ((thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
  360.         ((thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0) )
  361.     {
  362.         int result = compareValues(getMinInclusive(), getMaxExclusive());
  363.         if ( result != -1)
  364.         {
  365.             REPORT_FACET_ERROR(thisMinInclusive
  366.                              , thisMaxExclusive
  367.                              , XMLExcepts::FACET_maxExcl_minIncl)
  368.         }
  369.     }
  371.     checkAdditionalFacetConstraints();
  373. }// end of inspectFacet()
  375. //
  376. //  Check vs base
  377. //         check common facets
  378. //         check enumeration
  379. //         check Additional Facet Constraint
  380. //
  381. void AbstractNumericFacetValidator::inspectFacetBase()
  382. {
  384.     AbstractNumericFacetValidator* numBase = (AbstractNumericFacetValidator*) getBaseValidator();
  385.     int thisFacetsDefined = getFacetsDefined();
  387.     if ( (!thisFacetsDefined && !fEnumeration) ||
  388.          !numBase           )
  389.         return;
  391.     int baseFacetsDefined = numBase->getFacetsDefined();
  393.     XMLNumber *thisMaxInclusive = getMaxInclusive();
  394.     XMLNumber *thisMaxExclusive = getMaxExclusive();
  395.     XMLNumber *thisMinInclusive = getMinInclusive();
  396.     XMLNumber *thisMinExclusive = getMinExclusive();
  398.     XMLNumber *baseMaxInclusive = numBase->getMaxInclusive();
  399.     XMLNumber *baseMaxExclusive = numBase->getMaxExclusive();
  400.     XMLNumber *baseMinInclusive = numBase->getMinInclusive();
  401.     XMLNumber *baseMinExclusive = numBase->getMinExclusive();
  402.     int       baseFixed = numBase->getFixed();
  404.                 //                                     this
  405.                 //                 minExclusive                          maxExclusive
  406.                 //                    minInclusive                  maxInclusive
  407.                 //
  408.                 //                                     base
  409.                 //  minExclusive                                                          maxExclusive
  410.                 //      minInclusive                                                   maxInclusive
  411.                 //
  413.     // check 4.3.7.c2 error:
  414.     // maxInclusive > base.maxInclusive && maxInclusive != base.maxInclusive if (base.fixed)
  415.     // maxInclusive >= base.maxExclusive
  416.     // maxInclusive < base.minInclusive
  417.     // maxInclusive <= base.minExclusive
  419.     if ((thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
  420.     {
  421.         if ((baseFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
  422.         {
  423.             int result = compareValues(thisMaxInclusive, baseMaxInclusive);
  425.             if (((baseFixed & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
  426.                  (result != 0 ))
  427.             {
  428.                 REPORT_FACET_ERROR(baseMaxInclusive
  429.                                  , thisMaxInclusive
  430.                                  , XMLExcepts::FACET_maxIncl_base_fixed)
  431.             }
  433.             if (result == 1 || result == INDETERMINATE)
  434.             {
  435.                 REPORT_FACET_ERROR(baseMaxInclusive
  436.                                  , thisMaxInclusive
  437.                                  , XMLExcepts::FACET_maxIncl_base_maxIncl)
  438.             }
  440.         }
  442.         if ((baseFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
  443.         {
  444.             int result = compareValues(thisMaxInclusive, baseMaxExclusive);
  445.             if (result != -1 )
  446.             {
  447.                 REPORT_FACET_ERROR(baseMaxExclusive
  448.                                  , thisMaxInclusive
  449.                                  , XMLExcepts::FACET_maxIncl_base_maxExcl)
  450.             }
  451.         }
  454.         if ((baseFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
  455.         {
  456.             int result = compareValues(thisMaxInclusive, baseMinInclusive);
  457.             if (result == -1 || result == INDETERMINATE)
  458.             {
  459.                 REPORT_FACET_ERROR(baseMinInclusive
  460.                                  , thisMaxInclusive
  461.                                  , XMLExcepts::FACET_maxIncl_base_minIncl)
  462.             }
  463.         }
  465.         if ((baseFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
  466.         {
  467.             int result = compareValues(thisMaxInclusive, baseMinExclusive);
  468.             if (result != 1 )
  469.             {
  470.                 REPORT_FACET_ERROR(baseMinExclusive
  471.                                  , thisMaxInclusive
  472.                                  , XMLExcepts::FACET_maxIncl_base_minExcl)
  473.             }
  474.         }
  476.     }
  478.     // check 4.3.8.c3 error:
  479.     // maxExclusive > base.maxExclusive  && maxExclusive != base.maxExclusive if (base.fixed)
  480.     // maxExclusive > base.maxInclusive
  481.     // maxExclusive <= base.minInclusive
  482.     // maxExclusive <= base.minExclusive
  484.     if ((thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
  485.     {
  486.         if (( baseFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
  487.         {
  488.             int result = compareValues(thisMaxExclusive, baseMaxExclusive);
  490.             if (((baseFixed & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
  491.                  (result != 0 ))
  492.             {
  493.                 REPORT_FACET_ERROR(baseMaxExclusive
  494.                                  , thisMaxExclusive
  495.                                  , XMLExcepts::FACET_maxExcl_base_fixed)
  496.              }
  498.             if (result == 1 || result == INDETERMINATE)
  499.             {
  500.                 REPORT_FACET_ERROR(baseMaxExclusive
  501.                                  , thisMaxExclusive
  502.                                  , XMLExcepts::FACET_maxExcl_base_maxExcl)
  503.             }
  504.         }
  506.         if (( baseFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
  507.         {
  508.             int result = compareValues(thisMaxExclusive, baseMaxInclusive);
  509.             if (result == 1 || result == INDETERMINATE)
  510.             {
  511.                 REPORT_FACET_ERROR(baseMaxInclusive
  512.                                  , thisMaxExclusive
  513.                                  , XMLExcepts::FACET_maxExcl_base_maxIncl)
  514.             }
  515.         }
  517.         if (( baseFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
  518.         {
  519.             int result = compareValues(thisMaxExclusive, baseMinExclusive);
  520.             if (result != 1)
  521.             {
  522.                 REPORT_FACET_ERROR(baseMinExclusive
  523.                                  , thisMaxExclusive
  524.                                  , XMLExcepts::FACET_maxExcl_base_minExcl)
  525.             }
  526.         }
  528.         if (( baseFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
  529.         {
  530.             int result = compareValues(thisMaxExclusive, baseMinInclusive);
  531.             if (result != 1)
  532.             {
  533.                 REPORT_FACET_ERROR(baseMinInclusive
  534.                                  , thisMaxExclusive
  535.                                  , XMLExcepts::FACET_maxExcl_base_minExcl)
  536.             }
  537.         }
  538.     }
  540.     // check 4.3.9.c3 error:
  541.     // minExclusive < base.minExclusive     minExclusive != base.minExclusive if (base.fixed)
  542.     // minExclusive > base.maxInclusive ??? minExclusive >= base.maxInclusive
  543.     // minExclusive < base.minInclusive
  544.     // minExclusive >= base.maxExclusive
  546.     if ((thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
  547.     {
  548.         if (( baseFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
  549.         {
  550.             int result = compareValues(thisMinExclusive, baseMinExclusive);
  552.             if (((baseFixed & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) &&
  553.                  (result != 0 ))
  554.             {
  555.                 REPORT_FACET_ERROR(baseMinExclusive
  556.                                  , thisMinExclusive
  557.                                  , XMLExcepts::FACET_minExcl_base_fixed)
  558.             }
  560.             if (result == -1 || result == INDETERMINATE)
  561.             {
  562.                 REPORT_FACET_ERROR(baseMinExclusive
  563.                                  , thisMinExclusive
  564.                                  , XMLExcepts::FACET_minExcl_base_minExcl)
  565.             }
  566.         }
  568.         if (( baseFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
  569.         {
  570.             int result = compareValues(thisMinExclusive, baseMaxInclusive);
  571.             if (result == 1 || result == INDETERMINATE)
  572.             {
  573.                 REPORT_FACET_ERROR(baseMaxInclusive
  574.                                  , thisMinExclusive
  575.                                  , XMLExcepts::FACET_minExcl_base_maxIncl)
  576.             }
  577.         }
  579.         if (( baseFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
  580.         {
  581.             int result = compareValues(thisMinExclusive, baseMinInclusive);
  582.             if (result == -1 || result == INDETERMINATE)
  583.             {
  584.                 REPORT_FACET_ERROR(baseMinInclusive
  585.                                  , thisMinExclusive
  586.                                  , XMLExcepts::FACET_minExcl_base_minIncl)
  587.             }
  588.         }
  590.         if (( baseFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
  591.         {
  592.             int result = compareValues(thisMinExclusive, baseMaxExclusive);
  593.             if (result != -1)
  594.             {
  595.                 REPORT_FACET_ERROR(baseMaxExclusive
  596.                                  , thisMinExclusive
  597.                                  , XMLExcepts::FACET_minExcl_base_maxExcl)
  598.             }
  599.         }
  601.     }
  603.     // check 4.3.10.c2 error:
  604.     // minInclusive < base.minInclusive   minInclusive != base.minInclusive if (base.fixed)
  605.     // minInclusive > base.maxInclusive
  606.     // minInclusive <= base.minExclusive
  607.     // minInclusive >= base.maxExclusive
  610.     if ((thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
  611.     {
  612.         if ((baseFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
  613.         {
  614.             int result = compareValues(thisMinInclusive, baseMinInclusive);
  616.             if (((baseFixed & DatatypeValidator::FACET_MININCLUSIVE) != 0) &&
  617.                  (result != 0 ))
  618.             {
  619.                 REPORT_FACET_ERROR(baseMinInclusive
  620.                                  , thisMinInclusive
  621.                                  , XMLExcepts::FACET_minIncl_base_fixed)
  622.             }
  624.             if (result == -1 || result == INDETERMINATE)
  625.             {
  626.                 REPORT_FACET_ERROR(baseMinInclusive
  627.                                  , thisMinInclusive
  628.                                  , XMLExcepts::FACET_minIncl_base_minIncl)
  629.             }
  630.         }
  632.         if (( baseFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
  633.         {
  634.             int result = compareValues(thisMinInclusive, baseMaxInclusive);
  635.             if (result == 1 || result == INDETERMINATE)
  636.             {
  637.                 REPORT_FACET_ERROR(baseMaxInclusive
  638.                                  , thisMinInclusive
  639.                                  , XMLExcepts::FACET_minIncl_base_maxIncl)
  640.             }
  641.         }
  643.         if (( baseFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
  644.         {
  645.             int result = compareValues(thisMinInclusive, baseMinExclusive);
  646.             if (result != 1)
  647.             {
  648.                 REPORT_FACET_ERROR(baseMinExclusive
  649.                                  , thisMinInclusive
  650.                                  , XMLExcepts::FACET_minIncl_base_minExcl)
  651.             }
  652.         }
  654.         if (( baseFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
  655.         {
  656.             int result = compareValues(thisMinInclusive, baseMaxExclusive);
  657.             if (result != -1)
  658.             {
  659.                 REPORT_FACET_ERROR(baseMaxExclusive
  660.                                  , thisMinInclusive
  661.                                  , XMLExcepts::FACET_minIncl_base_maxExcl)
  662.             }
  663.         }
  665.     }
  667.     checkAdditionalFacetConstraintsBase();
  669.     // check 4.3.5.c0 must: enumeration values from the value space of base
  670.     //
  671.     // In fact, the values in the enumeration shall go through validation
  672.     // of this class as well.
  673.     // this->checkContent(value, false);
  674.     //
  675.     if ( ((thisFacetsDefined & DatatypeValidator::FACET_ENUMERATION) != 0) &&
  676.         ( fStrEnumeration ))
  677.     {
  678.         setEnumeration();
  679.     }
  681.     //
  682.     // maxInclusive, maxExclusive, minInclusive and minExclusive
  683.     // shall come from the base's value space as well
  684.     //
  686.     FROM_BASE_VALUE_SPACE(thisMaxInclusive
  687.                         , DatatypeValidator::FACET_MAXINCLUSIVE
  688.                         , XMLExcepts::FACET_maxIncl_notFromBase)
  690.     FROM_BASE_VALUE_SPACE(thisMaxExclusive
  691.                         , DatatypeValidator::FACET_MAXEXCLUSIVE
  692.                         , XMLExcepts::FACET_maxExcl_notFromBase)
  694.     FROM_BASE_VALUE_SPACE(thisMinInclusive
  695.                         , DatatypeValidator::FACET_MININCLUSIVE
  696.                         , XMLExcepts::FACET_minIncl_notFromBase)
  698.     FROM_BASE_VALUE_SPACE(thisMinExclusive
  699.                         , DatatypeValidator::FACET_MINEXCLUSIVE
  700.                         , XMLExcepts::FACET_minExcl_notFromBase)
  702. } //end of inspectFacetBase
  704. //
  705. //  Inherit facet from base
  706. //    a. inherit common facets
  707. //    b. inherit additional facet
  708. //
  709. void AbstractNumericFacetValidator::inheritFacet()
  710. {
  712.     AbstractNumericFacetValidator* numBase = (AbstractNumericFacetValidator*) getBaseValidator();
  713.     if (!numBase)
  714.         return;
  716.     int thisFacetsDefined = getFacetsDefined();
  717.     int baseFacetsDefined = numBase->getFacetsDefined();
  719.     // inherit enumeration
  720.     if ((( baseFacetsDefined & DatatypeValidator::FACET_ENUMERATION) != 0) &&
  721.         (( thisFacetsDefined & DatatypeValidator::FACET_ENUMERATION) == 0))
  722.     {
  723.         fEnumeration = numBase->fEnumeration;
  724.         fEnumerationInherited = true;
  725.         setFacetsDefined(DatatypeValidator::FACET_ENUMERATION);
  726.     }
  728.     // inherit maxInclusive
  729.     if ((( baseFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
  730.         (( thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) == 0) &&
  731.         (( thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) == 0) )
  732.     {
  733.         fMaxInclusive = numBase->getMaxInclusive();
  734.         fMaxInclusiveInherited = true;
  735.         setFacetsDefined(DatatypeValidator::FACET_MAXINCLUSIVE);
  736.     }
  738.     // inherit maxExclusive
  739.     if ((( baseFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
  740.         (( thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) == 0) &&
  741.         (( thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) == 0) )
  742.     {
  743.         fMaxExclusive = numBase->getMaxExclusive();
  744.         fMaxExclusiveInherited = true;
  745.         setFacetsDefined(DatatypeValidator::FACET_MAXEXCLUSIVE);
  746.     }
  748.     // inherit minExclusive
  749.     if ((( baseFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0) &&
  750.         (( thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) == 0) &&
  751.         (( thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) == 0) )
  752.     {
  753.         fMinInclusive = numBase->getMinInclusive();
  754.         fMinInclusiveInherited = true;
  755.         setFacetsDefined(DatatypeValidator::FACET_MININCLUSIVE);
  756.     }
  758.     // inherit minExclusive
  759.     if ((( baseFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) &&
  760.         (( thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) == 0) &&
  761.         (( thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) == 0) )
  762.     {
  763.         fMinExclusive = numBase->getMinExclusive();
  764.         fMinExclusiveInherited = true;
  765.         setFacetsDefined(DatatypeValidator::FACET_MINEXCLUSIVE);
  766.     }
  768.     inheritAdditionalFacet();
  770.     // inherit "fixed" option
  771.     setFixed(getFixed() | numBase->getFixed());
  773. }
  775. /**
  776.   * End of file AbstractNumericFacetValidator::cpp
  777.   */