xtemplatecomparator.cpp

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

        XMLCh*     key   = (XMLCh*) lEnum.nextElementKey();
        DTDAttDef* data1 = (DTDAttDef*) lValue->get(key);
        DTDAttDef* data2 = (DTDAttDef*) rValue->get(key);

        if (!XObjectComparator::isEquivalent(data1, data2))
            return false;

    }  

    return true;

}

bool XTemplateComparator::isEquivalent(RefHashTableOf<ComplexTypeInfo>* const lValue
                                     , RefHashTableOf<ComplexTypeInfo>* const rValue)
{
    IS_EQUIVALENT(lValue, rValue);

    RefHashTableOfEnumerator<ComplexTypeInfo> lEnum(lValue, false, lValue->getMemoryManager());
    int lItemNumber = 0;        
    while (lEnum.hasMoreElements())
    {
        lEnum.nextElement();
        lItemNumber++;
    }

    RefHashTableOfEnumerator<ComplexTypeInfo> rEnum(rValue, false, rValue->getMemoryManager());
    int rItemNumber = 0;        
    while (rEnum.hasMoreElements())
    {
        rEnum.nextElement();
        rItemNumber++;
    }

    //both shall have the number of item in it
    if (lItemNumber != rItemNumber)
        return false;

    //Any thing in the lValue shall be found in the rValue
    lEnum.Reset();
    while (lEnum.hasMoreElements())
    {
        XMLCh*           key   = (XMLCh*) lEnum.nextElementKey();
        ComplexTypeInfo* data1 = (ComplexTypeInfo*) lValue->get(key);
        ComplexTypeInfo* data2 = (ComplexTypeInfo*) rValue->get(key);

        if (!XObjectComparator::isEquivalent(data1, data2))
            return false;

    }  

    return true;
}

bool XTemplateComparator::isEquivalent(RefHashTableOf<XercesGroupInfo>* const lValue
                                     , RefHashTableOf<XercesGroupInfo>* const rValue)
{
    IS_EQUIVALENT(lValue, rValue);

    RefHashTableOfEnumerator<XercesGroupInfo> lEnum(lValue, false, lValue->getMemoryManager());
    int lItemNumber = 0;        
    while (lEnum.hasMoreElements())
    {
        lEnum.nextElement();
        lItemNumber++;
    }

    RefHashTableOfEnumerator<XercesGroupInfo> rEnum(rValue, false, rValue->getMemoryManager());
    int rItemNumber = 0;        
    while (rEnum.hasMoreElements())
    {
        rEnum.nextElement();
        rItemNumber++;
    }

    //both shall have the number of item in it
    if (lItemNumber != rItemNumber)
        return false;

    //Any thing in the lValue shall be found in the rValue
    lEnum.Reset();
    while (lEnum.hasMoreElements())
    {
        XMLCh*           key   = (XMLCh*) lEnum.nextElementKey();
        XercesGroupInfo* data1 = (XercesGroupInfo*) lValue->get(key);
        XercesGroupInfo* data2 = (XercesGroupInfo*) rValue->get(key);

        if (!XObjectComparator::isEquivalent(data1, data2))
            return false;

    }  

    return true;
}

bool XTemplateComparator::isEquivalent(RefHashTableOf<XercesAttGroupInfo>* const lValue
                                     , RefHashTableOf<XercesAttGroupInfo>* const rValue)
{
    IS_EQUIVALENT(lValue, rValue);

    RefHashTableOfEnumerator<XercesAttGroupInfo> lEnum(lValue, false, lValue->getMemoryManager());
    int lItemNumber = 0;        
    while (lEnum.hasMoreElements())
    {
        lEnum.nextElement();
        lItemNumber++;
    }

    RefHashTableOfEnumerator<XercesAttGroupInfo> rEnum(rValue, false, rValue->getMemoryManager());
    int rItemNumber = 0;        
    while (rEnum.hasMoreElements())
    {
        rEnum.nextElement();
        rItemNumber++;
    }

    //both shall have the number of item in it
    if (lItemNumber != rItemNumber)
        return false;

    //Any thing in the lValue shall be found in the rValue
    lEnum.Reset();
    while (lEnum.hasMoreElements())
    {
        XMLCh*              key   = (XMLCh*) lEnum.nextElementKey();
        XercesAttGroupInfo* data1 = (XercesAttGroupInfo*) lValue->get(key);
        XercesAttGroupInfo* data2 = (XercesAttGroupInfo*) rValue->get(key);

        if (!XObjectComparator::isEquivalent(data1, data2))
            return false;

    }  

    return true;
}

bool XTemplateComparator::isEquivalent(RefHashTableOf<XMLRefInfo>* const lValue
                                     , RefHashTableOf<XMLRefInfo>* const rValue)
{
    IS_EQUIVALENT(lValue, rValue);

    RefHashTableOfEnumerator<XMLRefInfo> lEnum(lValue, false, lValue->getMemoryManager());
    int lItemNumber = 0;        
    while (lEnum.hasMoreElements())
    {
        lEnum.nextElement();
        lItemNumber++;
    }

    RefHashTableOfEnumerator<XMLRefInfo> rEnum(rValue, false, rValue->getMemoryManager());
    int rItemNumber = 0;        
    while (rEnum.hasMoreElements())
    {
        rEnum.nextElement();
        rItemNumber++;
    }

    //both shall have the number of item in it
    if (lItemNumber != rItemNumber)
        return false;

    //Any thing in the lValue shall be found in the rValue
    lEnum.Reset();
    while (lEnum.hasMoreElements())
    {
        XMLCh*      key   = (XMLCh*) lEnum.nextElementKey();
        XMLRefInfo* data1 = (XMLRefInfo*) lValue->get(key);
        XMLRefInfo* data2 = (XMLRefInfo*) rValue->get(key);

        if (!XObjectComparator::isEquivalent(data1, data2))
            return false;

    }  

    return true;
}

bool XTemplateComparator::isEquivalent(RefHashTableOf<DatatypeValidator>* const lValue
                                     , RefHashTableOf<DatatypeValidator>* const rValue)
{
    IS_EQUIVALENT(lValue, rValue);

    RefHashTableOfEnumerator<DatatypeValidator> lEnum(lValue, false, lValue->getMemoryManager());
    int lItemNumber = 0;        
    while (lEnum.hasMoreElements())
    {
        lEnum.nextElement();
        lItemNumber++;
    }

    RefHashTableOfEnumerator<DatatypeValidator> rEnum(rValue, false, rValue->getMemoryManager());
    int rItemNumber = 0;        
    while (rEnum.hasMoreElements())
    {
        rEnum.nextElement();
        rItemNumber++;
    }

    //both shall have the number of item in it
    if (lItemNumber != rItemNumber)
        return false;

    //Any thing in the lValue shall be found in the rValue
    lEnum.Reset();
    while (lEnum.hasMoreElements())
    {
        XMLCh*             key   = (XMLCh*) lEnum.nextElementKey();
        DatatypeValidator* data1 = (DatatypeValidator*) lValue->get(key);
        DatatypeValidator* data2 = (DatatypeValidator*) rValue->get(key);

        if (!XObjectComparator::isEquivalent(data1, data2))
            return false;

    }  

    return true;
}

bool XTemplateComparator::isEquivalent(RefHashTableOf<Grammar>* const lValue
                                     , RefHashTableOf<Grammar>* const rValue)
{
    IS_EQUIVALENT(lValue, rValue);

    RefHashTableOfEnumerator<Grammar> lEnum(lValue, false, lValue->getMemoryManager());
    int lItemNumber = 0;        
    while (lEnum.hasMoreElements())
    {
        lEnum.nextElement();
        lItemNumber++;
    }

    RefHashTableOfEnumerator<Grammar> rEnum(rValue, false, rValue->getMemoryManager());
    int rItemNumber = 0;        
    while (rEnum.hasMoreElements())
    {
        rEnum.nextElement();
        rItemNumber++;
    }

    //both shall have the number of item in it
    if (lItemNumber != rItemNumber)
        return false;

    //Any thing in the lValue shall be found in the rValue
    lEnum.Reset();
    while (lEnum.hasMoreElements())
    {
        XMLCh*   key   = (XMLCh*) lEnum.nextElementKey();
        Grammar* data1 = (Grammar*) lValue->get(key);
        Grammar* data2 = (Grammar*) rValue->get(key);

        if (!XObjectComparator::isEquivalent(data1, data2))
            return false;

    }  

    return true;
}

    /**********************************************************
     *
     * RefHash2KeysTableOf
     *
     *   SchemaAttDef
     *   ElemVector
     *
     ***********************************************************/
bool XTemplateComparator::isEquivalent(RefHash2KeysTableOf<SchemaAttDef>* const lValue
                                     , RefHash2KeysTableOf<SchemaAttDef>* const rValue)
{
    IS_EQUIVALENT(lValue, rValue);

    RefHash2KeysTableOfEnumerator<SchemaAttDef> lEnum(lValue, false, lValue->getMemoryManager());
    int lItemNumber = 0;        
    while (lEnum.hasMoreElements())
    {
        lEnum.nextElement();
        lItemNumber++;
    }

    RefHash2KeysTableOfEnumerator<SchemaAttDef> rEnum(rValue, false, rValue->getMemoryManager());
    int rItemNumber = 0;        
    while (rEnum.hasMoreElements())
    {
        rEnum.nextElement();
        rItemNumber++;
    }

    //both shall have the number of item in it
    if (lItemNumber != rItemNumber)
        return false;

    //Any thing in the lValue shall be found in the rValue
    lEnum.Reset();
    while (lEnum.hasMoreElements())
    {
        XMLCh*     key1;
        int        key2;
            
        lEnum.nextElementKey((void*&)key1, key2);

        SchemaAttDef* data1 = (SchemaAttDef*) lValue->get(key1, key2);
        SchemaAttDef* data2 = (SchemaAttDef*) rValue->get(key1, key2);

        if (!XObjectComparator::isEquivalent(data1, data2))
            return false;

    }  

    return true;
}

bool XTemplateComparator::isEquivalent(RefHash2KeysTableOf<ElemVector>* const lValue
                                     , RefHash2KeysTableOf<ElemVector>* const rValue)
{

    IS_EQUIVALENT(lValue, rValue);

    RefHash2KeysTableOfEnumerator<ElemVector> lEnum(lValue, false, lValue->getMemoryManager());
    int lItemNumber = 0;        
    while (lEnum.hasMoreElements())
    {
        lEnum.nextElement();
        lItemNumber++;
    }

    RefHash2KeysTableOfEnumerator<ElemVector> rEnum(rValue, false, rValue->getMemoryManager());
    int rItemNumber = 0;        
    while (rEnum.hasMoreElements())
    {
        rEnum.nextElement();
        rItemNumber++;
    }

    //both shall have the number of item in it
    if (lItemNumber != rItemNumber)
        return false;

    //Any thing in the lValue shall be found in the rValue
    lEnum.Reset();
    while (lEnum.hasMoreElements())
    {
        XMLCh*     key1;
        int        key2;
            
        lEnum.nextElementKey((void*&)key1, key2);

        ElemVector* data1 = (ElemVector*) lValue->get(key1, key2);
        ElemVector* data2 = (ElemVector*) rValue->get(key1, key2);

        if (!isEquivalent(data1, data2))
            return false;

    }  

    return true;
}

    /**********************************************************
     *
     * RefHash3KeysIdPool
     *
     *   SchemaElementDecl
     *
     ***********************************************************/
bool XTemplateComparator::isEquivalent(RefHash3KeysIdPool<SchemaElementDecl>* const lValue
                                     , RefHash3KeysIdPool<SchemaElementDecl>* const rValue)
{

    IS_EQUIVALENT(lValue, rValue)

    RefHash3KeysIdPoolEnumerator<SchemaElementDecl> lEnum(lValue, false, lValue->getMemoryManager());
    RefHash3KeysIdPoolEnumerator<SchemaElementDecl> rEnum(rValue, false, rValue->getMemoryManager());

    if (lEnum.size() != rEnum.size())
        return false;

    for (int i = 0; i < lEnum.size(); i++)
    {
        SchemaElementDecl&  lData = lEnum.nextElement();
        SchemaElementDecl&  rData = rEnum.nextElement();

        if (!XObjectComparator::isEquivalent(&lData, &rData))
            return false;
    }

    return true;

}

    /**********************************************************
     *
     * NameIdPool
     *
     *   DTDElementDecl
     *   DTDEntityDecl
     *   XMLNotationDecl
     *
     ***********************************************************/
bool XTemplateComparator::isEquivalent(NameIdPool<DTDElementDecl>* const lValue
                                     , NameIdPool<DTDElementDecl>* const rValue)
{

    IS_EQUIVALENT(lValue, rValue)

    NameIdPoolEnumerator<DTDElementDecl> lEnum(lValue, lValue->getMemoryManager());
    NameIdPoolEnumerator<DTDElementDecl> rEnum(rValue, rValue->getMemoryManager());

    if (lEnum.size() != rEnum.size())
        return false;

    for (int i = 0; i < lEnum.size(); i++)
    {
        DTDElementDecl& lData = lEnum.nextElement();
        DTDElementDecl& rData = rEnum.nextElement();

        if (!XObjectComparator::isEquivalent(&lData, &rData))
            return false;

    }

    return true;

}

bool XTemplateComparator::isEquivalent(NameIdPool<DTDEntityDecl>* const lValue
                                     , NameIdPool<DTDEntityDecl>* const rValue)
{

    IS_EQUIVALENT(lValue, rValue)

    NameIdPoolEnumerator<DTDEntityDecl> lEnum(lValue, lValue->getMemoryManager());
    NameIdPoolEnumerator<DTDEntityDecl> rEnum(rValue, rValue->getMemoryManager());

    if (lEnum.size() != rEnum.size())
        return false;

    for (int i = 0; i < lEnum.size(); i++)
    {
        DTDEntityDecl& lData = lEnum.nextElement();
        DTDEntityDecl& rData = rEnum.nextElement();

        if (!XObjectComparator::isEquivalent(&lData, &rData))
            return false;

    }

    return true;

}

bool XTemplateComparator::isEquivalent(NameIdPool<XMLNotationDecl>* const lValue
                                     , NameIdPool<XMLNotationDecl>* const rValue)
{
    IS_EQUIVALENT(lValue, rValue)

    NameIdPoolEnumerator<XMLNotationDecl> lEnum(lValue, lValue->getMemoryManager());
    NameIdPoolEnumerator<XMLNotationDecl> rEnum(rValue, rValue->getMemoryManager());

    if (lEnum.size() != rEnum.size())
        return false;

    for (int i = 0; i < lEnum.size(); i++)
    {
        XMLNotationDecl& lData = lEnum.nextElement();
        XMLNotationDecl& rData = rEnum.nextElement();

        if (!XObjectComparator::isEquivalent(&lData, &rData))
            return false;

    }

    return true;

}

XERCES_CPP_NAMESPACE_END