int OsContact::compareTo(UtlContainable const * inVal) const { int result ; const OsContact* pContact = static_cast<const OsContact*>(inVal); if (inVal->isInstanceOf(OsContact::TYPE) && pContact) { UtlString address; pContact->getAddress(address); result = mAddress.compareTo(address); if (0 == result) { result = compareInt(mPort, pContact->getPort()); } if (0 == result) { result = compareInt(mProtocol, pContact->getProtocol()); } if (0 == result) { result = compareInt((const int)mType, (const int)pContact->getAddressType()); } } else { result = INT_MAX ; } return result ; }
int DeclarationName::compare(DeclarationName LHS, DeclarationName RHS) { if (LHS.getNameKind() != RHS.getNameKind()) return (LHS.getNameKind() < RHS.getNameKind() ? -1 : 1); switch (LHS.getNameKind()) { case DeclarationName::Identifier: { IdentifierInfo *LII = LHS.getAsIdentifierInfo(); IdentifierInfo *RII = RHS.getAsIdentifierInfo(); if (!LII) return RII ? -1 : 0; if (!RII) return 1; return LII->getName().compare(RII->getName()); } case DeclarationName::ObjCZeroArgSelector: case DeclarationName::ObjCOneArgSelector: case DeclarationName::ObjCMultiArgSelector: { Selector LHSSelector = LHS.getObjCSelector(); Selector RHSSelector = RHS.getObjCSelector(); unsigned LN = LHSSelector.getNumArgs(), RN = RHSSelector.getNumArgs(); for (unsigned I = 0, N = std::min(LN, RN); I != N; ++I) { switch (LHSSelector.getNameForSlot(I).compare( RHSSelector.getNameForSlot(I))) { case -1: return true; case 1: return false; default: break; } } return compareInt(LN, RN); } case DeclarationName::CXXConstructorName: case DeclarationName::CXXDestructorName: case DeclarationName::CXXConversionFunctionName: if (QualTypeOrdering()(LHS.getCXXNameType(), RHS.getCXXNameType())) return -1; if (QualTypeOrdering()(RHS.getCXXNameType(), LHS.getCXXNameType())) return 1; return 0; case DeclarationName::CXXOperatorName: return compareInt(LHS.getCXXOverloadedOperator(), RHS.getCXXOverloadedOperator()); case DeclarationName::CXXLiteralOperatorName: return LHS.getCXXLiteralIdentifier()->getName().compare( RHS.getCXXLiteralIdentifier()->getName()); case DeclarationName::CXXUsingDirective: return 0; } return 0; }
int TaskCompare::compare(Task *const &pt1, Task *const &pt2) { // result's intent is to catch a definitive: less than or more // it is important for sortable containers to avoid zero (0) // as zero represents equality //TODO: review for means of generic extensible implementation int result = 0; int sortLvl = 0; do { switch(m_pFields[sortLvl]) { case COMPARE_TASK_ID: result = compareDate(pt1->GetID(), pt2->GetID()); break; case COMPARE_DUE_DATE: result = compareDate(pt1->GetDueDate(), pt2->GetDueDate()); break; case COMPARE_PRIORITY: result = compareInt(pt1->GetPriority(), pt2->GetPriority()); break; //case COMPARE_PERCENT_COMPLETE: // result = compareInt(pt1->getPercentComplete(), pt2->getPercentComplete()); // break; case COMPARE_CREATE_DATE: result = compareDate(pt1->GetCreatedDate(), pt2->GetCreatedDate()); break; case COMPARE_ESTIMATED_DURATION: result = compareDate(pt1->GetEstimatedDuration(), pt2->GetEstimatedDuration()); break; case COMPARE_START_DATE: result = compareDate(pt1->GetScheduledStart(), pt2->GetScheduledStart()); break; case COMPARE_TASK_TITLE: result = compareText(pt1->GetTitle(), pt2->GetTitle()); break; default: break; } ++sortLvl; } while(!result && sortLvl < m_numSortLvls); if(!result)result = compareDate(pt1->GetID(), pt2->GetID()); return result; }
A_Test void whenComparingTwoAndOne_thenReturnsPositiveNumber(void) { int n1 = 2; int n2 = 1; assertTrueM("Comparing 2 with 1 must return a value >0.", compareInt(&n1, &n2) > 0); }
A_Test void whenComparingOneAndTwo_thenReturnsNegativeNumber(void) { int n1 = 1; int n2 = 2; assertTrueM("Comparing 1 with 2 must return a value <0.", compareInt(&n1, &n2) < 0); }
A_Test void whenComparingZeroAndZero_thenReturnsZero(void) { int n1 = 0; int n2 = 0; assertEqualsM("Comparing two equal numbers must return 0.", 0, compareInt(&n1, &n2)); }
static unsigned int handleAlpha(ruleset *tree, char *sid, char *mid, char *state, alpha *alphaNode, jsonProperty *allProperties, void **rulesBinding, unsigned short actionType, unsigned short *commandCount) { alpha *alphaStack[MAX_STACK_SIZE]; jsonProperty *propertyStack[MAX_STACK_SIZE]; alphaStack[0] = alphaNode; propertyStack[0] = NULL; alpha *currentAlpha; jsonProperty *currentProperty; unsigned short top = 1; unsigned int result = ERR_EVENT_NOT_HANDLED; unsigned int propertyHash = 1; while (top > 0) { --top; currentAlpha = alphaStack[top]; currentProperty = propertyStack[top]; unsigned char alphaOp = currentAlpha->operator; unsigned char propertyMatch = 1; if (alphaOp != OP_NEX && alphaOp != OP_EX && alphaOp != OP_TYPE) { char *propertyLast = currentProperty->lastValue; char *propertyFirst = currentProperty->firstValue; unsigned char propertyType = currentProperty->type; char temp; if (!currentProperty->isMaterial) { switch(propertyType) { case JSON_INT: ++propertyLast; temp = propertyLast[0]; propertyLast[0] = '\0'; currentProperty->value.i = atol(propertyFirst); propertyLast[0] = temp; break; case JSON_DOUBLE: ++propertyLast; temp = propertyLast[0]; propertyLast[0] = '\0'; currentProperty->value.i = atof(propertyFirst); propertyLast[0] = temp; break; case JSON_BOOL: ++propertyLast; unsigned int leftLength = propertyLast - propertyFirst; unsigned char b = 1; if (leftLength == 5 && strncmp("false", propertyFirst, 5)) { b = 0; } currentProperty->value.b = b; break; } currentProperty->isMaterial = 1; } unsigned short type = propertyType << 8; type = type + currentAlpha->right.type; int leftLength; switch(type) { case COMP_BOOL_BOOL: propertyMatch = compareBool(currentProperty->value.b, currentAlpha->right.value.b, alphaOp); break; case COMP_BOOL_INT: propertyMatch = compareInt(currentProperty->value.b, currentAlpha->right.value.i, alphaOp); break; case COMP_BOOL_DOUBLE: propertyMatch = compareDouble(currentProperty->value.b, currentAlpha->right.value.d, alphaOp); break; case COMP_BOOL_STRING: propertyMatch = compareString(propertyFirst, propertyLast, &tree->stringPool[currentAlpha->right.value.stringOffset], alphaOp); break; case COMP_INT_BOOL: propertyMatch = compareInt(currentProperty->value.i, currentAlpha->right.value.b, alphaOp); break; case COMP_INT_INT: propertyMatch = compareInt(currentProperty->value.i, currentAlpha->right.value.i, alphaOp); break; case COMP_INT_DOUBLE: propertyMatch = compareDouble(currentProperty->value.i, currentAlpha->right.value.d, alphaOp); break; case COMP_INT_STRING: propertyMatch = compareString(propertyFirst, propertyLast, &tree->stringPool[currentAlpha->right.value.stringOffset], alphaOp); break; case COMP_DOUBLE_BOOL: propertyMatch = compareDouble(currentProperty->value.i, currentAlpha->right.value.b, alphaOp); break; case COMP_DOUBLE_INT: propertyMatch = compareDouble(currentProperty->value.i, currentAlpha->right.value.i, alphaOp); break; case COMP_DOUBLE_DOUBLE: propertyMatch = compareDouble(currentProperty->value.i, currentAlpha->right.value.d, alphaOp); break; case COMP_DOUBLE_STRING: propertyMatch = compareString(propertyFirst, propertyLast, &tree->stringPool[currentAlpha->right.value.stringOffset], alphaOp); break; case COMP_STRING_BOOL: if (currentAlpha->right.value.b) { propertyMatch = compareString(propertyFirst, propertyLast, "true", alphaOp); } else { propertyMatch = compareString(propertyFirst, propertyLast, "false", alphaOp); } break; case COMP_STRING_INT: { leftLength = propertyLast - propertyFirst + 1; char rightStringInt[leftLength]; snprintf(rightStringInt, leftLength, "%ld", currentAlpha->right.value.i); propertyMatch = compareString(propertyFirst, propertyLast, rightStringInt, alphaOp); } break; case COMP_STRING_DOUBLE: { leftLength = propertyLast - propertyFirst + 1; char rightStringDouble[leftLength]; snprintf(rightStringDouble, leftLength, "%f", currentAlpha->right.value.d); propertyMatch = compareString(propertyFirst, propertyLast, rightStringDouble, alphaOp); break; } case COMP_STRING_STRING: propertyMatch = compareString(propertyFirst, propertyLast, &tree->stringPool[currentAlpha->right.value.stringOffset], alphaOp); break; } } if (propertyMatch) { unsigned int nextLength = currentAlpha->nextLength; unsigned int nextOffset = currentAlpha->nextOffset; for (unsigned int i = 0; i < nextLength; ++i) { node *currentNode = &tree->nodePool[tree->nextPool[nextOffset + i]]; unsigned int nodeHash; if (currentNode->type != NODE_ALPHA) { result = handleBeta(tree, sid, mid, state, currentNode, rulesBinding, actionType, commandCount); } else { nodeHash = currentNode->value.a.hash; propertyHash = 1; for (int ii = 0; propertyHash && (propertyHash != nodeHash) && (ii < MAX_CONFLICTS); ++ii) { currentProperty = &allProperties[(nodeHash & HASH_MASK) + (ii * MAX_BUCKET_LENGTH)]; propertyHash = currentProperty->hash; } if (((nodeHash == propertyHash) && (currentNode->value.a.operator != OP_NEX)) || ((nodeHash != propertyHash) && (currentNode->value.a.operator == OP_NEX))) { if (top == MAX_STACK_SIZE) { return ERR_MAX_STACK_SIZE; } alphaStack[top] = ¤tNode->value.a; propertyStack[top] = currentProperty; ++top; } } } } } return result; }
int compareInt(uint64_t const a, uint64_t const b) const { uint8_t const * da = data + a + sizeof(uint32_t); uint8_t const * db = data + b + sizeof(uint32_t); return compareInt(da,db); }
void SoConditionalTrigger::inputChanged(SoField * whichField) { if ((whichField == &token) | (whichField == &triggerAtInit)) { trigger.enable(FALSE); tokenOut.enable(FALSE); boolOut.enable(FALSE); //SoDebugError::postInfo("SoConditionalTrigger::inputChanged()", // "%s: token now set to: %s", // this->getName().getString(), token.getValue().getString()); } else { bool localC = true; bool any = false; int i,j, num, tnum; if (whichField == &triggerIn) { any = true; triggerNotified = false; } // check all conditions. if (((num = boolIn.getNum()) > 0) && ((tnum = triggerBool.getNum()) > 0)){ localC = false; any = true; for (i=0; i<num; i++){ for (j=0; j<tnum; j++){ if (boolIn[i] == triggerBool[j]){ localC = true; break; } } if (localC) break; } } if (localC && ((num = floatIn.getNum()) > 0) && (triggerFloat.getNum() > 0)) { localC = false; any = true; for (i=0; i<num; i++){ if (compareFloat(floatIn[i])){ localC = true; break; } } } if (localC && ((num = intIn.getNum()) > 0) && (triggerInt.getNum() > 0)) { localC = false; any = true; for (i=0; i<num; i++){ if (compareInt(intIn[i])){ localC = true; break; } } } if (localC && ((num = stringIn.getNum()) > 0) && ((tnum = triggerString.getNum()) > 0)) { localC = false; any = true; if (comparison.getValue() == EQUAL) { for (i=0; i<num; i++){ for (j=0; j<tnum; j++){ if (stringIn[i] == triggerString[j]){ localC = true; break; } } if (localC) break; } } else { for (i=0; i<num; i++){ for (j=0; j<tnum; j++){ if (! stringIn[i] == triggerString[j]){ localC = true; break; } } if (localC) break; } } } if (localC && ((num = nodeIn.getNum()) > 0) && ((tnum = triggerNode.getNum()) > 0)) { localC = false; any = true; for (i=0; i<num; i++){ for (j=0; j<tnum; j++){ if (nodeIn[i] == triggerNode[j]){ localC = true; break; } } if (localC) break; } } if (!any) localC = false; if (localC) { if (!retrigger.getValue()) { if (!triggerNotified) { //SoDebugError::postInfo("SoConditionalTrigger::inputChanged()", // "%s: condition == TRUE -> notify trigger!\n",this->getName().getString()); boolOut.enable(TRUE); trigger.enable(TRUE); tokenOut.enable(TRUE); triggerNotified = true; tempBool = true; } else { trigger.enable(FALSE); tokenOut.enable(FALSE); } } else { boolOut.enable(TRUE); trigger.enable(TRUE); tokenOut.enable(TRUE); triggerNotified = true; tempBool = true; } } else { if (tempBool) { //SoDebugError::postInfo("SoConditionalTrigger::inputChanged()", // "%s: condition == FALSE -> update boolOut!", // this->getName().getString()); tempBool = false; boolOut.enable(TRUE); } trigger.enable(FALSE); tokenOut.enable(FALSE); triggerNotified = false; } } }
/** *Description : To remove a node from the AVL tree * *Inputs : **ptrToRoot -> The pointer to pointer to the root of the current tree * *nodeToRemove -> The node to be removed from the tree * *Output : returnNode -> The node that is removed * */ Node *avlRemove(Node **ptrToRoot, Node *nodeToRemove, int (*compare)(void *, void *)){ Node *returnNode = NULL; Node *tempNode; int tempBalanceLeft, tempBalanceRight, tempBalanceForReplacement; int compareResult; if((*ptrToRoot) !=NULL){ compareResult = compareInt((*ptrToRoot), nodeToRemove); if(compareResult == 0){ returnNode = (*ptrToRoot); tempNode = returnNode; if((*ptrToRoot)->leftChild == NULL){ (*ptrToRoot) = (*ptrToRoot)->rightChild; if((*ptrToRoot) != NULL){ (*ptrToRoot)->leftChild = tempNode->leftChild; (*ptrToRoot)->rightChild = tempNode->rightChild; (*ptrToRoot)->balance = tempNode->balance; (*ptrToRoot)->balance--; } } else{ tempBalanceForReplacement = (*ptrToRoot)->leftChild->balance; (*ptrToRoot) = avlGetReplacer(&(*ptrToRoot)->leftChild); if((*ptrToRoot) != NULL){ (*ptrToRoot)->leftChild = tempNode->leftChild; (*ptrToRoot)->rightChild = tempNode->rightChild; (*ptrToRoot)->balance = tempNode->balance; if((*ptrToRoot)->leftChild == NULL) (*ptrToRoot)->balance++; else if((*ptrToRoot)->leftChild->balance == 0){ if(tempBalanceForReplacement - (*ptrToRoot)->leftChild->balance != 0) (*ptrToRoot)->balance++; else{} } else{} } } } else if(compareResult == 1){ if((*ptrToRoot)->leftChild != NULL) tempBalanceLeft = (*ptrToRoot )->leftChild->balance; returnNode = avlRemove(&(*ptrToRoot)->leftChild, nodeToRemove, compare); if(returnNode == NULL) return returnNode; if((*ptrToRoot)->leftChild == NULL) (*ptrToRoot)->balance++; else if((*ptrToRoot)->leftChild->balance == 0){ if(tempBalanceLeft - (*ptrToRoot)->leftChild->balance != 0) (*ptrToRoot)->balance++; else {} } else{} } else if(compareResult == -1){ if((*ptrToRoot)->rightChild != NULL) tempBalanceRight = (*ptrToRoot)->rightChild->balance; returnNode = avlRemove(&(*ptrToRoot)->rightChild, nodeToRemove, compare); if(returnNode == NULL) return returnNode; if((*ptrToRoot)->rightChild == NULL) (*ptrToRoot)->balance--; else if((*ptrToRoot)->rightChild->balance == 0){ if(tempBalanceRight - (*ptrToRoot)->rightChild->balance != 0) (*ptrToRoot)->balance--; else{} } else{} } } if((*ptrToRoot) !=NULL){ if((*ptrToRoot)->balance == 2 && (*ptrToRoot)->rightChild->balance == 1) (*ptrToRoot) = leftRotate((*ptrToRoot)); else if((*ptrToRoot)->balance == 2 && (*ptrToRoot)->rightChild->balance == 0) (*ptrToRoot) = leftRotate((*ptrToRoot)); else if((*ptrToRoot)->balance == 2 && (*ptrToRoot)->rightChild->balance == -1) (*ptrToRoot) = doubleLeftRotate((*ptrToRoot)); else if((*ptrToRoot)->balance == -2 && (*ptrToRoot)->leftChild->balance == 1) (*ptrToRoot) = doubleRightRotate((*ptrToRoot)); else if((*ptrToRoot)->balance == -2 && (*ptrToRoot)->leftChild->balance == -1) (*ptrToRoot) = rightRotate((*ptrToRoot)); else if((*ptrToRoot)->balance == -2 && (*ptrToRoot)->leftChild->balance == 0) (*ptrToRoot) = rightRotate((*ptrToRoot)); else{} } return returnNode; }