source: icXML/icXML-devel/src/xercesc/validators/datatype/StringDatatypeValidator.cpp @ 2722

Last change on this file since 2722 was 2722, checked in by cameron, 6 years ago

Original Xerces files with import mods for icxercesc

File size: 7.8 KB
Line 
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18/*
19 * $Id: StringDatatypeValidator.cpp 471747 2006-11-06 14:31:56Z amassari $
20 */
21
22// ---------------------------------------------------------------------------
23//  Includes
24// ---------------------------------------------------------------------------
25#include <xercesc/validators/datatype/StringDatatypeValidator.hpp>
26#include <xercesc/validators/schema/SchemaSymbols.hpp>
27#include <xercesc/validators/datatype/InvalidDatatypeFacetException.hpp>
28#include <xercesc/validators/datatype/InvalidDatatypeValueException.hpp>
29
30XERCES_CPP_NAMESPACE_BEGIN
31
32// ---------------------------------------------------------------------------
33//  Constructors and Destructor
34// ---------------------------------------------------------------------------
35StringDatatypeValidator::StringDatatypeValidator(MemoryManager* const manager)
36:AbstractStringValidator(0, 0, 0, DatatypeValidator::String, manager)
37{
38    setWhiteSpace(DatatypeValidator::PRESERVE);
39}
40
41StringDatatypeValidator::StringDatatypeValidator(
42                          DatatypeValidator*            const baseValidator
43                        , RefHashTableOf<KVStringPair>* const facets
44                        , RefArrayVectorOf<XMLCh>*      const enums
45                        , const int                           finalSet
46                        , MemoryManager* const                manager)
47:AbstractStringValidator(baseValidator, facets, finalSet, DatatypeValidator::String, manager)
48{
49    setWhiteSpace(DatatypeValidator::PRESERVE);
50    init(enums, manager);
51}
52
53StringDatatypeValidator::~StringDatatypeValidator()
54{}
55
56DatatypeValidator* StringDatatypeValidator::newInstance
57(
58      RefHashTableOf<KVStringPair>* const facets
59    , RefArrayVectorOf<XMLCh>* const      enums
60    , const int                           finalSet
61    , MemoryManager* const                manager
62)
63{
64    return (DatatypeValidator*) new (manager) StringDatatypeValidator(this, facets, enums, finalSet, manager);
65}
66
67StringDatatypeValidator::StringDatatypeValidator(
68                          DatatypeValidator*            const baseValidator
69                        , RefHashTableOf<KVStringPair>* const facets
70                        , const int                           finalSet
71                        , const ValidatorType                 type
72                        , MemoryManager* const                manager)
73:AbstractStringValidator(baseValidator, facets, finalSet, type, manager)
74{
75    setWhiteSpace(DatatypeValidator::PRESERVE);
76    // do not invoke init() here!!!
77}
78
79// ---------------------------------------------------------------------------
80//  Utilities
81// ---------------------------------------------------------------------------
82void StringDatatypeValidator::assignAdditionalFacet(const XMLCh* const key
83                                                  , const XMLCh* const value
84                                                  , MemoryManager* const manager)
85{
86    if (XMLString::equals(key, SchemaSymbols::fgELT_WHITESPACE))
87    {
88        // whiteSpace = preserve | replace | collapse
89        if (XMLString::equals(value, SchemaSymbols::fgWS_PRESERVE))
90            setWhiteSpace(DatatypeValidator::PRESERVE);
91        else if (XMLString::equals(value, SchemaSymbols::fgWS_REPLACE))
92            setWhiteSpace(DatatypeValidator::REPLACE);
93        else if (XMLString::equals(value, SchemaSymbols::fgWS_COLLAPSE))
94            setWhiteSpace(DatatypeValidator::COLLAPSE);
95        else
96            ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_WS, value, manager);
97        //("whiteSpace value '" + ws + "' must be one of 'preserve', 'replace', 'collapse'.");
98
99        setFacetsDefined(DatatypeValidator::FACET_WHITESPACE);
100    }
101    else
102    {
103        ThrowXMLwithMemMgr1(InvalidDatatypeFacetException
104                , XMLExcepts::FACET_Invalid_Tag
105                , key
106                , manager);
107    }
108}
109
110void StringDatatypeValidator::inheritAdditionalFacet()
111{
112    StringDatatypeValidator *pBaseValidator = (StringDatatypeValidator*) getBaseValidator();
113
114    if (!pBaseValidator)
115        return;
116
117    // inherit whitespace
118    if (((pBaseValidator->getFacetsDefined() & DatatypeValidator::FACET_WHITESPACE) !=0) &&
119        ((getFacetsDefined() & DatatypeValidator::FACET_WHITESPACE) == 0))
120    {
121        setWhiteSpace(getBaseValidator()->getWSFacet());
122        setFacetsDefined(DatatypeValidator::FACET_WHITESPACE);
123    }
124}
125
126void StringDatatypeValidator::checkAdditionalFacetConstraints(MemoryManager* const manager) const
127{
128
129    StringDatatypeValidator *pBaseValidator = (StringDatatypeValidator*) getBaseValidator();
130
131    if (!pBaseValidator)
132        return;
133
134    short    thisWSFacet = getWSFacet();
135    short    baseWSFacet = pBaseValidator->getWSFacet();
136
137    // check 4.3.6.c1 error: whitespace
138    if (((getFacetsDefined() & DatatypeValidator::FACET_WHITESPACE) != 0) &&
139        ((pBaseValidator->getFacetsDefined() & DatatypeValidator::FACET_WHITESPACE) != 0 ))
140    {
141        if ((baseWSFacet == DatatypeValidator::COLLAPSE) &&
142            ((thisWSFacet == DatatypeValidator::PRESERVE) ||
143             (thisWSFacet == DatatypeValidator::REPLACE)))
144             ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_WS_collapse, manager);
145
146        if ((baseWSFacet == DatatypeValidator::REPLACE) &&
147            (thisWSFacet == DatatypeValidator::PRESERVE))
148            ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_WS_replace, manager);
149
150        if (((pBaseValidator->getFixed() & DatatypeValidator::FACET_WHITESPACE) !=0) &&
151            ( thisWSFacet != baseWSFacet))
152        {
153            ThrowXMLwithMemMgr2(InvalidDatatypeFacetException
154                        , XMLExcepts::FACET_whitespace_base_fixed
155                        , getWSstring(thisWSFacet)
156                        , getWSstring(baseWSFacet)
157                        , manager);
158        }
159    }
160
161}
162
163void StringDatatypeValidator::checkAdditionalFacet(const XMLCh* const content
164                                                   , MemoryManager* const manager) const
165{
166    //
167    // check WhiteSpace
168    //
169    if ((getFacetsDefined() & DatatypeValidator::FACET_WHITESPACE) != 0 )
170    {
171        if ( getWSFacet() == DatatypeValidator::REPLACE )
172        {
173            if (!XMLString::isWSReplaced(content))
174                ThrowXMLwithMemMgr1(InvalidDatatypeValueException, XMLExcepts::VALUE_WS_replaced, content, manager);
175        }
176        else if ( getWSFacet() == DatatypeValidator::COLLAPSE )
177        {
178            if (!XMLString::isWSCollapsed(content))
179                ThrowXMLwithMemMgr1(InvalidDatatypeValueException, XMLExcepts::VALUE_WS_collapsed, content, manager);
180        }
181
182    }
183}
184
185void StringDatatypeValidator::checkValueSpace(const XMLCh* const
186                                              , MemoryManager* const)
187{}
188
189/***
190 * Support for Serialization/De-serialization
191 ***/
192
193IMPL_XSERIALIZABLE_TOCREATE(StringDatatypeValidator)
194
195void StringDatatypeValidator::serialize(XSerializeEngine& serEng)
196{
197    AbstractStringValidator::serialize(serEng);
198}
199
200XERCES_CPP_NAMESPACE_END
201
202/**
203  * End of file StringDatatypeValidator.cpp
204  */
Note: See TracBrowser for help on using the repository browser.