Ignore:
Timestamp:
Nov 18, 2013, 5:53:53 AM (6 years ago)
Author:
cameron
Message:

Updates to xercesc sources

Location:
icXML/icXML-devel/src/xercesc/validators/schema/identity
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • icXML/icXML-devel/src/xercesc/validators/schema/identity/FieldActivator.cpp

    r2722 r3565  
    2727#include <xercesc/validators/schema/identity/ValueStoreCache.hpp>
    2828#include <xercesc/validators/schema/identity/XPathMatcherStack.hpp>
     29#include <xercesc/util/StringPool.hpp>
    2930
    3031XERCES_CPP_NAMESPACE_BEGIN
     
    8586//  FieldActivator: Operator methods
    8687// ---------------------------------------------------------------------------
    87 XPathMatcher* FieldActivator::activateField(IC_Field* const field, const int initialDepth) {
    88 
     88XPathMatcher* FieldActivator::activateField(IC_Field* const field, XMLStringPool * const stringPool, const int initialDepth)
     89{
    8990    ValueStore* valueStore = fValueStoreCache->getValueStoreFor(field, initialDepth);
    90     XPathMatcher* matcher = field->createMatcher(this, valueStore, fMemoryManager);
     91    XPathMatcher* matcher = field->createMatcher(this, valueStore, stringPool, fMemoryManager);
    9192
    9293    setMayMatch(field, true);
     
    118119}
    119120
     121XPathMatcher* FieldActivator::activateField(IC_Field* const, const int)
     122{
     123    DEPRECATED_FEATURE_IN_ICXML;
     124}
     125
    120126XERCES_CPP_NAMESPACE_END
    121127
  • icXML/icXML-devel/src/xercesc/validators/schema/identity/FieldActivator.hpp

    r2722 r3565  
    4343class IC_Field;
    4444class XPathMatcherStack;
    45 
     45class XMLStringPool;
    4646
    4747class VALIDATORS_EXPORT FieldActivator : public XMemory
     
    5151    //  Constructors/Destructor
    5252    // -----------------------------------------------------------------------
    53     FieldActivator(ValueStoreCache* const valueStoreCache,
    54                    XPathMatcherStack* const matcherStack,
    55                    MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
     53    FieldActivator
     54    (
     55        ValueStoreCache* const      valueStoreCache
     56        , XPathMatcherStack* const  matcherStack
     57        , MemoryManager* const      manager = XMLPlatformUtils::fgMemoryManager
     58    );
     59
    5660        FieldActivator(const FieldActivator& other);
     61
     62
    5763        ~FieldActivator();
    5864
     
    8995      */
    9096    XPathMatcher* activateField(IC_Field* const field, const int initialDepth);
     97
     98    XPathMatcher* activateField(IC_Field* const field, XMLStringPool * const stringPool, const int initialDepth);
    9199
    92100    /**
  • icXML/icXML-devel/src/xercesc/validators/schema/identity/IC_Field.cpp

    r3153 r3565  
    3434//  FieldMatcher: Constructors and Destructor
    3535// ---------------------------------------------------------------------------
    36 FieldMatcher::FieldMatcher(XercesXPath* const xpath,
    37                            IC_Field* const aField,
    38                            ValueStore* const valueStore,
    39                            FieldActivator* const fieldActivator,
    40                            MemoryManager* const manager)
    41     : XPathMatcher(xpath, (IdentityConstraint*) 0, manager)
    42     , fValueStore(valueStore)
    43     , fField(aField)   
    44     , fFieldActivator(fieldActivator)
     36FieldMatcher::FieldMatcher
     37(
     38    XercesXPath* const      xpath
     39    , IC_Field* const       aField
     40    , ValueStore* const     valueStore
     41    , FieldActivator* const fieldActivator
     42    , XMLStringPool* const  stringPool
     43    , MemoryManager* const  manager
     44)
     45: XPathMatcher(xpath, (IdentityConstraint*) 0, stringPool, manager)
     46, fValueStore(valueStore)
     47, fField(aField)
     48, fFieldActivator(fieldActivator)
    4549{
    4650}
     51
    4752
    4853// ---------------------------------------------------------------------------
     
    7378    , fIdentityConstraint(identityConstraint)
    7479{
     80
    7581}
    7682
     
    99105XPathMatcher* IC_Field::createMatcher(FieldActivator* const fieldActivator,
    100106                                      ValueStore* const valueStore,
     107                                      XMLStringPool * const stringPool,
    101108                                      MemoryManager* const manager)
    102109{
    103     return new (manager) FieldMatcher(fXPath, this, valueStore, fieldActivator, manager);
     110    return new (manager) FieldMatcher(fXPath, this, valueStore, fieldActivator, stringPool, manager);
    104111}
    105112
     
    134141}
    135142
     143FieldMatcher::FieldMatcher(XercesXPath* const, IC_Field* const , ValueStore* const , FieldActivator* const , MemoryManager* const )
     144: XPathMatcher(0, (IdentityConstraint*)0, 0, 0)
     145{
     146    DEPRECATED_FEATURE_IN_ICXML;
     147}
     148
     149XPathMatcher* IC_Field::createMatcher(FieldActivator* const, ValueStore* const, MemoryManager* const)
     150{
     151    DEPRECATED_FEATURE_IN_ICXML;
     152}
     153
     154
    136155XERCES_CPP_NAMESPACE_END
    137156
  • icXML/icXML-devel/src/xercesc/validators/schema/identity/IC_Field.hpp

    r2722 r3565  
    4646    //  Constructors/Destructor
    4747    // -----------------------------------------------------------------------
    48     IC_Field(XercesXPath* const xpath,
    49              IdentityConstraint* const identityConstraint);
     48    IC_Field
     49    (
     50        XercesXPath* const xpath
     51        , IdentityConstraint* const identityConstraint
     52    );
     53
     54
     55
    5056        ~IC_Field();
    5157
     
    6975        FieldActivator* const fieldActivator
    7076        , ValueStore* const valueStore
     77        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
     78    );
     79
     80    XPathMatcher* createMatcher
     81    (
     82        FieldActivator* const fieldActivator
     83        , ValueStore* const valueStore
     84        , XMLStringPool * const stringPool
    7185        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
    7286    );
     
    124138                 MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
    125139
     140    FieldMatcher(XercesXPath* const anXPath,
     141                 IC_Field* const aField,
     142                 ValueStore* const valueStore,
     143                 FieldActivator* const fieldActivator,
     144                 XMLStringPool* const stringPool,
     145                 MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
     146
    126147    // -----------------------------------------------------------------------
    127148    //  Unimplemented constructors and operators
  • icXML/icXML-devel/src/xercesc/validators/schema/identity/IC_Key.cpp

    r2722 r3565  
    3030//  IC_Key: Constructors and Destructor
    3131// ---------------------------------------------------------------------------
    32 IC_Key::IC_Key(const XMLCh* const identityConstraintName,
    33                const XMLCh* const elemName,
    34                            MemoryManager* const manager)
    35 :IdentityConstraint(identityConstraintName, elemName, manager)
     32IC_Key::IC_Key
     33(
     34    const XMLCh* const      identityConstraintName
     35    , const XMLCh* const    elemName
     36    , XMLStringPool* const  stringPool
     37    , MemoryManager* const  manager
     38)
     39:IdentityConstraint(identityConstraintName, elemName, stringPool, manager)
    3640{
    3741}
     
    6064}
    6165
     66IC_Key::IC_Key(const XMLCh* const, const XMLCh* const, MemoryManager* const)
     67:IdentityConstraint(0, 0, 0, 0)
     68{
     69    DEPRECATED_FEATURE_IN_ICXML;
     70}
     71
     72
    6273XERCES_CPP_NAMESPACE_END
    6374
  • icXML/icXML-devel/src/xercesc/validators/schema/identity/IC_Key.hpp

    r3153 r3565  
    3737    //  Constructors/Destructor
    3838    // -----------------------------------------------------------------------
    39     IC_Key(const XMLCh* const identityConstraintName,
    40            const XMLCh* const elemName,
    41            MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
     39    IC_Key
     40    (
     41        const XMLCh* const identityConstraintName
     42        , const XMLCh* const elemName
     43        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
     44    );
     45
     46    explicit IC_Key
     47    (
     48        const XMLCh* const identityConstraintName
     49        , const XMLCh* const elemName
     50        , XMLStringPool* const stringPool
     51        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
     52    );
     53
    4254        ~IC_Key();
    4355
  • icXML/icXML-devel/src/xercesc/validators/schema/identity/IC_KeyRef.cpp

    r2722 r3565  
    3030//  IC_KeyRef: Constructors and Destructor
    3131// ---------------------------------------------------------------------------
    32 IC_KeyRef::IC_KeyRef(const XMLCh* const identityConstraintName,
    33                      const XMLCh* const elemName,
    34                      IdentityConstraint* const icKey,
    35                      MemoryManager* const manager)
    36     : IdentityConstraint(identityConstraintName, elemName, manager)
    37     , fKey(icKey)
     32IC_KeyRef::IC_KeyRef
     33(
     34    const XMLCh* const          identityConstraintName
     35    , const XMLCh* const        elemName
     36    , IdentityConstraint* const icKey
     37    , XMLStringPool* const      stringPool
     38    , MemoryManager* const      manager
     39)
     40: IdentityConstraint(identityConstraintName, elemName, stringPool, manager)
     41, fKey(icKey)
    3842{
     43
    3944}
    4045
     
    6671
    6772IC_KeyRef::IC_KeyRef(MemoryManager* const manager)
    68 :IdentityConstraint(0, 0, manager)
     73:IdentityConstraint(0, 0, 0, manager)
    6974,fKey(0)
    7075{
     76
    7177}
     78
     79IC_KeyRef::IC_KeyRef(const XMLCh* const , const XMLCh* const , IdentityConstraint* const , MemoryManager* const )
     80: IdentityConstraint(0, 0, 0, 0)
     81{
     82    DEPRECATED_FEATURE_IN_ICXML;
     83}
     84
    7285
    7386XERCES_CPP_NAMESPACE_END
  • icXML/icXML-devel/src/xercesc/validators/schema/identity/IC_KeyRef.hpp

    r3153 r3565  
    3737    //  Constructors/Destructor
    3838    // -----------------------------------------------------------------------
    39     IC_KeyRef(const XMLCh* const identityConstraintName,
    40               const XMLCh* const elemName,
    41               IdentityConstraint* const icKey,
    42               MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
     39    IC_KeyRef
     40    (
     41        const XMLCh* const identityConstraintName
     42        , const XMLCh* const elemName
     43        , IdentityConstraint* const icKey
     44        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
     45    );
     46
     47    explicit IC_KeyRef
     48    (
     49        const XMLCh* const identityConstraintName
     50        , const XMLCh* const elemName
     51        , IdentityConstraint* const icKey
     52        , XMLStringPool* const stringPool
     53        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
     54    );
     55
    4356        ~IC_KeyRef();
    4457
  • icXML/icXML-devel/src/xercesc/validators/schema/identity/IC_Selector.cpp

    r3153 r3565  
    2828#include <icxercesc/validators/schema/identity/IdentityConstraint.hpp>
    2929#include <xercesc/validators/schema/identity/FieldActivator.hpp>
     30#include <xercesc/util/StringPool.hpp>
    3031
    3132XERCES_CPP_NAMESPACE_BEGIN
     
    3435//  SelectorMatcher: Constructors and Destructor
    3536// ---------------------------------------------------------------------------
    36 SelectorMatcher::SelectorMatcher(XercesXPath* const xpath,
    37                                  IC_Selector* const selector,
    38                                  FieldActivator* const fieldActivator,
    39                                  const int initialDepth,
    40                                  MemoryManager* const manager)
    41     : XPathMatcher(xpath, selector->getIdentityConstraint(), manager)
    42     , fInitialDepth(initialDepth)
    43     , fElementDepth(0)
    44     , fMatchedDepth(-1)
    45     , fSelector(selector)
    46     , fFieldActivator(fieldActivator)
    47 {
    48 }
     37SelectorMatcher::SelectorMatcher
     38(
     39    XercesXPath* const xpath
     40    , IC_Selector* const selector
     41    , FieldActivator* const fieldActivator
     42    , const int initialDepth
     43    , XMLStringPool * stringPool
     44    , MemoryManager* const manager
     45)
     46: XPathMatcher(xpath, selector->getIdentityConstraint(), stringPool, manager)
     47, fInitialDepth(initialDepth)
     48, fElementDepth(0)
     49, fMatchedDepth(-1)
     50, fSelector(selector)
     51, fStringPool(stringPool)
     52, fFieldActivator(fieldActivator)
     53{
     54
     55}
     56
     57
    4958
    5059// ---------------------------------------------------------------------------
     
    7180    // activate the fields, if selector is matched
    7281    unsigned char matched = isMatched();
    73     if ((fMatchedDepth == -1 && ((matched & XP_MATCHED) == XP_MATCHED))
    74         || ((matched & XP_MATCHED_D) == XP_MATCHED_D)) {
    75 
     82    if ((fMatchedDepth == -1 && ((matched & XP_MATCHED) == XP_MATCHED)) || ((matched & XP_MATCHED_D) == XP_MATCHED_D))
     83    {
    7684        IdentityConstraint* ic = fSelector->getIdentityConstraint();
    7785        XMLSize_t count = ic->getFieldCount();
     
    8088        fFieldActivator->startValueScopeFor(ic, fInitialDepth);
    8189
    82         for (XMLSize_t i = 0; i < count; i++) {
    83 
    84             XPathMatcher* matcher = fFieldActivator->activateField(ic->getFieldAt(i), fInitialDepth);
     90        for (XMLSize_t i = 0; i < count; i++)
     91        {
     92            XPathMatcher* matcher = fFieldActivator->activateField(ic->getFieldAt(i), fStringPool, fInitialDepth);
    8593            matcher->startElement(elemDecl, urlId, elemPrefix, attrList, attrCount, validationContext);
    8694        }
     
    135143//  IC_Selector: Factory methods
    136144// ---------------------------------------------------------------------------
    137 XPathMatcher* IC_Selector::createMatcher(FieldActivator* const fieldActivator,
    138                                          const int initialDepth,
    139                                          MemoryManager* const manager) {
    140 
    141     return new (manager) SelectorMatcher(fXPath, this, fieldActivator, initialDepth, manager);
     145XPathMatcher* IC_Selector::createMatcher
     146(
     147    FieldActivator* const   fieldActivator
     148    , const int             initialDepth
     149    , XMLStringPool *       stringPool
     150    , MemoryManager * const manager
     151)
     152{
     153    return new (manager) SelectorMatcher(fXPath, this, fieldActivator, initialDepth, stringPool, manager);
    142154}
    143155
     
    171183}
    172184
     185XPathMatcher* IC_Selector::createMatcher
     186(
     187    FieldActivator* const
     188    , const int
     189    , MemoryManager* const
     190)
     191{
     192    DEPRECATED_FEATURE_IN_ICXML;
     193}
     194
     195SelectorMatcher::SelectorMatcher(XercesXPath* const,
     196                                 IC_Selector* const,
     197                                 FieldActivator* const,
     198                                 const int,
     199                                 MemoryManager* const)
     200: XPathMatcher(NULL, NULL, NULL, NULL)
     201{
     202    DEPRECATED_FEATURE_IN_ICXML;
     203}
     204
    173205XERCES_CPP_NAMESPACE_END
    174206
  • icXML/icXML-devel/src/xercesc/validators/schema/identity/IC_Selector.hpp

    r2722 r3565  
    3737// ---------------------------------------------------------------------------
    3838class FieldActivator;
    39 
     39class XMLStringPool;
    4040
    4141class VALIDATORS_EXPORT IC_Selector : public XSerializable, public XMemory
     
    6464    //  Factory methods
    6565    // -----------------------------------------------------------------------
    66     XPathMatcher* createMatcher(FieldActivator* const fieldActivator,
    67                                 const int initialDepth,
    68                                 MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
     66    XPathMatcher* createMatcher
     67    (
     68        FieldActivator* const   fieldActivator
     69        , const int             initialDepth
     70        , XMLStringPool * const stringPool
     71        , MemoryManager * const manager = XMLPlatformUtils::fgMemoryManager
     72    );
     73
     74    XPathMatcher* createMatcher
     75    (
     76        FieldActivator* const   fieldActivator
     77        , const int             initialDepth
     78        , MemoryManager* const  manager = XMLPlatformUtils::fgMemoryManager
     79    );
    6980
    7081    /***
     
    119130    //  Constructors/Destructor
    120131    // -----------------------------------------------------------------------
    121     SelectorMatcher(XercesXPath* const anXPath,
    122                     IC_Selector* const selector,
    123                     FieldActivator* const fieldActivator,
    124                     const int initialDepth,
    125                     MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
     132    SelectorMatcher
     133    (
     134        XercesXPath* const      anXPath,
     135        IC_Selector* const      selector,
     136        FieldActivator* const   fieldActivator,
     137        const int               initialDepth,
     138        MemoryManager* const    manager = XMLPlatformUtils::fgMemoryManager
     139    );
     140
     141    SelectorMatcher
     142    (
     143        XercesXPath* const      anXPath,
     144        IC_Selector* const      selector,
     145        FieldActivator* const   fieldActivator,
     146        const int               initialDepth,
     147        XMLStringPool * const   stringPool,
     148        MemoryManager* const    manager = XMLPlatformUtils::fgMemoryManager
     149    );
    126150
    127151    // -----------------------------------------------------------------------
     
    143167    int             fMatchedDepth;
    144168    IC_Selector*    fSelector;
     169    XMLStringPool*  fStringPool;
    145170    FieldActivator* fFieldActivator;
    146171};
  • icXML/icXML-devel/src/xercesc/validators/schema/identity/IC_Unique.cpp

    r2722 r3565  
    3030//  IC_Unique: Constructors and Destructor
    3131// ---------------------------------------------------------------------------
    32 IC_Unique::IC_Unique(const XMLCh* const identityConstraintName,
    33                      const XMLCh* const elemName,
    34                      MemoryManager* const manager)
    35     : IdentityConstraint(identityConstraintName, elemName, manager)
     32IC_Unique::IC_Unique
     33(
     34    const XMLCh* const      identityConstraintName
     35    , const XMLCh* const    elemName
     36    , XMLStringPool* const  stringPool
     37    , MemoryManager* const  manager
     38)
     39: IdentityConstraint(identityConstraintName, elemName, stringPool, manager)
    3640{
    3741}
     
    5660
    5761IC_Unique::IC_Unique(MemoryManager* const manager)
    58 :IdentityConstraint(0, 0, manager)
     62:IdentityConstraint(0, 0, 0, manager)
    5963{
     64}
     65
     66IC_Unique::IC_Unique(const XMLCh* const , const XMLCh* const , MemoryManager* const )
     67: IdentityConstraint(0, 0, 0, 0)
     68{
     69    DEPRECATED_FEATURE_IN_ICXML;
    6070}
    6171
  • icXML/icXML-devel/src/xercesc/validators/schema/identity/IC_Unique.hpp

    r3153 r3565  
    3535XERCES_CPP_NAMESPACE_BEGIN
    3636
     37class XMLStringPool;
     38
    3739class VALIDATORS_EXPORT IC_Unique: public IdentityConstraint
    3840{
     
    4143    //  Constructors/Destructor
    4244    // -----------------------------------------------------------------------
    43     IC_Unique(const XMLCh* const identityConstraintName,
    44               const XMLCh* const elemName,
    45               MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
     45    IC_Unique
     46    (
     47        const XMLCh* const identityConstraintName
     48        , const XMLCh* const elemName
     49        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
     50    );
     51
     52    IC_Unique
     53    (
     54        const XMLCh* const identityConstraintName
     55        , const XMLCh* const elemName
     56        , XMLStringPool* const stringPool
     57        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
     58    );
     59
    4660        ~IC_Unique();
    4761
  • icXML/icXML-devel/src/xercesc/validators/schema/identity/XPathMatcher.cpp

    r3153 r3565  
    3030#include <xercesc/util/RuntimeException.hpp>
    3131#include <xercesc/util/OutOfMemoryException.hpp>
     32#include <xercesc/util/StringPool.hpp>
    3233#include <xercesc/framework/ValidationContext.hpp>
    3334
     35
    3436XERCES_CPP_NAMESPACE_BEGIN
    3537
     
    3941//  XPathMatcher: Constructors and Destructor
    4042// ---------------------------------------------------------------------------
    41 XPathMatcher::XPathMatcher( XercesXPath* const xpath
    42                           , MemoryManager* const manager)
    43     : fLocationPathSize(0)
    44     , fMatched(0)
    45     , fNoMatchDepth(0)
    46     , fCurrentStep(0)
    47     , fStepIndexes(0)
    48     , fLocationPaths(0)
    49     , fIdentityConstraint(0)
    50     , fMemoryManager(manager)
     43
     44
     45XPathMatcher::XPathMatcher
     46(
     47    XercesXPath* const      xpath
     48    , XMLStringPool* const  stringPool
     49    , MemoryManager* const  manager
     50)
     51: fLocationPathSize(0)
     52, fMatched(0)
     53, fNoMatchDepth(0)
     54, fCurrentStep(0)
     55, fStepIndexes(0)
     56, fLocationPaths(0)
     57, fIdentityConstraint(0)
     58, fStringPool(stringPool)
     59, fMemoryManager(manager)
    5160{
    5261    CleanupType cleanup(this, &XPathMatcher::cleanUp);
     
    6675
    6776
    68 XPathMatcher::XPathMatcher(XercesXPath* const xpath,
    69                            IdentityConstraint* const ic,
    70                                                    MemoryManager* const manager)
    71     : fLocationPathSize(0)
    72     , fMatched(0)
    73     , fNoMatchDepth(0)
    74     , fCurrentStep(0)
    75     , fStepIndexes(0)
    76     , fLocationPaths(0)
    77     , fIdentityConstraint(ic)
    78     , fMemoryManager(manager)
     77XPathMatcher::XPathMatcher
     78(
     79    XercesXPath* const          xpath
     80    , IdentityConstraint* const ic
     81    , XMLStringPool* const      stringPool
     82    , MemoryManager* const      manager
     83)
     84: fLocationPathSize(0)
     85, fMatched(0)
     86, fNoMatchDepth(0)
     87, fCurrentStep(0)
     88, fStepIndexes(0)
     89, fLocationPaths(0)
     90, fIdentityConstraint(ic)
     91, fStringPool(stringPool)
     92, fMemoryManager(manager)
    7993{
    8094    CleanupType cleanup(this, &XPathMatcher::cleanUp);
     
    210224            XercesNodeTest* nodeTest = step->getNodeTest();
    211225
    212             QName elemQName(elemPrefix, elemDecl.getElementName()->getLocalPart(), urlId, fMemoryManager);
     226            QName elemQName(elemPrefix, elemDecl.getElementName()->getLocalPart(), urlId, fStringPool);
    213227            if (!matches(nodeTest, &elemQName)) {
    214228
     
    263277                            const XMLCh* value = curDef->getValue();
    264278                            // store QName using their Clark name
    265                             if(dv && dv->getType()==DatatypeValidator::QName)
     279                            if (dv && dv->getType()==DatatypeValidator::QName)
    266280                            {
    267281                                int index=XMLString::indexOf(value, chColon);
     
    285299                            }
    286300                            else
     301                            {
    287302                                matched(value, dv, false);
     303                            }
    288304                        }
    289305                        break;
     
    344360                    XMLBuffer buff(1023, fMemoryManager);
    345361                    buff.append(chOpenCurly);
    346                     if(validationContext)
     362                    if (validationContext)
    347363                    {
    348364                        XMLCh* prefix=(XMLCh*)fMemoryManager->allocate((index+1)*sizeof(XMLCh));
     
    406422}
    407423
     424XPathMatcher::XPathMatcher( XercesXPath* const, MemoryManager* const)
     425{
     426    DEPRECATED_FEATURE_IN_ICXML;
     427}
     428
     429
     430XPathMatcher::XPathMatcher(XercesXPath* const, IdentityConstraint* const, MemoryManager* const)
     431{
     432    DEPRECATED_FEATURE_IN_ICXML;
     433}
     434
     435
    408436XERCES_CPP_NAMESPACE_END
    409437
  • icXML/icXML-devel/src/xercesc/validators/schema/identity/XPathMatcher.hpp

    r2722 r3565  
    5353    //  Constructors/Destructor
    5454    // -----------------------------------------------------------------------
    55     XPathMatcher(XercesXPath* const xpath,
    56                  MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
    57     XPathMatcher(XercesXPath* const xpath,
    58                  IdentityConstraint* const ic,
    59                  MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
     55    XPathMatcher
     56    (
     57        XercesXPath* const xpath
     58        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
     59    );
     60
     61    XPathMatcher
     62    (
     63        XercesXPath* const xpath
     64        , IdentityConstraint* const ic
     65        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
     66    );
     67
     68    XPathMatcher
     69    (
     70        XercesXPath* const     xpath
     71        , XMLStringPool* const stringPool
     72        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
     73    );
     74
     75    XPathMatcher
     76    (
     77        XercesXPath* const xpath
     78        , IdentityConstraint* const ic
     79        , XMLStringPool* const stringPool
     80        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
     81    );
     82
     83
     84
    6085    virtual ~XPathMatcher();
    6186
     
    127152    void cleanUp();
    128153
     154protected:
     155
    129156    // -----------------------------------------------------------------------
    130157    //  Data members
     
    159186    RefVectorOf<XercesLocationPath>*        fLocationPaths;
    160187    IdentityConstraint*                     fIdentityConstraint;
     188    XMLStringPool*                          fStringPool;
    161189    MemoryManager*                          fMemoryManager;
    162190};
  • icXML/icXML-devel/src/xercesc/validators/schema/identity/XPathMatcherStack.hpp

    r2722 r3565  
    3030
    3131XERCES_CPP_NAMESPACE_BEGIN
     32
     33class XMLStringPool;
    3234
    3335class VALIDATORS_EXPORT XPathMatcherStack : public XMemory
  • icXML/icXML-devel/src/xercesc/validators/schema/identity/XercesXPath.cpp

    r3153 r3565  
    5858//  XercesNodeTest: Constructors and Destructor
    5959// ---------------------------------------------------------------------------
    60 XercesNodeTest::XercesNodeTest(const short aType,
    61                                MemoryManager* const manager)
    62     : fType(aType)
    63     , fName(new (manager) QName(manager))
    64 {
    65 }
     60XercesNodeTest::XercesNodeTest(const short aType, XMLStringPool * const qNameManager, MemoryManager* const manager)
     61: fType(aType)
     62, fName(new (manager) QName(qNameManager))
     63{
     64}
     65
     66XercesNodeTest::XercesNodeTest(const XMLCh* const prefix, const unsigned int uriId, XMLStringPool* const qNameManager, MemoryManager* const manager)
     67: fType(NodeType_NAMESPACE)
     68, fName(new (manager) QName(prefix, XMLUni::fgZeroLenString, uriId, qNameManager))
     69{
     70
     71}
     72
    6673
    6774XercesNodeTest::XercesNodeTest(const QName* const qName)
    68     : fType(NodeType_QNAME)
    69     , fName(new (qName->getMemoryManager()) QName(*qName))
    70 {
    71 }
    72 
    73 XercesNodeTest::XercesNodeTest(const XMLCh* const prefix,
    74                                const unsigned int uriId,
    75                                MemoryManager* const manager)
    76     : fType(NodeType_NAMESPACE)
    77     , fName(new (manager) QName(manager))
    78 {
    79     fName->setURI(uriId);
    80     fName->setPrefix(prefix);
     75: fType(NodeType_QNAME)
     76, fName(new (qName->getMemoryManager()) QName(*qName))
     77{
     78
    8179}
    8280
    8381XercesNodeTest::XercesNodeTest(const XercesNodeTest& other)
    84     : XSerializable(other)
    85     , XMemory(other)
    86     , fType(other.fType)
    87     , fName(new ((other.fName)->getMemoryManager()) QName(*other.fName))
    88 {
    89 }
     82: XSerializable(other)
     83, XMemory(other)
     84, fType(other.fType)
     85, fName(new ((other.fName)->getMemoryManager()) QName(*other.fName))
     86{
     87
     88}
     89
     90XercesNodeTest::XercesNodeTest(const short, MemoryManager* const)
     91{
     92    DEPRECATED_FEATURE_IN_ICXML;
     93}
     94
     95XercesNodeTest::XercesNodeTest(const XMLCh* const, const unsigned int, MemoryManager* const)
     96{
     97    DEPRECATED_FEATURE_IN_ICXML;
     98}
     99
    90100
    91101/***
     
    424434                {
    425435                    // prepend ./
    426                     XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::NodeType_NODE, fMemoryManager);
     436                    XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::NodeType_NODE, stringPool, fMemoryManager);
    427437                    XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::AxisType_SELF, nodeTest);
    428438                    stepsVector->insertElementAt(step, 0);
     
    472482                case XercesXPath::EXPRTOKEN_NAMETEST_ANY:
    473483                    {
    474                         XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::NodeType_WILDCARD, fMemoryManager);
     484                        XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::NodeType_WILDCARD, stringPool, fMemoryManager);
    475485                        XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::AxisType_ATTRIBUTE, nodeTest);
    476486                        stepsVector->addElement(step);
     
    501511
    502512                            // build step
    503                             XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(prefix, uri, fMemoryManager);
     513                            XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(prefix, uri, stringPool, fMemoryManager);
    504514                            XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::AxisType_ATTRIBUTE, nodeTest);
    505515                            stepsVector->addElement(step);
     
    510520
    511521                        const XMLCh* localPart = stringPool->getValueForId(aToken);
    512                         QName aQName(prefix, localPart, uri, fMemoryManager);
     522                        QName aQName(prefix, localPart, uri, stringPool);
    513523
    514524                        // build step
     
    542552        case XercesXPath::EXPRTOKEN_NAMETEST_ANY:
    543553            {
    544                 XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::NodeType_WILDCARD, fMemoryManager);
     554                XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::NodeType_WILDCARD, stringPool, fMemoryManager);
    545555                XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::AxisType_CHILD, nodeTest);
    546556                stepsVector->addElement(step);
     
    573583
    574584                    // build step
    575                     XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(prefix, uri, fMemoryManager);
     585                    XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(prefix, uri, stringPool, fMemoryManager);
    576586                    XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::AxisType_CHILD, nodeTest);
    577587                    stepsVector->addElement(step);
     
    581591                aToken = tokens.elementAt(++i);
    582592                const XMLCh* localPart = stringPool->getValueForId(aToken);
    583                 QName aQName(prefix, localPart, uri, fMemoryManager);
     593                QName aQName(prefix, localPart, uri, stringPool);
    584594
    585595                // build step
     
    593603            {
    594604                // build step
    595                 XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::NodeType_NODE, fMemoryManager);
     605                XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::NodeType_NODE, stringPool, fMemoryManager);
    596606                XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::AxisType_SELF, nodeTest);
    597607                stepsVector->addElement(step);
     
    616626                        }
    617627                        // build step
    618                         nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::NodeType_NODE, fMemoryManager);
     628                        nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::NodeType_NODE, stringPool, fMemoryManager);
    619629                        step = new (fMemoryManager) XercesStep(XercesStep::AxisType_DESCENDANT, nodeTest);
    620630                        stepsVector->addElement(step);
     
    669679    {
    670680        // prepend ./
    671         XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::NodeType_NODE, fMemoryManager);
     681        XercesNodeTest * nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::NodeType_NODE, stringPool, fMemoryManager);
    672682        XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::AxisType_SELF, nodeTest);
    673683        stepsVector->insertElementAt(step, 0);
  • icXML/icXML-devel/src/xercesc/validators/schema/identity/XercesXPath.hpp

    r3153 r3565  
    5757    //  Constructors/Destructor
    5858    // -----------------------------------------------------------------------
    59     XercesNodeTest(const short type,
    60                    MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
    61     XercesNodeTest(const QName* const qName);
    62     XercesNodeTest(const XMLCh* const prefix, const unsigned int uriId,
    63                    MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
     59    XercesNodeTest(const short type, XMLStringPool* const qNameManager, MemoryManager* const manager);
     60    XercesNodeTest(const XMLCh* const prefix, const unsigned int uriId, XMLStringPool* const qNameManager, MemoryManager* const manager);
     61    XercesNodeTest(const QName* const qName);   
    6462    XercesNodeTest(const XercesNodeTest& other);
     63
    6564    ~XercesNodeTest() { delete fName; }
     65
     66    // -----------------------------------------------------------------------
     67    //  Deprecated Constructors
     68    // -----------------------------------------------------------------------
     69    XercesNodeTest(const short type, MemoryManager* const manager);
     70    XercesNodeTest(const XMLCh* const prefix, const unsigned int uriId, MemoryManager* const manager);
     71
    6672
    6773    // -----------------------------------------------------------------------
Note: See TracChangeset for help on using the changeset viewer.