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;
}
XERCES_CPP_NAMESPACE_BEGIN
/**********************************************************
*
* ValueVectorOf
*
* SchemaElementDecl*
* unsigned int
*
***********************************************************/
bool XTemplateComparator::isEquivalent(ValueVectorOf<SchemaElementDecl*>* const lValue
, ValueVectorOf<SchemaElementDecl*>* const rValue)
{
IS_EQUIVALENT(lValue, rValue);
int size1 = lValue->size();
int size2 = rValue->size();
if (size1 != size2)
return false;
for ( int i = 0; i < size1; i++)
{
SchemaElementDecl*& data1 = lValue->elementAt(i);
SchemaElementDecl*& data2 = rValue->elementAt(i);
if (!XObjectComparator::isEquivalent(data1, data2))
return false;
}
return true;
}
/**********************************************************
*
* RefArrayVectorOf
*
* XMLCh
*
***********************************************************/
bool XTemplateComparator::isEquivalent(RefArrayVectorOf<XMLCh>* const lValue
, RefArrayVectorOf<XMLCh>* const rValue)
{
IS_EQUIVALENT(lValue, rValue);
int size1 = lValue->size();
int size2 = rValue->size();
if (size1 != size2)
return false;
for ( int i = 0; i < size1; i++)
{
XMLCh* data1 = lValue->elementAt(i);
XMLCh* data2 = rValue->elementAt(i);
if (!XMLString::equals(data1, data2))
{
return false;
}
}
return true;
}
/**
* 查找
* 返回Dstate的索引
*/
PRIVATE int in_dstates(SET* NFA_set)
{
DFA_STATE *p;
for (p = &Dstates[Nstates]; --p >= Dstates;)
{
if (IS_EQUIVALENT(NFA_set, p->set))
return (p - Dstates);
}
return (-1);
}
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;
}
bool XTemplateComparator::isEquivalent(RefHashTableOf<XMLAttDef>* const lValue
, RefHashTableOf<XMLAttDef>* const rValue)
{
IS_EQUIVALENT(lValue, rValue);
RefHashTableOfEnumerator<XMLAttDef> lEnum(lValue, false, lValue->getMemoryManager());
int lItemNumber = 0;
while (lEnum.hasMoreElements())
{
lEnum.nextElement();
lItemNumber++;
}
RefHashTableOfEnumerator<XMLAttDef> 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();
//we know they are SchemaAttDef
SchemaAttDef* data1 = (SchemaAttDef*) lValue->get(key);
SchemaAttDef* data2 = (SchemaAttDef*) rValue->get(key);
if (!XObjectComparator::isEquivalent(data1, data2))
return false;
}
return true;
}
bool XTemplateComparator::isEquivalent(RefVectorOf<XercesStep>* const lValue
, RefVectorOf<XercesStep>* const rValue)
{
IS_EQUIVALENT(lValue, rValue);
int size1 = lValue->size();
int size2 = rValue->size();
if (size1 != size2)
return false;
for ( int i = 0; i < size1; i++)
{
XercesStep* data1 = lValue->elementAt(i);
XercesStep* data2 = rValue->elementAt(i);
if (!XObjectComparator::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;
}
bool XTemplateComparator::isEquivalent(ValueVectorOf<unsigned int>* const lValue
, ValueVectorOf<unsigned int>* const rValue)
{
IS_EQUIVALENT(lValue, rValue);
int size1 = lValue->size();
int size2 = rValue->size();
if (size1 != size2)
return false;
for ( int i = 0; i < size1; i++)
{
unsigned int& data1 = lValue->elementAt(i);
unsigned int& data2 = rValue->elementAt(i);
if (data1!=data2)
return false;
}
return true;
}
