xobjectcomparator.cpp

来自「IBM的解析xml的工具Xerces的源代码」· C++ 代码 · 共 970 行 · 第 1/3 页

    bool v18 = XTemplateComparator::isEquivalent(lValue->fAttDefs
                                               , rValue->fAttDefs);
    bool v19 = XTemplateComparator::isEquivalent(lValue->fIdentityConstraints
                                               , rValue->fIdentityConstraints);

    return v1&&v2&&v3&&v4&&v5&&v6&&v7&&v8&&v9&&v10&&v11&&v12&&v13&&v14&&v15&&v16&&v17&&v18&&v19;

#endif

}

bool XObjectComparator::isEquivalent(DTDElementDecl* const lValue
                                   , DTDElementDecl* const rValue)
{
    IS_EQUIVALENT(lValue, rValue)

    if (!isBaseEquivalent((XMLElementDecl*)lValue, (XMLElementDecl*)rValue))
        return false;

    //don't compare
    //XMLContentModel*            fContentModel;
    //XMLCh*                      fFormattedModel;

    return (            
            (lValue->fModelType == rValue->fModelType)         &&
            isEquivalent(lValue->fContentSpec
                       , rValue->fContentSpec)                 &&
            isEquivalent(lValue->fAttList
                       , rValue->fAttList)                     &&
            XTemplateComparator::isEquivalent(lValue->fAttDefs
                                            , rValue->fAttDefs) 
          );                                            

}

/**********************************************************
 * XMLAttDef
 *   SchemaAttDef
 *   DTDAttDef
 *
***********************************************************/   
bool XObjectComparator::isBaseEquivalent(XMLAttDef* const lValue
                                       , XMLAttDef* const rValue)
{
    return (
             (lValue->fDefaultType       == rValue->fDefaultType)         &&
             (lValue->fType              == rValue->fType)                &&
             (lValue->fCreateReason      == rValue->fCreateReason)        &&
             (lValue->fProvided          == rValue->fProvided)            &&
             (lValue->fExternalAttribute == rValue->fExternalAttribute)   &&
             (lValue->fId                == rValue->fId)                  &&
             XMLString::equals(lValue->fValue,       rValue->fValue)      &&
             XMLString::equals(lValue->fEnumeration, rValue->fEnumeration)     
            );
}

bool XObjectComparator::isEquivalent(SchemaAttDef* const lValue
                                   , SchemaAttDef* const rValue)
{
    IS_EQUIVALENT(lValue, rValue)

    if (!isBaseEquivalent((XMLAttDef*)lValue, (XMLAttDef*)rValue))
        return false;

    return (
            (lValue->fValidity   == rValue->fValidity)                       &&
            (lValue->fValidation == rValue->fValidation)                     &&
            (lValue->fElemId     == rValue->fElemId)                         &&
            isEquivalent(lValue->fAttName, rValue->fAttName)                 &&
            isEquivalent(lValue->fDatatypeValidator
                                          , rValue->fDatatypeValidator)      &&
            isEquivalent(lValue->fAnyDatatypeValidator
                       , rValue->fAnyDatatypeValidator)                      &&
            isEquivalent((DatatypeValidator*) lValue->fAnyDatatypeValidator
                       , (DatatypeValidator*) rValue->fAnyDatatypeValidator) &&
            XTemplateComparator::isEquivalent(lValue->fNamespaceList
                                            , rValue->fNamespaceList)
           );

}

bool XObjectComparator::isEquivalent(DTDAttDef* const lValue
                                   , DTDAttDef* const rValue)
{
    IS_EQUIVALENT(lValue, rValue)

    if (!isBaseEquivalent((XMLAttDef*)lValue, (XMLAttDef*)rValue))
        return false;

    return (
            (lValue->fElemId   == rValue->fElemId)          &&
            XMLString::equals(lValue->fName, rValue->fName)
           );

}

/**********************************************************
 * XMLAttDefList
 *   SchemaAttDefList
 *   DTDAttDefList
 *
***********************************************************/   
bool XObjectComparator::isBaseEquivalent(XMLAttDefList* const lValue
                                       , XMLAttDefList* const rValue)
{
     IS_EQUIVALENT(lValue, rValue)

     return true;
}
   
bool XObjectComparator::isEquivalent(SchemaAttDefList* const lValue
                                   , SchemaAttDefList* const rValue)
{
    IS_EQUIVALENT(lValue, rValue)

    //no base comparision needed

    return XTemplateComparator::isEquivalent(lValue->fList, rValue->fList);    
}

bool XObjectComparator::isEquivalent(DTDAttDefList* const lValue
                                   , DTDAttDefList* const rValue)
{
    IS_EQUIVALENT(lValue, rValue)

    //no base comparision needed

    return XTemplateComparator::isEquivalent(lValue->fList, rValue->fList);    
}

/**********************************************************
 * XMLEntityDecl
 *    DTDEntityDecl 
 *
 ***********************************************************/   
bool XObjectComparator::isBaseEquivalent(XMLEntityDecl* const lValue
                                       , XMLEntityDecl* const rValue )
{

    return (
             (lValue->fId       == rValue->fId)         &&
             (lValue->fValueLen == rValue->fValueLen)   &&
             XMLString::equals(lValue->fValue
                             , rValue->fValue)          &&
             XMLString::equals(lValue->fName
                             , rValue->fName)           &&
             XMLString::equals(lValue->fNotationName
                             , rValue->fNotationName)   &&
             XMLString::equals(lValue->fPublicId
                             , rValue->fPublicId)       &&
             XMLString::equals(lValue->fSystemId
                             , rValue->fSystemId)       &&
             XMLString::equals(lValue->fBaseURI
                             , rValue->fBaseURI)   
            );

}

bool XObjectComparator::isEquivalent(DTDEntityDecl* const lValue
                                   , DTDEntityDecl* const rValue )
{

    IS_EQUIVALENT(lValue, rValue)

    if (!isBaseEquivalent((XMLEntityDecl*)lValue, (XMLEntityDecl*)rValue))
        return false;

    return (
             (lValue->fDeclaredInIntSubset == rValue->fDeclaredInIntSubset) &&
             (lValue->fIsParameter         == rValue->fIsParameter)         &&
             (lValue->fIsSpecialChar       == rValue->fIsSpecialChar)
           );

}

/**********************************************************
 * XMLNotationDecl
 *
 * XMLEntityDecl
 *
 * ComplexTypeInfo
 * XercesGroupInfo
 * XercesAttGroupInfo
 ***********************************************************/   
bool XObjectComparator::isEquivalent(XMLNotationDecl* const lValue
                                   , XMLNotationDecl* const rValue )
{

    IS_EQUIVALENT(lValue, rValue)

    return (
            (lValue->fId == rValue->fId)                             &&
            XMLString::equals(lValue->fName    , rValue->fName)      &&
            XMLString::equals(lValue->fPublicId, rValue->fPublicId)  &&
            XMLString::equals(lValue->fSystemId, rValue->fSystemId)  &&
            XMLString::equals(lValue->fBaseURI,  rValue->fBaseURI)  
           );

}

bool XObjectComparator::isEquivalent(ComplexTypeInfo* const lValue
                                   , ComplexTypeInfo* const rValue )
{
  /***
    don't compare
    XMLContentModel*                   fContentModel;
    XMLCh*                             fFormattedModel;    
    XSDLocator*                        fLocator;
    * 
    * fContentSpecOrgURI:     start of the array
    * fContentSpecOrgURISize: size of the array
    * fUniqueURI:             the current last element in the array
    ***/

    IS_EQUIVALENT(lValue, rValue)

#ifndef _DEBUG
return (
            (lValue->fAnonymous        == rValue->fAnonymous)        &&
            (lValue->fAbstract         == rValue->fAbstract)         &&
            (lValue->fAdoptContentSpec == rValue->fAdoptContentSpec) &&
            (lValue->fAttWithTypeId    == rValue->fAttWithTypeId)    &&
            (lValue->fPreprocessed     == rValue->fPreprocessed)     &&
            (lValue->fDerivedBy        == rValue->fDerivedBy)        &&
            (lValue->fBlockSet         == rValue->fBlockSet)         &&
            (lValue->fFinalSet         == rValue->fFinalSet)         &&
            (lValue->fScopeDefined     == rValue->fScopeDefined)     &&
            (lValue->fElementId        == rValue->fElementId)        &&
            (lValue->fContentType      == rValue->fContentType)      &&
            XMLString::equals(lValue->fTypeName,      rValue->fTypeName)      &&
            XMLString::equals(lValue->fTypeLocalName, rValue->fTypeLocalName) &&
            XMLString::equals(lValue->fTypeUri,       rValue->fTypeUri)       &&
            isEquivalent(lValue->fBaseDatatypeValidator
                       , rValue->fBaseDatatypeValidator)                      &&
            isEquivalent(lValue->fDatatypeValidator
                       , rValue->fDatatypeValidator)                          &&
            isEquivalent(lValue->fBaseComplexTypeInfo
                       , rValue->fBaseComplexTypeInfo)                        &&
            isEquivalent(lValue->fContentSpec
                       , rValue->fContentSpec)                                &&
            isEquivalent(lValue->fAttWildCard
                       , rValue->fAttWildCard)                                &&
            isEquivalent(lValue->fAttList
                       , rValue->fAttList)                                    &&
            XTemplateComparator::isEquivalent(lValue->fElements
                                            , rValue->fElements)              &&
            XTemplateComparator::isEquivalent(lValue->fAttDefs
                                            , rValue->fAttDefs)              
        );

#else

    bool v1 =  lValue->fAnonymous        == rValue->fAnonymous;
    bool v2 =  lValue->fAbstract         == rValue->fAbstract;         
    bool v3 =  lValue->fAdoptContentSpec == rValue->fAdoptContentSpec;
    bool v4 =  lValue->fAttWithTypeId    == rValue->fAttWithTypeId;  
    bool v5 =  lValue->fPreprocessed     == rValue->fPreprocessed;     
    bool v6 =  lValue->fDerivedBy        == rValue->fDerivedBy;      
    bool v7 =  lValue->fBlockSet         == rValue->fBlockSet;         
    bool v8 =  lValue->fFinalSet         == rValue->fFinalSet;          
    bool v9 =  lValue->fScopeDefined     == rValue->fScopeDefined;
    bool v10 = lValue->fElementId        == rValue->fElementId;      
    bool v11 = lValue->fContentType      == rValue->fContentType;
    bool v12 = XMLString::equals(lValue->fTypeName
                               , rValue->fTypeName);
    bool v13 = XMLString::equals(lValue->fTypeLocalName
                               , rValue->fTypeLocalName);
    bool v14 = XMLString::equals(lValue->fTypeUri
                               , rValue->fTypeUri);
    bool v15 = isEquivalent(lValue->fBaseDatatypeValidator
                          , rValue->fBaseDatatypeValidator);
    bool v16 = isEquivalent(lValue->fDatatypeValidator
                          , rValue->fDatatypeValidator);
    bool v17 = isEquivalent(lValue->fBaseComplexTypeInfo
                          , rValue->fBaseComplexTypeInfo);
    bool v18 = isEquivalent(lValue->fContentSpec
                          , rValue->fContentSpec);
    bool v19 = isEquivalent(lValue->fAttWildCard
                          , rValue->fAttWildCard);
    bool v20 = isEquivalent(lValue->fAttList
                          , rValue->fAttList);
    bool v21 = XTemplateComparator::isEquivalent(lValue->fElements
                                               , rValue->fElements);
    bool v22 = XTemplateComparator::isEquivalent(lValue->fAttDefs
                                               , rValue->fAttDefs);
                                                       
    return v1&&v2&&v3&&v4&&v5&&v6&&v7&&v8&&v9&&v10&&v11&&v12&&v13&&v14&&v15&&v16&&v17&&v18&&v19&&v20&&v21&&v22;

#endif

}

bool XObjectComparator::isEquivalent(XercesGroupInfo* const lValue
                                   , XercesGroupInfo* const rValue )
{

    IS_EQUIVALENT(lValue, rValue)

    //    don't compare
    //    XSDLocator*                     fLocator;

    return (
            (lValue->fCheckElementConsistency == rValue->fCheckElementConsistency)  &&
            (lValue->fScope                   == rValue->fScope)                    &&
            isEquivalent(lValue->fContentSpec
                       , rValue->fContentSpec)                                      &&
            isEquivalent(lValue->fBaseGroup
                       , rValue->fBaseGroup)                                        &&
            XTemplateComparator::isEquivalent(lValue->fElements
                                            , rValue->fElements)              
           );

}

bool XObjectComparator::isEquivalent(XercesAttGroupInfo* const lValue
                                   , XercesAttGroupInfo* const rValue )
{

    IS_EQUIVALENT(lValue, rValue)

    return (
            (lValue->fTypeWithId == rValue->fTypeWithId)              &&
            isEquivalent(lValue->fCompleteWildCard
                       , rValue->fCompleteWildCard)                   &&