static_cast<uint32_t>(hash)*37u + static_cast<uint32_t>(ustr_hashCharsN(bytes, len)));
}
-UBool
+bool
BytesTrieBuilder::BTLinearMatchNode::operator==(const Node &other) const {
if(this==&other) {
return TRUE;
}
-UBool
+bool
DateInterval::operator==(const DateInterval& other) const {
return ( fromDate == other.fromDate && toDate == other.toDate );
}
}
virtual SimpleFilteredSentenceBreakIterator* clone() const { return new SimpleFilteredSentenceBreakIterator(*this); }
virtual UClassID getDynamicClassID(void) const { return NULL; }
- virtual UBool operator==(const BreakIterator& o) const { if(this==&o) return true; return false; }
+ virtual bool operator==(const BreakIterator& o) const { if(this==&o) return true; return false; }
/* -- text modifying -- */
virtual void setText(UText *text, UErrorCode &status) { fDelegate->setText(text,status); }
return new Locale(*this);
}
-UBool
+bool
Locale::operator==( const Locale& other) const
{
return (uprv_strcmp(other.fullName, fullName) == 0);
(regionIndex > 0 || uprv_strcmp(region, other.region) == 0);
}
-UBool LSR::operator==(const LSR &other) const {
+bool LSR::operator==(const LSR &other) const {
return
uprv_strcmp(language, other.language) == 0 &&
uprv_strcmp(script, other.script) == 0 &&
static int32_t indexForRegion(const char *region);
UBool isEquivalentTo(const LSR &other) const;
- UBool operator==(const LSR &other) const;
+ bool operator==(const LSR &other) const;
- inline UBool operator!=(const LSR &other) const {
+ inline bool operator!=(const LSR &other) const {
return !operator==(other);
}
numericValuesLength=0;
}
-UBool
+bool
MessagePattern::operator==(const MessagePattern &other) const {
if(this==&other) {
return TRUE;
// MessagePattern::Part ---------------------------------------------------- ***
-UBool
+bool
MessagePattern::Part::operator==(const Part &other) const {
if(this==&other) {
return TRUE;
return text->hashCode() + fUMode + fOptions + buffer.hashCode() + bufferPos + currentIndex + nextIndex;
}
-UBool Normalizer::operator==(const Normalizer& that) const
+bool Normalizer::operator==(const Normalizer& that) const
{
return
this==&that ||
}
/**
- * Equality operator. Returns TRUE if both BreakIterators are of the
+ * Equality operator. Returns true if both BreakIterators are of the
* same class, have the same behavior, and iterate over the same text.
*/
-UBool
+bool
RuleBasedBreakIterator::operator==(const BreakIterator& that) const {
if (typeid(*this) != typeid(that)) {
return FALSE;
// should still be ==.
//
//-----------------------------------------------------------------------------
-UBool RBBIDataWrapper::operator ==(const RBBIDataWrapper &other) const {
+bool RBBIDataWrapper::operator ==(const RBBIDataWrapper &other) const {
if (fHeader == other.fHeader) {
return TRUE;
}
void init(const RBBIDataHeader *data, UErrorCode &status);
RBBIDataWrapper *addReference();
void removeReference();
- UBool operator ==(const RBBIDataWrapper &other) const;
+ bool operator ==(const RBBIDataWrapper &other) const;
int32_t hashCode();
const UnicodeString &getRuleSourceString() const;
void printData();
private:
RBBINode &operator = (const RBBINode &other); // No defs.
- UBool operator == (const RBBINode &other); // Private, so these functions won't accidentally be used.
+ bool operator == (const RBBINode &other); // Private, so these functions won't accidentally be used.
#ifdef RBBI_DEBUG
public:
return *this;
}
-UBool
+bool
StringCharacterIterator::operator==(const ForwardCharacterIterator& that) const {
if (this == &that) {
return TRUE;
return *(const Node *)left==*(const Node *)right;
}
-UBool
+bool
StringTrieBuilder::Node::operator==(const Node &other) const {
return this==&other || (typeid(*this)==typeid(other) && hash==other.hash);
}
return edgeNumber;
}
-UBool
+bool
StringTrieBuilder::FinalValueNode::operator==(const Node &other) const {
if(this==&other) {
return TRUE;
offset=builder.writeValueAndFinal(value, TRUE);
}
-UBool
+bool
StringTrieBuilder::ValueNode::operator==(const Node &other) const {
if(this==&other) {
return TRUE;
return hasValue==o.hasValue && (!hasValue || value==o.value);
}
-UBool
+bool
StringTrieBuilder::IntermediateValueNode::operator==(const Node &other) const {
if(this==&other) {
return TRUE;
offset=builder.writeValueAndFinal(value, FALSE);
}
-UBool
+bool
StringTrieBuilder::LinearMatchNode::operator==(const Node &other) const {
if(this==&other) {
return TRUE;
return edgeNumber;
}
-UBool
+bool
StringTrieBuilder::ListBranchNode::operator==(const Node &other) const {
if(this==&other) {
return TRUE;
}
}
-UBool
+bool
StringTrieBuilder::SplitBranchNode::operator==(const Node &other) const {
if(this==&other) {
return TRUE;
offset=builder.write(unit);
}
-UBool
+bool
StringTrieBuilder::BranchHeadNode::operator==(const Node &other) const {
if(this==&other) {
return TRUE;
hash=hash*37u+ustr_hashUCharsN(units, len);
}
-UBool
+bool
UCharsTrieBuilder::UCTLinearMatchNode::operator==(const Node &other) const {
if(this==&other) {
return TRUE;
UCharCharacterIterator::~UCharCharacterIterator() {
}
-UBool
+bool
UCharCharacterIterator::operator==(const ForwardCharacterIterator& that) const {
if (this == &that) {
return TRUE;
* object, and styles are not considered.
* @stable ICU 2.0
*/
- virtual UBool operator==(const BreakIterator&) const = 0;
+ virtual bool operator==(const BreakIterator&) const = 0;
/**
* Returns the complement of the result of operator==
* @return the complement of the result of operator==
* @stable ICU 2.0
*/
- UBool operator!=(const BreakIterator& rhs) const { return !operator==(rhs); }
+ bool operator!=(const BreakIterator& rhs) const { return !operator==(rhs); }
/**
* Return a polymorphic copy of this object. This is an abstract
class BTLinearMatchNode : public LinearMatchNode {
public:
BTLinearMatchNode(const char *units, int32_t len, Node *nextNode);
- virtual UBool operator==(const Node &other) const;
+ virtual bool operator==(const Node &other) const;
virtual void write(StringTrieBuilder &builder);
private:
const char *s;
* character in the same character-storage object
* @stable ICU 2.0
*/
- virtual UBool operator==(const ForwardCharacterIterator& that) const = 0;
+ virtual bool operator==(const ForwardCharacterIterator& that) const = 0;
/**
* Returns true when the iterators refer to different
* same text-storage object
* @stable ICU 2.0
*/
- inline UBool operator!=(const ForwardCharacterIterator& that) const;
+ inline bool operator!=(const ForwardCharacterIterator& that) const;
/**
* Generates a hash code for this iterator.
int32_t end;
};
-inline UBool
+inline bool
ForwardCharacterIterator::operator!=(const ForwardCharacterIterator& that) const {
return !operator==(that);
}
* @return true if the two DateIntervals are the same
* @stable ICU 4.0
*/
- virtual UBool operator==(const DateInterval& other) const;
+ virtual bool operator==(const DateInterval& other) const;
/**
* Non-equality operator
* @return true if the two DateIntervals are not the same
* @stable ICU 4.0
*/
- inline UBool operator!=(const DateInterval& other) const;
+ inline bool operator!=(const DateInterval& other) const;
/**
}
-inline UBool
+inline bool
DateInterval::operator!=(const DateInterval& other) const {
return ( !operator==(other) );
}
* Checks if two locale keys are the same.
*
* @param other The locale key object to be compared with this.
- * @return True if the two locale keys are the same, false otherwise.
+ * @return true if the two locale keys are the same, false otherwise.
* @stable ICU 2.0
*/
- UBool operator==(const Locale& other) const;
+ bool operator==(const Locale& other) const;
/**
* Checks if two locale keys are not the same.
*
* @param other The locale key object to be compared with this.
- * @return True if the two locale keys are not the same, false
+ * @return true if the two locale keys are not the same, false
* otherwise.
* @stable ICU 2.0
*/
- inline UBool operator!=(const Locale& other) const;
+ inline bool operator!=(const Locale& other) const;
/**
* Clone this object.
friend void U_CALLCONV locale_available_init();
};
-inline UBool
+inline bool
Locale::operator!=(const Locale& other) const
{
return !operator==(other);
* @return true if this object is equivalent to the other one.
* @stable ICU 4.8
*/
- UBool operator==(const MessagePattern &other) const;
+ bool operator==(const MessagePattern &other) const;
/**
* @param other another object to compare with.
* @return false if this object is equivalent to the other one.
* @stable ICU 4.8
*/
- inline UBool operator!=(const MessagePattern &other) const {
+ inline bool operator!=(const MessagePattern &other) const {
return !operator==(other);
}
* @return true if this object is equivalent to the other one.
* @stable ICU 4.8
*/
- UBool operator==(const Part &other) const;
+ bool operator==(const Part &other) const;
/**
* @param other another object to compare with.
* @return false if this object is equivalent to the other one.
* @stable ICU 4.8
*/
- inline UBool operator!=(const Part &other) const {
+ inline bool operator!=(const Part &other) const {
return !operator==(other);
}
* @return comparison result
* @deprecated ICU 56 Use Normalizer2 instead.
*/
- UBool operator==(const Normalizer& that) const;
+ bool operator==(const Normalizer& that) const;
/**
* Returns false when both iterators refer to the same character in the same
* @return comparison result
* @deprecated ICU 56 Use Normalizer2 instead.
*/
- inline UBool operator!=(const Normalizer& that) const;
+ inline bool operator!=(const Normalizer& that) const;
/**
* Returns a pointer to a new Normalizer that is a clone of this one.
//-------------------------------------------------------------------------
#ifndef U_HIDE_DEPRECATED_API
-inline UBool
+inline bool
Normalizer::operator!= (const Normalizer& other) const
{ return ! operator==(other); }
* @return true if the two parse positions are equal, false otherwise.
* @stable ICU 2.0
*/
- inline UBool operator==(const ParsePosition& that) const;
+ inline bool operator==(const ParsePosition& that) const;
/**
* Equality operator.
* @return true if the two parse positions are not equal, false otherwise.
* @stable ICU 2.0
*/
- inline UBool operator!=(const ParsePosition& that) const;
+ inline bool operator!=(const ParsePosition& that) const;
/**
* Clone this object.
return *this;
}
-inline UBool
+inline bool
ParsePosition::operator==(const ParsePosition& copy) const
{
if(index != copy.index || errorIndex != copy.errorIndex)
return true;
}
-inline UBool
+inline bool
ParsePosition::operator!=(const ParsePosition& copy) const
{
return !operator==(copy);
* same class, have the same behavior, and iterate over the same text.
* @stable ICU 2.0
*/
- virtual UBool operator==(const BreakIterator& that) const;
+ virtual bool operator==(const BreakIterator& that) const;
/**
* Not-equal operator. If operator== returns true, this returns false,
* @return true if both BreakIterators are not same.
* @stable ICU 2.0
*/
- inline UBool operator!=(const BreakIterator& that) const;
+ inline bool operator!=(const BreakIterator& that) const;
/**
* Returns a newly-constructed RuleBasedBreakIterator with the same
//
//------------------------------------------------------------------------------
-inline UBool RuleBasedBreakIterator::operator!=(const BreakIterator& that) const {
+inline bool RuleBasedBreakIterator::operator!=(const BreakIterator& that) const {
return !operator==(that);
}
* same string and are pointing at the same character.
* @stable ICU 2.0
*/
- virtual UBool operator==(const ForwardCharacterIterator& that) const;
+ virtual bool operator==(const ForwardCharacterIterator& that) const;
/**
* Returns a new StringCharacterIterator referring to the same
* @return true if the enumerations are equal. false if not.
* @stable ICU 3.6
*/
- virtual UBool operator==(const StringEnumeration& that)const;
+ virtual bool operator==(const StringEnumeration& that)const;
/**
* Compares this enumeration to other to check if both are not equal
*
* @return true if the enumerations are equal. false if not.
* @stable ICU 3.6
*/
- virtual UBool operator!=(const StringEnumeration& that)const;
+ virtual bool operator!=(const StringEnumeration& that)const;
protected:
/**
* @return true if the string data is not equal
* @stable ICU 4.8
*/
-inline UBool operator!=(const StringPiece& x, const StringPiece& y) {
+inline bool operator!=(const StringPiece& x, const StringPiece& y) {
return !(x == y);
}
// Handles node==NULL.
static inline int32_t hashCode(const Node *node) { return node==NULL ? 0 : node->hashCode(); }
// Base class operator==() compares the actual class types.
- virtual UBool operator==(const Node &other) const;
- inline UBool operator!=(const Node &other) const { return !operator==(other); }
+ virtual bool operator==(const Node &other) const;
+ inline bool operator!=(const Node &other) const { return !operator==(other); }
/**
* Traverses the Node graph and numbers branch edges, with rightmost edges first.
* This is to avoid writing a duplicate node twice.
class FinalValueNode : public Node {
public:
FinalValueNode(int32_t v) : Node(0x111111u*37u+v), value(v) {}
- virtual UBool operator==(const Node &other) const;
+ virtual bool operator==(const Node &other) const;
virtual void write(StringTrieBuilder &builder);
protected:
int32_t value;
class ValueNode : public Node {
public:
ValueNode(int32_t initialHash) : Node(initialHash), hasValue(false), value(0) {}
- virtual UBool operator==(const Node &other) const;
+ virtual bool operator==(const Node &other) const;
void setValue(int32_t v) {
hasValue=true;
value=v;
public:
IntermediateValueNode(int32_t v, Node *nextNode)
: ValueNode(0x222222u*37u+hashCode(nextNode)), next(nextNode) { setValue(v); }
- virtual UBool operator==(const Node &other) const;
+ virtual bool operator==(const Node &other) const;
virtual int32_t markRightEdgesFirst(int32_t edgeNumber);
virtual void write(StringTrieBuilder &builder);
protected:
LinearMatchNode(int32_t len, Node *nextNode)
: ValueNode((0x333333u*37u+len)*37u+hashCode(nextNode)),
length(len), next(nextNode) {}
- virtual UBool operator==(const Node &other) const;
+ virtual bool operator==(const Node &other) const;
virtual int32_t markRightEdgesFirst(int32_t edgeNumber);
protected:
int32_t length;
class ListBranchNode : public BranchNode {
public:
ListBranchNode() : BranchNode(0x444444), length(0) {}
- virtual UBool operator==(const Node &other) const;
+ virtual bool operator==(const Node &other) const;
virtual int32_t markRightEdgesFirst(int32_t edgeNumber);
virtual void write(StringTrieBuilder &builder);
// Adds a unit with a final value.
: BranchNode(((0x555555u*37u+middleUnit)*37u+
hashCode(lessThanNode))*37u+hashCode(greaterOrEqualNode)),
unit(middleUnit), lessThan(lessThanNode), greaterOrEqual(greaterOrEqualNode) {}
- virtual UBool operator==(const Node &other) const;
+ virtual bool operator==(const Node &other) const;
virtual int32_t markRightEdgesFirst(int32_t edgeNumber);
virtual void write(StringTrieBuilder &builder);
protected:
BranchHeadNode(int32_t len, Node *subNode)
: ValueNode((0x666666u*37u+len)*37u+hashCode(subNode)),
length(len), next(subNode) {}
- virtual UBool operator==(const Node &other) const;
+ virtual bool operator==(const Node &other) const;
virtual int32_t markRightEdgesFirst(int32_t edgeNumber);
virtual void write(StringTrieBuilder &builder);
protected:
class UCTLinearMatchNode : public LinearMatchNode {
public:
UCTLinearMatchNode(const char16_t *units, int32_t len, Node *nextNode);
- virtual UBool operator==(const Node &other) const;
+ virtual bool operator==(const Node &other) const;
virtual void write(StringTrieBuilder &builder);
private:
const char16_t *s;
* same string and are pointing at the same character.
* @stable ICU 2.0
*/
- virtual UBool operator==(const ForwardCharacterIterator& that) const;
+ virtual bool operator==(const ForwardCharacterIterator& that) const;
/**
* Generates a hash code for this iterator.
* @return <tt>true</tt> if the specified set is equal to this set.
* @stable ICU 2.0
*/
- virtual UBool operator==(const UnicodeSet& o) const;
+ virtual bool operator==(const UnicodeSet& o) const;
/**
* Compares the specified object with this set for equality. Returns
* <tt>true</tt> if the specified set is not equal to this set.
* @stable ICU 2.0
*/
- inline UBool operator!=(const UnicodeSet& o) const;
+ inline bool operator!=(const UnicodeSet& o) const;
/**
* Returns a copy of this object. All UnicodeFunctor objects have
-inline UBool UnicodeSet::operator!=(const UnicodeSet& o) const {
+inline bool UnicodeSet::operator!=(const UnicodeSet& o) const {
return !operator==(o);
}
* false otherwise.
* @stable ICU 2.0
*/
- inline UBool operator== (const UnicodeString& text) const;
+ inline bool operator== (const UnicodeString& text) const;
/**
* Inequality operator. Performs only bitwise comparison.
* true otherwise.
* @stable ICU 2.0
*/
- inline UBool operator!= (const UnicodeString& text) const;
+ inline bool operator!= (const UnicodeString& text) const;
/**
* Greater than operator. Performs only bitwise comparison.
}
}
-inline UBool
+inline bool
UnicodeString::operator== (const UnicodeString& text) const
{
if(isBogus()) {
}
}
-inline UBool
+inline bool
UnicodeString::operator!= (const UnicodeString& text) const
{ return (! operator==(text)); }
// UObject &operator=(const UObject &other) { return *this; }
// comparison operators
- virtual inline UBool operator==(const UObject &other) const { return this==&other; }
- inline UBool operator!=(const UObject &other) const { return !operator==(other); }
+ virtual inline bool operator==(const UObject &other) const { return this==&other; }
+ inline bool operator!=(const UObject &other) const { return !operator==(other); }
// clone() commented out from the base class:
// some compilers do not support co-variant return types
/**
* Equality operator.
*/
- virtual UBool operator == (const CacheKeyBase &other) const = 0;
+ virtual bool operator == (const CacheKeyBase &other) const = 0;
/**
* Create a new object for this key. Called by cache on cache miss.
/**
* Inequality operator.
*/
- UBool operator != (const CacheKeyBase &other) const {
+ bool operator != (const CacheKeyBase &other) const {
return !(*this == other);
}
private:
/**
* Two objects are equal if they are of the same type.
*/
- virtual UBool operator == (const CacheKeyBase &other) const {
+ virtual bool operator == (const CacheKeyBase &other) const {
return typeid(*this) == typeid(other);
}
};
virtual int32_t hashCode() const {
return (int32_t)(37u * (uint32_t)CacheKey<T>::hashCode() + (uint32_t)fLoc.hashCode());
}
- virtual UBool operator == (const CacheKeyBase &other) const {
+ virtual bool operator == (const CacheKeyBase &other) const {
// reflexive
if (this == &other) {
return true;
* @param o set to be compared for equality with this set.
* @return <tt>true</tt> if the specified set is equal to this set.
*/
-UBool UnicodeSet::operator==(const UnicodeSet& o) const {
+bool UnicodeSet::operator==(const UnicodeSet& o) const {
if (len != o.len) return FALSE;
for (int32_t i = 0; i < len; ++i) {
if (list[i] != o.list[i]) return FALSE;
public:
WholeStringBreakIterator() : BreakIterator(), length(0) {}
~WholeStringBreakIterator() U_OVERRIDE;
- UBool operator==(const BreakIterator&) const U_OVERRIDE;
+ bool operator==(const BreakIterator&) const U_OVERRIDE;
WholeStringBreakIterator *clone() const U_OVERRIDE;
static UClassID U_EXPORT2 getStaticClassID();
UClassID getDynamicClassID() const U_OVERRIDE;
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(WholeStringBreakIterator)
WholeStringBreakIterator::~WholeStringBreakIterator() {}
-UBool WholeStringBreakIterator::operator==(const BreakIterator&) const { return FALSE; }
+bool WholeStringBreakIterator::operator==(const BreakIterator&) const { return FALSE; }
WholeStringBreakIterator *WholeStringBreakIterator::clone() const { return nullptr; }
CharacterIterator &WholeStringBreakIterator::getText() const {
return NULL;
}
-UBool
+bool
StringEnumeration::operator==(const StringEnumeration& that)const {
return typeid(*this) == typeid(that);
}
-UBool
+bool
StringEnumeration::operator!=(const StringEnumeration& that)const {
return !operator==(that);
}
}
// This only does something sensible if this object has a non-null comparer
-UBool UVector::operator==(const UVector& other) {
+bool UVector::operator==(const UVector& other) {
int32_t i;
if (count != other.count) return FALSE;
if (comparer != NULL) {
* equal if they are of the same size and all elements are equal,
* as compared using this object's comparer.
*/
- UBool operator==(const UVector& other);
+ bool operator==(const UVector& other);
/**
* Equivalent to !operator==()
*/
- inline UBool operator!=(const UVector& other);
+ inline bool operator!=(const UVector& other);
//------------------------------------------------------------
// java.util.Vector API
return elementAt(index);
}
-inline UBool UVector::operator!=(const UVector& other) {
+inline bool UVector::operator!=(const UVector& other) {
return !operator==(other);
}
}
-UBool UVector32::operator==(const UVector32& other) {
+bool UVector32::operator==(const UVector32& other) {
int32_t i;
if (count != other.count) return FALSE;
for (i=0; i<count; ++i) {
* equal if they are of the same size and all elements are equal,
* as compared using this object's comparer.
*/
- UBool operator==(const UVector32& other);
+ bool operator==(const UVector32& other);
/**
* Equivalent to !operator==()
*/
- inline UBool operator!=(const UVector32& other);
+ inline bool operator!=(const UVector32& other);
//------------------------------------------------------------
// java.util.Vector API
return elementAti(count-1);
}
-inline UBool UVector32::operator!=(const UVector32& other) {
+inline bool UVector32::operator!=(const UVector32& other) {
return !operator==(other);
}
}
-UBool UVector64::operator==(const UVector64& other) {
+bool UVector64::operator==(const UVector64& other) {
int32_t i;
if (count != other.count) return FALSE;
for (i=0; i<count; ++i) {
* equal if they are of the same size and all elements are equal,
* as compared using this object's comparer.
*/
- UBool operator==(const UVector64& other);
+ bool operator==(const UVector64& other);
/**
* Equivalent to !operator==()
*/
- inline UBool operator!=(const UVector64& other);
+ inline bool operator!=(const UVector64& other);
//------------------------------------------------------------
// subset of java.util.Vector API
return elementAti(count-1);
}
-inline UBool UVector64::operator!=(const UVector64& other) {
+inline bool UVector64::operator!=(const UVector64& other) {
return !operator==(other);
}
}
-UBool AlphabeticIndex::operator==(const AlphabeticIndex& /* other */) const {
+bool AlphabeticIndex::operator==(const AlphabeticIndex& /* other */) const {
return FALSE;
}
-UBool AlphabeticIndex::operator!=(const AlphabeticIndex& /* other */) const {
+bool AlphabeticIndex::operator!=(const AlphabeticIndex& /* other */) const {
return FALSE;
}
}
}
-UBool
+bool
Calendar::operator==(const Calendar& that) const
{
UErrorCode status = U_ZERO_ERROR;
}
// -------------------------------------
-UBool
+bool
ChoiceFormat::operator==(const Format& that) const
{
if (this == &that) return TRUE;
return firstHalf;
}
-UBool CollationElementIterator::operator!=(
+bool CollationElementIterator::operator!=(
const CollationElementIterator& other) const
{
return !(*this == other);
}
-UBool CollationElementIterator::operator==(
+bool CollationElementIterator::operator==(
const CollationElementIterator& that) const
{
if (this == &that) {
{
}
-UBool Collator::operator==(const Collator& other) const
+bool Collator::operator==(const Collator& other) const
{
// Subclasses: Call this method and then add more specific checks.
return typeid(*this) == typeid(other);
}
-UBool Collator::operator!=(const Collator& other) const
+bool Collator::operator!=(const Collator& other) const
{
- return (UBool)!(*this == other);
+ return !operator==(other);
}
int32_t U_EXPORT2 Collator::getBound(const uint8_t *source,
delete skipped;
}
-UBool
+bool
CollationIterator::operator==(const CollationIterator &other) const {
// Subclasses: Call this method and then add more specific checks.
// Compare the iterator state but not the collation data (trie & data fields):
virtual ~CollationIterator();
- virtual UBool operator==(const CollationIterator &other) const;
- inline UBool operator!=(const CollationIterator &other) const {
+ virtual bool operator==(const CollationIterator &other) const;
+ inline bool operator!=(const CollationIterator &other) const {
return !operator==(other);
}
}
}
-UBool
+bool
CollationSettings::operator==(const CollationSettings &other) const {
if(options != other.options) { return FALSE; }
if((options & ALTERNATE_MASK) != 0 && variableTop != other.variableTop) { return FALSE; }
CollationSettings(const CollationSettings &other);
virtual ~CollationSettings();
- UBool operator==(const CollationSettings &other) const;
+ bool operator==(const CollationSettings &other) const;
- inline UBool operator!=(const CollationSettings &other) const {
+ inline bool operator!=(const CollationSettings &other) const {
return !operator==(other);
}
fLocale = nullptr;
}
-UBool
+bool
CurrencyPluralInfo::operator==(const CurrencyPluralInfo& info) const {
#ifdef CURRENCY_PLURAL_INFO_DEBUG
if (*fPluralRules == *info.fPluralRules) {
virtual int32_t hashCode() const {
return (int32_t)(37u * (uint32_t)LocaleCacheKey<DateFmtBestPattern>::hashCode() + (uint32_t)fSkeleton.hashCode());
}
- virtual UBool operator==(const CacheKeyBase &other) const {
+ virtual bool operator==(const CacheKeyBase &other) const {
// reflexive
if (this == &other) {
return TRUE;
//----------------------------------------------------------------------
-UBool
+bool
DateFormat::operator==(const Format& other) const
{
// This protected comparison operator should only be called by subclasses
// -------------------------------------
-UBool
+bool
DecimalFormatSymbols::operator==(const DecimalFormatSymbols& that) const
{
if (this == &that) {
return nullptr;
}
-UBool DecimalFormat::operator==(const Format& other) const {
+bool DecimalFormat::operator==(const Format& other) const {
auto* otherDF = dynamic_cast<const DecimalFormat*>(&other);
if (otherDF == nullptr) {
return false;
return TRUE;
}
-UBool
+bool
DateFormatSymbols::operator==(const DateFormatSymbols& other) const
{
// First do cheap comparisons
}
-UBool
+bool
DateIntervalFormat::operator==(const Format& other) const {
if (typeid(*this) != typeid(other)) {return FALSE;}
const DateIntervalFormat* fmt = (DateIntervalFormat*)&other;
}
-UBool
+bool
DateIntervalInfo::operator==(const DateIntervalInfo& other) const {
UBool equal = (
fFallbackIntervalPattern == other.fFallbackIntervalPattern &&
}
-UBool
+bool
DateTimePatternGenerator::operator==(const DateTimePatternGenerator& other) const {
if (this == &other) {
return TRUE;
}
}
-UBool
+bool
DateTimePatternGenerator::operator!=(const DateTimePatternGenerator& other) const {
return !operator==(other);
}
UnicodeString& appendTo(UnicodeString& string) const;
UnicodeString& appendFieldTo(int32_t field, UnicodeString& string) const;
UChar getFirstChar() const;
- inline UBool operator==(const SkeletonFields& other) const;
- inline UBool operator!=(const SkeletonFields& other) const;
+ inline bool operator==(const SkeletonFields& other) const;
+ inline bool operator!=(const SkeletonFields& other) const;
private:
int8_t chars[UDATPG_FIELD_COUNT];
int8_t lengths[UDATPG_FIELD_COUNT];
};
-inline UBool SkeletonFields::operator==(const SkeletonFields& other) const {
+inline bool SkeletonFields::operator==(const SkeletonFields& other) const {
return (uprv_memcmp(chars, other.chars, sizeof(chars)) == 0
&& uprv_memcmp(lengths, other.lengths, sizeof(lengths)) == 0);
}
-inline UBool SkeletonFields::operator!=(const SkeletonFields& other) const {
+inline bool SkeletonFields::operator!=(const SkeletonFields& other) const {
return (! operator==(other));
}
return *this;
}
-UBool
+bool
DateTimeRule::operator==(const DateTimeRule& that) const {
return ((this == &that) ||
(typeid(*this) == typeid(that) &&
fTimeRuleType == that.fTimeRuleType));
}
-UBool
+bool
DateTimeRule::operator!=(const DateTimeRule& that) const {
return !operator==(that);
}
// -------------------------------------
-UBool
+bool
Formattable::operator==(const Formattable& that) const
{
int32_t i;
// -------------------------------------
-UBool
+bool
Format::operator==(const Format& that) const
{
// Subclasses: Call this method and then add more specific checks.
}
}
-UBool FieldPositionIterator::operator==(const FieldPositionIterator &rhs) const {
+bool FieldPositionIterator::operator==(const FieldPositionIterator &rhs) const {
if (&rhs == this) {
return TRUE;
}
delete listFormatter;
}
-UBool MeasureFormat::operator==(const Format &other) const {
+bool MeasureFormat::operator==(const Format &other) const {
if (this == &other) { // Same object, equal
return TRUE;
}
return fImpl ? fImpl->identifier.data() : gSubTypes[getOffset()];
}
-UBool MeasureUnit::operator==(const UObject& other) const {
+bool MeasureUnit::operator==(const UObject& other) const {
if (this == &other) { // Same object, equal
return TRUE;
}
delete unit;
}
-UBool Measure::operator==(const UObject& other) const {
+bool Measure::operator==(const UObject& other) const {
if (this == &other) { // Same object, equal
return TRUE;
}
return *this;
}
-UBool
+bool
MessageFormat::operator==(const Format& rhs) const
{
if (this == &rhs) return TRUE;
}
-UBool MessageFormat::DummyFormat::operator==(const Format&) const {
+bool MessageFormat::DummyFormat::operator==(const Format&) const {
return TRUE;
}
return FALSE;
}
-UBool
+bool
NFRuleSet::operator==(const NFRuleSet& rhs) const
{
if (rules.size() == rhs.rules.size() &&
~NFRuleSet();
- UBool operator==(const NFRuleSet& rhs) const;
- UBool operator!=(const NFRuleSet& rhs) const { return !operator==(rhs); }
+ bool operator==(const NFRuleSet& rhs) const;
+ bool operator!=(const NFRuleSet& rhs) const { return !operator==(rhs); }
UBool isPublic() const { return fIsPublic; }
* @param that The rule to compare this one against
* @return True is the two rules are functionally equivalent
*/
-UBool
+bool
NFRule::operator==(const NFRule& rhs) const
{
return baseValue == rhs.baseValue
NFRule(const RuleBasedNumberFormat* rbnf, const UnicodeString &ruleText, UErrorCode &status);
~NFRule();
- UBool operator==(const NFRule& rhs) const;
- UBool operator!=(const NFRule& rhs) const { return !operator==(rhs); }
+ bool operator==(const NFRule& rhs) const;
+ bool operator!=(const NFRule& rhs) const { return !operator==(rhs); }
ERuleType getType() const { return (ERuleType)(baseValue <= kNoBase ? (ERuleType)baseValue : kOtherRule); }
void setType(ERuleType ruleType) { baseValue = (int32_t)ruleType; }
}
}
- virtual UBool operator==(const NFSubstitution& rhs) const;
+ virtual bool operator==(const NFSubstitution& rhs) const;
virtual int64_t transformNumber(int64_t number) const {
return number / divisor;
}
}
- virtual UBool operator==(const NFSubstitution& rhs) const;
+ virtual bool operator==(const NFSubstitution& rhs) const;
virtual void doSubstitution(int64_t number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const;
virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const;
UErrorCode& status);
virtual ~FractionalPartSubstitution();
- virtual UBool operator==(const NFSubstitution& rhs) const;
+ virtual bool operator==(const NFSubstitution& rhs) const;
virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const;
virtual void doSubstitution(int64_t /*number*/, UnicodeString& /*toInsertInto*/, int32_t /*_pos*/, int32_t /*recursionCount*/, UErrorCode& /*status*/) const {}
}
virtual ~NumeratorSubstitution();
- virtual UBool operator==(const NFSubstitution& rhs) const;
+ virtual bool operator==(const NFSubstitution& rhs) const;
virtual int64_t transformNumber(int64_t number) const { return number * ldenominator; }
virtual double transformNumber(double number) const { return uprv_round(number * denominator); }
* @param The substitution to compare this one to
* @return true if the two substitutions are functionally equivalent
*/
-UBool
+bool
NFSubstitution::operator==(const NFSubstitution& rhs) const
{
// compare class and all of the fields all substitutions have
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(MultiplierSubstitution)
-UBool MultiplierSubstitution::operator==(const NFSubstitution& rhs) const
+bool MultiplierSubstitution::operator==(const NFSubstitution& rhs) const
{
return NFSubstitution::operator==(rhs) &&
divisor == ((const MultiplierSubstitution*)&rhs)->divisor;
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ModulusSubstitution)
-UBool ModulusSubstitution::operator==(const NFSubstitution& rhs) const
+bool ModulusSubstitution::operator==(const NFSubstitution& rhs) const
{
return NFSubstitution::operator==(rhs) &&
divisor == ((const ModulusSubstitution*)&rhs)->divisor &&
}
}
-UBool
+bool
FractionalPartSubstitution::operator==(const NFSubstitution& rhs) const
{
return NFSubstitution::operator==(rhs) &&
return TRUE;
}
-UBool
+bool
NumeratorSubstitution::operator==(const NFSubstitution& rhs) const
{
return NFSubstitution::operator==(rhs) &&
* @param rhs the object to be compared with.
* @return true if the given Format objects are semantically equal.
*/
- virtual UBool operator==(const NFSubstitution& rhs) const;
+ virtual bool operator==(const NFSubstitution& rhs) const;
/**
* Return true if the given Format objects are semantically unequal.
* @param rhs the object to be compared with.
* @return true if the given Format objects are semantically unequal.
*/
- UBool operator!=(const NFSubstitution& rhs) const { return !operator==(rhs); }
+ bool operator!=(const NFSubstitution& rhs) const { return !operator==(rhs); }
/**
* Sets the substitution's divisor. Used by NFRule.setBaseValue().
LocalizedNumberFormatterAsFormat::~LocalizedNumberFormatterAsFormat() = default;
-UBool LocalizedNumberFormatterAsFormat::operator==(const Format& other) const {
+bool LocalizedNumberFormatterAsFormat::operator==(const Format& other) const {
auto* _other = dynamic_cast<const LocalizedNumberFormatterAsFormat*>(&other);
if (_other == nullptr) {
return false;
/**
* Equals operator.
*/
- UBool operator==(const Format& other) const U_OVERRIDE;
+ bool operator==(const Format& other) const U_OVERRIDE;
/**
* Creates a copy of this object.
// -------------------------------------
-UBool
+bool
NumberFormat::operator==(const Format& that) const
{
// Format::operator== guarantees this cast is safe
/**
* Returns true if the two TimeZone objects are equal.
*/
-UBool OlsonTimeZone::operator==(const TimeZone& other) const {
+bool OlsonTimeZone::operator==(const TimeZone& other) const {
return ((this == &other) ||
(typeid(*this) == typeid(other) &&
TimeZone::operator==(other) &&
/**
* Returns true if the two TimeZone objects are equal.
*/
- virtual UBool operator==(const TimeZone& other) const;
+ virtual bool operator==(const TimeZone& other) const;
/**
* TimeZone API.
return *this;
}
-UBool
+bool
PluralFormat::operator==(const Format& other) const {
if (this == &other) {
return TRUE;
*pluralRulesWrapper.pluralRules == *o.pluralRulesWrapper.pluralRules);
}
-UBool
+bool
PluralFormat::operator!=(const Format& other) const {
return !operator==(other);
}
return UnicodeString(TRUE, PLURAL_KEYWORD_OTHER, 5);
}
-UBool
+bool
PluralRules::operator==(const PluralRules& other) const {
const UnicodeString *ptrKeyword;
UErrorCode status= U_ZERO_ERROR;
return NULL;
}
- virtual UBool operator==(const LocalizationInfo* rhs) const;
- inline UBool operator!=(const LocalizationInfo* rhs) const { return !operator==(rhs); }
+ virtual bool operator==(const LocalizationInfo* rhs) const;
+ inline bool operator!=(const LocalizationInfo* rhs) const { return !operator==(rhs); }
virtual int32_t getNumberOfRuleSets(void) const = 0;
virtual const UChar* getRuleSetName(int32_t index) const = 0;
return FALSE;
}
-UBool
+bool
LocalizationInfo::operator==(const LocalizationInfo* rhs) const {
if (rhs) {
if (this == rhs) {
return new RuleBasedNumberFormat(*this);
}
-UBool
+bool
RuleBasedNumberFormat::operator==(const Format& other) const
{
if (this == &other) {
return *this;
}
-UBool
+bool
RuleBasedTimeZone::operator==(const TimeZone& that) const {
if (this == &that) {
return TRUE;
return FALSE;
}
-UBool
+bool
RuleBasedTimeZone::operator!=(const TimeZone& that) const {
return !operator==(that);
}
* Returns true if the two regions are equal.
* Per PMC, just use pointer compare, since we have at most one instance of each Region.
*/
-UBool
+bool
Region::operator==(const Region &that) const {
return (idStr == that.idStr);
}
* Returns true if the two regions are NOT equal; that is, if operator ==() returns false.
* Per PMC, just use pointer compare, since we have at most one instance of each Region.
*/
-UBool
+bool
Region::operator!=(const Region &that) const {
return (idStr != that.idStr);
}
return new RelativeDateFormat(*this);
}
-UBool RelativeDateFormat::operator==(const Format& other) const {
+bool RelativeDateFormat::operator==(const Format& other) const {
if(DateFormat::operator==(other)) {
// The DateFormat::operator== check for fCapitalizationContext equality above
// is sufficient to check equality of all derived context-related data.
* @return true if the given Format objects are semantically equal.
* @internal ICU 3.8
*/
- virtual UBool operator==(const Format& other) const;
+ virtual bool operator==(const Format& other) const;
using DateFormat::format;
// characters can still be considered different.
//
//--------------------------------------------------------------------------
-UBool RegexPattern::operator ==(const RegexPattern &other) const {
+bool RegexPattern::operator ==(const RegexPattern &other) const {
if (this->fFlags == other.fFlags && this->fDeferredStatus == other.fDeferredStatus) {
if (this->fPatternString != NULL && other.fPatternString != NULL) {
return *(this->fPatternString) == *(other.fPatternString);
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(RuleBasedCollator)
-UBool
+bool
RuleBasedCollator::operator==(const Collator& other) const {
if(this == &other) { return TRUE; }
if(!Collator::operator==(other)) { return FALSE; }
return *this;
}
-UBool ScriptSet::operator == (const ScriptSet &other) const {
+bool ScriptSet::operator == (const ScriptSet &other) const {
for (uint32_t i=0; i<UPRV_LENGTHOF(bits); i++) {
if (bits[i] != other.bits[i]) {
return FALSE;
ScriptSet(const ScriptSet &other);
~ScriptSet();
- UBool operator == (const ScriptSet &other) const;
- UBool operator != (const ScriptSet &other) const {return !(*this == other);}
+ bool operator == (const ScriptSet &other) const;
+ bool operator != (const ScriptSet &other) const {return !(*this == other);}
ScriptSet & operator = (const ScriptSet &other);
UBool test(UScriptCode script, UErrorCode &status) const;
// operator overloading ----------------------------------------------
-UBool SearchIterator::operator==(const SearchIterator &that) const
+bool SearchIterator::operator==(const SearchIterator &that) const
{
if (this == &that) {
return TRUE;
return *this;
}
-UBool
+bool
SelectFormat::operator==(const Format& other) const {
if (this == &other) {
return TRUE;
return msgPattern == o.msgPattern;
}
-UBool
+bool
SelectFormat::operator!=(const Format& other) const {
return !operator==(other);
}
// -------------------------------------
-UBool
+bool
SimpleTimeZone::operator==(const TimeZone& that) const
{
return ((this == &that) ||
//----------------------------------------------------------------------
-UBool
+bool
SimpleDateFormat::operator==(const Format& other) const
{
if (DateFormat::operator==(other)) {
return *this;
}
-UBool
+bool
CollationKey::operator==(const CollationKey& source) const
{
return getLength() == source.getLength() &&
return *this;
}
-UBool StringSearch::operator==(const SearchIterator &that) const
+bool StringSearch::operator==(const SearchIterator &that) const
{
if (this == &that) {
return TRUE;
// -------------------------------------
-UBool
+bool
TimeZone::operator==(const TimeZone& that) const
{
return typeid(*this) == typeid(that) &&
}
-UBool
+bool
TimeUnitAmount::operator==(const UObject& other) const {
return Measure::operator==(other);
}
}
-UBool
+bool
TimeZoneFormat::operator==(const Format& other) const {
TimeZoneFormat* tzfmt = (TimeZoneFormat*)&other;
return instance;
}
-UBool
+bool
TimeZoneGenericNames::operator==(const TimeZoneGenericNames& other) const {
// Just compare if the other object also use the same
// ref entry
static TimeZoneGenericNames* createInstance(const Locale& locale, UErrorCode& status);
- virtual UBool operator==(const TimeZoneGenericNames& other) const;
- virtual UBool operator!=(const TimeZoneGenericNames& other) const {return !operator==(other);}
+ virtual bool operator==(const TimeZoneGenericNames& other) const;
+ virtual bool operator!=(const TimeZoneGenericNames& other) const {return !operator==(other);}
virtual TimeZoneGenericNames* clone() const;
UnicodeString& getDisplayName(const TimeZone& tz, UTimeZoneGenericNameType type,
TimeZoneNamesDelegate(const Locale& locale, UErrorCode& status);
virtual ~TimeZoneNamesDelegate();
- virtual UBool operator==(const TimeZoneNames& other) const;
- virtual UBool operator!=(const TimeZoneNames& other) const {return !operator==(other);}
+ virtual bool operator==(const TimeZoneNames& other) const;
+ virtual bool operator!=(const TimeZoneNames& other) const {return !operator==(other);}
virtual TimeZoneNamesDelegate* clone() const;
StringEnumeration* getAvailableMetaZoneIDs(UErrorCode& status) const;
umtx_unlock(&gTimeZoneNamesLock);
}
-UBool
+bool
TimeZoneNamesDelegate::operator==(const TimeZoneNames& other) const {
if (this == &other) {
return TRUE;
}
}
-UBool
+bool
TimeZoneNamesImpl::operator==(const TimeZoneNames& other) const {
if (this == &other) {
return TRUE;
TZDBTimeZoneNames::~TZDBTimeZoneNames() {
}
-UBool
+bool
TZDBTimeZoneNames::operator==(const TimeZoneNames& other) const {
if (this == &other) {
return TRUE;
virtual ~TimeZoneNamesImpl();
- virtual UBool operator==(const TimeZoneNames& other) const;
+ virtual bool operator==(const TimeZoneNames& other) const;
virtual TimeZoneNamesImpl* clone() const;
StringEnumeration* getAvailableMetaZoneIDs(UErrorCode& status) const;
TZDBTimeZoneNames(const Locale& locale);
virtual ~TZDBTimeZoneNames();
- virtual UBool operator==(const TimeZoneNames& other) const;
+ virtual bool operator==(const TimeZoneNames& other) const;
virtual TZDBTimeZoneNames* clone() const;
StringEnumeration* getAvailableMetaZoneIDs(UErrorCode& status) const;
return *this;
}
-UBool
+bool
TimeZoneRule::operator==(const TimeZoneRule& that) const {
return ((this == &that) ||
(typeid(*this) == typeid(that) &&
fDSTSavings == that.fDSTSavings));
}
-UBool
+bool
TimeZoneRule::operator!=(const TimeZoneRule& that) const {
return !operator==(that);
}
return *this;
}
-UBool
+bool
InitialTimeZoneRule::operator==(const TimeZoneRule& that) const {
return ((this == &that) ||
(typeid(*this) == typeid(that) &&
TimeZoneRule::operator==(that)));
}
-UBool
+bool
InitialTimeZoneRule::operator!=(const TimeZoneRule& that) const {
return !operator==(that);
}
return *this;
}
-UBool
+bool
AnnualTimeZoneRule::operator==(const TimeZoneRule& that) const {
if (this == &that) {
return TRUE;
fEndYear == atzr->fEndYear);
}
-UBool
+bool
AnnualTimeZoneRule::operator!=(const TimeZoneRule& that) const {
return !operator==(that);
}
return *this;
}
-UBool
+bool
TimeArrayTimeZoneRule::operator==(const TimeZoneRule& that) const {
if (this == &that) {
return TRUE;
return res;
}
-UBool
+bool
TimeArrayTimeZoneRule::operator!=(const TimeZoneRule& that) const {
return !operator==(that);
}
return *this;
}
-UBool
+bool
TimeZoneTransition::operator==(const TimeZoneTransition& that) const {
if (this == &that) {
return TRUE;
return FALSE;
}
-UBool
+bool
TimeZoneTransition::operator!=(const TimeZoneTransition& that) const {
return !operator==(that);
}
* No Equality operators.
* @internal
*/
- virtual UBool operator==(const AlphabeticIndex& other) const;
+ virtual bool operator==(const AlphabeticIndex& other) const;
/**
* Inequality operator.
* @internal
*/
- virtual UBool operator!=(const AlphabeticIndex& other) const;
+ virtual bool operator!=(const AlphabeticIndex& other) const;
// Common initialization, for use from all constructors.
void init(const Locale *locale, UErrorCode &status);
* represented time, use equals() instead.
*
* @param that The Calendar object to be compared with.
- * @return True if the given Calendar is the same as this Calendar; false
+ * @return true if the given Calendar is the same as this Calendar; false
* otherwise.
* @stable ICU 2.0
*/
- virtual UBool operator==(const Calendar& that) const;
+ virtual bool operator==(const Calendar& that) const;
/**
* Compares the inequality of two Calendar objects.
*
* @param that The Calendar object to be compared with.
- * @return True if the given Calendar is not the same as this Calendar; false
+ * @return true if the given Calendar is not the same as this Calendar; false
* otherwise.
* @stable ICU 2.0
*/
- UBool operator!=(const Calendar& that) const {return !operator==(that);}
+ bool operator!=(const Calendar& that) const {return !operator==(that);}
/**
* Returns true if the given Calendar object is equivalent to this
* @return true if other is the same as this.
* @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
*/
- virtual UBool operator==(const Format& other) const;
+ virtual bool operator==(const Format& other) const;
/**
* Sets the pattern.
* @return true if "other" is the same as "this"
* @stable ICU 2.0
*/
- UBool operator==(const CollationElementIterator& other) const;
+ bool operator==(const CollationElementIterator& other) const;
/**
* Returns true if "other" is not the same as "this".
* @return true if "other" is not the same as "this"
* @stable ICU 2.0
*/
- UBool operator!=(const CollationElementIterator& other) const;
+ bool operator!=(const CollationElementIterator& other) const;
/**
* Resets the cursor to the beginning of the string.
* @return true if other is the same as this.
* @stable ICU 2.0
*/
- virtual UBool operator==(const Collator& other) const;
+ virtual bool operator==(const Collator& other) const;
/**
* Returns true if "other" is not the same as "this".
* @return true if other is not the same as this.
* @stable ICU 2.0
*/
- virtual UBool operator!=(const Collator& other) const;
+ virtual bool operator!=(const Collator& other) const;
/**
* Makes a copy of this object.
*
* @stable ICU 4.2
*/
- UBool operator==(const CurrencyPluralInfo& info) const;
+ bool operator==(const CurrencyPluralInfo& info) const;
/**
*
* @stable ICU 4.2
*/
- UBool operator!=(const CurrencyPluralInfo& info) const;
+ bool operator!=(const CurrencyPluralInfo& info) const;
/**
};
-inline UBool
+inline bool
CurrencyPluralInfo::operator!=(const CurrencyPluralInfo& info) const {
return !operator==(info);
}
* Equality operator. Returns true if the two formats have the same behavior.
* @stable ICU 2.0
*/
- virtual UBool operator==(const Format&) const;
+ virtual bool operator==(const Format&) const;
using Format::format;
* @return true if another object is semantically equal to this one.
* @stable ICU 2.0
*/
- UBool operator==(const DecimalFormatSymbols& other) const;
+ bool operator==(const DecimalFormatSymbols& other) const;
/**
* Return true if another object is semantically unequal to this one.
* @return true if another object is semantically unequal to this one.
* @stable ICU 2.0
*/
- UBool operator!=(const DecimalFormatSymbols& other) const { return !operator==(other); }
+ bool operator!=(const DecimalFormatSymbols& other) const { return !operator==(other); }
/**
* Get one of the format symbols by its enum constant.
* @return true if the given Format objects are semantically equal.
* @stable ICU 2.0
*/
- UBool operator==(const Format& other) const U_OVERRIDE;
+ bool operator==(const Format& other) const U_OVERRIDE;
using NumberFormat::format;
* @return true if other is semantically equal to this.
* @stable ICU 2.0
*/
- UBool operator==(const DateFormatSymbols& other) const;
+ bool operator==(const DateFormatSymbols& other) const;
/**
* Return true if another object is semantically unequal to this one.
* @return true if other is semantically unequal to this.
* @stable ICU 2.0
*/
- UBool operator!=(const DateFormatSymbols& other) const { return !operator==(other); }
+ bool operator!=(const DateFormatSymbols& other) const { return !operator==(other); }
/**
* Gets abbreviated era strings. For example: "AD" and "BC".
* @return true if the given Format objects are semantically equal.
* @stable ICU 4.0
*/
- virtual UBool operator==(const Format& other) const;
+ virtual bool operator==(const Format& other) const;
/**
* Return true if the given Format objects are not semantically equal.
* @return true if the given Format objects are not semantically equal.
* @stable ICU 4.0
*/
- UBool operator!=(const Format& other) const;
+ bool operator!=(const Format& other) const;
using Format::format;
UDisplayContext fCapitalizationContext;
};
-inline UBool
+inline bool
DateIntervalFormat::operator!=(const Format& other) const {
return !operator==(other);
}
* @return true if other is semantically equal to this.
* @stable ICU 4.0
*/
- virtual UBool operator==(const DateIntervalInfo& other) const;
+ virtual bool operator==(const DateIntervalInfo& other) const;
/**
* Return true if another object is semantically unequal to this one.
* @return true if other is semantically unequal to this.
* @stable ICU 4.0
*/
- UBool operator!=(const DateIntervalInfo& other) const;
+ bool operator!=(const DateIntervalInfo& other) const;
};// end class DateIntervalInfo
-inline UBool
+inline bool
DateIntervalInfo::operator!=(const DateIntervalInfo& other) const {
return !operator==(other);
}
* @return true if other is semantically equal to this.
* @stable ICU 3.8
*/
- UBool operator==(const DateTimePatternGenerator& other) const;
+ bool operator==(const DateTimePatternGenerator& other) const;
/**
* Return true if another object is semantically unequal to this one.
* @return true if other is semantically unequal to this.
* @stable ICU 3.8
*/
- UBool operator!=(const DateTimePatternGenerator& other) const;
+ bool operator!=(const DateTimePatternGenerator& other) const;
/**
* Utility to return a unique skeleton from a given pattern. For example,
* @return true if the given DateTimeRule objects are semantically equal.
* @stable ICU 3.8
*/
- UBool operator==(const DateTimeRule& that) const;
+ bool operator==(const DateTimeRule& that) const;
/**
* Return true if the given DateTimeRule objects are semantically unequal. Objects
* @return true if the given DateTimeRule objects are semantically unequal.
* @stable ICU 3.8
*/
- UBool operator!=(const DateTimeRule& that) const;
+ bool operator!=(const DateTimeRule& that) const;
/**
* Gets the date rule type, such as <code>DOM</code>
* @return true if the two field positions are equal, false otherwise.
* @stable ICU 2.0
*/
- UBool operator==(const FieldPosition& that) const;
+ bool operator==(const FieldPosition& that) const;
/**
* Equality operator.
* @return true if the two field positions are not equal, false otherwise.
* @stable ICU 2.0
*/
- UBool operator!=(const FieldPosition& that) const;
+ bool operator!=(const FieldPosition& that) const;
/**
* Clone this object.
return *this;
}
-inline UBool
+inline bool
FieldPosition::operator==(const FieldPosition& copy) const
{
return (fField == copy.fField &&
fBeginIndex == copy.fBeginIndex);
}
-inline UBool
+inline bool
FieldPosition::operator!=(const FieldPosition& copy) const
{
return !operator==(copy);
* @return true if other are equal to this, false otherwise.
* @stable ICU 2.0
*/
- UBool operator==(const Formattable &other) const;
+ bool operator==(const Formattable &other) const;
/**
* Equality operator.
* @return true if other are unequal to this, false otherwise.
* @stable ICU 2.0
*/
- UBool operator!=(const Formattable& other) const
+ bool operator!=(const Formattable& other) const
{ return !operator==(other); }
/**
* Objects of different subclasses are considered unequal.
* @stable ICU 2.0
*/
- virtual UBool operator==(const Format& other) const = 0;
+ virtual bool operator==(const Format& other) const = 0;
/**
* Return true if the given Format objects are not semantically
* @return Return true if the given Format objects are not semantically.
* @stable ICU 2.0
*/
- UBool operator!=(const Format& other) const { return !operator==(other); }
+ bool operator!=(const Format& other) const { return !operator==(other); }
/**
* Clone this object polymorphically. The caller is responsible
* equal array of run values.
* @stable ICU 4.4
*/
- UBool operator==(const FieldPositionIterator&) const;
+ bool operator==(const FieldPositionIterator&) const;
/**
* Returns the complement of the result of operator==
* @return the complement of the result of operator==
* @stable ICU 4.4
*/
- UBool operator!=(const FieldPositionIterator& rhs) const { return !operator==(rhs); }
+ bool operator!=(const FieldPositionIterator& rhs) const { return !operator==(rhs); }
/**
* If the current position is valid, updates the FieldPosition values, advances the iterator,
* Return true if given Format objects are semantically equal.
* @stable ICU 53
*/
- virtual UBool operator==(const Format &other) const;
+ virtual bool operator==(const Format &other) const;
/**
* Clones this object polymorphically.
* to the given object.
* @stable ICU 3.0
*/
- virtual UBool operator==(const UObject& other) const;
+ virtual bool operator==(const UObject& other) const;
/**
* Inequality operator. Return true if this object is not equal
* to the given object.
* @stable ICU 53
*/
- UBool operator!=(const UObject& other) const {
+ bool operator!=(const UObject& other) const {
return !(*this == other);
}
* to the given object.
* @stable ICU 3.0
*/
- UBool operator==(const UObject& other) const;
+ bool operator==(const UObject& other) const;
/**
* Return a reference to the numeric value of this object. The
* @return true if the given Format objects are semantically equal.
* @stable ICU 2.0
*/
- virtual UBool operator==(const Format& other) const;
+ virtual bool operator==(const Format& other) const;
/**
* Sets the locale to be used for creating argument Format objects.
*/
class U_I18N_API DummyFormat : public Format {
public:
- virtual UBool operator==(const Format&) const;
+ virtual bool operator==(const Format&) const;
virtual DummyFormat* clone() const;
virtual UnicodeString& format(const Formattable& obj,
UnicodeString& appendTo,
* @return true if the given Format objects are semantically equal.
* @stable ICU 2.0
*/
- virtual UBool operator==(const Format& other) const;
+ virtual bool operator==(const Format& other) const;
using Format::format;
* @return true if other is semantically equal to this.
* @stable ICU 4.0
*/
- virtual UBool operator==(const Format& other) const;
+ virtual bool operator==(const Format& other) const;
/**
* Return true if another object is semantically unequal to this one.
* @return true if other is semantically unequal to this.
* @stable ICU 4.0
*/
- virtual UBool operator!=(const Format& other) const;
+ virtual bool operator!=(const Format& other) const;
/**
* Clones this Format object polymorphically. The caller owns the
* Compares the equality of two PluralRules objects.
*
* @param other The other PluralRules object to be compared with.
- * @return True if the given PluralRules is the same as this
+ * @return true if the given PluralRules is the same as this
* PluralRules; false otherwise.
* @stable ICU 4.0
*/
- virtual UBool operator==(const PluralRules& other) const;
+ virtual bool operator==(const PluralRules& other) const;
/**
* Compares the inequality of two PluralRules objects.
*
* @param other The PluralRules object to be compared with.
- * @return True if the given PluralRules is not the same as this
+ * @return true if the given PluralRules is not the same as this
* PluralRules; false otherwise.
* @stable ICU 4.0
*/
- UBool operator!=(const PluralRules& other) const {return !operator==(other);}
+ bool operator!=(const PluralRules& other) const {return !operator==(other);}
/**
* @return true if the given Format objects are semantically equal.
* @stable ICU 2.6
*/
- virtual UBool operator==(const Format& other) const;
+ virtual bool operator==(const Format& other) const;
//-----------------------------------------------------------------------
// public API functions
*semantically equal.
* @stable ICU 3.8
*/
- virtual UBool operator==(const TimeZone& that) const;
+ virtual bool operator==(const TimeZone& that) const;
/**
* Return true if the given <code>TimeZone</code> objects are
* semantically unequal.
* @stable ICU 3.8
*/
- virtual UBool operator!=(const TimeZone& that) const;
+ virtual bool operator!=(const TimeZone& that) const;
/**
* Adds the <code>TimeZoneRule</code> which represents time transitions.
* @return true if the objects are equivalent.
* @stable ICU 2.4
*/
- UBool operator==(const RegexPattern& that) const;
+ bool operator==(const RegexPattern& that) const;
/**
* Comparison operator. Two RegexPattern objects are considered equal if they
* @return true if the objects are different.
* @stable ICU 2.4
*/
- inline UBool operator!=(const RegexPattern& that) const {return ! operator ==(that);}
+ inline bool operator!=(const RegexPattern& that) const {return ! operator ==(that);}
/**
* Assignment operator. After assignment, this RegexPattern will behave identically
* Returns true if the two regions are equal.
* @stable ICU 51
*/
- UBool operator==(const Region &that) const;
+ bool operator==(const Region &that) const;
/**
* Returns true if the two regions are NOT equal; that is, if operator ==() returns false.
* @stable ICU 51
*/
- UBool operator!=(const Region &that) const;
+ bool operator!=(const Region &that) const;
/**
* Returns a pointer to a Region using the given region code. The region code can be either 2-letter ISO code,
* attributes. false otherwise.
* @stable ICU 2.0
*/
- virtual UBool operator==(const SearchIterator &that) const;
+ virtual bool operator==(const SearchIterator &that) const;
/**
* Not-equal operator.
* @return false if operator== returns true, and vice versa.
* @stable ICU 2.0
*/
- UBool operator!=(const SearchIterator &that) const;
+ bool operator!=(const SearchIterator &that) const;
// public methods ----------------------------------------------------
void setMatchNotFound();
};
-inline UBool SearchIterator::operator!=(const SearchIterator &that) const
+inline bool SearchIterator::operator!=(const SearchIterator &that) const
{
return !operator==(that);
}
* @return true if other is semantically equal to this.
* @stable ICU 4.4
*/
- virtual UBool operator==(const Format& other) const;
+ virtual bool operator==(const Format& other) const;
/**
* Return true if another object is semantically unequal to this one.
* @return true if other is semantically unequal to this.
* @stable ICU 4.4
*/
- virtual UBool operator!=(const Format& other) const;
+ virtual bool operator!=(const Format& other) const;
/**
* Clones this Format object polymorphically. The caller owns the
* the same ID, raw GMT offset, and DST rules.
*
* @param that The SimpleTimeZone object to be compared with.
- * @return True if the given time zone is equal to this time zone; false
+ * @return true if the given time zone is equal to this time zone; false
* otherwise.
* @stable ICU 2.0
*/
- virtual UBool operator==(const TimeZone& that) const;
+ virtual bool operator==(const TimeZone& that) const;
/**
* Constructs a SimpleTimeZone with the given raw GMT offset and time zone ID,
* @return true if the given Format objects are semantically equal.
* @stable ICU 2.0
*/
- virtual UBool operator==(const Format& other) const;
+ virtual bool operator==(const Format& other) const;
using DateFormat::format;
* @return Returns true if two collation keys are equal, false otherwise.
* @stable ICU 2.0
*/
- UBool operator==(const CollationKey& source) const;
+ bool operator==(const CollationKey& source) const;
/**
* Compare if two collation keys are not the same.
* @return Returns true if two collation keys are different, false otherwise.
* @stable ICU 2.0
*/
- UBool operator!=(const CollationKey& source) const;
+ bool operator!=(const CollationKey& source) const;
/**
} fUnion;
};
-inline UBool
+inline bool
CollationKey::operator!=(const CollationKey& other) const
{
return !(*this == other);
* while looking for the same pattern.
* @stable ICU 2.0
*/
- virtual UBool operator==(const SearchIterator &that) const;
+ virtual bool operator==(const SearchIterator &that) const;
// public get and set methods ----------------------------------------
* @return true if arguments is the same as this object.
* @stable ICU 2.0
*/
- virtual UBool operator==(const Collator& other) const;
+ virtual bool operator==(const Collator& other) const;
/**
* Makes a copy of this object.
* IDs, but subclasses are expected to also compare the fields they add.)
*
* @param that The TimeZone object to be compared with.
- * @return True if the given TimeZone is equal to this TimeZone; false
+ * @return true if the given TimeZone is equal to this TimeZone; false
* otherwise.
* @stable ICU 2.0
*/
- virtual UBool operator==(const TimeZone& that) const;
+ virtual bool operator==(const TimeZone& that) const;
/**
* Returns true if the two TimeZones are NOT equal; that is, if operator==() returns
* false.
*
* @param that The TimeZone object to be compared with.
- * @return True if the given TimeZone is not equal to this TimeZone; false
+ * @return true if the given TimeZone is not equal to this TimeZone; false
* otherwise.
* @stable ICU 2.0
*/
- UBool operator!=(const TimeZone& that) const {return !operator==(that);}
+ bool operator!=(const TimeZone& that) const {return !operator==(that);}
/**
* Returns the TimeZone's adjusted GMT offset (i.e., the number of milliseconds to add
* @return true if this object is equal to the given object.
* @stable ICU 4.2
*/
- virtual UBool operator==(const UObject& other) const;
+ virtual bool operator==(const UObject& other) const;
/**
* @return true if this object is not equal to the given object.
* @stable ICU 4.2
*/
- UBool operator!=(const UObject& other) const;
+ bool operator!=(const UObject& other) const;
/**
-inline UBool
+inline bool
TimeUnitAmount::operator!=(const UObject& other) const {
return !operator==(other);
}
* @return true if the given Format objects are not semantically equal.
* @deprecated ICU 53
*/
- UBool operator!=(const Format& other) const;
+ bool operator!=(const Format& other) const;
/**
* Set the locale used for formatting or parsing.
friend struct TimeUnitFormatReadSink;
};
-inline UBool
+inline bool
TimeUnitFormat::operator!=(const Format& other) const {
return !operator==(other);
}
* Objects of different subclasses are considered unequal.
* @stable ICU 50
*/
- virtual UBool operator==(const Format& other) const;
+ virtual bool operator==(const Format& other) const;
/**
* Clone this object polymorphically. The caller is responsible
* @return Return true if the given Format objects are semantically equal.
* @stable ICU 50
*/
- virtual UBool operator==(const TimeZoneNames& other) const = 0;
+ virtual bool operator==(const TimeZoneNames& other) const = 0;
/**
* Return true if the given TimeZoneNames objects are not semantically
* @return Return true if the given Format objects are not semantically equal.
* @stable ICU 50
*/
- UBool operator!=(const TimeZoneNames& other) const { return !operator==(other); }
+ bool operator!=(const TimeZoneNames& other) const { return !operator==(other); }
/**
* Clone this object polymorphically. The caller is responsible
* @return true if the given <code>TimeZoneRule</code> objects are semantically equal.
* @stable ICU 3.8
*/
- virtual UBool operator==(const TimeZoneRule& that) const;
+ virtual bool operator==(const TimeZoneRule& that) const;
/**
* Return true if the given <code>TimeZoneRule</code> objects are semantically unequal. Objects
* @return true if the given <code>TimeZoneRule</code> objects are semantically unequal.
* @stable ICU 3.8
*/
- virtual UBool operator!=(const TimeZoneRule& that) const;
+ virtual bool operator!=(const TimeZoneRule& that) const;
/**
* Fills in "name" with the name of this time zone.
* @return true if the given <code>TimeZoneRule</code> objects are semantically equal.
* @stable ICU 3.8
*/
- virtual UBool operator==(const TimeZoneRule& that) const;
+ virtual bool operator==(const TimeZoneRule& that) const;
/**
* Return true if the given <code>TimeZoneRule</code> objects are semantically unequal. Objects
* @return true if the given <code>TimeZoneRule</code> objects are semantically unequal.
* @stable ICU 3.8
*/
- virtual UBool operator!=(const TimeZoneRule& that) const;
+ virtual bool operator!=(const TimeZoneRule& that) const;
/**
* Gets the time when this rule takes effect in the given year.
* @return true if the given <code>TimeZoneRule</code> objects are semantically equal.
* @stable ICU 3.8
*/
- virtual UBool operator==(const TimeZoneRule& that) const;
+ virtual bool operator==(const TimeZoneRule& that) const;
/**
* Return true if the given <code>TimeZoneRule</code> objects are semantically unequal. Objects
* @return true if the given <code>TimeZoneRule</code> objects are semantically unequal.
* @stable ICU 3.8
*/
- virtual UBool operator!=(const TimeZoneRule& that) const;
+ virtual bool operator!=(const TimeZoneRule& that) const;
/**
* Gets the start date/time rule used by this rule.
* @return true if the given <code>TimeZoneRule</code> objects are semantically equal.
* @stable ICU 3.8
*/
- virtual UBool operator==(const TimeZoneRule& that) const;
+ virtual bool operator==(const TimeZoneRule& that) const;
/**
* Return true if the given <code>TimeZoneRule</code> objects are semantically unequal. Objects
* @return true if the given <code>TimeZoneRule</code> objects are semantically unequal.
* @stable ICU 3.8
*/
- virtual UBool operator!=(const TimeZoneRule& that) const;
+ virtual bool operator!=(const TimeZoneRule& that) const;
/**
* Gets the time type of the start times used by this rule. The return value
* @return true if the given TimeZoneTransition objects are semantically equal.
* @stable ICU 3.8
*/
- UBool operator==(const TimeZoneTransition& that) const;
+ bool operator==(const TimeZoneTransition& that) const;
/**
* Return true if the given TimeZoneTransition objects are semantically unequal. Objects
* @return true if the given TimeZoneTransition objects are semantically unequal.
* @stable ICU 3.8
*/
- UBool operator!=(const TimeZoneTransition& that) const;
+ bool operator!=(const TimeZoneTransition& that) const;
/**
* Returns the time of transition in milliseconds.
*semantically equal.
* @stable ICU 3.8
*/
- virtual UBool operator==(const TimeZone& that) const;
+ virtual bool operator==(const TimeZone& that) const;
/**
* Return true if the given <code>TimeZone</code> objects are
* semantically unequal.
* @stable ICU 3.8
*/
- virtual UBool operator!=(const TimeZone& that) const;
+ virtual bool operator!=(const TimeZone& that) const;
/**
* Create a <code>VTimeZone</code> instance by the time zone ID.
UTF16CollationIterator::~UTF16CollationIterator() {}
-UBool
+bool
UTF16CollationIterator::operator==(const CollationIterator &other) const {
if(!CollationIterator::operator==(other)) { return FALSE; }
const UTF16CollationIterator &o = static_cast<const UTF16CollationIterator &>(other);
FCDUTF16CollationIterator::~FCDUTF16CollationIterator() {}
-UBool
+bool
FCDUTF16CollationIterator::operator==(const CollationIterator &other) const {
// Skip the UTF16CollationIterator and call its parent.
if(!CollationIterator::operator==(other)) { return FALSE; }
virtual ~UTF16CollationIterator();
- virtual UBool operator==(const CollationIterator &other) const;
+ virtual bool operator==(const CollationIterator &other) const;
virtual void resetToOffset(int32_t newOffset);
virtual ~FCDUTF16CollationIterator();
- virtual UBool operator==(const CollationIterator &other) const;
+ virtual bool operator==(const CollationIterator &other) const;
virtual void resetToOffset(int32_t newOffset);
return *this;
}
-UBool
+bool
VTimeZone::operator==(const TimeZone& that) const {
if (this == &that) {
return TRUE;
return FALSE;
}
-UBool
+bool
VTimeZone::operator!=(const TimeZone& that) const {
return !operator==(that);
}
virtual int32_t getSortKey(const UChar*source, int32_t sourceLength,
uint8_t*result, int32_t resultLength) const;
virtual UnicodeSet *getTailoredSet(UErrorCode &status) const;
- virtual UBool operator==(const Collator& other) const;
+ virtual bool operator==(const Collator& other) const;
// Collator::operator!= calls !Collator::operator== which works for all subclasses.
virtual void setLocales(const Locale& requestedLocale, const Locale& validLocale, const Locale& actualLocale);
TestCollator() : Collator() {}
UNormalizationMode decompositionMode) : Collator(collationStrength, decompositionMode) {}
};
-inline UBool TestCollator::operator==(const Collator& other) const {
+inline bool TestCollator::operator==(const Collator& other) const {
// TestCollator has no fields, so we test for identity.
return this == &other;
CalFields(const Calendar& cal, UErrorCode& status);
void setTo(Calendar& cal) const;
char* toString(char* buf, int32_t len) const;
- UBool operator==(const CalFields& rhs) const;
- UBool operator!=(const CalFields& rhs) const;
+ bool operator==(const CalFields& rhs) const;
+ bool operator!=(const CalFields& rhs) const;
UBool isEquivalentTo(const Calendar& cal, UErrorCode& status) const;
private:
return buf;
}
-UBool
+bool
CalFields::operator==(const CalFields& rhs) const {
return year == rhs.year
&& month == rhs.month
&& ms == rhs.ms;
}
-UBool
+bool
CalFields::operator!=(const CalFields& rhs) const {
return !(*this == rhs);
}
return getStaticClassID();
}
- virtual UBool operator==(const ForwardCharacterIterator& /*that*/) const{
- return TRUE;
+ virtual bool operator==(const ForwardCharacterIterator& /*that*/) const{
+ return true;
}
virtual SCharacterIterator* clone(void) const {
}
// dummy implementations of other pure virtual base class functions
- virtual UBool operator==(const ForwardCharacterIterator &that) const {
+ virtual bool operator==(const ForwardCharacterIterator &that) const {
return
this==&that ||
(typeid(*this)==typeid(that) && pos==((SubCharIter &)that).pos);
return getStaticClassID();
}
- virtual UBool operator==(const UObject& other) const
+ virtual bool operator==(const UObject& other) const
{
return typeid(*this) == typeid(other) &&
_val == ((Integer&)other)._val;
class PluralMapForPluralMapTest : public PluralMap<UnicodeString> {
public:
- UBool operator==(const PluralMapForPluralMapTest &other) {
+ bool operator==(const PluralMapForPluralMapTest &other) {
return equals(other, strEqual);
}
private:
}
#if 0 // not used
-UBool SimpleFwdCharIterator::operator==(const ForwardCharacterIterator& that) const {
+bool SimpleFwdCharIterator::operator==(const ForwardCharacterIterator& that) const {
if(this == &that) {
- return TRUE;
+ return true;
}
/*
if(that->fHashCode != kInvalidHashCode && this->fHashCode = that->fHashCode) {
- return TRUE;
+ return true;
}
if(this->fStart == that->fStart) {
- return TRUE;
+ return true;
}
if(this->fLen == that->fLen && uprv_memcmp(this->fStart, that->fStart, this->fLen) {
- return TRUE;
+ return true;
}
*/
- return FALSE;
+ return false;
}
#endif
* Returns true when both iterators refer to the same
* character in the same character-storage object.
*/
- // not used -- virtual UBool operator==(const ForwardCharacterIterator& that) const;
+ // not used -- virtual bool operator==(const ForwardCharacterIterator& that) const;
/**
* Generates a hash code for this iterator.
*/
static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
- UBool operator!=(const TestSearch &that) const;
+ bool operator!=(const TestSearch &that) const;
UnicodeString m_pattern_;
return new TestSearch(m_text_, m_breakiterator_, m_pattern_);
}
-UBool TestSearch::operator!=(const TestSearch &that) const
+bool TestSearch::operator!=(const TestSearch &that) const
{
if (SearchIterator::operator !=(that)) {
return FALSE;
projects / icu / commitdiff