bool OSString::isEqualTo(const OSMetaClassBase *obj) const
{
OSString * str;
OSData * data;
if ((str = OSDynamicCast(OSString, obj)))
return isEqualTo(str);
else if ((data = OSDynamicCast (OSData, obj)))
return isEqualTo(data);
else
return false;
}
bool Date::operator!=(
const Date& other
)
const
{
return( !isEqualTo( other ) );
} /* end Date::operator!=() */
bool OSString::isEqualTo(const OSString *aString) const
{
if (length != aString->length)
return false;
else
return isEqualTo((const char *) aString->string);
}
bool Date::operator>(
const Date& other
)
const
{
return( !isLessThan( other ) && !isEqualTo( other ) );
} /* end Date::operator>() */
bool Date::operator<=(
const Date& other
)
const
{
return( isLessThan( other ) || isEqualTo( other ) );
} /* end Date::operator<=() */
bool HugeInteger::isNotEqualTo(const HugeInteger &a_hi1, const HugeInteger &a_hi2) const
{
if (isEqualTo(a_hi1, a_hi2))
return false;
return true;
}
bool FakeSMCKey::isEqualTo(const OSMetaClassBase *anObject)
{
if (FakeSMCKey *aKey = OSDynamicCast(FakeSMCKey, anObject))
return isEqualTo(aKey);
return false;
}
bool OSOrderedSet::isEqualTo(const OSMetaClassBase *anObject) const
{
OSOrderedSet *oSet;
oSet = OSDynamicCast(OSOrderedSet, anObject);
if ( oSet )
return isEqualTo(oSet);
else
return false;
}
bool OSDictionary::isEqualTo(const OSMetaClassBase *anObject) const
{
OSDictionary *dict;
dict = OSDynamicCast(OSDictionary, anObject);
if ( dict )
return isEqualTo(dict);
else
return false;
}
bool OSArray::isEqualTo(const OSMetaClassBase *anObject) const
{
OSArray *otherArray;
otherArray = OSDynamicCast(OSArray, anObject);
if ( otherArray )
return isEqualTo(otherArray);
else
return false;
}
bool OSSymbol::isEqualTo(const OSMetaClassBase *obj) const
{
OSSymbol * sym;
OSString * str;
if ((sym = OSDynamicCast(OSSymbol, obj)))
return isEqualTo(sym);
else if ((str = OSDynamicCast(OSString, obj)))
return super::isEqualTo(str);
else
return false;
}
int setSchedTime(struct timeval tMin)
{
int ret = 0;
struct __client *pClient;
struct timeval tRet;
pClient = g_Resource1.next;
while(pClient)
{
if(isEqualTo(pClient->tSched, tMin))
{
;
//printf("Equal!\n");
}
else
{
subTimeValue(&tRet, pClient->tSched, tMin);
addTimeValue(&tRet, tRet, tRet);
struct timeval tB;
tB.tv_sec = pClient->uiReqInterval/1000;
tB.tv_usec = (pClient->uiReqInterval%1000)*1000;
//printf("NOT Equal!\n");
if(isBiggerThan(tB, tRet))
{
setTimeValue(&(pClient->tSched), tMin.tv_sec , tMin.tv_usec);
}
}
pClient = pClient->next;
}
return ret;
}
/**
* Adds a movie in the correct order of a list using recursion.
* Creates a new head if necessary.
*
* precondition: none
*
* param: movie - the movie to insert
* param: head - the head of the list to insert into
* param: method - the method of sorting (BY_TITLE, BY_LENGTH, BY_RATING)
* param: size - the size of the list.
*/
void model::InterlacedMovieList::addToList(MovieNode* movie, MovieNode* head, const string& method, int size) {
if (size == 1) {
int result = compareMovies(head, movie, method);
if (result > 0 && this->size == 1) {
replaceHead(head, movie, method);
return;
} else {
insertAfter(head, movie, method);
return;
}
} else {
MovieNode* next;
if (method.compare(BY_TITLE) == 0) {
next = head->getNextTitle();
} else if (method.compare(BY_LENGTH) == 0) {
next = head->getNextLength();
} else {
next = head->getNextRating();
}
int comparedToHead = compareMovies(movie, head, method);
int comparedToNext = compareMovies(movie, next, method);
if (size == this->size && comparedToHead == -1) {
insertAfter(head, movie, method);
}
if (isEqualTo(comparedToHead) || (isSmallerThan(comparedToHead) && isBiggerThan(comparedToNext))) {
insertAfter(head, movie, method);
return;
} else {
addToList(movie, next, method, (size - 1));
return;
}
}
}
// Operator that determines whether two points are equal. Two points
// are equal if they have the same coordinates.
bool Point2D::operator==(const Point2D& pt) const
{
return isEqualTo(pt);
}
int main()
{
// test if two ints are equal or not
cout << "*** Integers Tests ***" << endl;
int leftInts[4] = { 1, 2, -1, -1 }; // lhs integers used for testing equality
int rightInts[4] = { 1, 4, 1, -1 }; // rhs integers used for testing equality
for (int a = 0; a < 4; a++)
{
cout << "Integers: " << leftInts[a] << " and " << rightInts[a] << " are "
<< (isEqualTo(leftInts[a], rightInts[a]) ? "equal" : "\"NOT\" equal") << '\n';
}
// test if two chars are equal or not
cout << "\n\n*** Chars Tests ***" << endl;
char leftChars[4] = { 'a', 'a', 'c', 'c' }; // lhs chars used for testing equality
char rightChars[4] = { 'a', 'c', 'a', 'c' }; // rhs chars used for testing equality
for (int a = 0; a < 4; a++)
{
cout << "Characters: " << leftChars[a] << " and " << rightChars[a] << " are "
<< (isEqualTo(leftChars[a], rightChars[a]) ? "equal" : "\"NOT\" equal") << '\n';
}
// test if two doubles are equal or not
cout << "\n\n*** Double Tests ***" << endl;
double leftDoubles[4] = { 2.2, 2.2, -2.2, -2.2 }; // lhs integers used for testing equality
double rightDoubles[4] = { 2.2, 2.3, 2.2, -2.2 }; // rhs integers used for testing equality
for (int a = 0; a < 4; a++)
{
cout << "Double numbers: " << leftDoubles[a] << " and " << rightDoubles[a] << " are "
<< (isEqualTo(leftDoubles[a], rightDoubles[a]) ? "equal" : "\"NOT\" equal") << '\n';
}
// test if two Complex objects are equal
cout << "\n\n*** Complex Tests ***" << endl;
Complex a(10, 5); // Complex objects used
Complex a1(10, 5); // for testing equality
cout << "Class objects: " << a << " and " << a1 << " are "
<< (isEqualTo(a, a1) ? "equal" : "\"NOT\" equal");
Complex b(10, 5); // Complex objects used
Complex b1(10, 54); // for testing equality
cout << "\nClass objects: " << b << " and " << b1 << " are "
<< (isEqualTo(b, b1) ? "equal" : "\"NOT\" equal");
Complex c(10, -5); // Complex objects used
Complex c1(10, 5); // for testing equality
cout << "\nClass objects: " << c << " and " << c1 << " are "
<< (isEqualTo(c, c1) ? "equal" : "\"NOT\" equal");
Complex d(-10, -5); // Complex objects used
Complex d1(-10, -5); // for testing equality
cout << "\nClass objects: " << d << " and " << d1 << " are "
<< (isEqualTo(d, d1) ? "equal" : "\"NOT\" equal");
//test if two strings are equal or not
cout << "\n\n\n*** String Tests ***" << endl;
string leftStrings[4] = { "abcdefg", "abcdefg", "-abcdefg", "-abcdefg" }; // lhs chars used for testing equality
string rightStrings[4] = { "abcdefg", "abcdefh", "abcdefg", "-abcdefg" }; // rhs chars used for testing equality
for (int a = 0; a < 4; a++)
{
cout << "String objects: " << leftStrings[a] << " and " << rightStrings[a] << " are "
<< (isEqualTo(leftStrings[a], rightStrings[a]) ? "equal" : "\"NOT\" equal") << '\n';
}
//test if two dates are equal or not
cout << "\n\n*** Date Tests ***";
Date dayA(2, 31, 2016); // create date object
Date dayB(2, 31, 2016); // create date object
cout << "\nDate objects: " << dayA << " and " << dayB << " are "
<< (isEqualTo(dayA, dayB) ? "equal" : "\"NOT\" equal");
Date dayC(-2, 13, 2016); // create date object
Date dayD(2, 14, 2016); // create date object
cout << "\nDate objects: " << dayC << " and " << dayD << " are "
<< (isEqualTo(dayC, dayD) ? "equal" : "\"NOT\" equal");
Date dayE(-2, 13, 2016); // create date object
Date dayF(2, 13, 2016); // create date object
cout << "\nDate objects: " << dayE << " and " << dayF << " are "
<< (isEqualTo(dayE, dayF) ? "equal" : "\"NOT\" equal");
Date dayG(-2, 13, 2016); // create date object
Date dayH(2, 31, 2016); // create date object
cout << "\nDate objects: " << dayG << " and " << dayH << " are "
<< (isEqualTo(dayG, dayH) ? "equal" : "\"NOT\" equal") << '\n';
cout << endl << endl;
return 0;
} // end main
// ---------------------------------------------------------------------------------
// 히스토리: 2011-07-07 이태훈 개발 완료
// ---------------------------------------------------------------------------------
bool NE_DLL NEKey::operator==(const NEKey& source) const
{
return isEqualTo(source);
}
bool NE_DLL NEKey::operator>(const NEKey& source) const
{
return ( ! isLower(source)) && ( ! isEqualTo(source));
}
bool Matrix2d::operator!=(const Matrix2d& mat) const
{
return !isEqualTo(mat);
}
//=========================================================
bool SGLVector2d::operator != (const SGLVector2d& vec) const
{
return !isEqualTo(vec);
}
//=========================================================
bool SGLVector2d::isUnitLength(const SGLTol& tol) const
{
return isEqualTo(normal(tol), tol);
}
//=========================================================
bool SGLPoint2d::operator == (const SGLPoint2d& pt) const
{
return isEqualTo(pt);
}
bool NE_DLL NEKey::operator<=(const NEKey& source) const
{
return isEqualTo(source) || isLower(source);
}
