int
QueryElemMatch(char* key,BSONElem* objElem,BSONElem* query) {
bson_iterator oItr;
char* k = key;
bson obj;
bson so;
BSONElem tmpVal;
BSONElem valElem;
BSONElemItr it1;
bson_iterator_init(&oItr,&obj);
if (!objElem) {
BSONElemInit(&tmpVal,BSON_EOO,NULL,0,NULL);
return CompareValue(&tmpVal,query);
}
BSONElemItrInit(&it1,objElem);
if (*k) {
BSONElem soElem;
BSONElem* elemPtr = NULL;
bson_iterator sItr;
bson b;
char* keyEnd = strchr(key,'.');
//printf("Key in new elem '%s','%s'\n",key,keyEnd);
if (keyEnd) {
*keyEnd = '\0';
keyEnd ++;
} else {
//printf("No dot \n");
keyEnd = key+strlen(key);
}
while (BSONElemItrNext(&it1,&tmpVal)) {
if (tmpVal.type != BSON_OBJECT) {
continue;
}
bson_iterator_subobject(tmpVal.itr,&b);
bson_iterator_init(&sItr,&b);
if (bson_find(&sItr,&b,key)) {
BSONElemInitFromItr(&soElem,&sItr);
elemPtr = &soElem;
}
if (QueryElemMatch(keyEnd,elemPtr,query)) {
return True;
}
}
} else {
// end of the string
if (query->type == BSON_ARRAY || query->type == BSON_OBJECT) {
return CompareValue(objElem,query);
}
while (BSONElemItrNext(&it1,&tmpVal)) {
if (CompareValue(&tmpVal,query)) {
return True;
}
}
return False;
}
return False;
}
static int CompareAddress(const IPAddress &Address1, const IPAddress &Address2)
{
if (Address1.Type != Address2.Type)
return CompareValue(Address1.Type, Address2.Type);
if (Address1.Type == IP_ADDRESS_V4)
return CompareValue(Address1.V4.Address, Address2.V4.Address);
return ::memcmp(Address1.V6.Bytes, Address2.V6.Bytes, 16);
}
int CFileListView::CFileListItem::Compare(int ID,const CItem *pItem) const
{
const CFileListItem *pFileItem=static_cast<const CFileListItem*>(pItem);
int Cmp=0;
switch (ID) {
case COLUMN_TIME:
Cmp=CompareSystemTime(m_RecFileInfo.startTime,
pFileItem->m_RecFileInfo.startTime);
if (Cmp==0)
CompareValue(m_RecFileInfo.durationSecond,
pFileItem->m_RecFileInfo.durationSecond);
break;
case COLUMN_TITLE:
//Cmp=m_RecFileInfo.title.compare(pFileItem->m_RecFileInfo.title);
Cmp=::lstrcmpW(m_RecFileInfo.title.c_str(),
pFileItem->m_RecFileInfo.title.c_str());
break;
case COLUMN_SERVICE:
//Cmp=m_RecFileInfo.serviceName.compare(pFileItem->m_RecFileInfo.serviceName);
Cmp=::lstrcmpW(m_RecFileInfo.serviceName.c_str(),
pFileItem->m_RecFileInfo.serviceName.c_str());
break;
case COLUMN_RESULT:
Cmp=CompareValue(m_RecFileInfo.recStatus,
pFileItem->m_RecFileInfo.recStatus);
break;
case COLUMN_FILE:
/*
Cmp=::lstrcmpiW(m_RecFileInfo.recFilePath.c_str(),
pFileItem->m_RecFileInfo.recFilePath.c_str());
*/
Cmp=::StrCmpLogicalW(m_RecFileInfo.recFilePath.c_str(),
pFileItem->m_RecFileInfo.recFilePath.c_str());
break;
}
if (Cmp==0) {
if (ID!=COLUMN_TIME) {
Cmp=CompareSystemTime(m_RecFileInfo.startTime,
pFileItem->m_RecFileInfo.startTime);
if (Cmp==0)
CompareValue(m_RecFileInfo.durationSecond,
pFileItem->m_RecFileInfo.durationSecond);
}
if (Cmp==0)
Cmp=CompareValue(m_RecFileInfo.id,
pFileItem->m_RecFileInfo.id);
}
return Cmp;
}
int DeleteL(char* num, pnode *hashtable, int htsize, pnode_town start_town)
{
pnode temp;
int n = BKDRHash(num)%htsize;
if(hashtable[n] == NULL)
{
printf("Phone number %s not found.\n", num);
return 0;
}
else
{
if(CompareValue(hashtable[n]->data, num) == 1)
{
DeleteI(hashtable[n]->data, start_town);
if(hashtable[n]->next == NULL)
{
free(hashtable[n]);
hashtable[n] = NULL;
printf("Phone number %s deleted successfully.\n", num);
return 1;
}
temp = hashtable[n];
hashtable[n] = temp->next;
hashtable[n]->previous = NULL;
free(temp);
printf("Phone number %s deleted successfully.\n", num);
return 1;
}
temp = hashtable[n];
while(temp->next != NULL)
{
temp = temp->next;
if(CompareValue(temp->data, num) == 1)
{
if(temp->next == NULL)
{
temp->previous->next = NULL;
}
else
{
(temp->next)->previous = temp->previous;
(temp->previous)->next = temp->next;
}
DeleteI(temp->data, start_town);
free(temp);
printf("Phone number %s deleted successfully.\n", num);
return 1;
}
}
}
printf("Phone number %s not found.\n", num);
return 0;
}
PRBool nsAbIPCCard::Same(nsABCOMCardStruct * card, PRBool isUnicode)
{
if(!card)
return PR_FALSE;
if(mRecordId && card->dwRecordId)
return (mRecordId == card->dwRecordId);
if(CompareValue(isUnicode, card->firstName, m_FirstName))
if(CompareValue(isUnicode, card->lastName, m_LastName))
if(CompareValue(isUnicode, card->displayName, m_DisplayName))
if(CompareValue(isUnicode, card->nickName, m_NickName))
return PR_TRUE;
return PR_FALSE;
}
int SearchL(char* num, pnode* hashtable, int htsize, MyRecord* rec)
{
int n = BKDRHash(num)%htsize;
if(hashtable[n] == NULL)
return 0;
if(CompareValue(hashtable[n]->data, num) == 1)
{
//WriteValue(hashtable[n]->data);
RecSetVal(rec, hashtable[n]->data);
return 1;
}
pnode temp = hashtable[n];
while(temp->next != NULL)
{
temp = temp->next;
if(CompareValue(temp->data, num) == 1)
{
//WriteValue(temp->data);
RecSetVal(rec, temp->data);
return 1;
}
}
return 0;
}
INT32 QsortCompare( const void *pNum1, const void *pNum2)
{
UINT8 Num1 = *(UINT8*)pNum1;
UINT8 Num2 = *(UINT8*)pNum2;
switch( gubCurrentSortMode )
{
//Price INT16 uiWeeklySalary
case 0:
return( CompareValue((INT32)gMercProfiles[ Num1 ].uiWeeklySalary, (INT32)gMercProfiles[Num2].uiWeeklySalary ) );
break;
//Experience INT16 bExpLevel
case 1:
return( CompareValue((INT32)gMercProfiles[ Num1 ].bExpLevel, (INT32)gMercProfiles[Num2].bExpLevel) );
break;
//Marksmanship INT16 bMarksmanship
case 2:
return( CompareValue((INT32)gMercProfiles[ Num1 ].bMarksmanship, (INT32)gMercProfiles[Num2].bMarksmanship ) );
break;
//Medical INT16 bMedical
case 3:
return( CompareValue((INT32)gMercProfiles[ Num1 ].bMedical, (INT32)gMercProfiles[Num2].bMedical ) );
break;
//Explosives INT16 bExplosive
case 4:
return( CompareValue((INT32)gMercProfiles[ Num1 ].bExplosive, (INT32)gMercProfiles[Num2].bExplosive ) );
break;
//Mechanical INT16 bMechanical
case 5:
return( CompareValue((INT32)gMercProfiles[ Num1 ].bMechanical, (INT32)gMercProfiles[Num2].bMechanical ) );
break;
default:
Assert( 0 );
return( 0 );
break;
}
}
int CReserveListView::CReserveListItem::Compare(int ID,const CItem *pItem) const
{
const CReserveListItem *pReserveItem=static_cast<const CReserveListItem*>(pItem);
int Cmp=0;
switch (ID) {
case COLUMN_TITLE:
//Cmp=m_pReserveData->title.compare(pReserveItem->m_pReserveData->title);
Cmp=::lstrcmpW(m_pReserveData->title.c_str(),
pReserveItem->m_pReserveData->title.c_str());
break;
case COLUMN_TIME:
Cmp=CompareSystemTime(m_pReserveData->startTime,
pReserveItem->m_pReserveData->startTime);
if (Cmp==0)
Cmp=CompareValue(m_pReserveData->durationSecond,
pReserveItem->m_pReserveData->durationSecond);
break;
case COLUMN_SERVICE:
//Cmp=m_pReserveData->stationName.compare(pReserveItem->m_pReserveData->stationName);
Cmp=::lstrcmpW(m_pReserveData->stationName.c_str(),
pReserveItem->m_pReserveData->stationName.c_str());
break;
case COLUMN_STATUS:
if (m_pReserveData->recSetting.recMode==RECMODE_NO) {
if (pReserveItem->m_pReserveData->recSetting.recMode==RECMODE_NO)
Cmp=0;
else
Cmp=1;
} else {
if (pReserveItem->m_pReserveData->recSetting.recMode==RECMODE_NO)
Cmp=-1;
else
Cmp=CompareValue(m_pReserveData->overlapMode,
pReserveItem->m_pReserveData->overlapMode);
}
break;
case COLUMN_RECMODE:
Cmp=CompareValue(m_pReserveData->recSetting.recMode,
pReserveItem->m_pReserveData->recSetting.recMode);
break;
case COLUMN_PRIORITY:
Cmp=CompareValue(m_pReserveData->recSetting.priority,
pReserveItem->m_pReserveData->recSetting.priority);
break;
}
if (Cmp==0) {
if (ID!=COLUMN_TIME) {
Cmp=CompareSystemTime(m_pReserveData->startTime,
pReserveItem->m_pReserveData->startTime);
if (Cmp==0)
Cmp=CompareValue(m_pReserveData->durationSecond,
pReserveItem->m_pReserveData->durationSecond);
}
if (Cmp==0)
Cmp=CompareValue(m_pReserveData->reserveID,
pReserveItem->m_pReserveData->reserveID);
}
return Cmp;
}
static void
PrintValues( Widget window, char *label )
{
int n;
Arg Args[MAX_ARGS];
Widget VerticalSB;
Widget HorizontalSB;
Pixel SBbackground, SWbackground;
Pixel SBbottomShadowColor, SWbottomShadowColor;
Pixel SBtopShadowColor, SWtopShadowColor;
Pixmap SBbackgroundPixmap, SWbackgroundPixmap;
Pixmap SBbottomShadowPixmap, SWbottomShadowPixmap;
Pixmap SBtopShadowPixmap, SWtopShadowPixmap;
(void)printf( "%s\n", label );
VerticalSB = XtNameToWidget( window, "VertScrollBar" );
HorizontalSB = XtNameToWidget( window, "VertScrollBar" );
n = 0;
XtSetArg( Args[n], XmNbackground, &SBbackground ); n++;
XtSetArg( Args[n], XmNbottomShadowColor, &SBbottomShadowColor ); n++;
XtSetArg( Args[n], XmNtopShadowColor, &SBtopShadowColor ); n++;
XtSetArg( Args[n], XmNbackgroundPixmap, &SBbackgroundPixmap ); n++;
XtSetArg( Args[n], XmNbottomShadowPixmap, &SBbottomShadowPixmap ); n++;
XtSetArg( Args[n], XmNtopShadowPixmap, &SBtopShadowPixmap ); n++;
XtGetValues( VerticalSB, Args, n );
n = 0;
XtSetArg( Args[n], XmNbackground, &SWbackground ); n++;
XtSetArg( Args[n], XmNbottomShadowColor, &SWbottomShadowColor ); n++;
XtSetArg( Args[n], XmNtopShadowColor, &SWtopShadowColor ); n++;
XtSetArg( Args[n], XmNbackgroundPixmap, &SWbackgroundPixmap ); n++;
XtSetArg( Args[n], XmNbottomShadowPixmap, &SWbottomShadowPixmap ); n++;
XtSetArg( Args[n], XmNtopShadowPixmap, &SWtopShadowPixmap ); n++;
XtGetValues( window, Args, n );
#define CompareValue(desc) \
(void)printf( "\tVertical ScrollBar " #desc " is %s\n", \
(SW ## desc == SB ## desc) ? "identical" : "different" )
CompareValue(background);
CompareValue(bottomShadowColor);
CompareValue(topShadowColor);
CompareValue(backgroundPixmap);
CompareValue(bottomShadowPixmap);
CompareValue(topShadowPixmap);
#undef CompareValue
n = 0;
XtSetArg( Args[n], XmNbackground, &SBbackground ); n++;
XtSetArg( Args[n], XmNbottomShadowColor, &SBbottomShadowColor ); n++;
XtSetArg( Args[n], XmNtopShadowColor, &SBtopShadowColor ); n++;
XtSetArg( Args[n], XmNbackgroundPixmap, &SBbackgroundPixmap ); n++;
XtSetArg( Args[n], XmNbottomShadowPixmap, &SBbottomShadowPixmap ); n++;
XtSetArg( Args[n], XmNtopShadowPixmap, &SBtopShadowPixmap ); n++;
XtGetValues( HorizontalSB, Args, n );
(void)printf( "\n" );
#define CompareValue(desc) \
(void)printf( "\tHorizontal ScrollBar " #desc " is %s\n", \
(SW ## desc == SB ## desc) ? "identical" : "different" )
CompareValue(background);
CompareValue(bottomShadowColor);
CompareValue(topShadowColor);
CompareValue(backgroundPixmap);
CompareValue(bottomShadowPixmap);
CompareValue(topShadowPixmap);
#undef CompareValue
(void)printf( "\n" );
return;
}
// Default implementation for RFX functions
void CDaoFieldExchange::Default(LPCTSTR lpszName, void* pv,
DWORD dwColumnType, DWORD dwBindOptions)
{
switch (m_nOperation)
{
case AddToParameterList:
if (m_nParam != 1)
m_prs->m_strSQL += ",";
m_prs->m_strSQL += lpszName;
AppendParamType(m_prs->m_strSQL, dwColumnType);
return;
case AddToSelectList:
if (m_nField != 1)
m_prs->m_strSQL += ",";
m_prs->m_strSQL += lpszName;
return;
case BindField:
{
// Query parser needs "[" & "]", GetRows can't tolerate them.
LPTSTR lpszNoBracketName = new TCHAR[lstrlen(lpszName) + 1];
m_prs->StripBrackets(lpszName, lpszNoBracketName);
// Finish setting up column binding info struct
LPDAOCOLUMNBINDING pcb =
&m_prs->m_prgDaoColBindInfo[m_nField-1];
pcb->cbInfoOffset =
(DWORD)&m_prs->m_pulColumnLengths[m_nField-1];
#ifndef _UNICODE
pcb->columnID.dwKind = DAOCOLKIND_STR;
pcb->columnID.lpstr = lpszNoBracketName;
#else
pcb->columnID.dwKind = DAOCOLKIND_WSTR;
pcb->columnID.lpwstr = lpszNoBracketName;
#endif
// Setup the field index map (and store value as void ptr)
m_prs->m_pMapFieldIndex->SetAt(pv, (void*)m_nField);
}
return;
case BindParam:
{
COleVariant* pvar = NULL;
TRY
{
// NULL params not supported, use IS NULL in SQL
// (i.e. - m_strFilter = _T("Foo IS NULL");
FillVariant(pv, dwColumnType, &pvar);
m_prs->m_pQueryDef->SetParamValue(lpszName, *pvar);
}
CATCH_ALL(e)
{
if (pvar != NULL)
pvar->Clear();
delete pvar;
pvar = NULL;
THROW_LAST();
}
END_CATCH_ALL
pvar->Clear();
delete pvar;
pvar = NULL;
}
return;
case Fixup:
if (m_prs->GetFieldLength(m_nField-1) == DAO_NULL)
{
// Set the value to PSEUDO NULL and mark the status NULL
SetNullValue(pv, dwColumnType);
m_prs->SetNullFieldStatus(m_nField-1);
}
return;
case AllocCache:
if (dwBindOptions & AFX_DAO_ENABLE_FIELD_CACHE)
{
CDaoFieldCache* pCache;
// Allocate new storage and add to map
AllocCacheValue(pCache, dwColumnType);
m_prs->m_pMapFieldCache->SetAt(pv, pCache);
}
return;
case StoreField:
if (dwBindOptions & AFX_DAO_ENABLE_FIELD_CACHE)
{
CDaoFieldCache* pCache = GetCacheValue(m_prs, pv);
// Copy the data to the cache
if (dwBindOptions & AFX_DAO_CACHE_BY_VALUE)
CopyValue(pv, (void*)&pCache->m_pvData, dwColumnType);
else
CopyValue(pv, pCache->m_pvData, dwColumnType);
// Cache the NULL status
if (m_prs->IsFieldStatusNull(m_nField-1))
pCache->m_nStatus |= AFX_DAO_FIELD_FLAG_NULL;
else
pCache->m_nStatus &= ~AFX_DAO_FIELD_FLAG_NULL;
}
return;
case LoadField:
if (dwBindOptions & AFX_DAO_ENABLE_FIELD_CACHE)
{
CDaoFieldCache* pCache = GetCacheValue(m_prs, pv);
// Copy the data from the cache
if (dwBindOptions & AFX_DAO_CACHE_BY_VALUE)
CopyValue((void*)&pCache->m_pvData, pv, dwColumnType);
else
CopyValue(pCache->m_pvData, pv, dwColumnType);
// Set the NULL status from the cache
if (pCache->m_nStatus & AFX_DAO_FIELD_FLAG_NULL)
m_prs->SetNullFieldStatus(m_nField-1);
else
m_prs->ClearNullFieldStatus(m_nField-1);
}
return;
case SetFieldNull:
// Setting field NOT NULL doesn't require field exchange
if ((m_pvField == NULL && m_nFieldType == outputColumn)
|| m_pvField == pv)
{
SetNullValue(pv, dwColumnType);
// Also set the status array if not a parameter
if (m_nFieldType == outputColumn)
m_prs->SetNullFieldStatus(m_nField-1);
#ifdef _DEBUG
m_nFieldFound = m_nField;
#endif
}
return;
case MarkForAddNew:
if (dwBindOptions & AFX_DAO_ENABLE_FIELD_CACHE)
{
// Don't need to do anything if field marked dirty
if (!m_prs->IsFieldStatusDirty(m_nField-1))
{
// Mark dirty & not NULL if not set to pseudo NULL value
if (!IsNullValue(pv, dwColumnType))
{
m_prs->SetDirtyFieldStatus(m_nField-1);
m_prs->ClearNullFieldStatus(m_nField-1);
}
}
}
return;
case MarkForEdit:
if (dwBindOptions & AFX_DAO_ENABLE_FIELD_CACHE)
{
// If value not pseudo NULL value, clear NULL status
if (!IsNullValue(pv, dwColumnType))
m_prs->ClearNullFieldStatus(m_nField-1);
// If field already marked dirty, don't need to check cache
if (!m_prs->IsFieldStatusDirty(m_nField-1))
{
CDaoFieldCache* pCache = GetCacheValue(m_prs, pv);
BOOL bNullField = m_prs->IsFieldStatusNull(m_nField-1);
BOOL bNullCache = pCache->m_nStatus & AFX_DAO_FIELD_FLAG_NULL;
void* pvData;
if (dwBindOptions & AFX_DAO_CACHE_BY_VALUE)
pvData = &pCache->m_pvData;
else
pvData = pCache->m_pvData;
// Mark dirty if NULL status differs or value differs
if ( (bNullCache && !bNullField) ||
(!bNullCache && bNullField) ||
CompareValue(pv, pvData, dwColumnType))
{
m_prs->SetDirtyFieldStatus(m_nField-1);
}
}
}
return;
case SetDirtyField:
if (m_prs->IsFieldStatusDirty(m_nField-1))
{
COleVariant* pvar = NULL;
TRY
{
// If field is NULL don't set the value
if (!m_prs->IsFieldStatusNull(m_nField-1))
FillVariant(pv, dwColumnType, &pvar);
else
{
pvar = new COleVariant;
pvar->vt = VT_NULL;
}
// SetFieldValue (put_Collect) doesn't like brackets
// Assumes no brackets if first char not a bracket
LPTSTR lpszModifiedName = NULL;
if (*lpszName == '[')
{
lpszModifiedName = new TCHAR[_tcslen(lpszName) + 1];
// Copy the name with no brackets, and reset lpszName
m_prs->StripBrackets(lpszName, lpszModifiedName);
lpszName = lpszModifiedName;
}
m_prs->SetFieldValue(lpszName, *pvar);
delete lpszModifiedName;
}
CATCH_ALL(e)
{
if (pvar != NULL)
pvar->Clear();
delete pvar;
pvar = NULL;
THROW_LAST();
}
END_CATCH_ALL
pvar->Clear();
delete pvar;
pvar = NULL;
}
return;
default:
ASSERT(FALSE);
return;
}
INT32 QsortCompare( const void *pNum1, const void *pNum2)
{
UINT8 Num1 = *(UINT8*)pNum1;
UINT8 Num2 = *(UINT8*)pNum2;
switch( gubCurrentSortMode )
{
//Price INT16 uiWeeklySalary
case 0:
return( CompareValue((INT32)gMercProfiles[ Num1 ].uiWeeklySalary, (INT32)gMercProfiles[Num2].uiWeeklySalary ) );
break;
//Experience INT16 bExpLevel
case 1:
return( CompareValue((INT32)gMercProfiles[ Num1 ].bExpLevel, (INT32)gMercProfiles[Num2].bExpLevel) );
break;
//Marksmanship INT16 bMarksmanship
case 2:
return( CompareValue((INT32)gMercProfiles[ Num1 ].bMarksmanship, (INT32)gMercProfiles[Num2].bMarksmanship ) );
break;
//Mechanical INT16 bMechanical
case 3:
return( CompareValue((INT32)gMercProfiles[ Num1 ].bMechanical, (INT32)gMercProfiles[Num2].bMechanical ) );
break;
//Explosives INT16 bExplosive
case 4:
return( CompareValue((INT32)gMercProfiles[ Num1 ].bExplosive, (INT32)gMercProfiles[Num2].bExplosive ) );
break;
//Medical INT16 bMedical
case 5:
return( CompareValue((INT32)gMercProfiles[ Num1 ].bMedical, (INT32)gMercProfiles[Num2].bMedical ) );
break;
//Health INT16 bLifeMax
case 6:
return( CompareValue((INT32)gMercProfiles[ Num1 ].bLifeMax, (INT32)gMercProfiles[Num2].bLifeMax ) );
break;
//Agility INT16 bAgility
case 7:
return( CompareValue((INT32)gMercProfiles[ Num1 ].bAgility, (INT32)gMercProfiles[Num2].bAgility ) );
break;
//Dexterity INT16 bDexterity
case 8:
return( CompareValue((INT32)gMercProfiles[ Num1 ].bDexterity, (INT32)gMercProfiles[Num2].bDexterity ) );
break;
//Strength INT16 bStrength
case 9:
return( CompareValue((INT32)gMercProfiles[ Num1 ].bStrength, (INT32)gMercProfiles[Num2].bStrength ) );
break;
//Leadership INT16 bLeadership
case 10:
return( CompareValue((INT32)gMercProfiles[ Num1 ].bLeadership, (INT32)gMercProfiles[Num2].bLeadership ) );
break;
//Wisdom INT16 bWisdom
case 11:
return( CompareValue((INT32)gMercProfiles[ Num1 ].bWisdom, (INT32)gMercProfiles[Num2].bWisdom ) );
break;
//Name CHAR16 zNickname
case 12:
return( wcscmp(gMercProfiles[ Num1 ].zNickname, gMercProfiles[Num2].zNickname ) );
break;
default:
Assert( 0 );
return( 0 );
break;
}
}
int
QueryMatch2(BinaryStr* query, BinaryStr* obj ) {
bson_iterator q,o;
bson_type qType,tType;
bson qBson,oBson;
bson_iterator_from_buffer(&q, query->data);
bson_iterator_from_buffer(&o, obj->data);
bson_init_finished_data(&qBson,(char*)query->data);
bson_init_finished_data(&oBson,(char*)obj->data);
while((qType = bson_iterator_next(&q))) {
// for all keys in query
const char* key = bson_iterator_key(&q);
//printf("Key %s \n",key);
BSONElem val1,val2;
BSONElemInit(&val1,bson_iterator_type(&q),(char*) bson_iterator_value(&q),0,&q);
tType = bson_find(&o,&oBson,key);
if (!tType) {
BSONElemInit(&val2,BSON_EOO,NULL,0,NULL);
if (!CompareValue(&val2,&val1)) {
return False;
}
continue;
} else if (tType == BSON_OBJECT && qType == BSON_OBJECT) {
BinaryStr qData,oData;
qData.data = (char*) bson_iterator_value(&q);
oData.data = (char*) bson_iterator_value(&o);
if (!QueryMatch(&qData,&oData)) {
return False;
}
} else if (tType == BSON_ARRAY && qType != BSON_OBJECT && qType != BSON_ARRAY) {
bson_iterator si;
bson_type t;
bson_iterator_subiterator(&o,&si);
uint8_t found = False;
while ((t=bson_iterator_next(&si))){
//BSONElemInit(&val2,bson_iterator_type(&si),(char*) bson_iterator_value(&si),0,&si);
BSONElemInitFromItr(&val2,&si);
//BSONElemInit(&val2,bson_iterator_type(&si),(char*) bson_iterator_value(&si),0,&si);
if (CompareValue(&val2,&val1)) {
found = True;
break;
}
}
if (!found) {
return False;
}
} else {
//BSONElemInit(&val2,bson_iterator_type(&o),(char*) bson_iterator_value(&o),0,&o);
BSONElemInitFromItr(&val2,&o);
if (!CompareValue(&val2,&val1)) {
return False;
}
}
}
return True;
}
