Ignore:
Timestamp:
Dec 4, 2012, 6:02:04 PM (6 years ago)
Author:
cameron
Message:

Script for generating link files.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icXML/icXML-devel/src/xercesc/validators/schema/ComplexTypeInfo.hpp

    r2722 r2747  
    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: ComplexTypeInfo.hpp 932887 2010-04-11 13:04:59Z borisk $
    20  */
    21 
    22 #if !defined(XERCESC_INCLUDE_GUARD_COMPLEXTYPEINFO_HPP)
    23 #define XERCESC_INCLUDE_GUARD_COMPLEXTYPEINFO_HPP
    24 
    25 
    26 /**
    27   * The class act as a place holder to store complex type information.
    28   *
    29   * The class is intended for internal use.
    30   */
    31 
    32 // ---------------------------------------------------------------------------
    33 //  Includes
    34 // ---------------------------------------------------------------------------
    35 #include <icxercesc/util/XMLString.hpp>
    36 #include <xercesc/util/RefHash2KeysTableOf.hpp>
    37 #include <xercesc/util/RefVectorOf.hpp>
    38 #include <icxercesc/framework/XMLElementDecl.hpp>
    39 #include <icxercesc/framework/XMLContentModel.hpp>
    40 #include <xercesc/validators/schema/SchemaAttDef.hpp>
    41 #include <xercesc/internal/XSerializable.hpp>
    42 
    43 XERCES_CPP_NAMESPACE_BEGIN
    44 
    45 
    46 // ---------------------------------------------------------------------------
    47 //  Forward Declarations
    48 // ---------------------------------------------------------------------------
    49 class DatatypeValidator;
    50 class ContentSpecNode;
    51 class SchemaAttDefList;
    52 class SchemaElementDecl;
    53 class XSDLocator;
    54 
    55 
    56 class VALIDATORS_EXPORT ComplexTypeInfo : public XSerializable, public XMemory
    57 {
    58 public:
    59     // -----------------------------------------------------------------------
    60     //  Public Constructors/Destructor
    61     // -----------------------------------------------------------------------
    62     ComplexTypeInfo(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
    63     ~ComplexTypeInfo();
    64 
    65     // -----------------------------------------------------------------------
    66     //  Getter methods
    67     // -----------------------------------------------------------------------
    68     bool                     getAbstract() const;
    69     bool                     getAdoptContentSpec() const;
    70     bool                     containsAttWithTypeId() const;
    71     bool                     getPreprocessed() const;
    72     int                      getDerivedBy() const;
    73     int                      getBlockSet() const;
    74     int                      getFinalSet() const;
    75     unsigned int             getScopeDefined() const;
    76     unsigned int             getElementId() const;
    77     int                      getContentType() const;
    78     XMLSize_t                elementCount() const;
    79     XMLCh*                   getTypeName() const;
    80     DatatypeValidator*       getBaseDatatypeValidator() const;
    81     DatatypeValidator*       getDatatypeValidator() const;
    82     ComplexTypeInfo*         getBaseComplexTypeInfo() const;
    83     ContentSpecNode*         getContentSpec() const;
    84     const SchemaAttDef*      getAttWildCard() const;
    85     SchemaAttDef*            getAttWildCard();
    86     const SchemaAttDef*      getAttDef(const XMLCh* const baseName,
    87                                        const int uriId) const;
    88     SchemaAttDef*            getAttDef(const XMLCh* const baseName,
    89                                        const int uriId);
    90     XMLAttDefList&           getAttDefList() const;
    91     const SchemaElementDecl* elementAt(const XMLSize_t index) const;
    92     SchemaElementDecl*       elementAt(const XMLSize_t index);
    93     XMLContentModel*         getContentModel(const bool checkUPA = false);
    94     const XMLCh*             getFormattedContentModel ()   const;
    95     XSDLocator*              getLocator() const;
    96     const XMLCh*             getTypeLocalName() const;
    97     const XMLCh*             getTypeUri() const;
    98 
    99     /**
    100      * returns true if this type is anonymous
    101      **/
    102     bool getAnonymous() const;
    103 
    104     // -----------------------------------------------------------------------
    105     //  Setter methods
    106     // -----------------------------------------------------------------------
    107     void setAbstract(const bool isAbstract);
    108     void setAdoptContentSpec(const bool toAdopt);
    109     void setAttWithTypeId(const bool value);
    110     void setPreprocessed(const bool aValue = true);
    111     void setDerivedBy(const int derivedBy);
    112     void setBlockSet(const int blockSet);
    113     void setFinalSet(const int finalSet);
    114     void setScopeDefined(const unsigned int scopeDefined);
    115     void setElementId(const unsigned int elemId);
    116     void setTypeName(const XMLCh* const typeName);
    117     void setContentType(const int contentType);
    118     void setBaseDatatypeValidator(DatatypeValidator* const baseValidator);
    119     void setDatatypeValidator(DatatypeValidator* const validator);
    120     void setBaseComplexTypeInfo(ComplexTypeInfo* const typeInfo);
    121     void setContentSpec(ContentSpecNode* const toAdopt);
    122     void setAttWildCard(SchemaAttDef* const toAdopt);
    123     void addAttDef(SchemaAttDef* const toAdd);
    124     void addElement(SchemaElementDecl* const toAdd);
    125     void setLocator(XSDLocator* const aLocator);
    126 
    127     /**
    128      * sets this type to be anonymous
    129      **/
    130     void setAnonymous();
    131 
    132     // -----------------------------------------------------------------------
    133     //  Helper methods
    134     // -----------------------------------------------------------------------
    135     bool hasAttDefs() const;
    136     bool contains(const XMLCh* const attName);
    137     void checkUniqueParticleAttribution
    138     (
    139         SchemaGrammar*    const pGrammar
    140       , GrammarResolver*  const pGrammarResolver
    141       , XMLStringPool*    const pStringPool
    142       , XMLValidator*     const pValidator
    143     ) ;
    144 
    145     /**
    146       * Return a singleton that represents 'anyType'
    147       *
    148       * @param emptyNSId the uri id of the empty namespace
    149       */
    150     static ComplexTypeInfo* getAnyType(unsigned int emptyNSId);
    151 
    152     /**
    153       *  Notification that lazy data has been deleted
    154       */
    155     static void reinitAnyType();
    156 
    157     /***
    158      * Support for Serialization/De-serialization
    159      ***/
    160     DECL_XSERIALIZABLE(ComplexTypeInfo)
    161 
    162 private:
    163     // -----------------------------------------------------------------------
    164     //  Unimplemented constructors and operators
    165     // -----------------------------------------------------------------------
    166     ComplexTypeInfo(const ComplexTypeInfo& elemInfo);
    167     ComplexTypeInfo& operator= (const ComplexTypeInfo& other);
    168 
    169     // -----------------------------------------------------------------------
    170     //  Private helper methods
    171     // -----------------------------------------------------------------------
    172     void faultInAttDefList() const;
    173     bool useRepeatingLeafNodes(ContentSpecNode* particle);
    174     XMLContentModel* makeContentModel(bool checkUPA = false);
    175     XMLCh* formatContentModel () const ;
    176     ContentSpecNode* expandContentModel(ContentSpecNode* const curNode, int minOccurs, int maxOccurs, bool bAllowCompactSyntax);
    177     ContentSpecNode* convertContentSpecTree(ContentSpecNode* const curNode, bool checkUPA, bool bAllowCompactSyntax);
    178     void resizeContentSpecOrgURI();
    179 
    180     // -----------------------------------------------------------------------
    181     //  Private data members
    182     // -----------------------------------------------------------------------
    183     bool                               fAnonymous;
    184     bool                               fAbstract;
    185     bool                               fAdoptContentSpec;
    186     bool                               fAttWithTypeId;
    187     bool                               fPreprocessed;
    188     int                                fDerivedBy;
    189     int                                fBlockSet;
    190     int                                fFinalSet;
    191     unsigned int                       fScopeDefined;
    192     int                                fContentType;
    193 
    194     unsigned int                       fElementId;
    195     unsigned int                       fUniqueURI;
    196     unsigned int                       fContentSpecOrgURISize;
    197 
    198     XMLCh*                             fTypeName;
    199     XMLCh*                             fTypeLocalName;
    200     XMLCh*                             fTypeUri;
    201     DatatypeValidator*                 fBaseDatatypeValidator;
    202     DatatypeValidator*                 fDatatypeValidator;
    203     ComplexTypeInfo*                   fBaseComplexTypeInfo;
    204     ContentSpecNode*                   fContentSpec;
    205     SchemaAttDef*                      fAttWildCard;
    206     SchemaAttDefList*                  fAttList;
    207     RefVectorOf<SchemaElementDecl>*    fElements;
    208     RefHash2KeysTableOf<SchemaAttDef>* fAttDefs;
    209     XMLContentModel*                   fContentModel;
    210     XMLCh*                             fFormattedModel;
    211     unsigned int*                      fContentSpecOrgURI;
    212     XSDLocator*                        fLocator;
    213     MemoryManager*                     fMemoryManager;
    214 
    215     static ComplexTypeInfo*            fAnyType;
    216 
    217     friend class XMLInitializer;
    218 };
    219 
    220 // ---------------------------------------------------------------------------
    221 //  ComplexTypeInfo: Getter methods
    222 // ---------------------------------------------------------------------------
    223 inline bool ComplexTypeInfo::getAbstract() const {
    224 
    225     return fAbstract;
    226 }
    227 
    228 inline bool ComplexTypeInfo::getAdoptContentSpec() const {
    229 
    230     return fAdoptContentSpec;
    231 }
    232 
    233 inline bool ComplexTypeInfo::containsAttWithTypeId() const {
    234 
    235     return fAttWithTypeId;
    236 }
    237 
    238 inline bool ComplexTypeInfo::getPreprocessed() const {
    239 
    240     return fPreprocessed;
    241 }
    242 
    243 inline int ComplexTypeInfo::getDerivedBy() const {
    244 
    245     return fDerivedBy;
    246 }
    247 
    248 inline int ComplexTypeInfo::getBlockSet() const {
    249 
    250     return fBlockSet;
    251 }
    252 
    253 inline int ComplexTypeInfo::getFinalSet() const {
    254 
    255     return fFinalSet;
    256 }
    257 
    258 inline unsigned int ComplexTypeInfo::getScopeDefined() const {
    259 
    260     return fScopeDefined;
    261 }
    262 
    263 inline unsigned int ComplexTypeInfo::getElementId() const {
    264 
    265     return fElementId;
    266 }
    267 
    268 inline int ComplexTypeInfo::getContentType() const {
    269 
    270     return fContentType;
    271 }
    272 
    273 inline XMLSize_t ComplexTypeInfo::elementCount() const {
    274 
    275     if (fElements) {
    276         return fElements->size();
    277     }
    278 
    279     return 0;
    280 }
    281 
    282 inline XMLCh* ComplexTypeInfo::getTypeName() const {
    283     return fTypeName;
    284 }
    285 
    286 inline DatatypeValidator* ComplexTypeInfo::getBaseDatatypeValidator() const {
    287 
    288     return fBaseDatatypeValidator;
    289 }
    290 
    291 inline DatatypeValidator* ComplexTypeInfo::getDatatypeValidator() const {
    292 
    293     return fDatatypeValidator;
    294 }
    295 
    296 inline ComplexTypeInfo* ComplexTypeInfo::getBaseComplexTypeInfo() const {
    297 
    298     return fBaseComplexTypeInfo;
    299 }
    300 
    301 inline ContentSpecNode* ComplexTypeInfo::getContentSpec() const {
    302 
    303     return fContentSpec;
    304 }
    305 
    306 inline const SchemaAttDef* ComplexTypeInfo::getAttWildCard() const {
    307 
    308     return fAttWildCard;
    309 }
    310 
    311 inline SchemaAttDef* ComplexTypeInfo::getAttWildCard() {
    312 
    313     return fAttWildCard;
    314 }
    315 
    316 inline const SchemaAttDef* ComplexTypeInfo::getAttDef(const XMLCh* const baseName,
    317                                                       const int uriId) const {
    318 
    319     return fAttDefs->get(baseName, uriId);
    320 }
    321 
    322 inline SchemaAttDef* ComplexTypeInfo::getAttDef(const XMLCh* const baseName,
    323                                                 const int uriId)
    324 {
    325     return fAttDefs->get(baseName, uriId);
    326 }
    327 
    328 inline SchemaElementDecl*
    329 ComplexTypeInfo::elementAt(const XMLSize_t index) {
    330 
    331     if (!fElements) {
    332         return 0; // REVISIT - need to throw an exception
    333     }
    334 
    335     return fElements->elementAt(index);
    336 }
    337 
    338 inline const SchemaElementDecl*
    339 ComplexTypeInfo::elementAt(const XMLSize_t index) const {
    340 
    341     if (!fElements) {
    342         return 0; // REVISIT - need to throw an exception
    343     }
    344 
    345     return fElements->elementAt(index);
    346 }
    347 
    348 inline XMLContentModel* ComplexTypeInfo::getContentModel(const bool checkUPA)
    349 {
    350     if (!fContentModel && fContentSpec)
    351         fContentModel = makeContentModel(checkUPA);
    352 
    353     return fContentModel;
    354 }
    355 
    356 inline XSDLocator* ComplexTypeInfo::getLocator() const
    357 {
    358     return fLocator;
    359 }
    360 
    361 inline bool ComplexTypeInfo::getAnonymous() const {
    362     return fAnonymous;
    363 }
    364 
    365 inline const XMLCh* ComplexTypeInfo::getTypeLocalName() const
    366 {
    367     return fTypeLocalName;
    368 }
    369 
    370 inline const XMLCh* ComplexTypeInfo::getTypeUri() const
    371 {
    372    return fTypeUri;
    373 }
    374 
    375 // ---------------------------------------------------------------------------
    376 //  ComplexTypeInfo: Setter methods
    377 // ---------------------------------------------------------------------------
    378 inline void ComplexTypeInfo::setAbstract(const bool isAbstract) {
    379 
    380     fAbstract = isAbstract;
    381 }
    382 
    383 inline void ComplexTypeInfo::setAdoptContentSpec(const bool toAdopt) {
    384 
    385     fAdoptContentSpec = toAdopt;
    386 }
    387 
    388 inline void ComplexTypeInfo::setAttWithTypeId(const bool value) {
    389 
    390     fAttWithTypeId = value;
    391 }
    392 
    393 inline void ComplexTypeInfo::setPreprocessed(const bool aValue) {
    394 
    395     fPreprocessed = aValue;
    396 }
    397 
    398 inline void ComplexTypeInfo::setDerivedBy(const int derivedBy) {
    399 
    400     fDerivedBy = derivedBy;
    401 }
    402 
    403 inline void ComplexTypeInfo::setBlockSet(const int blockSet) {
    404 
    405     fBlockSet = blockSet;
    406 }
    407 
    408 inline void ComplexTypeInfo::setFinalSet(const int finalSet) {
    409 
    410     fFinalSet = finalSet;
    411 }
    412 
    413 inline void ComplexTypeInfo::setScopeDefined(const unsigned int scopeDefined) {
    414 
    415     fScopeDefined = scopeDefined;
    416 }
    417 
    418 inline void ComplexTypeInfo::setElementId(const unsigned int elemId) {
    419 
    420     fElementId = elemId;
    421 }
    422 
    423 inline void
    424 ComplexTypeInfo::setContentType(const int contentType) {
    425 
    426     fContentType = contentType;
    427 }
    428 
    429 inline void ComplexTypeInfo::setTypeName(const XMLCh* const typeName) {
    430 
    431     fMemoryManager->deallocate(fTypeName);//delete [] fTypeName;
    432     fMemoryManager->deallocate(fTypeLocalName);//delete [] fTypeLocalName;
    433     fMemoryManager->deallocate(fTypeUri);//delete [] fTypeUri;
    434 
    435     if (typeName)
    436     {
    437         fTypeName = XMLString::replicate(typeName, fMemoryManager);
    438 
    439         int index = XMLString::indexOf(fTypeName, chComma);
    440         XMLSize_t length = XMLString::stringLen(fTypeName);
    441         fTypeLocalName = (XMLCh*) fMemoryManager->allocate
    442         (
    443             (length - index + 1) * sizeof(XMLCh)
    444         ); //new XMLCh[length - index + 1];
    445         XMLString::subString(fTypeLocalName, fTypeName, index + 1, length, fMemoryManager);
    446 
    447         fTypeUri = (XMLCh*) fMemoryManager->allocate
    448         (
    449             (index + 1) * sizeof(XMLCh)
    450         ); //new XMLCh[index + 1];
    451         XMLString::subString(fTypeUri, fTypeName, 0, index, fMemoryManager);
    452     }
    453     else
    454     {
    455         fTypeName = fTypeLocalName = fTypeUri = 0;
    456     }
    457 }
    458 
    459 inline void
    460 ComplexTypeInfo::setBaseDatatypeValidator(DatatypeValidator* const validator) {
    461 
    462     fBaseDatatypeValidator = validator;
    463 }
    464 
    465 inline void
    466 ComplexTypeInfo::setDatatypeValidator(DatatypeValidator* const validator) {
    467 
    468     fDatatypeValidator = validator;
    469 }
    470 
    471 inline void
    472 ComplexTypeInfo::setBaseComplexTypeInfo(ComplexTypeInfo* const typeInfo) {
    473 
    474     fBaseComplexTypeInfo = typeInfo;
    475 }
    476 
    477 inline void ComplexTypeInfo::addElement(SchemaElementDecl* const elem) {
    478 
    479     if (!fElements) {
    480         fElements = new (fMemoryManager) RefVectorOf<SchemaElementDecl>(8, false, fMemoryManager);
    481     }
    482     else if (fElements->containsElement(elem)) {
    483         return;
    484     }
    485 
    486     fElements->addElement(elem);
    487 }
    488 
    489 inline void ComplexTypeInfo::setAttWildCard(SchemaAttDef* const toAdopt) {
    490 
    491     if (fAttWildCard) {
    492        delete fAttWildCard;
    493     }
    494 
    495     fAttWildCard = toAdopt;
    496 }
    497 
    498 inline void ComplexTypeInfo::setAnonymous() {
    499     fAnonymous = true;
    500 }
    501 
    502 // ---------------------------------------------------------------------------
    503 //  ComplexTypeInfo: Helper methods
    504 // ---------------------------------------------------------------------------
    505 inline bool ComplexTypeInfo::hasAttDefs() const
    506 {
    507     return !fAttDefs->isEmpty();
    508 }
    509 
    510 inline bool ComplexTypeInfo::contains(const XMLCh* const attName) {
    511 
    512     RefHash2KeysTableOfEnumerator<SchemaAttDef> enumDefs(fAttDefs, false, fMemoryManager);
    513 
    514     while (enumDefs.hasMoreElements()) {
    515 
    516         if (XMLString::equals(attName, enumDefs.nextElement().getAttName()->getLocalPart())) {
    517             return true;
    518         }
    519     }
    520 
    521     return false;
    522 }
    523 
    524 XERCES_CPP_NAMESPACE_END
    525 
    526 #endif
    527 
    528 /**
    529   * End of file ComplexTypeInfo.hpp
    530   */
    531 
     1#include <icxercesc/validators/schema/ComplexTypeInfo.hpp>
Note: See TracChangeset for help on using the changeset viewer.