source: icXML/icXML-devel/src/xercesc/validators/datatype/AbstractStringValidator.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: 25.3 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: AbstractStringValidator.cpp 834826 2009-11-11 10:03:53Z borisk $
20 */
21
22// ---------------------------------------------------------------------------
23//  Includes
24// ---------------------------------------------------------------------------
25#include <xercesc/validators/datatype/AbstractStringValidator.hpp>
26#include <xercesc/validators/datatype/InvalidDatatypeFacetException.hpp>
27#include <xercesc/validators/datatype/InvalidDatatypeValueException.hpp>
28#include <xercesc/util/NumberFormatException.hpp>
29
30#include <xercesc/internal/XTemplateSerializer.hpp>
31
32XERCES_CPP_NAMESPACE_BEGIN
33
34static const int BUF_LEN = 64;
35
36#define  REPORT_FACET_ERROR(val1, val2, except_code, manager)    \
37    XMLCh value1[BUF_LEN+1]; \
38    XMLCh value2[BUF_LEN+1]; \
39   XMLString::sizeToText(val1, value1, BUF_LEN, 10, manager);     \
40   XMLString::sizeToText(val2, value2, BUF_LEN, 10, manager);     \
41   ThrowXMLwithMemMgr2(InvalidDatatypeFacetException              \
42           , except_code                                \
43           , value1                                     \
44           , value2                                     \
45           , manager);
46
47#define  REPORT_VALUE_ERROR(data, val1, val2, except_code, manager)       \
48    XMLCh value1[BUF_LEN+1]; \
49    XMLCh value2[BUF_LEN+1]; \
50   XMLString::sizeToText(val1, value1, BUF_LEN, 10, manager);             \
51   XMLString::sizeToText(val2, value2, BUF_LEN, 10, manager);             \
52   ThrowXMLwithMemMgr3(InvalidDatatypeValueException                      \
53           , except_code                                        \
54           , data                                               \
55           , value1                                             \
56           , value2                                             \
57           , manager);
58
59// ---------------------------------------------------------------------------
60//  Constructors and Destructor
61// ---------------------------------------------------------------------------
62AbstractStringValidator::~AbstractStringValidator()
63{
64    //~RefVectorOf will delete all adopted elements
65    if ( !fEnumerationInherited && fEnumeration)
66    {
67        delete fEnumeration;
68        fEnumeration = 0;
69    }
70}
71
72AbstractStringValidator::AbstractStringValidator(
73                          DatatypeValidator*            const baseValidator
74                        , RefHashTableOf<KVStringPair>* const facets
75                        , const int                           finalSet
76                        , const ValidatorType                 type
77                        , MemoryManager* const                manager)
78:DatatypeValidator(baseValidator, facets, finalSet, type, manager)
79,fLength(0)
80,fMaxLength(SchemaSymbols::fgINT_MAX_VALUE)
81,fMinLength(0)
82,fEnumerationInherited(false)
83,fEnumeration(0)
84{
85    // init() is invoked from derived class's ctor instead of from
86    // here to allow correct resolution of virutal method, such as
87    // assigneAdditionalFacet(), inheritAdditionalFacet().
88}
89
90void AbstractStringValidator::init(RefArrayVectorOf<XMLCh>*           const enums
91                                   ,MemoryManager*                    const manager)
92{
93
94    if (enums)
95    {
96        setEnumeration(enums, false);
97        normalizeEnumeration(manager);
98    }
99
100    assignFacet(manager);
101    inspectFacet(manager);
102    inspectFacetBase(manager);
103    inheritFacet();
104
105}
106
107//
108//   Assign facets
109//        assign common facets
110//        assign additional facet
111//
112void AbstractStringValidator::assignFacet(MemoryManager* const manager)
113{
114
115    RefHashTableOf<KVStringPair>* facets = getFacets();
116
117    if (!facets)
118        return;
119
120    XMLCh* key;
121    RefHashTableOfEnumerator<KVStringPair> e(facets, false, manager);
122
123    while (e.hasMoreElements())
124    {
125        KVStringPair pair = e.nextElement();
126        key = pair.getKey();
127        XMLCh* value = pair.getValue();
128
129        if (XMLString::equals(key, SchemaSymbols::fgELT_LENGTH))
130        {
131            int val;
132            try
133            {
134                val = XMLString::parseInt(value, manager);
135            }
136            catch (NumberFormatException&)
137            {
138                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_Len, value, manager);
139            }
140
141            if ( val < 0 )
142                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_NonNeg_Len, value, manager);
143
144            setLength(val);
145            setFacetsDefined(DatatypeValidator::FACET_LENGTH);
146        }
147        else if (XMLString::equals(key, SchemaSymbols::fgELT_MINLENGTH))
148        {
149            int val;
150            try
151            {
152                val = XMLString::parseInt(value, manager);
153            }
154            catch (NumberFormatException&)
155            {
156                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_minLen, value, manager);
157            }
158
159            if ( val < 0 )
160                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_NonNeg_minLen, value, manager);
161
162            setMinLength(val);
163            setFacetsDefined(DatatypeValidator::FACET_MINLENGTH);
164        }
165        else if (XMLString::equals(key, SchemaSymbols::fgELT_MAXLENGTH))
166        {
167            int val;
168            try
169            {
170                val = XMLString::parseInt(value, manager);
171            }
172            catch (NumberFormatException&)
173            {
174                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_maxLen, value, manager);
175            }
176
177            if ( val < 0 )
178                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_NonNeg_maxLen, value, manager);
179
180            setMaxLength(val);
181            setFacetsDefined(DatatypeValidator::FACET_MAXLENGTH);
182        }
183        else if (XMLString::equals(key, SchemaSymbols::fgELT_PATTERN))
184        {
185            setPattern(value);
186            if (getPattern())
187                setFacetsDefined(DatatypeValidator::FACET_PATTERN);
188            // do not construct regex until needed
189        }
190        else if (XMLString::equals(key, SchemaSymbols::fgATT_FIXED))
191        {
192            unsigned int val;
193            bool         retStatus;
194            try
195            {
196                retStatus = XMLString::textToBin(value, val, fMemoryManager);
197            }
198            catch (RuntimeException&)
199            {
200                ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_internalError_fixed, manager);
201            }
202
203            if (!retStatus)
204            {
205                ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_internalError_fixed, manager);
206            }
207
208            setFixed(val);
209            //no setFacetsDefined here
210        }
211        //
212        // else if (XMLString::equals(key, SchemaSymbols::fgELT_SPECIAL_TOKEN))
213        // TODO
214        //
215        // Note: whitespace is taken care of by TraverseSchema.
216        //
217        else
218        {
219            assignAdditionalFacet(key, value, manager);
220        }
221    }//while
222}//end of assigneFacet()
223
224//
225// Check facet among self
226//         check common facets
227//         check Additional Facet Constraint
228//
229void AbstractStringValidator::inspectFacet(MemoryManager* const manager)
230{
231
232    int thisFacetsDefined = getFacetsDefined();
233
234    if (!thisFacetsDefined)
235        return;
236
237    // check 4.3.1.c1 error: length & (maxLength | minLength)
238    if ((thisFacetsDefined & DatatypeValidator::FACET_LENGTH) != 0)
239    {
240        if ((thisFacetsDefined & DatatypeValidator::FACET_MAXLENGTH) != 0)
241            ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_Len_maxLen, manager);
242        else if (((thisFacetsDefined & DatatypeValidator::FACET_MINLENGTH) != 0))
243            ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_Len_minLen, manager);
244    }
245
246    // check 4.3.2.c1 must: minLength <= maxLength
247    if ((thisFacetsDefined & (DatatypeValidator::FACET_MINLENGTH
248        |DatatypeValidator::FACET_MAXLENGTH)) != 0)
249    {
250        XMLSize_t thisMinLength = getMinLength();
251        XMLSize_t thisMaxLength = getMaxLength();
252        if ( thisMinLength > thisMaxLength )
253        {
254            REPORT_FACET_ERROR(thisMaxLength
255                             , thisMinLength
256                             , XMLExcepts::FACET_maxLen_minLen
257                             , manager)
258        }
259    }
260
261}// end of inspectFacet()
262
263//
264//  Check vs base
265//         check common facets
266//         check enumeration
267//         check Additional Facet Constraint
268//
269void AbstractStringValidator::inspectFacetBase(MemoryManager* const manager)
270{
271
272    AbstractStringValidator *pBaseValidator = (AbstractStringValidator*) getBaseValidator();
273    int thisFacetsDefined = getFacetsDefined();
274
275    if ( (!thisFacetsDefined && !fEnumeration) ||
276         (!pBaseValidator)                      )
277        return;
278
279    int baseFacetsDefined = pBaseValidator->getFacetsDefined();
280
281    XMLSize_t thisLength    = getLength();
282    XMLSize_t thisMinLength = getMinLength();
283    XMLSize_t thisMaxLength = getMaxLength();
284
285    XMLSize_t baseLength    = pBaseValidator->getLength();
286    XMLSize_t baseMinLength = pBaseValidator->getMinLength();
287    XMLSize_t baseMaxLength = pBaseValidator->getMaxLength();
288    int baseFixed     = pBaseValidator->getFixed();
289
290    /***
291       check facets against base.facets
292       Note: later we need to check the "fix" option of the base type
293            and apply that to every individual facet.
294    ***/
295
296    /***
297                Non coexistence of derived' length and base'    (minLength | maxLength)
298                                   base'    length and derived' (minLength | maxLength)
299
300     E2-35
301     It is an error for both length and either of minLength or maxLength to be members of {facets},
302     unless they are specified in different derivation steps in which case the following must be true:
303     the {value} of minLength <= the {value} of length <= the {value} of maxLength
304    ***/
305
306    // error: length > base.maxLength
307    //        length < base.minLength
308    if ((thisFacetsDefined & DatatypeValidator::FACET_LENGTH) !=0)
309    {
310        if (((baseFacetsDefined & DatatypeValidator::FACET_MAXLENGTH) !=0) &&
311             (thisLength > baseMaxLength)                                   )
312        {
313            REPORT_FACET_ERROR(thisLength
314                             , baseMaxLength
315                             , XMLExcepts::FACET_Len_baseMaxLen
316                             , manager)
317        }
318
319        if (((baseFacetsDefined & DatatypeValidator::FACET_MINLENGTH) !=0) &&
320             (thisLength < baseMinLength)                                   )
321        {
322            REPORT_FACET_ERROR(thisLength
323                             , baseMinLength
324                             , XMLExcepts::FACET_Len_baseMinLen
325                             , manager)
326        }
327    }
328
329    // error: baseLength > maxLength
330    //        baseLength < minLength
331    if ((baseFacetsDefined & DatatypeValidator::FACET_LENGTH) !=0)
332    {
333        if (((thisFacetsDefined & DatatypeValidator::FACET_MAXLENGTH) !=0) &&
334             (baseLength > thisMaxLength)                                   )
335        {
336            REPORT_FACET_ERROR(thisMaxLength
337                             , baseLength
338                             , XMLExcepts::FACET_maxLen_baseLen
339                             , manager)
340        }
341
342        if (((thisFacetsDefined & DatatypeValidator::FACET_MINLENGTH) !=0) &&
343             (baseLength < thisMinLength)                                   )
344        {
345            REPORT_FACET_ERROR(thisMinLength
346                             , baseLength
347                             , XMLExcepts::FACET_minLen_baseLen
348                             , manager)
349        }
350    }
351
352    // check 4.3.1.c2 error: length != base.length
353    if (((thisFacetsDefined & DatatypeValidator::FACET_LENGTH) !=0) &&
354        ((baseFacetsDefined & DatatypeValidator::FACET_LENGTH) !=0))
355    {
356        if ( thisLength != baseLength )
357        {
358            REPORT_FACET_ERROR(thisLength
359                             , baseLength
360                             , XMLExcepts::FACET_Len_baseLen
361                             , manager)
362        }
363    }
364
365    /***
366                                   |---  derived   ---|
367                base.minLength <= minLength <= maxLength <= base.maxLength
368                |-------------------        base      -------------------|
369    ***/
370
371    // check 4.3.2.c1 must: minLength <= base.maxLength
372    if (((thisFacetsDefined & DatatypeValidator::FACET_MINLENGTH ) != 0) &&
373        ((baseFacetsDefined & DatatypeValidator::FACET_MAXLENGTH ) != 0))
374    {
375        if ( thisMinLength > baseMaxLength )
376        {
377            REPORT_FACET_ERROR(thisMinLength
378                             , baseMaxLength
379                             , XMLExcepts::FACET_minLen_basemaxLen
380                             , manager)
381        }
382    }
383
384    // check 4.3.2.c2 error: minLength < base.minLength
385    if (((thisFacetsDefined & DatatypeValidator::FACET_MINLENGTH) !=0) &&
386        ((baseFacetsDefined & DatatypeValidator::FACET_MINLENGTH) != 0))
387    {
388        if ((baseFixed & DatatypeValidator::FACET_MINLENGTH) !=0)
389        {
390            if ( thisMinLength != baseMinLength )
391            {
392                REPORT_FACET_ERROR(thisMinLength
393                                 , baseMinLength
394                                 , XMLExcepts::FACET_minLen_base_fixed
395                                 , manager)
396            }
397
398        }
399        else
400        {
401            if ( thisMinLength < baseMinLength )
402            {
403                REPORT_FACET_ERROR(thisMinLength
404                                 , baseMinLength
405                                 , XMLExcepts::FACET_minLen_baseminLen
406                                 , manager)
407            }
408        }
409    }
410
411    // check 4.3.2.c1 must: base.minLength <= maxLength
412    if (((baseFacetsDefined & DatatypeValidator::FACET_MINLENGTH) !=0) &&
413        ((thisFacetsDefined & DatatypeValidator::FACET_MAXLENGTH) !=0))
414    {
415        if ( baseMinLength > thisMaxLength )
416        {
417            REPORT_FACET_ERROR(thisMaxLength
418                             , baseMinLength
419                             , XMLExcepts::FACET_maxLen_baseminLen
420                             , manager)
421        }
422    }
423
424    // check 4.3.3.c1 error: maxLength > base.maxLength
425    if (((thisFacetsDefined & DatatypeValidator::FACET_MAXLENGTH) !=0) &&
426        ((baseFacetsDefined & DatatypeValidator::FACET_MAXLENGTH) !=0))
427    {
428        if ((baseFixed & DatatypeValidator::FACET_MAXLENGTH) !=0)
429        {
430            if ( thisMaxLength != baseMaxLength )
431            {
432                REPORT_FACET_ERROR(thisMaxLength
433                                 , baseMaxLength
434                                 , XMLExcepts::FACET_maxLen_base_fixed
435                                 , manager)
436            }
437        }
438        else
439        {
440            if ( thisMaxLength > baseMaxLength )
441            {
442                REPORT_FACET_ERROR(thisMaxLength
443                                 , baseMaxLength
444                                 , XMLExcepts::FACET_maxLen_basemaxLen
445                                 , manager)
446            }
447        }
448    }
449
450    // check 4.3.5.c0 must: enumeration values from the value space of base
451    if ( ((thisFacetsDefined & DatatypeValidator::FACET_ENUMERATION) != 0) &&
452        (getEnumeration() !=0))
453    {
454        XMLSize_t i = 0;
455        XMLSize_t enumLength = getEnumeration()->size();
456        for ( ; i < enumLength; i++)
457        {
458            // ask parent do a complete check
459            pBaseValidator->checkContent(getEnumeration()->elementAt(i), (ValidationContext*)0, false, manager);
460#if 0
461// spec says that only base has to checkContent
462            // enum shall pass this->checkContent() as well.
463            checkContent(getEnumeration()->elementAt(i), (ValidationContext*)0, false, manager);
464#endif
465        }
466    }
467
468    checkAdditionalFacetConstraints(manager);
469
470} //end of inspectFacetBase
471
472//
473//  Inherit facet from base
474//    a. inherit common facets
475//    b. inherit additional facet
476//
477void AbstractStringValidator::inheritFacet()
478{
479    /***
480        P3. Inherit facets from base.facets
481
482        The reason of this inheriting (or copying values) is to ease
483        schema constraint checking, so that we need NOT trace back to our
484        very first base validator in the hierachy. Instead, we are pretty
485        sure checking against immediate base validator is enough.
486    ***/
487
488    AbstractStringValidator *pBaseValidator = (AbstractStringValidator*) getBaseValidator();
489
490    if (!pBaseValidator)
491        return;
492
493    int thisFacetsDefined = getFacetsDefined();
494    int baseFacetsDefined = pBaseValidator->getFacetsDefined();
495
496    // inherit length
497    if (((baseFacetsDefined & DatatypeValidator::FACET_LENGTH) != 0) &&
498        ((thisFacetsDefined & DatatypeValidator::FACET_LENGTH) == 0))
499    {
500        setLength(pBaseValidator->getLength());
501        setFacetsDefined(DatatypeValidator::FACET_LENGTH);
502    }
503
504    // inherit minLength
505    if (((baseFacetsDefined & DatatypeValidator::FACET_MINLENGTH) !=0) &&
506        ((thisFacetsDefined & DatatypeValidator::FACET_MINLENGTH) == 0))
507    {
508        setMinLength(pBaseValidator->getMinLength());
509        setFacetsDefined(DatatypeValidator::FACET_MINLENGTH);
510    }
511
512    // inherit maxLength
513    if (((baseFacetsDefined & DatatypeValidator::FACET_MAXLENGTH) !=0) &&
514        ((thisFacetsDefined & DatatypeValidator::FACET_MAXLENGTH) == 0))
515    {
516        setMaxLength(pBaseValidator->getMaxLength());
517        setFacetsDefined(DatatypeValidator::FACET_MAXLENGTH);
518    }
519
520    // inherit enumeration
521    if (((baseFacetsDefined & DatatypeValidator::FACET_ENUMERATION) !=0) &&
522        ((thisFacetsDefined & DatatypeValidator::FACET_ENUMERATION) == 0))
523    {
524        setEnumeration(pBaseValidator->getEnumeration(), true);
525    }
526
527    // we don't inherit pattern
528
529    // inherit "fixed" option
530    setFixed(getFixed() | pBaseValidator->getFixed());
531
532    // inherit additional facet
533    inheritAdditionalFacet();
534
535} // end of inheritance
536
537
538// -----------------------------------------------------------------------
539// Compare methods
540// -----------------------------------------------------------------------
541int AbstractStringValidator::compare(const XMLCh* const lValue
542                                   , const XMLCh* const rValue
543                                   , MemoryManager*     const)
544{
545    return XMLString::compareString(lValue, rValue);
546}
547
548void AbstractStringValidator::validate( const XMLCh*             const content
549                                      ,       ValidationContext* const context
550                                      ,       MemoryManager*     const manager)
551{
552    checkContent(content, context, false, manager);
553}
554
555void AbstractStringValidator::checkContent( const XMLCh*             const content
556                                          ,       ValidationContext* const context
557                                          ,       bool                     asBase
558                                          ,       MemoryManager*     const manager
559                                          )
560{
561
562    //validate against base validator if any
563    AbstractStringValidator *pBaseValidator = (AbstractStringValidator*) this->getBaseValidator();
564    if (pBaseValidator)
565        pBaseValidator->checkContent(content, context, true, manager);
566
567    int thisFacetsDefined = getFacetsDefined();
568
569    // we check pattern first
570    if ( (thisFacetsDefined & DatatypeValidator::FACET_PATTERN ) != 0 )
571    {
572        if (getRegex()->matches(content, manager) ==false)
573        {
574            ThrowXMLwithMemMgr2(InvalidDatatypeValueException
575                    , XMLExcepts::VALUE_NotMatch_Pattern
576                    , content
577                    , getPattern()
578                    , manager);
579        }
580    }
581
582    // if this is a base validator, we only need to check pattern facet
583    // all other facet were inherited by the derived type
584    if (asBase)
585        return;
586
587    checkValueSpace(content, manager);
588    XMLSize_t length = getLength(content, manager);
589
590    if (((thisFacetsDefined & DatatypeValidator::FACET_MAXLENGTH) != 0) &&
591        (length > getMaxLength()))
592    {
593        REPORT_VALUE_ERROR(content
594                         , length
595                         , getMaxLength()
596                         , XMLExcepts::VALUE_GT_maxLen
597                         , manager)
598    }
599
600    if (((thisFacetsDefined & DatatypeValidator::FACET_MINLENGTH) != 0) &&
601        (length < getMinLength()))
602    {
603        REPORT_VALUE_ERROR(content
604                         , length
605                         , getMinLength()
606                         , XMLExcepts::VALUE_LT_minLen
607                         , manager)
608    }
609
610    if (((thisFacetsDefined & DatatypeValidator::FACET_LENGTH) != 0) &&
611        (length != getLength()))
612    {
613        REPORT_VALUE_ERROR(content
614                         , length
615                         , getLength()
616                         , XMLExcepts::VALUE_NE_Len
617                         , manager)
618    }
619
620    if ((thisFacetsDefined & DatatypeValidator::FACET_ENUMERATION) != 0 &&
621        (getEnumeration() != 0))
622    {
623        XMLCh* normContent = XMLString::replicate(content, manager);
624        ArrayJanitor<XMLCh>  jan(normContent, manager);
625        normalizeContent(normContent, manager);
626
627        XMLSize_t i=0;
628        XMLSize_t enumLength = getEnumeration()->size();
629        for ( ; i < enumLength; i++)
630        {
631            if (XMLString::equals(normContent, getEnumeration()->elementAt(i)))
632                break;
633        }
634
635        if (i == enumLength)
636            ThrowXMLwithMemMgr1(InvalidDatatypeValueException, XMLExcepts::VALUE_NotIn_Enumeration, content, manager);
637    }
638
639    checkAdditionalFacet(content, manager);
640
641}
642
643const RefArrayVectorOf<XMLCh>* AbstractStringValidator::getEnumString() const
644{
645        return getEnumeration();
646}
647
648void AbstractStringValidator::normalizeEnumeration(MemoryManager* const manager)
649{
650    AbstractStringValidator *pBaseValidator = (AbstractStringValidator*) getBaseValidator();
651
652    if (!fEnumeration || !pBaseValidator)
653        return;
654
655    int baseFacetsDefined = pBaseValidator->getFacetsDefined();
656    if ((baseFacetsDefined & DatatypeValidator::FACET_WHITESPACE) == 0)
657        return;
658
659    short whiteSpace = pBaseValidator->getWSFacet();
660
661    if ( whiteSpace == DatatypeValidator::PRESERVE )
662    {
663        return;
664    }
665    else if ( whiteSpace == DatatypeValidator::REPLACE )
666    {
667        XMLSize_t enumLength = getEnumeration()->size();
668        for ( XMLSize_t i=0; i < enumLength; i++)
669        {
670            XMLString::replaceWS(getEnumeration()->elementAt(i), manager);
671        }
672    }
673    else if ( whiteSpace == DatatypeValidator::COLLAPSE )
674    {
675        XMLSize_t enumLength = getEnumeration()->size();
676        for ( XMLSize_t i=0; i < enumLength; i++)
677        {
678            XMLString::collapseWS(getEnumeration()->elementAt(i), manager);
679        }
680    }
681}
682
683void AbstractStringValidator::normalizeContent(XMLCh* const, MemoryManager* const) const
684{
685    // default implementation: do nothing
686    return;
687}
688
689
690void AbstractStringValidator::checkAdditionalFacetConstraints(MemoryManager* const) const
691{
692    return;
693}
694
695void AbstractStringValidator::checkAdditionalFacet(const XMLCh* const
696                                    , MemoryManager* const) const
697{
698    return;
699}
700
701void AbstractStringValidator::inheritAdditionalFacet()
702{
703    return;
704}
705
706void AbstractStringValidator::assignAdditionalFacet( const XMLCh* const key
707                                                   , const XMLCh* const
708                                                   , MemoryManager* const manager)
709{
710    ThrowXMLwithMemMgr1(InvalidDatatypeFacetException
711            , XMLExcepts::FACET_Invalid_Tag
712            , key
713            , manager);
714}
715
716XMLSize_t AbstractStringValidator::getLength(const XMLCh* const content
717                                           , MemoryManager* const) const
718{
719    return XMLString::stringLen(content);
720}
721
722/***
723 * Support for Serialization/De-serialization
724 ***/
725
726IMPL_XSERIALIZABLE_NOCREATE(AbstractStringValidator)
727
728void AbstractStringValidator::serialize(XSerializeEngine& serEng)
729{
730
731    DatatypeValidator::serialize(serEng);
732
733    if (serEng.isStoring())
734    {
735        serEng.writeSize (fLength);
736        serEng.writeSize (fMaxLength);
737        serEng.writeSize (fMinLength);
738        serEng<<fEnumerationInherited;
739
740        /***
741         *
742         * Serialize RefArrayVectorOf<XMLCh>
743         *
744         ***/
745        XTemplateSerializer::storeObject(fEnumeration, serEng);
746
747    }
748    else
749    {
750        serEng.readSize (fLength);
751        serEng.readSize (fMaxLength);
752        serEng.readSize (fMinLength);
753        serEng>>fEnumerationInherited;
754
755        /***
756         *
757         *  Deserialize RefArrayVectorOf<XMLCh>
758         *
759        ***/
760        XTemplateSerializer::loadObject(&fEnumeration, 8, true, serEng);
761
762    }
763
764}
765
766XERCES_CPP_NAMESPACE_END
767
768/**
769  * End of file AbstractStringValidator.cpp
770  */
Note: See TracBrowser for help on using the repository browser.