Get ICU 4.6 to be compiled without RTTI....

third_party/icu/source/i18n/tzrule.cpp

 /*
 *******************************************************************************
 * Copyright (C) 2007-2010, International Business Machines Corporation and
 * others. All Rights Reserved.
 *******************************************************************************
 */
 
-#include <typeinfo>  // for 'typeid' to work
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_FORMATTING
 
 #include "unicode/tzrule.h"
 #include "unicode/ucal.h"
 #include "gregoimp.h"
 #include "cmemory.h"
 #include "uarrsort.h"
@@ skipping 28 matching lines @@
         fName = right.fName;
         fRawOffset = right.fRawOffset;
         fDSTSavings = right.fDSTSavings;
     }
     return *this;
 }
 
 UBool
 TimeZoneRule::operator==(const TimeZoneRule& that) const {
     return ((this == &that) ||
-            (typeid(*this) == typeid(that) &&
+            (CR_TYPEID(*this) == CR_TYPEID(that) &&
             fName == that.fName &&
             fRawOffset == that.fRawOffset &&
             fDSTSavings == that.fDSTSavings));
 }
 
 UBool
 TimeZoneRule::operator!=(const TimeZoneRule& that) const {
     return !operator==(that);
 }
 
 UnicodeString&
 TimeZoneRule::getName(UnicodeString& name) const {
     name = fName;
     return name;
 }
 
 int32_t
 TimeZoneRule::getRawOffset(void) const {
     return fRawOffset;
 }
 
 int32_t
 TimeZoneRule::getDSTSavings(void) const {
     return fDSTSavings;
 }
 
 UBool
 TimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const {
     return ((this == &other) ||
-            (typeid(*this) == typeid(other) &&
+            (CR_TYPEID(*this) == CR_TYPEID(other) &&
             fRawOffset == other.fRawOffset &&
             fDSTSavings == other.fDSTSavings));
 }
 
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(InitialTimeZoneRule)
 
 InitialTimeZoneRule::InitialTimeZoneRule(const UnicodeString& name,
                                          int32_t rawOffset,
                                          int32_t dstSavings)
@@ skipping 16 matching lines @@
 InitialTimeZoneRule::operator=(const InitialTimeZoneRule& right) {
     if (this != &right) {
         TimeZoneRule::operator=(right);
     }
     return *this;
 }
 
 UBool
 InitialTimeZoneRule::operator==(const TimeZoneRule& that) const {
     return ((this == &that) ||
-            (typeid(*this) == typeid(that) &&
+            (CR_TYPEID(*this) == CR_TYPEID(that) &&
             TimeZoneRule::operator==(that)));
 }
 
 UBool
 InitialTimeZoneRule::operator!=(const TimeZoneRule& that) const {
     return !operator==(that);
 }
 
 UBool
 InitialTimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const {
     if (this == &other) {
         return TRUE;
     }
-    if (typeid(*this) != typeid(other) || TimeZoneRule::isEquivalentTo(other) == FALSE) {
+    if (CR_TYPEID(*this) != CR_TYPEID(other) || TimeZoneRule::isEquivalentTo(other) == FALSE) {
         return FALSE;
     }
     return TRUE;
 }
 
 UBool
 InitialTimeZoneRule::getFirstStart(int32_t /*prevRawOffset*/,
                                   int32_t /*prevDSTSavings*/,
                                   UDate& /*result*/) const {
     return FALSE;
@@ skipping 73 matching lines @@
         fEndYear = right.fEndYear;
     }
     return *this;
 }
 
 UBool
 AnnualTimeZoneRule::operator==(const TimeZoneRule& that) const {
     if (this == &that) {
         return TRUE;
     }
-    if (typeid(*this) != typeid(that)) {
+    if (CR_TYPEID(*this) != CR_TYPEID(that)) {
         return FALSE;
     }
     AnnualTimeZoneRule *atzr = (AnnualTimeZoneRule*)&that;
     return (*fDateTimeRule == *(atzr->fDateTimeRule) &&
             fStartYear == atzr->fStartYear &&
             fEndYear == atzr->fEndYear);
 }
 
 UBool
 AnnualTimeZoneRule::operator!=(const TimeZoneRule& that) const {
@@ skipping 71 matching lines @@
         result -= prevDSTSavings;
     }
     return TRUE;
 }
 
 UBool
 AnnualTimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const {
     if (this == &other) {
         return TRUE;
     }
-    if (typeid(*this) != typeid(other) || TimeZoneRule::isEquivalentTo(other) == FALSE) {
+    if (CR_TYPEID(*this) != CR_TYPEID(other) || TimeZoneRule::isEquivalentTo(other) == FALSE) {
         return FALSE;
     }
     AnnualTimeZoneRule* that = (AnnualTimeZoneRule*)&other;
     return (*fDateTimeRule == *(that->fDateTimeRule) &&
             fStartYear == that->fStartYear &&
             fEndYear == that->fEndYear);
 }
 
 UBool
 AnnualTimeZoneRule::getFirstStart(int32_t prevRawOffset,
@@ skipping 106 matching lines @@
         fTimeRuleType = right.fTimeRuleType;        
     }
     return *this;
 }
 
 UBool
 TimeArrayTimeZoneRule::operator==(const TimeZoneRule& that) const {
     if (this == &that) {
         return TRUE;
     }
-    if (typeid(*this) != typeid(that) || TimeZoneRule::operator==(that) == FALSE) {
+    if (CR_TYPEID(*this) != CR_TYPEID(that) || TimeZoneRule::operator==(that) == FALSE) {
         return FALSE;
     }
     TimeArrayTimeZoneRule *tatzr = (TimeArrayTimeZoneRule*)&that;
     if (fTimeRuleType != tatzr->fTimeRuleType ||
         fNumStartTimes != tatzr->fNumStartTimes) {
         return FALSE;
     }
     // Compare start times
     UBool res = TRUE;
     for (int32_t i = 0; i < fNumStartTimes; i++) {
@@ skipping 27 matching lines @@
 int32_t
 TimeArrayTimeZoneRule::countStartTimes(void) const {
     return fNumStartTimes;
 }
 
 UBool
 TimeArrayTimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const {
     if (this == &other) {
         return TRUE;
     }
-    if (typeid(*this) != typeid(other) || TimeZoneRule::isEquivalentTo(other) == FALSE) {
+    if (CR_TYPEID(*this) != CR_TYPEID(other) || TimeZoneRule::isEquivalentTo(other) == FALSE) {
         return FALSE;
     }
     TimeArrayTimeZoneRule* that = (TimeArrayTimeZoneRule*)&other;
     if (fTimeRuleType != that->fTimeRuleType ||
         fNumStartTimes != that->fNumStartTimes) {
         return FALSE;
     }
     // Compare start times
     UBool res = TRUE;
     for (int32_t i = 0; i < fNumStartTimes; i++) {
@@ skipping 108 matching lines @@
     }
     return time;
 }
 
 U_NAMESPACE_END
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
 
 //eof