source: icXML/icXML-devel/src/xercesc/validators/datatype/UnionDatatypeValidator.hpp @ 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: 9.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: UnionDatatypeValidator.hpp 676911 2008-07-15 13:27:32Z amassari $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_UNION_DATATYPEVALIDATOR_HPP)
23#define XERCESC_INCLUDE_GUARD_UNION_DATATYPEVALIDATOR_HPP
24
25#include <xercesc/validators/datatype/DatatypeValidator.hpp>
26
27XERCES_CPP_NAMESPACE_BEGIN
28
29class VALIDATORS_EXPORT UnionDatatypeValidator : public DatatypeValidator
30{
31public:
32
33    // -----------------------------------------------------------------------
34    //  Public ctor/dtor
35    // -----------------------------------------------------------------------
36        /** @name Constructors and Destructor. */
37    //@{
38
39    UnionDatatypeValidator
40    (
41        MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
42    );
43
44    //
45    // constructor for native Union datatype validator
46    // <simpleType name="nativeUnion">
47    //      <union   memberTypes="member1 member2 ...">
48    // </simpleType>
49    //
50    UnionDatatypeValidator
51    (
52        RefVectorOf<DatatypeValidator>* const memberTypeValidators
53        , const int finalSet
54        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
55    );
56
57    //
58    // constructor for derived Union datatype validator
59    // <simpleType name="derivedUnion">
60    //      <restriction base="nativeUnion">
61    //          <pattern     value="patter_value"/>
62    //          <enumeration value="enum_value"/>
63    //      </restriction>
64    // </simpleType>
65    //
66    UnionDatatypeValidator
67    (
68        DatatypeValidator* const baseValidator
69        , RefHashTableOf<KVStringPair>* const facets
70        , RefArrayVectorOf<XMLCh>* const enums
71        , const int finalSet
72        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
73        , RefVectorOf<DatatypeValidator>* const memberTypeValidators = 0
74        , const bool memberTypesInherited = true
75    );
76
77    virtual ~UnionDatatypeValidator();
78
79        //@}
80
81        virtual const RefArrayVectorOf<XMLCh>* getEnumString() const;
82
83    // -----------------------------------------------------------------------
84    // Getter methods
85    // -----------------------------------------------------------------------
86    /** @name Getter Functions */
87    //@{
88    /**
89      * Returns whether the type is atomic or not
90      */
91    virtual bool isAtomic() const;
92
93    virtual const XMLCh* getCanonicalRepresentation
94                        (
95                          const XMLCh*         const rawData
96                        ,       MemoryManager* const memMgr = 0
97                        ,       bool                 toValidate = false
98                        ) const;
99
100    //@}
101
102    // -----------------------------------------------------------------------
103    // Validation methods
104    // -----------------------------------------------------------------------
105    /** @name Validation Function */
106    //@{
107
108    /**
109     * validate that a string matches the boolean datatype
110     * @param content A string containing the content to be validated
111     *
112     * @exception throws InvalidDatatypeException if the content is
113     * is not valid.
114     */
115
116        virtual void validate
117                 (
118                  const XMLCh*             const content
119                ,       ValidationContext* const context = 0
120                ,       MemoryManager*     const manager = XMLPlatformUtils::fgMemoryManager
121                  );
122
123    /**
124      * Checks whether a given type can be used as a substitute
125      *
126      * @param  toCheck    A datatype validator of the type to be used as a
127      *                    substitute
128      *
129      * To be redefined in UnionDatatypeValidator
130      */
131
132    virtual bool isSubstitutableBy(const DatatypeValidator* const toCheck);
133
134    //@}
135
136    // -----------------------------------------------------------------------
137    // Compare methods
138    // -----------------------------------------------------------------------
139    /** @name Compare Function */
140    //@{
141
142    /**
143     * Compare two boolean data types
144     *
145     * @param content1
146     * @param content2
147     * @return
148     */
149    int compare(const XMLCh* const, const XMLCh* const
150        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
151        );
152
153    //@}
154
155    /**
156      * Returns an instance of the base datatype validator class
157          * Used by the DatatypeValidatorFactory.
158      */
159    virtual DatatypeValidator* newInstance
160    (
161        RefHashTableOf<KVStringPair>* const facets
162        , RefArrayVectorOf<XMLCh>* const enums
163        , const int finalSet
164        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
165    );
166
167    /***
168     * Support for Serialization/De-serialization
169     ***/
170    DECL_XSERIALIZABLE(UnionDatatypeValidator)
171
172
173    RefVectorOf<DatatypeValidator>* getMemberTypeValidators() const;
174
175private:
176    // -----------------------------------------------------------------------
177    //  Unimplemented constructors and operators
178    // -----------------------------------------------------------------------   
179    UnionDatatypeValidator(const UnionDatatypeValidator&);
180    UnionDatatypeValidator& operator=(const UnionDatatypeValidator&);
181
182    virtual void checkContent(const XMLCh*             const content
183                            ,       ValidationContext* const context
184                            , bool                           asBase
185                            ,       MemoryManager*     const manager);
186
187    void init(DatatypeValidator*            const baseValidator
188            , RefHashTableOf<KVStringPair>* const facets
189            , RefArrayVectorOf<XMLCh>*      const enums
190            , MemoryManager*                const manager);
191
192    void cleanUp();
193   
194    RefArrayVectorOf<XMLCh>*  getEnumeration() const;
195
196    void                 setEnumeration(RefArrayVectorOf<XMLCh>*, bool);
197
198
199    // -----------------------------------------------------------------------
200    //  Private data members
201    //
202    //  fEnumeration
203    //      we own it (or not, depending on state of fEnumerationInherited).
204    //
205    //  fMemberTypeValidators
206    //      we own it (or not, depending on the state of fMemberTypesInherited).
207    //
208    // -----------------------------------------------------------------------
209
210     bool                             fEnumerationInherited;
211     bool                             fMemberTypesInherited;
212     RefArrayVectorOf<XMLCh>*         fEnumeration;
213     RefVectorOf<DatatypeValidator>*  fMemberTypeValidators;   
214};
215
216inline DatatypeValidator* UnionDatatypeValidator::newInstance
217(
218      RefHashTableOf<KVStringPair>* const facets
219    , RefArrayVectorOf<XMLCh>* const      enums
220    , const int                           finalSet
221    , MemoryManager* const                manager
222)
223{
224    return (DatatypeValidator*) new (manager) UnionDatatypeValidator(this, facets, enums, finalSet, manager, fMemberTypeValidators, true);
225}
226
227inline void UnionDatatypeValidator::validate( const XMLCh*             const content
228                                           ,        ValidationContext* const context
229                                           ,        MemoryManager*     const manager)
230{
231    checkContent(content, context, false, manager);
232}
233
234inline void UnionDatatypeValidator::cleanUp()
235{
236    //~RefVectorOf will delete all adopted elements
237    if ( !fEnumerationInherited && fEnumeration)
238        delete fEnumeration;
239
240    if (!fMemberTypesInherited && fMemberTypeValidators)
241        delete fMemberTypeValidators;
242   
243}
244
245inline RefArrayVectorOf<XMLCh>* UnionDatatypeValidator:: getEnumeration() const
246{
247    return fEnumeration;
248}
249
250inline void UnionDatatypeValidator::setEnumeration(RefArrayVectorOf<XMLCh>* enums
251                                                 , bool                inherited)
252{
253    if (enums)
254    {
255        if (  !fEnumerationInherited && fEnumeration)
256            delete fEnumeration;
257
258        fEnumeration = enums;
259        fEnumerationInherited = inherited;
260        setFacetsDefined(DatatypeValidator::FACET_ENUMERATION);
261    }
262}
263
264//
265// get the native UnionDTV's fMemberTypeValidators
266//
267inline
268RefVectorOf<DatatypeValidator>* UnionDatatypeValidator::getMemberTypeValidators() const
269{
270    return this->fMemberTypeValidators;
271}
272
273inline bool UnionDatatypeValidator::isAtomic() const {
274
275
276
277    if (!fMemberTypeValidators) {
278        return false;
279    }
280
281    XMLSize_t memberSize = fMemberTypeValidators->size();
282
283    for (XMLSize_t i=0; i < memberSize; i++) {
284        if (!fMemberTypeValidators->elementAt(i)->isAtomic()) {
285            return false;
286        }
287    }
288
289    return true;
290}
291
292inline bool UnionDatatypeValidator::isSubstitutableBy(const DatatypeValidator* const toCheck) {
293
294    if (toCheck == this) {
295        return true;
296    }
297
298    if (fMemberTypeValidators) {
299        XMLSize_t memberSize = fMemberTypeValidators->size();
300
301        for (XMLSize_t i=0; i < memberSize; i++) {
302            if ((fMemberTypeValidators->elementAt(i)->getType() == DatatypeValidator::Union) &&
303                (fMemberTypeValidators->elementAt(i) == toCheck))
304                return false;
305            if (fMemberTypeValidators->elementAt(i)->isSubstitutableBy(toCheck)) {
306                return true;
307            }
308        }
309    }
310    return false;
311}
312
313XERCES_CPP_NAMESPACE_END
314
315#endif
316
317/**
318  * End of file UnionDatatypeValidator.hpp
319  */
320
Note: See TracBrowser for help on using the repository browser.