* @return true if this engine handles the particular character and break
* type.
*/
- virtual UBool handles(UChar32 c) const;
+ virtual UBool handles(UChar32 c) const override;
/**
* <p>Find any breaks within a run in the supplied text.</p>
int32_t startPos,
int32_t endPos,
UVector32 &foundBreaks,
- UErrorCode &status) const;
+ UErrorCode &status) const override;
/**
* <p>Tell the engine to handle a particular character and break type.</p>
* sought.
* @return A LanguageBreakEngine with the desired characteristics, or 0.
*/
- virtual const LanguageBreakEngine *getEngineFor(UChar32 c);
+ virtual const LanguageBreakEngine *getEngineFor(UChar32 c) override;
protected:
/**
public:
virtual ~ICUBreakIteratorFactory();
protected:
- virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* /*service*/, UErrorCode& status) const {
+ virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* /*service*/, UErrorCode& status) const override {
return BreakIterator::makeInstance(loc, kind, status);
}
};
virtual ~ICUBreakIteratorService();
- virtual UObject* cloneInstance(UObject* instance) const {
+ virtual UObject* cloneInstance(UObject* instance) const override {
return ((BreakIterator*)instance)->clone();
}
- virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /*actualID*/, UErrorCode& status) const {
+ virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /*actualID*/, UErrorCode& status) const override {
LocaleKey& lkey = (LocaleKey&)key;
int32_t kind = lkey.kind();
Locale loc;
return BreakIterator::makeInstance(loc, kind, status);
}
- virtual UBool isDefault() const {
+ virtual UBool isDefault() const override {
return countFactories() == 1;
}
};
* @return true if this engine handles the particular character and break
* type.
*/
- virtual UBool handles(UChar32 c) const;
+ virtual UBool handles(UChar32 c) const override;
/**
* <p>Find any breaks within a run in the supplied text.</p>
int32_t startPos,
int32_t endPos,
UVector32 &foundBreaks,
- UErrorCode& status ) const;
+ UErrorCode& status ) const override;
protected:
int32_t rangeStart,
int32_t rangeEnd,
UVector32 &foundBreaks,
- UErrorCode& status) const;
+ UErrorCode& status) const override;
};
int32_t rangeStart,
int32_t rangeEnd,
UVector32 &foundBreaks,
- UErrorCode& status) const;
+ UErrorCode& status) const override;
};
int32_t rangeStart,
int32_t rangeEnd,
UVector32 &foundBreaks,
- UErrorCode& status) const;
+ UErrorCode& status) const override;
};
int32_t rangeStart,
int32_t rangeEnd,
UVector32 &foundBreaks,
- UErrorCode& status) const;
+ UErrorCode& status) const override;
};
int32_t rangeStart,
int32_t rangeEnd,
UVector32 &foundBreaks,
- UErrorCode& status) const;
+ UErrorCode& status) const override;
};
virtual ~UCharsDictionaryMatcher();
virtual int32_t matches(UText *text, int32_t maxLength, int32_t limit,
int32_t *lengths, int32_t *cpLengths, int32_t *values,
- int32_t *prefix) const;
- virtual int32_t getType() const;
+ int32_t *prefix) const override;
+ virtual int32_t getType() const override;
private:
const UChar *characters;
UDataMemory *file;
virtual ~BytesDictionaryMatcher();
virtual int32_t matches(UText *text, int32_t maxLength, int32_t limit,
int32_t *lengths, int32_t *cpLengths, int32_t *values,
- int32_t *prefix) const;
- virtual int32_t getType() const;
+ int32_t *prefix) const override;
+ virtual int32_t getType() const override;
private:
UChar32 transform(UChar32 c) const;
/* -- cloning and other subclass stuff -- */
virtual BreakIterator * createBufferClone(void * /*stackBuffer*/,
int32_t &/*BufferSize*/,
- UErrorCode &status) {
+ UErrorCode &status) override {
// for now - always deep clone
status = U_SAFECLONE_ALLOCATED_WARNING;
return clone();
}
- virtual SimpleFilteredSentenceBreakIterator* clone() const { return new SimpleFilteredSentenceBreakIterator(*this); }
- virtual UClassID getDynamicClassID(void) const { return NULL; }
- virtual bool operator==(const BreakIterator& o) const { if(this==&o) return true; return false; }
+ virtual SimpleFilteredSentenceBreakIterator* clone() const override { return new SimpleFilteredSentenceBreakIterator(*this); }
+ virtual UClassID getDynamicClassID(void) const override { return NULL; }
+ virtual bool operator==(const BreakIterator& o) const override { if(this==&o) return true; return false; }
/* -- text modifying -- */
- virtual void setText(UText *text, UErrorCode &status) { fDelegate->setText(text,status); }
- virtual BreakIterator &refreshInputText(UText *input, UErrorCode &status) { fDelegate->refreshInputText(input,status); return *this; }
- virtual void adoptText(CharacterIterator* it) { fDelegate->adoptText(it); }
- virtual void setText(const UnicodeString &text) { fDelegate->setText(text); }
+ virtual void setText(UText *text, UErrorCode &status) override { fDelegate->setText(text,status); }
+ virtual BreakIterator &refreshInputText(UText *input, UErrorCode &status) override { fDelegate->refreshInputText(input,status); return *this; }
+ virtual void adoptText(CharacterIterator* it) override { fDelegate->adoptText(it); }
+ virtual void setText(const UnicodeString &text) override { fDelegate->setText(text); }
/* -- other functions that are just delegated -- */
- virtual UText *getUText(UText *fillIn, UErrorCode &status) const { return fDelegate->getUText(fillIn,status); }
- virtual CharacterIterator& getText(void) const { return fDelegate->getText(); }
+ virtual UText *getUText(UText *fillIn, UErrorCode &status) const override { return fDelegate->getUText(fillIn,status); }
+ virtual CharacterIterator& getText(void) const override { return fDelegate->getText(); }
/* -- ITERATION -- */
- virtual int32_t first(void);
- virtual int32_t preceding(int32_t offset);
- virtual int32_t previous(void);
- virtual UBool isBoundary(int32_t offset);
- virtual int32_t current(void) const { return fDelegate->current(); } // we keep the delegate current, so this should be correct.
+ virtual int32_t first(void) override;
+ virtual int32_t preceding(int32_t offset) override;
+ virtual int32_t previous(void) override;
+ virtual UBool isBoundary(int32_t offset) override;
+ virtual int32_t current(void) const override { return fDelegate->current(); } // we keep the delegate current, so this should be correct.
- virtual int32_t next(void);
+ virtual int32_t next(void) override;
- virtual int32_t next(int32_t n);
- virtual int32_t following(int32_t offset);
- virtual int32_t last(void);
+ virtual int32_t next(int32_t n) override;
+ virtual int32_t following(int32_t offset) override;
+ virtual int32_t last(void) override;
private:
/**
virtual ~SimpleFilteredBreakIteratorBuilder();
SimpleFilteredBreakIteratorBuilder(const Locale &fromLocale, UErrorCode &status);
SimpleFilteredBreakIteratorBuilder(UErrorCode &status);
- virtual UBool suppressBreakAfter(const UnicodeString& exception, UErrorCode& status);
- virtual UBool unsuppressBreakAfter(const UnicodeString& exception, UErrorCode& status);
- virtual BreakIterator *build(BreakIterator* adoptBreakIterator, UErrorCode& status);
+ virtual UBool suppressBreakAfter(const UnicodeString& exception, UErrorCode& status) override;
+ virtual UBool unsuppressBreakAfter(const UnicodeString& exception, UErrorCode& status) override;
+ virtual BreakIterator *build(BreakIterator* adoptBreakIterator, UErrorCode& status) override;
private:
UStringSet fSet;
};
LocaleDisplayNamesImpl(const Locale& locale, UDisplayContext *contexts, int32_t length);
virtual ~LocaleDisplayNamesImpl();
- virtual const Locale& getLocale() const;
- virtual UDialectHandling getDialectHandling() const;
- virtual UDisplayContext getContext(UDisplayContextType type) const;
+ virtual const Locale& getLocale() const override;
+ virtual UDialectHandling getDialectHandling() const override;
+ virtual UDisplayContext getContext(UDisplayContextType type) const override;
virtual UnicodeString& localeDisplayName(const Locale& locale,
- UnicodeString& result) const;
+ UnicodeString& result) const override;
virtual UnicodeString& localeDisplayName(const char* localeId,
- UnicodeString& result) const;
+ UnicodeString& result) const override;
virtual UnicodeString& languageDisplayName(const char* lang,
- UnicodeString& result) const;
+ UnicodeString& result) const override;
virtual UnicodeString& scriptDisplayName(const char* script,
- UnicodeString& result) const;
+ UnicodeString& result) const override;
virtual UnicodeString& scriptDisplayName(UScriptCode scriptCode,
- UnicodeString& result) const;
+ UnicodeString& result) const override;
virtual UnicodeString& regionDisplayName(const char* region,
- UnicodeString& result) const;
+ UnicodeString& result) const override;
virtual UnicodeString& variantDisplayName(const char* variant,
- UnicodeString& result) const;
+ UnicodeString& result) const override;
virtual UnicodeString& keyDisplayName(const char* key,
- UnicodeString& result) const;
+ UnicodeString& result) const override;
virtual UnicodeString& keyValueDisplayName(const char* key,
const char* value,
- UnicodeString& result) const;
+ UnicodeString& result) const override;
private:
UnicodeString& localeIdName(const char* localeId,
UnicodeString& result, bool substitute) const;
virtual ~CapitalizationContextSink();
virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/,
- UErrorCode &errorCode) {
+ UErrorCode &errorCode) override {
ResourceTable contexts = value.getTable(errorCode);
if (U_FAILURE(errorCode)) { return; }
for (int i = 0; contexts.getKeyAndValue(i, key, value); ++i) {
public:
static UClassID U_EXPORT2 getStaticClassID(void) { return (UClassID)&fgClassID; }
- virtual UClassID getDynamicClassID(void) const { return getStaticClassID(); }
+ virtual UClassID getDynamicClassID(void) const override { return getStaticClassID(); }
public:
KeywordEnumeration(const char *keys, int32_t keywordLen, int32_t currentIndex, UErrorCode &status)
: keywords((char *)&fgClassID), current((char *)&fgClassID), length(0) {
virtual ~KeywordEnumeration();
- virtual StringEnumeration * clone() const
+ virtual StringEnumeration * clone() const override
{
UErrorCode status = U_ZERO_ERROR;
return new KeywordEnumeration(keywords, length, (int32_t)(current - keywords), status);
}
- virtual int32_t count(UErrorCode &/*status*/) const {
+ virtual int32_t count(UErrorCode &/*status*/) const override {
char *kw = keywords;
int32_t result = 0;
while(*kw) {
return result;
}
- virtual const char* next(int32_t* resultLength, UErrorCode& status) {
+ virtual const char* next(int32_t* resultLength, UErrorCode& status) override {
const char* result;
int32_t len;
if(U_SUCCESS(status) && *current != 0) {
return result;
}
- virtual const UnicodeString* snext(UErrorCode& status) {
+ virtual const UnicodeString* snext(UErrorCode& status) override {
int32_t resultLength = 0;
const char *s = next(&resultLength, status);
return setChars(s, resultLength, status);
}
- virtual void reset(UErrorCode& /*status*/) {
+ virtual void reset(UErrorCode& /*status*/) override {
current = keywords;
}
};
using KeywordEnumeration::KeywordEnumeration;
virtual ~UnicodeKeywordEnumeration();
- virtual const char* next(int32_t* resultLength, UErrorCode& status) {
+ virtual const char* next(int32_t* resultLength, UErrorCode& status) override {
const char* legacy_key = KeywordEnumeration::next(nullptr, status);
while (U_SUCCESS(status) && legacy_key != nullptr) {
const char* key = uloc_toUnicodeLocaleKey(legacy_key);
}
// ReadArray1D methods.
- virtual int32_t d1() const { return d1_; }
- virtual float get(int32_t i) const {
+ virtual int32_t d1() const override { return d1_; }
+ virtual float get(int32_t i) const override {
U_ASSERT(i < d1_);
return data_[i];
}
}
// ReadArray2D methods.
- inline int32_t d1() const { return d1_; }
- inline int32_t d2() const { return d2_; }
- float get(int32_t i, int32_t j) const {
+ inline int32_t d1() const override { return d1_; }
+ inline int32_t d2() const override { return d2_; }
+ float get(int32_t i, int32_t j) const override {
U_ASSERT(i < d1_);
U_ASSERT(j < d2_);
return data_[i * d2_ + j];
: memory_(nullptr), data_(data), d1_(d1) {}
// ReadArray1D methods.
- virtual int32_t d1() const { return d1_; }
- virtual float get(int32_t i) const {
+ virtual int32_t d1() const override { return d1_; }
+ virtual float get(int32_t i) const override {
U_ASSERT(i < d1_);
return data_[i];
}
virtual ~Array2D();
// ReadArray2D methods.
- virtual int32_t d1() const { return d1_; }
- virtual int32_t d2() const { return d2_; }
- virtual float get(int32_t i, int32_t j) const {
+ virtual int32_t d1() const override { return d1_; }
+ virtual int32_t d2() const override { return d2_; }
+ virtual float get(int32_t i, int32_t j) const override {
U_ASSERT(i < d1_);
U_ASSERT(j < d2_);
return data_[i * d2_ + j];
virtual ~CodePointsVectorizer();
virtual void vectorize(UText *text, int32_t startPos, int32_t endPos,
UVector32 &offsets, UVector32 &indices,
- UErrorCode &status) const;
+ UErrorCode &status) const override;
};
CodePointsVectorizer::~CodePointsVectorizer()
virtual ~GraphemeClusterVectorizer();
virtual void vectorize(UText *text, int32_t startPos, int32_t endPos,
UVector32 &offsets, UVector32 &indices,
- UErrorCode &status) const;
+ UErrorCode &status) const override;
};
GraphemeClusterVectorizer::~GraphemeClusterVectorizer()
int32_t rangeStart,
int32_t rangeEnd,
UVector32 &foundBreaks,
- UErrorCode& status) const;
+ UErrorCode& status) const override;
private:
const LSTMData* fData;
const Vectorizer* fVectorizer;
public:
// API inherited from class SymbolTable
- virtual const UnicodeString* lookup(const UnicodeString& s) const;
- virtual const UnicodeFunctor* lookupMatcher(UChar32 ch) const;
+ virtual const UnicodeString* lookup(const UnicodeString& s) const override;
+ virtual const UnicodeFunctor* lookupMatcher(UChar32 ch) const override;
virtual UnicodeString parseReference(const UnicodeString& text,
- ParsePosition& pos, int32_t limit) const;
+ ParsePosition& pos, int32_t limit) const override;
// Additional Functions
RBBISymbolTable(RBBIRuleScanner *, const UnicodeString &fRules, UErrorCode &status);
/**
* UObject RTTI boilerplate.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
#ifdef SERVICE_DEBUG
public:
* @param status the error code status.
* @return the service object, or NULL if the factory does not support the key.
*/
- virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const;
+ virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const override;
/**
* <p>This implementation adds a mapping from ID -> this to result if visible is true,
* @param result the mapping table to update.
* @param status the error code status.
*/
- virtual void updateVisibleIDs(Hashtable& result, UErrorCode& status) const;
+ virtual void updateVisibleIDs(Hashtable& result, UErrorCode& status) const override;
/**
* <p>This implementation returns the factory ID if it equals id and visible is true,
* @param result output parameter to hold the display name.
* @return result.
*/
- virtual UnicodeString& getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const;
+ virtual UnicodeString& getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const override;
public:
/**
/**
* UObject RTTI boilerplate.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
#ifdef SERVICE_DEBUG
public:
/**
* UObject RTTI boilerplate.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
};
* @param l the listener to test.
* @return true if the service accepts the listener.
*/
- virtual UBool acceptsListener(const EventListener& l) const;
+ virtual UBool acceptsListener(const EventListener& l) const override;
/**
* <p>Notify the listener of a service change.</p>
*
* @param l the listener to notify.
*/
- virtual void notifyListener(EventListener& l) const;
+ virtual void notifyListener(EventListener& l) const override;
/************************************************************************
* Utilities for subclasses.
/**
* Append the prefix associated with the kind, or nothing if the kind is KIND_ANY.
*/
- virtual UnicodeString& prefix(UnicodeString& result) const;
+ virtual UnicodeString& prefix(UnicodeString& result) const override;
/**
* Return the kind code associated with this key.
/**
* Return the canonicalID.
*/
- virtual UnicodeString& canonicalID(UnicodeString& result) const;
+ virtual UnicodeString& canonicalID(UnicodeString& result) const override;
/**
* Return the currentID.
*/
- virtual UnicodeString& currentID(UnicodeString& result) const;
+ virtual UnicodeString& currentID(UnicodeString& result) const override;
/**
* Return the (canonical) current descriptor, or null if no current id.
*/
- virtual UnicodeString& currentDescriptor(UnicodeString& result) const;
+ virtual UnicodeString& currentDescriptor(UnicodeString& result) const override;
/**
* Convenience method to return the locale corresponding to the (canonical) original ID.
* unless the primary id was the empty string, in which case
* there is no fallback.
*/
- virtual UBool fallback();
+ virtual UBool fallback() override;
/**
* Return true if a key created from id matches, or would eventually
* fallback to match, the canonical ID of this key.
*/
- virtual UBool isFallbackOf(const UnicodeString& id) const;
+ virtual UBool isFallbackOf(const UnicodeString& id) const override;
public:
/**
*/
static UClassID U_EXPORT2 getStaticClassID();
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* Destructor.
* kind off to handleCreate (which subclasses must implement).
*/
public:
- virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const;
+ virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const override;
protected:
virtual UBool handlesKey(const ICUServiceKey& key, UErrorCode& status) const;
* Override of superclass method. This adjusts the result based
* on the coverage rule for this factory.
*/
- virtual void updateVisibleIDs(Hashtable& result, UErrorCode& status) const;
+ virtual void updateVisibleIDs(Hashtable& result, UErrorCode& status) const override;
/**
* Return a localized name for the locale represented by id.
*/
- virtual UnicodeString& getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const;
+ virtual UnicodeString& getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const override;
protected:
/**
*/
static UClassID U_EXPORT2 getStaticClassID();
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
#ifdef SERVICE_DEBUG
public:
/**
* Override of superclass method. Returns the service object if kind/locale match. Service is not used.
*/
- virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const;
+ virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const override;
/**
* Override of superclass method. This adjusts the result based
* on the coverage rule for this factory.
*/
- virtual void updateVisibleIDs(Hashtable& result, UErrorCode& status) const;
+ virtual void updateVisibleIDs(Hashtable& result, UErrorCode& status) const override;
protected:
/**
*/
static UClassID U_EXPORT2 getStaticClassID();
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
#ifdef SERVICE_DEBUG
public:
/**
* Return the supported IDs. This is the set of all locale names in ICULocaleData.
*/
- virtual const Hashtable* getSupportedIDs(UErrorCode& status) const;
+ virtual const Hashtable* getSupportedIDs(UErrorCode& status) const override;
/**
* Create the service. The default implementation returns the resource bundle
* for the locale, ignoring kind, and service.
*/
- virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* service, UErrorCode& status) const;
+ virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* service, UErrorCode& status) const override;
public:
/**
* UObject boilerplate.
*/
static UClassID U_EXPORT2 getStaticClassID();
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
#ifdef SERVICE_DEBUG
* We really need a flag that is understood by all compilers that will suppress the warning about
* hidden overrides.
*/
- virtual URegistryKey registerInstance(UObject* objToAdopt, const UnicodeString& locale, UBool visible, UErrorCode& status);
+ virtual URegistryKey registerInstance(UObject* objToAdopt, const UnicodeString& locale, UBool visible, UErrorCode& status) override;
/**
* Convenience method for callers using locales. This returns the standard
/**
* Override superclass createKey method.
*/
- virtual ICUServiceKey* createKey(const UnicodeString* id, UErrorCode& status) const;
+ virtual ICUServiceKey* createKey(const UnicodeString* id, UErrorCode& status) const override;
/**
* Additional createKey that takes a kind.
virtual ~ServiceEnumeration();
- virtual StringEnumeration *clone() const {
+ virtual StringEnumeration *clone() const override {
UErrorCode status = U_ZERO_ERROR;
ServiceEnumeration *cl = new ServiceEnumeration(*this, status);
if(U_FAILURE(status)) {
return FALSE;
}
- virtual int32_t count(UErrorCode& status) const {
+ virtual int32_t count(UErrorCode& status) const override {
return upToDate(status) ? _ids.size() : 0;
}
- virtual const UnicodeString* snext(UErrorCode& status) {
+ virtual const UnicodeString* snext(UErrorCode& status) override {
if (upToDate(status) && (_pos < _ids.size())) {
return (const UnicodeString*)_ids[_pos++];
}
return NULL;
}
- virtual void reset(UErrorCode& status) {
+ virtual void reset(UErrorCode& status) override {
if (status == U_ENUM_OUT_OF_SYNC_ERROR) {
status = U_ZERO_ERROR;
}
public:
static UClassID U_EXPORT2 getStaticClassID(void);
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
};
ServiceEnumeration::~ServiceEnumeration() {}
public:
static UClassID U_EXPORT2 getStaticClassID();
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
public:
#ifdef SERVICE_DEBUG
* @return true if the operation succeeded
* @stable ICU 4.8
*/
- virtual UBool appendCodeUnit(char16_t c);
+ virtual UBool appendCodeUnit(char16_t c) override;
/**
* Appends a code point to the string.
* @return true if the operation succeeded
* @stable ICU 4.8
*/
- virtual UBool appendCodePoint(UChar32 c);
+ virtual UBool appendCodePoint(UChar32 c) override;
/**
* Appends a string to the UnicodeString.
* @return true if the operation succeeded
* @stable ICU 4.8
*/
- virtual UBool appendString(const char16_t *s, int32_t length);
+ virtual UBool appendString(const char16_t *s, int32_t length) override;
/**
* Tells the UnicodeString that the caller is going to append roughly
* @return true if the operation succeeded
* @stable ICU 4.8
*/
- virtual UBool reserveAppendCapacity(int32_t appendCapacity);
+ virtual UBool reserveAppendCapacity(int32_t appendCapacity) override;
/**
* Returns a writable buffer for appending and writes the buffer's capacity to
virtual char16_t *getAppendBuffer(int32_t minCapacity,
int32_t desiredCapacityHint,
char16_t *scratch, int32_t scratchCapacity,
- int32_t *resultCapacity);
+ int32_t *resultCapacity) override;
private:
UnicodeString &str;
* @param n the number of bytes; must be non-negative
* @stable ICU 4.2
*/
- virtual void Append(const char* bytes, int32_t n);
+ virtual void Append(const char* bytes, int32_t n) override;
/**
* Returns a writable buffer for appending and writes the buffer's capacity to
* *result_capacity. For details see the base class documentation.
virtual char* GetAppendBuffer(int32_t min_capacity,
int32_t desired_capacity_hint,
char* scratch, int32_t scratch_capacity,
- int32_t* result_capacity);
+ int32_t* result_capacity) override;
/**
* Returns the number of bytes actually written to the sink.
* @return number of bytes written to the buffer
* @param n the number of bytes; must be non-negative
* @stable ICU 4.2
*/
- virtual void Append(const char* data, int32_t n) { dest_->append(data, n); }
+ virtual void Append(const char* data, int32_t n) override { dest_->append(data, n); }
private:
StringClass* dest_;
void buildBytes(UStringTrieBuildOption buildOption, UErrorCode &errorCode);
- virtual int32_t getElementStringLength(int32_t i) const;
- virtual char16_t getElementUnit(int32_t i, int32_t byteIndex) const;
- virtual int32_t getElementValue(int32_t i) const;
+ virtual int32_t getElementStringLength(int32_t i) const override;
+ virtual char16_t getElementUnit(int32_t i, int32_t byteIndex) const override;
+ virtual int32_t getElementValue(int32_t i) const override;
- virtual int32_t getLimitOfLinearMatch(int32_t first, int32_t last, int32_t byteIndex) const;
+ virtual int32_t getLimitOfLinearMatch(int32_t first, int32_t last, int32_t byteIndex) const override;
- virtual int32_t countElementUnits(int32_t start, int32_t limit, int32_t byteIndex) const;
- virtual int32_t skipElementsBySomeUnits(int32_t i, int32_t byteIndex, int32_t count) const;
- virtual int32_t indexOfElementWithNextUnit(int32_t i, int32_t byteIndex, char16_t byte) const;
+ virtual int32_t countElementUnits(int32_t start, int32_t limit, int32_t byteIndex) const override;
+ virtual int32_t skipElementsBySomeUnits(int32_t i, int32_t byteIndex, int32_t count) const override;
+ virtual int32_t indexOfElementWithNextUnit(int32_t i, int32_t byteIndex, char16_t byte) const override;
- virtual UBool matchNodesCanHaveValues() const { return false; }
+ virtual UBool matchNodesCanHaveValues() const override { return false; }
- virtual int32_t getMaxBranchLinearSubNodeLength() const { return BytesTrie::kMaxBranchLinearSubNodeLength; }
- virtual int32_t getMinLinearMatch() const { return BytesTrie::kMinLinearMatch; }
- virtual int32_t getMaxLinearMatchLength() const { return BytesTrie::kMaxLinearMatchLength; }
+ virtual int32_t getMaxBranchLinearSubNodeLength() const override { return BytesTrie::kMaxBranchLinearSubNodeLength; }
+ virtual int32_t getMinLinearMatch() const override { return BytesTrie::kMinLinearMatch; }
+ virtual int32_t getMaxLinearMatchLength() const override { return BytesTrie::kMaxLinearMatchLength; }
/**
* @internal (private)
class BTLinearMatchNode : public LinearMatchNode {
public:
BTLinearMatchNode(const char *units, int32_t len, Node *nextNode);
- virtual bool operator==(const Node &other) const;
- virtual void write(StringTrieBuilder &builder);
+ virtual bool operator==(const Node &other) const override;
+ virtual void write(StringTrieBuilder &builder) override;
private:
const char *s;
};
virtual Node *createLinearMatchNode(int32_t i, int32_t byteIndex, int32_t length,
- Node *nextNode) const;
+ Node *nextNode) const override;
UBool ensureCapacity(int32_t length);
- virtual int32_t write(int32_t byte);
+ virtual int32_t write(int32_t byte) override;
int32_t write(const char *b, int32_t length);
- virtual int32_t writeElementUnits(int32_t i, int32_t byteIndex, int32_t length);
- virtual int32_t writeValueAndFinal(int32_t i, UBool isFinal);
- virtual int32_t writeValueAndType(UBool hasValue, int32_t value, int32_t node);
- virtual int32_t writeDeltaTo(int32_t jumpTarget);
+ virtual int32_t writeElementUnits(int32_t i, int32_t byteIndex, int32_t length) override;
+ virtual int32_t writeValueAndFinal(int32_t i, UBool isFinal) override;
+ virtual int32_t writeValueAndType(UBool hasValue, int32_t value, int32_t node) override;
+ virtual int32_t writeDeltaTo(int32_t jumpTarget) override;
static int32_t internalEncodeDelta(int32_t i, char intBytes[]);
CharString *strings; // Pointer not object so we need not #include internal charstr.h.
*
* @stable ICU 2.2
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
private:
// ===================== PRIVATES ==============================
* other classes have different class IDs.
* @stable ICU 4.0
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
*
* @stable ICU 2.2
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* A Locale iterator interface similar to a Java Iterator<Locale>.
* @return a UClassID for the actual class.
* @deprecated ICU 56 Use Normalizer2 instead.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
#endif // U_FORCE_HIDE_DEPRECATED_API
private:
*
* @stable ICU 2.2
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
private:
/**
* same class, have the same behavior, and iterate over the same text.
* @stable ICU 2.0
*/
- virtual bool operator==(const BreakIterator& that) const;
+ virtual bool operator==(const BreakIterator& that) const override;
/**
* Not-equal operator. If operator== returns true, this returns false,
* @return a newly-constructed RuleBasedBreakIterator
* @stable ICU 2.0
*/
- virtual RuleBasedBreakIterator* clone() const;
+ virtual RuleBasedBreakIterator* clone() const override;
/**
* Compute a hash code for this BreakIterator
* @return An iterator over the text being analyzed.
* @stable ICU 2.0
*/
- virtual CharacterIterator& getText(void) const;
+ virtual CharacterIterator& getText(void) const override;
/**
* UText was provided, it will always be returned.
* @stable ICU 3.4
*/
- virtual UText *getUText(UText *fillIn, UErrorCode &status) const;
+ virtual UText *getUText(UText *fillIn, UErrorCode &status) const override;
/**
* Set the iterator to analyze a new piece of text. This function resets
* takes ownership of the character iterator. The caller MUST NOT delete it!
* @stable ICU 2.0
*/
- virtual void adoptText(CharacterIterator* newText);
+ virtual void adoptText(CharacterIterator* newText) override;
/**
* Set the iterator to analyze a new piece of text. This function resets
* @param newText The text to analyze.
* @stable ICU 2.0
*/
- virtual void setText(const UnicodeString& newText);
+ virtual void setText(const UnicodeString& newText) override;
/**
* Reset the break iterator to operate over the text represented by
* @param status Receives any error codes.
* @stable ICU 3.4
*/
- virtual void setText(UText *text, UErrorCode &status);
+ virtual void setText(UText *text, UErrorCode &status) override;
/**
* Sets the current iteration position to the beginning of the text, position zero.
* @return The offset of the beginning of the text, zero.
* @stable ICU 2.0
*/
- virtual int32_t first(void);
+ virtual int32_t first(void) override;
/**
* Sets the current iteration position to the end of the text.
* @return The text's past-the-end offset.
* @stable ICU 2.0
*/
- virtual int32_t last(void);
+ virtual int32_t last(void) override;
/**
* Advances the iterator either forward or backward the specified number of steps.
* the current one.
* @stable ICU 2.0
*/
- virtual int32_t next(int32_t n);
+ virtual int32_t next(int32_t n) override;
/**
* Advances the iterator to the next boundary position.
* @return The position of the first boundary after this one.
* @stable ICU 2.0
*/
- virtual int32_t next(void);
+ virtual int32_t next(void) override;
/**
* Moves the iterator backwards, to the last boundary preceding this one.
* @return The position of the last boundary position preceding this one.
* @stable ICU 2.0
*/
- virtual int32_t previous(void);
+ virtual int32_t previous(void) override;
/**
* Sets the iterator to refer to the first boundary position following
* @return The position of the first break after the current position.
* @stable ICU 2.0
*/
- virtual int32_t following(int32_t offset);
+ virtual int32_t following(int32_t offset) override;
/**
* Sets the iterator to refer to the last boundary position before the
* @return The position of the last boundary before the starting position.
* @stable ICU 2.0
*/
- virtual int32_t preceding(int32_t offset);
+ virtual int32_t preceding(int32_t offset) override;
/**
* Returns true if the specified position is a boundary position. As a side
* @return True if "offset" is a boundary position.
* @stable ICU 2.0
*/
- virtual UBool isBoundary(int32_t offset);
+ virtual UBool isBoundary(int32_t offset) override;
/**
* Returns the current iteration position. Note that UBRK_DONE is never
* @return The current iteration position.
* @stable ICU 2.0
*/
- virtual int32_t current(void) const;
+ virtual int32_t current(void) const override;
/**
* @see UWordBreak
* @stable ICU 2.2
*/
- virtual int32_t getRuleStatus() const;
+ virtual int32_t getRuleStatus() const override;
/**
* Get the status (tag) values from the break rule(s) that determined the boundary
* @see getRuleStatus
* @stable ICU 3.0
*/
- virtual int32_t getRuleStatusVec(int32_t *fillInVec, int32_t capacity, UErrorCode &status);
+ virtual int32_t getRuleStatusVec(int32_t *fillInVec, int32_t capacity, UErrorCode &status) override;
/**
* Returns a unique class ID POLYMORPHICALLY. Pure virtual override.
* other classes have different class IDs.
* @stable ICU 2.0
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Returns the class ID for this class. This is useful only for
*/
virtual RuleBasedBreakIterator *createBufferClone(void *stackBuffer,
int32_t &BufferSize,
- UErrorCode &status);
+ UErrorCode &status) override;
#endif // U_FORCE_HIDE_DEPRECATED_API
/**
*
* @stable ICU 49
*/
- virtual RuleBasedBreakIterator &refreshInputText(UText *input, UErrorCode &status);
+ virtual RuleBasedBreakIterator &refreshInputText(UText *input, UErrorCode &status) override;
private:
*
* @stable ICU 2.2
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* same string and are pointing at the same character.
* @stable ICU 2.0
*/
- virtual bool operator==(const ForwardCharacterIterator& that) const;
+ virtual bool operator==(const ForwardCharacterIterator& that) const override;
/**
* Returns a new StringCharacterIterator referring to the same
* @return the newly cloned object.
* @stable ICU 2.0
*/
- virtual StringCharacterIterator* clone() const;
+ virtual StringCharacterIterator* clone() const override;
/**
* Sets the iterator to iterate over the provided string.
* @param result Receives a copy of the text under iteration.
* @stable ICU 2.0
*/
- virtual void getText(UnicodeString& result);
+ virtual void getText(UnicodeString& result) override;
/**
* Return a class ID for this object (not really public)
* @return a class ID for this object.
* @stable ICU 2.0
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Return a class ID for this class (not really public)
class FinalValueNode : public Node {
public:
FinalValueNode(int32_t v) : Node(0x111111u*37u+v), value(v) {}
- virtual bool operator==(const Node &other) const;
- virtual void write(StringTrieBuilder &builder);
+ virtual bool operator==(const Node &other) const override;
+ virtual void write(StringTrieBuilder &builder) override;
protected:
int32_t value;
};
class ValueNode : public Node {
public:
ValueNode(int32_t initialHash) : Node(initialHash), hasValue(false), value(0) {}
- virtual bool operator==(const Node &other) const;
+ virtual bool operator==(const Node &other) const override;
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 bool operator==(const Node &other) const;
- virtual int32_t markRightEdgesFirst(int32_t edgeNumber);
- virtual void write(StringTrieBuilder &builder);
+ virtual bool operator==(const Node &other) const override;
+ virtual int32_t markRightEdgesFirst(int32_t edgeNumber) override;
+ virtual void write(StringTrieBuilder &builder) override;
protected:
Node *next;
};
LinearMatchNode(int32_t len, Node *nextNode)
: ValueNode((0x333333u*37u+len)*37u+hashCode(nextNode)),
length(len), next(nextNode) {}
- virtual bool operator==(const Node &other) const;
- virtual int32_t markRightEdgesFirst(int32_t edgeNumber);
+ virtual bool operator==(const Node &other) const override;
+ virtual int32_t markRightEdgesFirst(int32_t edgeNumber) override;
protected:
int32_t length;
Node *next;
class ListBranchNode : public BranchNode {
public:
ListBranchNode() : BranchNode(0x444444), length(0) {}
- virtual bool operator==(const Node &other) const;
- virtual int32_t markRightEdgesFirst(int32_t edgeNumber);
- virtual void write(StringTrieBuilder &builder);
+ virtual bool operator==(const Node &other) const override;
+ virtual int32_t markRightEdgesFirst(int32_t edgeNumber) override;
+ virtual void write(StringTrieBuilder &builder) override;
// Adds a unit with a final value.
void add(int32_t c, int32_t value) {
units[length]=(char16_t)c;
: BranchNode(((0x555555u*37u+middleUnit)*37u+
hashCode(lessThanNode))*37u+hashCode(greaterOrEqualNode)),
unit(middleUnit), lessThan(lessThanNode), greaterOrEqual(greaterOrEqualNode) {}
- virtual bool operator==(const Node &other) const;
- virtual int32_t markRightEdgesFirst(int32_t edgeNumber);
- virtual void write(StringTrieBuilder &builder);
+ virtual bool operator==(const Node &other) const override;
+ virtual int32_t markRightEdgesFirst(int32_t edgeNumber) override;
+ virtual void write(StringTrieBuilder &builder) override;
protected:
char16_t unit;
Node *lessThan;
BranchHeadNode(int32_t len, Node *subNode)
: ValueNode((0x666666u*37u+len)*37u+hashCode(subNode)),
length(len), next(subNode) {}
- virtual bool operator==(const Node &other) const;
- virtual int32_t markRightEdgesFirst(int32_t edgeNumber);
- virtual void write(StringTrieBuilder &builder);
+ virtual bool operator==(const Node &other) const override;
+ virtual int32_t markRightEdgesFirst(int32_t edgeNumber) override;
+ virtual void write(StringTrieBuilder &builder) override;
protected:
int32_t length;
Node *next; // A branch sub-node.
void buildUChars(UStringTrieBuildOption buildOption, UErrorCode &errorCode);
- virtual int32_t getElementStringLength(int32_t i) const;
- virtual char16_t getElementUnit(int32_t i, int32_t unitIndex) const;
- virtual int32_t getElementValue(int32_t i) const;
+ virtual int32_t getElementStringLength(int32_t i) const override;
+ virtual char16_t getElementUnit(int32_t i, int32_t unitIndex) const override;
+ virtual int32_t getElementValue(int32_t i) const override;
- virtual int32_t getLimitOfLinearMatch(int32_t first, int32_t last, int32_t unitIndex) const;
+ virtual int32_t getLimitOfLinearMatch(int32_t first, int32_t last, int32_t unitIndex) const override;
- virtual int32_t countElementUnits(int32_t start, int32_t limit, int32_t unitIndex) const;
- virtual int32_t skipElementsBySomeUnits(int32_t i, int32_t unitIndex, int32_t count) const;
- virtual int32_t indexOfElementWithNextUnit(int32_t i, int32_t unitIndex, char16_t unit) const;
+ virtual int32_t countElementUnits(int32_t start, int32_t limit, int32_t unitIndex) const override;
+ virtual int32_t skipElementsBySomeUnits(int32_t i, int32_t unitIndex, int32_t count) const override;
+ virtual int32_t indexOfElementWithNextUnit(int32_t i, int32_t unitIndex, char16_t unit) const override;
- virtual UBool matchNodesCanHaveValues() const { return true; }
+ virtual UBool matchNodesCanHaveValues() const override { return true; }
- virtual int32_t getMaxBranchLinearSubNodeLength() const { return UCharsTrie::kMaxBranchLinearSubNodeLength; }
- virtual int32_t getMinLinearMatch() const { return UCharsTrie::kMinLinearMatch; }
- virtual int32_t getMaxLinearMatchLength() const { return UCharsTrie::kMaxLinearMatchLength; }
+ virtual int32_t getMaxBranchLinearSubNodeLength() const override { return UCharsTrie::kMaxBranchLinearSubNodeLength; }
+ virtual int32_t getMinLinearMatch() const override { return UCharsTrie::kMinLinearMatch; }
+ virtual int32_t getMaxLinearMatchLength() const override { return UCharsTrie::kMaxLinearMatchLength; }
class UCTLinearMatchNode : public LinearMatchNode {
public:
UCTLinearMatchNode(const char16_t *units, int32_t len, Node *nextNode);
- virtual bool operator==(const Node &other) const;
- virtual void write(StringTrieBuilder &builder);
+ virtual bool operator==(const Node &other) const override;
+ virtual void write(StringTrieBuilder &builder) override;
private:
const char16_t *s;
};
virtual Node *createLinearMatchNode(int32_t i, int32_t unitIndex, int32_t length,
- Node *nextNode) const;
+ Node *nextNode) const override;
UBool ensureCapacity(int32_t length);
- virtual int32_t write(int32_t unit);
+ virtual int32_t write(int32_t unit) override;
int32_t write(const char16_t *s, int32_t length);
- virtual int32_t writeElementUnits(int32_t i, int32_t unitIndex, int32_t length);
- virtual int32_t writeValueAndFinal(int32_t i, UBool isFinal);
- virtual int32_t writeValueAndType(UBool hasValue, int32_t value, int32_t node);
- virtual int32_t writeDeltaTo(int32_t jumpTarget);
+ virtual int32_t writeElementUnits(int32_t i, int32_t unitIndex, int32_t length) override;
+ virtual int32_t writeValueAndFinal(int32_t i, UBool isFinal) override;
+ virtual int32_t writeValueAndType(UBool hasValue, int32_t value, int32_t node) override;
+ virtual int32_t writeDeltaTo(int32_t jumpTarget) override;
UnicodeString strings;
UCharsTrieElement *elements;
* same string and are pointing at the same character.
* @stable ICU 2.0
*/
- virtual bool operator==(const ForwardCharacterIterator& that) const;
+ virtual bool operator==(const ForwardCharacterIterator& that) const override;
/**
* Generates a hash code for this iterator.
* @return the hash code.
* @stable ICU 2.0
*/
- virtual int32_t hashCode(void) const;
+ virtual int32_t hashCode(void) const override;
/**
* Returns a new UCharCharacterIterator referring to the same
* @return the CharacterIterator newly created
* @stable ICU 2.0
*/
- virtual UCharCharacterIterator* clone() const;
+ virtual UCharCharacterIterator* clone() const override;
/**
* Sets the iterator to refer to the first code unit in its
* @return the first code unit in its iteration range.
* @stable ICU 2.0
*/
- virtual char16_t first(void);
+ virtual char16_t first(void) override;
/**
* Sets the iterator to refer to the first code unit in its
* @return the first code unit in its iteration range
* @stable ICU 2.0
*/
- virtual char16_t firstPostInc(void);
+ virtual char16_t firstPostInc(void) override;
/**
* Sets the iterator to refer to the first code point in its
* @return the first code point in its iteration range
* @stable ICU 2.0
*/
- virtual UChar32 first32(void);
+ virtual UChar32 first32(void) override;
/**
* Sets the iterator to refer to the first code point in its
* @return the first code point in its iteration range.
* @stable ICU 2.0
*/
- virtual UChar32 first32PostInc(void);
+ virtual UChar32 first32PostInc(void) override;
/**
* Sets the iterator to refer to the last code unit in its
* @return the last code unit in its iteration range.
* @stable ICU 2.0
*/
- virtual char16_t last(void);
+ virtual char16_t last(void) override;
/**
* Sets the iterator to refer to the last code point in its
* @return the last code point in its iteration range.
* @stable ICU 2.0
*/
- virtual UChar32 last32(void);
+ virtual UChar32 last32(void) override;
/**
* Sets the iterator to refer to the "position"-th code unit
* @return the code unit
* @stable ICU 2.0
*/
- virtual char16_t setIndex(int32_t position);
+ virtual char16_t setIndex(int32_t position) override;
/**
* Sets the iterator to refer to the beginning of the code point
* @return the code unit
* @stable ICU 2.0
*/
- virtual UChar32 setIndex32(int32_t position);
+ virtual UChar32 setIndex32(int32_t position) override;
/**
* Returns the code unit the iterator currently refers to.
* @return the code unit the iterator currently refers to.
* @stable ICU 2.0
*/
- virtual char16_t current(void) const;
+ virtual char16_t current(void) const override;
/**
* Returns the code point the iterator currently refers to.
* @return the code point the iterator currently refers to.
* @stable ICU 2.0
*/
- virtual UChar32 current32(void) const;
+ virtual UChar32 current32(void) const override;
/**
* Advances to the next code unit in the iteration range (toward
* @return the next code unit in the iteration range.
* @stable ICU 2.0
*/
- virtual char16_t next(void);
+ virtual char16_t next(void) override;
/**
* Gets the current code unit for returning and advances to the next code unit
* @return the current code unit.
* @stable ICU 2.0
*/
- virtual char16_t nextPostInc(void);
+ virtual char16_t nextPostInc(void) override;
/**
* Advances to the next code point in the iteration range (toward
* @return the next code point in the iteration range.
* @stable ICU 2.0
*/
- virtual UChar32 next32(void);
+ virtual UChar32 next32(void) override;
/**
* Gets the current code point for returning and advances to the next code point
* @return the current point.
* @stable ICU 2.0
*/
- virtual UChar32 next32PostInc(void);
+ virtual UChar32 next32PostInc(void) override;
/**
* Returns false if there are no more code units or code points
* at or after the current position in the iteration range.
* @stable ICU 2.0
*/
- virtual UBool hasNext();
+ virtual UBool hasNext() override;
/**
* Advances to the previous code unit in the iteration range (toward
* @return the previous code unit in the iteration range.
* @stable ICU 2.0
*/
- virtual char16_t previous(void);
+ virtual char16_t previous(void) override;
/**
* Advances to the previous code point in the iteration range (toward
* @return the previous code point in the iteration range.
* @stable ICU 2.0
*/
- virtual UChar32 previous32(void);
+ virtual UChar32 previous32(void) override;
/**
* Returns false if there are no more code units or code points
* before the current position in the iteration range.
* @stable ICU 2.0
*/
- virtual UBool hasPrevious();
+ virtual UBool hasPrevious() override;
/**
* Moves the current position relative to the start or end of the
* @return the new position
* @stable ICU 2.0
*/
- virtual int32_t move(int32_t delta, EOrigin origin);
+ virtual int32_t move(int32_t delta, EOrigin origin) override;
/**
* Moves the current position relative to the start or end of the
// One of the system headers right now is sometimes defining a conflicting macro we don't use
#undef move32
#endif
- virtual int32_t move32(int32_t delta, EOrigin origin);
+ virtual int32_t move32(int32_t delta, EOrigin origin) override;
/**
* Sets the iterator to iterate over a new range of text
* @param result Receives a copy of the text under iteration.
* @stable ICU 2.0
*/
- virtual void getText(UnicodeString& result);
+ virtual void getText(UnicodeString& result) override;
/**
* Return a class ID for this class (not really public)
* @return a class ID for this object.
* @stable ICU 2.0
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
protected:
/**
* @see cloneAsThawed
* @stable ICU 2.0
*/
- virtual UnicodeSet* clone() const;
+ virtual UnicodeSet* clone() const override;
/**
* Returns the hash code value for this set.
* @stable ICU 2.0
*/
virtual UnicodeString& toPattern(UnicodeString& result,
- UBool escapeUnprintable = false) const;
+ UBool escapeUnprintable = false) const override;
/**
* Modifies this set to contain those code points which have the given value
* @return true if the test condition is met
* @stable ICU 2.0
*/
- virtual UBool contains(UChar32 c) const;
+ virtual UBool contains(UChar32 c) const override;
/**
* Returns true if this set contains every character
virtual UMatchDegree matches(const Replaceable& text,
int32_t& offset,
int32_t limit,
- UBool incremental);
+ UBool incremental) override;
private:
/**
* @param toUnionTo the set into which to union the source characters
* @stable ICU 2.4
*/
- virtual void addMatchSetTo(UnicodeSet& toUnionTo) const;
+ virtual void addMatchSetTo(UnicodeSet& toUnionTo) const override;
/**
* Returns the index of the given character within this set, where
* different class IDs.
* @stable ICU 2.4
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
private:
* is the given value. This is used by <tt>RuleBasedTransliterator</tt> for
* indexing.
*/
- virtual UBool matchesIndexValue(uint8_t v) const;
+ virtual UBool matchesIndexValue(uint8_t v) const override;
private:
friend class RBBIRuleScanner;
*/
virtual void extractBetween(int32_t start,
int32_t limit,
- UnicodeString& target) const;
+ UnicodeString& target) const override;
/**
* Copy the characters in the range
*/
virtual void handleReplaceBetween(int32_t start,
int32_t limit,
- const UnicodeString& text);
+ const UnicodeString& text) override;
/**
* Replaceable API
* @return true if it has MetaData
* @stable ICU 2.4
*/
- virtual UBool hasMetaData() const;
+ virtual UBool hasMetaData() const override;
/**
* Copy a substring of this object, retaining attribute (out-of-band)
* dest >= limit`.
* @stable ICU 2.0
*/
- virtual void copy(int32_t start, int32_t limit, int32_t dest);
+ virtual void copy(int32_t start, int32_t limit, int32_t dest) override;
/* Search and replace operations */
* @see getDynamicClassID
* @stable ICU 2.6
*/
- virtual UnicodeString *clone() const;
+ virtual UnicodeString *clone() const override;
/** Destructor.
* @stable ICU 2.0
*
* @stable ICU 2.2
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
//========================================
// Implementation methods
* Implement Replaceable::getLength() (see jitterbug 1027).
* @stable ICU 2.4
*/
- virtual int32_t getLength() const;
+ virtual int32_t getLength() const override;
/**
* The change in Replaceable to use virtual getCharAt() allows
* UnicodeString::charAt() to be inline again (see jitterbug 709).
* @stable ICU 2.4
*/
- virtual char16_t getCharAt(int32_t offset) const;
+ virtual char16_t getCharAt(int32_t offset) const override;
/**
* The change in Replaceable to use virtual getChar32At() allows
* UnicodeString::char32At() to be inline again (see jitterbug 709).
* @stable ICU 2.4
*/
- virtual UChar32 getChar32At(int32_t offset) const;
+ virtual UChar32 getChar32At(int32_t offset) const override;
private:
// For char* constructors. Could be made public.
*
* @stable ICU 2.4
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
// ======================= PRIVATES ===========================
/**
* The template parameter, T, determines the hash code returned.
*/
- virtual int32_t hashCode() const {
+ virtual int32_t hashCode() const override {
const char *s = typeid(T).name();
return ustr_hashCharsN(s, static_cast<int32_t>(uprv_strlen(s)));
}
/**
* Use the value type, T, as the description.
*/
- virtual char *writeDescription(char *buffer, int32_t bufLen) const {
+ virtual char *writeDescription(char *buffer, int32_t bufLen) const override {
const char *s = typeid(T).name();
uprv_strncpy(buffer, s, bufLen);
buffer[bufLen - 1] = 0;
/**
* Two objects are equal if they are of the same type.
*/
- virtual bool equals(const CacheKeyBase &other) const {
+ virtual bool equals(const CacheKeyBase &other) const override {
return this == &other || typeid(*this) == typeid(other);
}
};
class LocaleCacheKey : public CacheKey<T> {
protected:
Locale fLoc;
- virtual bool equals(const CacheKeyBase &other) const {
+ virtual bool equals(const CacheKeyBase &other) const override {
if (!CacheKey<T>::equals(other)) {
return false;
}
LocaleCacheKey(const LocaleCacheKey<T> &other)
: CacheKey<T>(other), fLoc(other.fLoc) { }
virtual ~LocaleCacheKey() { }
- virtual int32_t hashCode() const {
+ virtual int32_t hashCode() const override {
return (int32_t)(37u * (uint32_t)CacheKey<T>::hashCode() + (uint32_t)fLoc.hashCode());
}
inline bool operator == (const LocaleCacheKey<T> &other) const {
return fLoc == other.fLoc;
}
- virtual CacheKeyBase *clone() const {
+ virtual CacheKeyBase *clone() const override {
return new LocaleCacheKey<T>(*this);
}
virtual const T *createObject(
- const void *creationContext, UErrorCode &status) const;
+ const void *creationContext, UErrorCode &status) const override;
/**
* Use the locale id as the description.
*/
- virtual char *writeDescription(char *buffer, int32_t bufLen) const {
+ virtual char *writeDescription(char *buffer, int32_t bufLen) const override {
const char *s = fLoc.getName();
uprv_strncpy(buffer, s, bufLen);
buffer[bufLen - 1] = 0;
*/
int32_t unusedCount() const;
- virtual void handleUnreferencedObject() const;
+ virtual void handleUnreferencedObject() const override;
virtual ~UnifiedCache();
private:
const ResourceData &getData() const { return *pResData; }
UResourceDataEntry *getValidLocaleDataEntry() const { return validLocaleDataEntry; }
Resource getResource() const { return res; }
- virtual UResType getType() const;
- virtual const UChar *getString(int32_t &length, UErrorCode &errorCode) const;
- virtual const UChar *getAliasString(int32_t &length, UErrorCode &errorCode) const;
- virtual int32_t getInt(UErrorCode &errorCode) const;
- virtual uint32_t getUInt(UErrorCode &errorCode) const;
- virtual const int32_t *getIntVector(int32_t &length, UErrorCode &errorCode) const;
- virtual const uint8_t *getBinary(int32_t &length, UErrorCode &errorCode) const;
- virtual ResourceArray getArray(UErrorCode &errorCode) const;
- virtual ResourceTable getTable(UErrorCode &errorCode) const;
- virtual UBool isNoInheritanceMarker() const;
+ virtual UResType getType() const override;
+ virtual const UChar *getString(int32_t &length, UErrorCode &errorCode) const override;
+ virtual const UChar *getAliasString(int32_t &length, UErrorCode &errorCode) const override;
+ virtual int32_t getInt(UErrorCode &errorCode) const override;
+ virtual uint32_t getUInt(UErrorCode &errorCode) const override;
+ virtual const int32_t *getIntVector(int32_t &length, UErrorCode &errorCode) const override;
+ virtual const uint8_t *getBinary(int32_t &length, UErrorCode &errorCode) const override;
+ virtual ResourceArray getArray(UErrorCode &errorCode) const override;
+ virtual ResourceTable getTable(UErrorCode &errorCode) const override;
+ virtual UBool isNoInheritanceMarker() const override;
virtual int32_t getStringArray(UnicodeString *dest, int32_t capacity,
- UErrorCode &errorCode) const;
+ UErrorCode &errorCode) const override;
virtual int32_t getStringArrayOrStringAsArray(UnicodeString *dest, int32_t capacity,
- UErrorCode &errorCode) const;
- virtual UnicodeString getStringOrFirstOfArray(UErrorCode &errorCode) const;
+ UErrorCode &errorCode) const override;
+ virtual UnicodeString getStringOrFirstOfArray(UErrorCode &errorCode) const override;
private:
const ResourceData *pResData;
* @param status the error code.
* @return number of elements in the iterator.
*/
- virtual int32_t count(UErrorCode& status) const;
+ virtual int32_t count(UErrorCode& status) const override;
- virtual const char* next(int32_t *resultLength, UErrorCode& status);
+ virtual const char* next(int32_t *resultLength, UErrorCode& status) override;
/**
* Returns the next element a UnicodeString*. If there are no
* @param status the error code.
* @return a pointer to the string, or NULL.
*/
- virtual const UnicodeString* snext(UErrorCode& status);
+ virtual const UnicodeString* snext(UErrorCode& status) override;
/**
* Resets the iterator.
* @param status the error code.
*/
- virtual void reset(UErrorCode& status);
+ virtual void reset(UErrorCode& status) override;
/**
* ICU4C "poor man's RTTI", returns a UClassID for the actual ICU class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU4C "poor man's RTTI", returns a UClassID for this ICU class.
virtual UnicodeString &
labelToASCII(const UnicodeString &label, UnicodeString &dest,
- IDNAInfo &info, UErrorCode &errorCode) const;
+ IDNAInfo &info, UErrorCode &errorCode) const override;
virtual UnicodeString &
labelToUnicode(const UnicodeString &label, UnicodeString &dest,
- IDNAInfo &info, UErrorCode &errorCode) const;
+ IDNAInfo &info, UErrorCode &errorCode) const override;
virtual UnicodeString &
nameToASCII(const UnicodeString &name, UnicodeString &dest,
- IDNAInfo &info, UErrorCode &errorCode) const;
+ IDNAInfo &info, UErrorCode &errorCode) const override;
virtual UnicodeString &
nameToUnicode(const UnicodeString &name, UnicodeString &dest,
- IDNAInfo &info, UErrorCode &errorCode) const;
+ IDNAInfo &info, UErrorCode &errorCode) const override;
virtual void
labelToASCII_UTF8(StringPiece label, ByteSink &dest,
- IDNAInfo &info, UErrorCode &errorCode) const;
+ IDNAInfo &info, UErrorCode &errorCode) const override;
virtual void
labelToUnicodeUTF8(StringPiece label, ByteSink &dest,
- IDNAInfo &info, UErrorCode &errorCode) const;
+ IDNAInfo &info, UErrorCode &errorCode) const override;
virtual void
nameToASCII_UTF8(StringPiece name, ByteSink &dest,
- IDNAInfo &info, UErrorCode &errorCode) const;
+ IDNAInfo &info, UErrorCode &errorCode) const override;
virtual void
nameToUnicodeUTF8(StringPiece name, ByteSink &dest,
- IDNAInfo &info, UErrorCode &errorCode) const;
+ IDNAInfo &info, UErrorCode &errorCode) const override;
private:
UnicodeString &
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
private:
int32_t indexOf(UElement key, int32_t startIndex = 0, int8_t hint = 0) const;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
// Disallow
UStack(const UStack&) = delete;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
private:
void _init(int32_t initialCapacity, UErrorCode &status);
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
private:
void _init(int32_t initialCapacity, UErrorCode &status);
*
* @stable ICU 2.2
*/
- virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }
+ virtual inline UClassID getDynamicClassID() const override { return getStaticClassID(); }
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
/**
* Transliterator API.
*/
- virtual AnyTransliterator* clone() const;
+ virtual AnyTransliterator* clone() const override;
/**
* Implements {@link Transliterator#handleTransliterate}.
*/
virtual void handleTransliterate(Replaceable& text, UTransPosition& index,
- UBool incremental) const;
+ UBool incremental) const override;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
class SunTimeAngleFunc : public CalendarAstronomer::AngleFunc {
public:
virtual ~SunTimeAngleFunc();
- virtual double eval(CalendarAstronomer& a) { return a.getSunLongitude(); }
+ virtual double eval(CalendarAstronomer& a) override { return a.getSunLongitude(); }
};
SunTimeAngleFunc::~SunTimeAngleFunc() {}
class RiseSetCoordFunc : public CalendarAstronomer::CoordFunc {
public:
virtual ~RiseSetCoordFunc();
- virtual void eval(CalendarAstronomer::Equatorial& result, CalendarAstronomer&a) { a.getSunPosition(result); }
+ virtual void eval(CalendarAstronomer::Equatorial& result, CalendarAstronomer& a) override { a.getSunPosition(result); }
};
RiseSetCoordFunc::~RiseSetCoordFunc() {}
class MoonTimeAngleFunc : public CalendarAstronomer::AngleFunc {
public:
virtual ~MoonTimeAngleFunc();
- virtual double eval(CalendarAstronomer&a) { return a.getMoonAge(); }
+ virtual double eval(CalendarAstronomer& a) override { return a.getMoonAge(); }
};
MoonTimeAngleFunc::~MoonTimeAngleFunc() {}
class MoonRiseSetCoordFunc : public CalendarAstronomer::CoordFunc {
public:
virtual ~MoonRiseSetCoordFunc();
- virtual void eval(CalendarAstronomer::Equatorial& result, CalendarAstronomer&a) { result = a.getMoonPosition(); }
+ virtual void eval(CalendarAstronomer::Equatorial& result, CalendarAstronomer& a) override { result = a.getMoonPosition(); }
};
MoonRiseSetCoordFunc::~MoonRiseSetCoordFunc() {}
* Transliterator API.
* @return A copy of the object.
*/
- virtual BreakTransliterator* clone() const;
+ virtual BreakTransliterator* clone() const override;
virtual const UnicodeString &getInsertion() const;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* pos.contextLimit. Otherwise, assume the text is complete.
*/
virtual void handleTransliterate(Replaceable& text, UTransPosition& offset,
- UBool isIncremental) const;
+ UBool isIncremental) const override;
private:
LocalPointer<BreakIterator> cachedBI;
* @return return a polymorphic copy of this calendar.
* @internal
*/
- virtual BuddhistCalendar* clone() const;
+ virtual BuddhistCalendar* clone() const override;
public:
/**
* same class ID. Objects of other classes have different class IDs.
* @internal
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Return the class ID for this class. This is useful only for comparing to a return
* @return calendar type
* @internal
*/
- virtual const char * getType() const;
+ virtual const char * getType() const override;
private:
BuddhistCalendar(); // default constructor not implemented
* @return the extended year
* @internal
*/
- virtual int32_t handleGetExtendedYear();
+ virtual int32_t handleGetExtendedYear() override;
/**
* Subclasses may override this method to compute several fields
* specific to each calendar system.
* @internal
*/
- virtual void handleComputeFields(int32_t julianDay, UErrorCode& status);
+ virtual void handleComputeFields(int32_t julianDay, UErrorCode& status) override;
/**
* Subclass API for defining limits of different types.
* @param field one of the field numbers
* <code>LEAST_MAXIMUM</code>, or <code>MAXIMUM</code>
* @internal
*/
- virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const;
+ virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const override;
/**
* Return the Julian day number of day before the first day of the
* given month in the given extended year. Subclasses should override
* @internal
*/
virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month,
- UBool useMonth) const;
+ UBool useMonth) const override;
/**
* Returns true because the Buddhist Calendar does have a default century
* @internal
*/
- virtual UBool haveDefaultCentury() const;
+ virtual UBool haveDefaultCentury() const override;
/**
* Returns the date of the start of the default century
* @return start of century - in milliseconds since epoch, 1970
* @internal
*/
- virtual UDate defaultCenturyStart() const;
+ virtual UDate defaultCenturyStart() const override;
/**
* Returns the year in which the default century begins
* @internal
*/
- virtual int32_t defaultCenturyStartYear() const;
+ virtual int32_t defaultCenturyStartYear() const override;
};
U_NAMESPACE_END
// return isStandardSupportedKeyword(keyword, status);
//}
- virtual void updateVisibleIDs(Hashtable& result, UErrorCode& status) const
+ virtual void updateVisibleIDs(Hashtable& result, UErrorCode& status) const override
{
if (U_SUCCESS(status)) {
for(int32_t i=0;gCalTypes[i] != NULL;i++) {
}
}
- virtual UObject* create(const ICUServiceKey& key, const ICUService* /*service*/, UErrorCode& status) const {
+ virtual UObject* create(const ICUServiceKey& key, const ICUService* /*service*/, UErrorCode& status) const override {
#ifdef U_DEBUG_CALSVC
if(dynamic_cast<const LocaleKey*>(&key) == NULL) {
fprintf(stderr, "::create - not a LocaleKey!\n");
DefaultCalendarFactory() : ICUResourceBundleFactory() { }
virtual ~DefaultCalendarFactory();
protected:
- virtual UObject* create(const ICUServiceKey& key, const ICUService* /*service*/, UErrorCode& status) const {
+ virtual UObject* create(const ICUServiceKey& key, const ICUService* /*service*/, UErrorCode& status) const override {
LocaleKey &lkey = (LocaleKey&)key;
Locale loc;
virtual ~CalendarService();
- virtual UObject* cloneInstance(UObject* instance) const {
+ virtual UObject* cloneInstance(UObject* instance) const override {
UnicodeString *s = dynamic_cast<UnicodeString *>(instance);
if(s != NULL) {
return s->clone();
}
}
- virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /*actualID*/, UErrorCode& status) const {
+ virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /*actualID*/, UErrorCode& status) const override {
LocaleKey& lkey = (LocaleKey&)key;
//int32_t kind = lkey.kind();
return nc;
}
- virtual UBool isDefault() const {
+ virtual UBool isDefault() const override {
return countFactories() == 1;
}
};
* Return JD of start of given month/extended year
* @internal
*/
- virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const;
+ virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const override;
/**
* Calculate the limit for a specified type of limit and field
* @internal
*/
- virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const;
+ virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const override;
/**
* (Overrides Calendar) Return true if the current date for this Calendar is in
* false, otherwise.
* @internal
*/
- virtual UBool inDaylightTime(UErrorCode&) const;
+ virtual UBool inDaylightTime(UErrorCode&) const override;
/**
* Returns true because Coptic/Ethiopic Calendar does have a default century
* @internal
*/
- virtual UBool haveDefaultCentury() const;
+ virtual UBool haveDefaultCentury() const override;
protected:
/**
virtual ~ChineseCalendar();
// clone
- virtual ChineseCalendar* clone() const;
+ virtual ChineseCalendar* clone() const override;
private:
//----------------------------------------------------------------------
protected:
- virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const;
- virtual int32_t handleGetMonthLength(int32_t extendedYear, int32_t month) const;
- virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const;
- virtual int32_t handleGetExtendedYear();
- virtual void handleComputeFields(int32_t julianDay, UErrorCode &status);
- virtual const UFieldResolutionTable* getFieldResolutionTable() const;
+ virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const override;
+ virtual int32_t handleGetMonthLength(int32_t extendedYear, int32_t month) const override;
+ virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const override;
+ virtual int32_t handleGetExtendedYear() override;
+ virtual void handleComputeFields(int32_t julianDay, UErrorCode &status) override;
+ virtual const UFieldResolutionTable* getFieldResolutionTable() const override;
public:
- virtual void add(UCalendarDateFields field, int32_t amount, UErrorCode &status);
- virtual void add(EDateFields field, int32_t amount, UErrorCode &status);
- virtual void roll(UCalendarDateFields field, int32_t amount, UErrorCode &status);
- virtual void roll(EDateFields field, int32_t amount, UErrorCode &status);
+ virtual void add(UCalendarDateFields field, int32_t amount, UErrorCode &status) override;
+ virtual void add(EDateFields field, int32_t amount, UErrorCode &status) override;
+ virtual void roll(UCalendarDateFields field, int32_t amount, UErrorCode &status) override;
+ virtual void roll(EDateFields field, int32_t amount, UErrorCode &status) override;
//----------------------------------------------------------------------
// Internal methods & astronomical calculations
* same class ID. Objects of other classes have different class IDs.
* @internal
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Return the class ID for this class. This is useful only for comparing to a return
* @return calendar type
* @internal
*/
- virtual const char * getType() const;
+ virtual const char * getType() const override;
protected:
* false, otherwise.
* @internal
*/
- virtual UBool inDaylightTime(UErrorCode& status) const;
+ virtual UBool inDaylightTime(UErrorCode& status) const override;
/**
* Returns true because the Islamic Calendar does have a default century
* @internal
*/
- virtual UBool haveDefaultCentury() const;
+ virtual UBool haveDefaultCentury() const override;
/**
* Returns the date of the start of the default century
* @return start of century - in milliseconds since epoch, 1970
* @internal
*/
- virtual UDate defaultCenturyStart() const;
+ virtual UDate defaultCenturyStart() const override;
/**
* Returns the year in which the default century begins
* @internal
*/
- virtual int32_t defaultCenturyStartYear() const;
+ virtual int32_t defaultCenturyStartYear() const override;
private: // default century stuff.
public:
MaxExpSink(UHashtable *h, UErrorCode &ec) : maxExpansions(h), errorCode(ec) {}
virtual ~MaxExpSink();
- virtual void handleCE(int64_t /*ce*/) {}
- virtual void handleExpansion(const int64_t ces[], int32_t length) {
+ virtual void handleCE(int64_t /*ce*/) override {}
+ virtual void handleExpansion(const int64_t ces[], int32_t length) override {
if (length <= 1) {
// We do not need to add single CEs into the map.
return;
ICUCollatorFactory() : ICUResourceBundleFactory(UnicodeString(U_ICUDATA_COLL, -1, US_INV)) { }
virtual ~ICUCollatorFactory();
protected:
- virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const;
+ virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const override;
};
ICUCollatorFactory::~ICUCollatorFactory() {}
virtual ~ICUCollatorService();
- virtual UObject* cloneInstance(UObject* instance) const {
+ virtual UObject* cloneInstance(UObject* instance) const override {
return ((Collator*)instance)->clone();
}
- virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* actualID, UErrorCode& status) const {
+ virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* actualID, UErrorCode& status) const override {
LocaleKey& lkey = (LocaleKey&)key;
if (actualID) {
// Ugly Hack Alert! We return an empty actualID to signal
return Collator::makeInstance(loc, status);
}
- virtual UObject* getKey(ICUServiceKey& key, UnicodeString* actualReturn, UErrorCode& status) const {
+ virtual UObject* getKey(ICUServiceKey& key, UnicodeString* actualReturn, UErrorCode& status) const override {
UnicodeString ar;
if (actualReturn == NULL) {
actualReturn = &ar;
return (Collator*)ICULocaleService::getKey(key, actualReturn, status);
}
- virtual UBool isDefault() const {
+ virtual UBool isDefault() const override {
return countFactories() == 1;
}
};
virtual ~CFactory();
- virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const;
+ virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const override;
protected:
- virtual const Hashtable* getSupportedIDs(UErrorCode& status) const
+ virtual const Hashtable* getSupportedIDs(UErrorCode& status) const override
{
if (U_SUCCESS(status)) {
return _ids;
}
virtual UnicodeString&
- getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const;
+ getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const override;
};
CFactory::~CFactory()
int32_t index;
public:
static UClassID U_EXPORT2 getStaticClassID(void);
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
public:
CollationLocaleListEnumeration()
: index(0)
virtual ~CollationLocaleListEnumeration();
- virtual StringEnumeration * clone() const
+ virtual StringEnumeration * clone() const override
{
CollationLocaleListEnumeration *result = new CollationLocaleListEnumeration();
if (result) {
return result;
}
- virtual int32_t count(UErrorCode &/*status*/) const {
+ virtual int32_t count(UErrorCode &/*status*/) const override {
return availableLocaleListCount;
}
- virtual const char* next(int32_t* resultLength, UErrorCode& /*status*/) {
+ virtual const char* next(int32_t* resultLength, UErrorCode& /*status*/) override {
const char* result;
if(index < availableLocaleListCount) {
result = availableLocaleList[index++].getName();
return result;
}
- virtual const UnicodeString* snext(UErrorCode& status) {
+ virtual const UnicodeString* snext(UErrorCode& status) override {
int32_t resultLength = 0;
const char *s = next(&resultLength, status);
return setChars(s, resultLength, status);
}
- virtual void reset(UErrorCode& /*status*/) {
+ virtual void reset(UErrorCode& /*status*/) override {
index = 0;
}
};
virtual void getRules(
const char *localeID, const char *collationType,
UnicodeString &rules,
- const char *&errorReason, UErrorCode &errorCode);
+ const char *&errorReason, UErrorCode &errorCode) override;
};
BundleImporter::~BundleImporter() {}
public:
CEFinalizer(const int64_t *ces) : finalCEs(ces) {}
virtual ~CEFinalizer();
- virtual int64_t modifyCE32(uint32_t ce32) const {
+ virtual int64_t modifyCE32(uint32_t ce32) const override {
U_ASSERT(!Collation::isSpecialCE32(ce32));
if(CollationBuilder::isTempCE32(ce32)) {
// retain case bits
return Collation::NO_CE;
}
}
- virtual int64_t modifyCE(int64_t ce) const {
+ virtual int64_t modifyCE(int64_t ce) const override {
if(CollationBuilder::isTempCE(ce)) {
// retain case bits
return finalCEs[CollationBuilder::indexFromTempCE(ce)] | (ce & 0xc000);
/** Implements CollationRuleParser::Sink. */
virtual void addReset(int32_t strength, const UnicodeString &str,
- const char *&errorReason, UErrorCode &errorCode);
+ const char *&errorReason, UErrorCode &errorCode) override;
/**
* Returns the secondary or tertiary weight preceding the current node's weight.
* node=nodes[index].
/** Implements CollationRuleParser::Sink. */
virtual void addRelation(int32_t strength, const UnicodeString &prefix,
const UnicodeString &str, const UnicodeString &extension,
- const char *&errorReason, UErrorCode &errorCode);
+ const char *&errorReason, UErrorCode &errorCode) override;
/**
* Picks one of the current CEs and finds or inserts a node in the graph
/** Implements CollationRuleParser::Sink. */
virtual void suppressContractions(const UnicodeSet &set, const char *&parserErrorReason,
- UErrorCode &errorCode);
+ UErrorCode &errorCode) override;
/** Implements CollationRuleParser::Sink. */
virtual void optimize(const UnicodeSet &set, const char *&parserErrorReason,
- UErrorCode &errorCode);
+ UErrorCode &errorCode) override;
/**
* Adds the mapping and its canonical closure.
int32_t fetchCEs(const UnicodeString &str, int32_t start, int64_t ces[], int32_t cesLength);
- virtual void resetToOffset(int32_t newOffset);
- virtual int32_t getOffset() const;
+ virtual void resetToOffset(int32_t newOffset) override;
+ virtual int32_t getOffset() const override;
- virtual UChar32 nextCodePoint(UErrorCode &errorCode);
- virtual UChar32 previousCodePoint(UErrorCode &errorCode);
+ virtual UChar32 nextCodePoint(UErrorCode &errorCode) override;
+ virtual UChar32 previousCodePoint(UErrorCode &errorCode) override;
protected:
- virtual void forwardNumCodePoints(int32_t num, UErrorCode &errorCode);
- virtual void backwardNumCodePoints(int32_t num, UErrorCode &errorCode);
+ virtual void forwardNumCodePoints(int32_t num, UErrorCode &errorCode) override;
+ virtual void backwardNumCodePoints(int32_t num, UErrorCode &errorCode) override;
- virtual uint32_t getDataCE32(UChar32 c) const;
- virtual uint32_t getCE32FromBuilderData(uint32_t ce32, UErrorCode &errorCode);
+ virtual uint32_t getDataCE32(UChar32 c) const override;
+ virtual uint32_t getCE32FromBuilderData(uint32_t ce32, UErrorCode &errorCode) override;
CollationDataBuilder &builder;
CollationData builderData;
void IgnoreBytes(int32_t numIgnore) { ignore_ = numIgnore; }
- virtual void Append(const char *bytes, int32_t n);
+ virtual void Append(const char *bytes, int32_t n) override;
void Append(uint32_t b) {
if (ignore_ > 0) {
--ignore_;
virtual char *GetAppendBuffer(int32_t min_capacity,
int32_t desired_capacity_hint,
char *scratch, int32_t scratch_capacity,
- int32_t *result_capacity);
+ int32_t *result_capacity) override;
int32_t NumberOfBytesAppended() const { return appended_; }
/**
* @return return a polymorphic copy of this calendar.
* @internal
*/
- virtual CopticCalendar* clone() const;
+ virtual CopticCalendar* clone() const override;
/**
* return the calendar type, "coptic"
* @return calendar type
* @internal
*/
- const char * getType() const;
+ const char * getType() const override;
protected:
//-------------------------------------------------------------------------
* Return the extended year defined by the current fields.
* @internal
*/
- virtual int32_t handleGetExtendedYear();
+ virtual int32_t handleGetExtendedYear() override;
/**
* Compute fields from the JD
* @internal
*/
- virtual void handleComputeFields(int32_t julianDay, UErrorCode &status);
+ virtual void handleComputeFields(int32_t julianDay, UErrorCode &status) override;
/**
* Returns the date of the start of the default century
* @return start of century - in milliseconds since epoch, 1970
* @internal
*/
- virtual UDate defaultCenturyStart() const;
+ virtual UDate defaultCenturyStart() const override;
/**
* Returns the year in which the default century begins
* @internal
*/
- virtual int32_t defaultCenturyStartYear() const;
+ virtual int32_t defaultCenturyStartYear() const override;
/**
* Return the date offset from Julian
* @internal
*/
- virtual int32_t getJDEpochOffset() const;
+ virtual int32_t getJDEpochOffset() const override;
public:
* same class ID. Objects of other classes have different class IDs.
* @internal
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Return the class ID for this class. This is useful only for comparing to a return
/**
* Transliterator API.
*/
- virtual CompoundTransliterator* clone() const;
+ virtual CompoundTransliterator* clone() const override;
/**
* Returns the number of transliterators in this chain.
* U+000A, U+0020..U+007E.
*/
virtual UnicodeString& toRules(UnicodeString& result,
- UBool escapeUnprintable) const;
+ UBool escapeUnprintable) const override;
protected:
/**
* Implement Transliterator framework
*/
- virtual void handleGetSourceSet(UnicodeSet& result) const;
+ virtual void handleGetSourceSet(UnicodeSet& result) const override;
public:
/**
* Override Transliterator framework
*/
- virtual UnicodeSet& getTargetSet(UnicodeSet& result) const;
+ virtual UnicodeSet& getTargetSet(UnicodeSet& result) const override;
protected:
/**
* Implements {@link Transliterator#handleTransliterate}.
*/
virtual void handleTransliterate(Replaceable& text, UTransPosition& idx,
- UBool incremental) const;
+ UBool incremental) const override;
public:
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
public:
virtual ~CharsetRecog_2022JP();
- const char *getName() const;
+ const char *getName() const override;
- UBool match(InputText *textIn, CharsetMatch *results) const;
+ UBool match(InputText *textIn, CharsetMatch *results) const override;
};
#if !UCONFIG_ONLY_HTML_CONVERSION
public:
virtual ~CharsetRecog_2022KR();
- const char *getName() const;
+ const char *getName() const override;
- UBool match(InputText *textIn, CharsetMatch *results) const;
+ UBool match(InputText *textIn, CharsetMatch *results) const override;
};
public:
virtual ~CharsetRecog_2022CN();
- const char* getName() const;
+ const char* getName() const override;
- UBool match(InputText *textIn, CharsetMatch *results) const;
+ UBool match(InputText *textIn, CharsetMatch *results) const override;
};
#endif
private:
int32_t alef;
int32_t isLamAlef(int32_t b);
- int32_t nextByte(InputText *det);
- void parseCharacters(InputText *det);
+ int32_t nextByte(InputText *det) override;
+ void parseCharacters(InputText *det) override;
};
#endif
{
public:
virtual ~CharsetRecog_8859_1();
- const char *getName() const;
- virtual UBool match(InputText *det, CharsetMatch *results) const;
+ const char *getName() const override;
+ virtual UBool match(InputText *det, CharsetMatch *results) const override;
};
class CharsetRecog_8859_2 : public CharsetRecog_sbcs
{
public:
virtual ~CharsetRecog_8859_2();
- const char *getName() const;
- virtual UBool match(InputText *det, CharsetMatch *results) const;
+ const char *getName() const override;
+ virtual UBool match(InputText *det, CharsetMatch *results) const override;
};
class CharsetRecog_8859_5 : public CharsetRecog_sbcs
{
public:
virtual ~CharsetRecog_8859_5();
- const char *getName() const;
+ const char *getName() const override;
};
class CharsetRecog_8859_6 : public CharsetRecog_sbcs
public:
virtual ~CharsetRecog_8859_6();
- const char *getName() const;
+ const char *getName() const override;
};
class CharsetRecog_8859_7 : public CharsetRecog_sbcs
public:
virtual ~CharsetRecog_8859_7();
- const char *getName() const;
+ const char *getName() const override;
};
class CharsetRecog_8859_8 : public CharsetRecog_sbcs
public:
virtual ~CharsetRecog_8859_8();
- virtual const char *getName() const;
+ virtual const char *getName() const override;
};
class CharsetRecog_8859_9 : public CharsetRecog_sbcs
public:
virtual ~CharsetRecog_8859_9();
- const char *getName() const;
+ const char *getName() const override;
};
public:
virtual ~CharsetRecog_8859_5_ru();
- const char *getLanguage() const;
+ const char *getLanguage() const override;
- virtual UBool match(InputText *det, CharsetMatch *results) const;
+ virtual UBool match(InputText *det, CharsetMatch *results) const override;
};
class CharsetRecog_8859_6_ar : public CharsetRecog_8859_6
public:
virtual ~CharsetRecog_8859_6_ar();
- const char *getLanguage() const;
+ const char *getLanguage() const override;
- virtual UBool match(InputText *det, CharsetMatch *results) const;
+ virtual UBool match(InputText *det, CharsetMatch *results) const override;
};
class CharsetRecog_8859_7_el : public CharsetRecog_8859_7
public:
virtual ~CharsetRecog_8859_7_el();
- const char *getLanguage() const;
+ const char *getLanguage() const override;
- virtual UBool match(InputText *det, CharsetMatch *results) const;
+ virtual UBool match(InputText *det, CharsetMatch *results) const override;
};
class CharsetRecog_8859_8_I_he : public CharsetRecog_8859_8
public:
virtual ~CharsetRecog_8859_8_I_he();
- const char *getName() const;
+ const char *getName() const override;
- const char *getLanguage() const;
+ const char *getLanguage() const override;
- virtual UBool match(InputText *det, CharsetMatch *results) const;
+ virtual UBool match(InputText *det, CharsetMatch *results) const override;
};
class CharsetRecog_8859_8_he : public CharsetRecog_8859_8
public:
virtual ~CharsetRecog_8859_8_he ();
- const char *getLanguage() const;
+ const char *getLanguage() const override;
- virtual UBool match(InputText *det, CharsetMatch *results) const;
+ virtual UBool match(InputText *det, CharsetMatch *results) const override;
};
class CharsetRecog_8859_9_tr : public CharsetRecog_8859_9
public:
virtual ~CharsetRecog_8859_9_tr ();
- const char *getLanguage() const;
+ const char *getLanguage() const override;
- virtual UBool match(InputText *det, CharsetMatch *results) const;
+ virtual UBool match(InputText *det, CharsetMatch *results) const override;
};
class CharsetRecog_windows_1256 : public CharsetRecog_sbcs
public:
virtual ~CharsetRecog_windows_1256();
- const char *getName() const;
+ const char *getName() const override;
- const char *getLanguage() const;
+ const char *getLanguage() const override;
- virtual UBool match(InputText *det, CharsetMatch *results) const;
+ virtual UBool match(InputText *det, CharsetMatch *results) const override;
};
class CharsetRecog_windows_1251 : public CharsetRecog_sbcs
public:
virtual ~CharsetRecog_windows_1251();
- const char *getName() const;
+ const char *getName() const override;
- const char *getLanguage() const;
+ const char *getLanguage() const override;
- virtual UBool match(InputText *det, CharsetMatch *results) const;
+ virtual UBool match(InputText *det, CharsetMatch *results) const override;
};
public:
virtual ~CharsetRecog_KOI8_R();
- const char *getName() const;
+ const char *getName() const override;
- const char *getLanguage() const;
+ const char *getLanguage() const override;
- virtual UBool match(InputText *det, CharsetMatch *results) const;
+ virtual UBool match(InputText *det, CharsetMatch *results) const override;
};
#if !UCONFIG_ONLY_HTML_CONVERSION
public:
virtual ~CharsetRecog_IBM424_he();
- const char *getLanguage() const;
+ const char *getLanguage() const override;
};
class CharsetRecog_IBM424_he_rtl : public CharsetRecog_IBM424_he {
public:
virtual ~CharsetRecog_IBM424_he_rtl();
- const char *getName() const;
+ const char *getName() const override;
- virtual UBool match(InputText *det, CharsetMatch *results) const;
+ virtual UBool match(InputText *det, CharsetMatch *results) const override;
};
class CharsetRecog_IBM424_he_ltr : public CharsetRecog_IBM424_he {
virtual ~CharsetRecog_IBM424_he_ltr();
- const char *getName() const;
+ const char *getName() const override;
- virtual UBool match(InputText *det, CharsetMatch *results) const;
+ virtual UBool match(InputText *det, CharsetMatch *results) const override;
};
class CharsetRecog_IBM420_ar : public CharsetRecog_sbcs
public:
virtual ~CharsetRecog_IBM420_ar();
- const char *getLanguage() const;
- int32_t match_sbcs(InputText *det, const int32_t ngrams[], const uint8_t charMap[]) const;
+ const char *getLanguage() const override;
+ int32_t match_sbcs(InputText *det, const int32_t ngrams[], const uint8_t charMap[]) const override;
};
public:
virtual ~CharsetRecog_IBM420_ar_rtl();
- const char *getName() const;
+ const char *getName() const override;
- virtual UBool match(InputText *det, CharsetMatch *results) const;
+ virtual UBool match(InputText *det, CharsetMatch *results) const override;
};
class CharsetRecog_IBM420_ar_ltr : public CharsetRecog_IBM420_ar {
virtual ~CharsetRecog_IBM420_ar_ltr();
- const char *getName() const;
+ const char *getName() const override;
- virtual UBool match(InputText *det, CharsetMatch *results) const;
+ virtual UBool match(InputText *det, CharsetMatch *results) const override;
};
#endif
virtual ~CharsetRecog_UTF8();
- const char *getName() const;
+ const char *getName() const override;
/* (non-Javadoc)
* @see com.ibm.icu.text.CharsetRecognizer#match(com.ibm.icu.text.CharsetDetector)
*/
- UBool match(InputText *input, CharsetMatch *results) const;
+ UBool match(InputText *input, CharsetMatch *results) const override;
};
/**
* Override Format API.
*/
- virtual CurrencyFormat* clone() const;
+ virtual CurrencyFormat* clone() const override;
using MeasureFormat::format;
virtual UnicodeString& format(const Formattable& obj,
UnicodeString& appendTo,
FieldPosition& pos,
- UErrorCode& ec) const;
+ UErrorCode& ec) const override;
/**
* Override Format API.
*/
virtual void parseObject(const UnicodeString& source,
Formattable& result,
- ParsePosition& pos) const;
+ ParsePosition& pos) const override;
/**
* Override Format API.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* Returns the class ID for this class.
* Clone.
* @internal
*/
- virtual DangiCalendar* clone() const;
+ virtual DangiCalendar* clone() const override;
//----------------------------------------------------------------------
// Internal methods & astronomical calculations
* same class ID. Objects of other classes have different class IDs.
* @internal
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Return the class ID for this class. This is useful only for comparing to a return
* @return calendar type
* @internal
*/
- const char * getType() const;
+ const char * getType() const override;
private:
private:
UnicodeString fSkeleton;
protected:
- virtual bool equals(const CacheKeyBase &other) const {
+ virtual bool equals(const CacheKeyBase &other) const override {
if (!LocaleCacheKey<DateFmtBestPattern>::equals(other)) {
return false;
}
LocaleCacheKey<DateFmtBestPattern>(other),
fSkeleton(other.fSkeleton) { }
virtual ~DateFmtBestPatternKey();
- virtual int32_t hashCode() const {
+ virtual int32_t hashCode() const override {
return (int32_t)(37u * (uint32_t)LocaleCacheKey<DateFmtBestPattern>::hashCode() + (uint32_t)fSkeleton.hashCode());
}
inline bool operator==(const DateFmtBestPatternKey &other) const {
return fSkeleton == other.fSkeleton;
}
- virtual CacheKeyBase *clone() const {
+ virtual CacheKeyBase *clone() const override {
return new DateFmtBestPatternKey(*this);
}
virtual const DateFmtBestPattern *createObject(
- const void * /*unused*/, UErrorCode &status) const {
+ const void * /*unused*/, UErrorCode &status) const override {
LocalPointer<DateTimePatternGenerator> dtpg(
DateTimePatternGenerator::createInstance(fLoc, status));
if (U_FAILURE(status)) {
}
virtual ~DayPeriodRulesDataSink();
- virtual void put(const char *key, ResourceValue &value, UBool, UErrorCode &errorCode) {
+ virtual void put(const char *key, ResourceValue &value, UBool, UErrorCode &errorCode) override {
ResourceTable dayPeriodData = value.getTable(errorCode);
if (U_FAILURE(errorCode)) { return; }
struct DayPeriodRulesCountSink : public ResourceSink {
virtual ~DayPeriodRulesCountSink();
- virtual void put(const char *key, ResourceValue &value, UBool, UErrorCode &errorCode) {
+ virtual void put(const char *key, ResourceValue &value, UBool, UErrorCode &errorCode) override {
ResourceTable rules = value.getTable(errorCode);
if (U_FAILURE(errorCode)) { return; }
virtual ~DecFmtSymDataSink();
virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/,
- UErrorCode &errorCode) {
+ UErrorCode &errorCode) override {
ResourceTable symbolsTable = value.getTable(errorCode);
if (U_FAILURE(errorCode)) { return; }
for (int32_t j = 0; symbolsTable.getKeyAndValue(j, key, value); ++j) {
virtual ~CurrencySpacingSink();
virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/,
- UErrorCode &errorCode) {
+ UErrorCode &errorCode) override {
ResourceTable spacingTypesTable = value.getTable(errorCode);
for (int32_t i = 0; spacingTypesTable.getKeyAndValue(i, key, value); ++i) {
UBool beforeCurrency;
aliasPathPairs.removeAllElements();
}
- virtual void put(const char *key, ResourceValue &value, UBool, UErrorCode &errorCode) {
+ virtual void put(const char *key, ResourceValue &value, UBool, UErrorCode &errorCode) override {
if (U_FAILURE(errorCode)) { return; }
U_ASSERT(!currentCalendarType.isEmpty());
: dateIntervalInfo(diInfo), nextCalendarType(currentCalendarType, -1, US_INV) { }
virtual ~DateIntervalSink();
- virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/, UErrorCode &errorCode) {
+ virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/, UErrorCode &errorCode) override {
if (U_FAILURE(errorCode)) { return; }
// Iterate over all the calendar entries and only pick the 'intervalFormats' table.
virtual ~AllowedHourFormatsSink();
virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/,
- UErrorCode &errorCode) {
+ UErrorCode &errorCode) override {
ResourceTable timeData = value.getTable(errorCode);
if (U_FAILURE(errorCode)) { return; }
for (int32_t i = 0; timeData.getKeyAndValue(i, key, value); ++i) {
virtual ~AppendItemFormatsSink();
virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/,
- UErrorCode &errorCode) {
+ UErrorCode &errorCode) override {
UDateTimePatternField field = dtpg.getAppendFormatNumber(key);
if (field == UDATPG_FIELD_COUNT) { return; }
const UnicodeString& valueStr = value.getUnicodeString(errorCode);
virtual ~AppendItemNamesSink();
virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/,
- UErrorCode &errorCode) {
+ UErrorCode &errorCode) override {
UDateTimePGDisplayWidth width;
UDateTimePatternField field = dtpg.getFieldAndWidthIndices(key, &width);
if (field == UDATPG_FIELD_COUNT) { return; }
virtual ~AvailableFormatsSink();
virtual void put(const char *key, ResourceValue &value, UBool isRoot,
- UErrorCode &errorCode) {
+ UErrorCode &errorCode) override {
const UnicodeString formatKey(key, -1, US_INV);
if (!dtpg.isAvailableFormatSet(formatKey) ) {
dtpg.setAvailableFormat(formatKey, errorCode);
DTSkeletonEnumeration(PatternMap& patternMap, dtStrEnum type, UErrorCode& status);
virtual ~DTSkeletonEnumeration();
static UClassID U_EXPORT2 getStaticClassID(void);
- virtual UClassID getDynamicClassID(void) const;
- virtual const UnicodeString* snext(UErrorCode& status);
- virtual void reset(UErrorCode& status);
- virtual int32_t count(UErrorCode& status) const;
+ virtual UClassID getDynamicClassID(void) const override;
+ virtual const UnicodeString* snext(UErrorCode& status) override;
+ virtual void reset(UErrorCode& status) override;
+ virtual int32_t count(UErrorCode& status) const override;
private:
int32_t pos;
UBool isCanonicalItem(const UnicodeString& item);
DTRedundantEnumeration();
virtual ~DTRedundantEnumeration();
static UClassID U_EXPORT2 getStaticClassID(void);
- virtual UClassID getDynamicClassID(void) const;
- virtual const UnicodeString* snext(UErrorCode& status);
- virtual void reset(UErrorCode& status);
- virtual int32_t count(UErrorCode& status) const;
+ virtual UClassID getDynamicClassID(void) const override;
+ virtual const UnicodeString* snext(UErrorCode& status) override;
+ virtual void reset(UErrorCode& status) override;
+ virtual int32_t count(UErrorCode& status) const override;
void add(const UnicodeString &pattern, UErrorCode& status);
private:
int32_t pos;
/**
* Transliterator API.
*/
- virtual EscapeTransliterator* clone() const;
+ virtual EscapeTransliterator* clone() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* Implements {@link Transliterator#handleTransliterate}.
*/
virtual void handleTransliterate(Replaceable& text, UTransPosition& offset,
- UBool isIncremental) const;
+ UBool isIncremental) const override;
};
* @return return a polymorphic copy of this calendar.
* @internal
*/
- virtual EthiopicCalendar* clone() const;
+ virtual EthiopicCalendar* clone() const override;
/**
* return the calendar type, "ethiopic"
* @return calendar type
* @internal
*/
- virtual const char * getType() const;
+ virtual const char * getType() const override;
/**
* Set Alem or Mihret era.
* Return the extended year defined by the current fields.
* @internal
*/
- virtual int32_t handleGetExtendedYear();
+ virtual int32_t handleGetExtendedYear() override;
/**
* Compute fields from the JD
* @internal
*/
- virtual void handleComputeFields(int32_t julianDay, UErrorCode &status);
+ virtual void handleComputeFields(int32_t julianDay, UErrorCode &status) override;
/**
* Calculate the limit for a specified type of limit and field
* @internal
*/
- virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const;
+ virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const override;
/**
* Returns the date of the start of the default century
* @return start of century - in milliseconds since epoch, 1970
* @internal
*/
- virtual UDate defaultCenturyStart() const;
+ virtual UDate defaultCenturyStart() const override;
/**
* Returns the year in which the default century begins
* @internal
*/
- virtual int32_t defaultCenturyStartYear() const;
+ virtual int32_t defaultCenturyStartYear() const override;
/**
* Return the date offset from Julian
* @internal
*/
- virtual int32_t getJDEpochOffset() const;
+ virtual int32_t getJDEpochOffset() const override;
private:
/**
* same class ID. Objects of other classes have different class IDs.
* @internal
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Return the class ID for this class. This is useful only for comparing to a return
/**
* Implement UnicodeFunctor
*/
- virtual FunctionReplacer* clone() const;
+ virtual FunctionReplacer* clone() const override;
/**
* UnicodeFunctor API. Cast 'this' to a UnicodeReplacer* pointer
* and return the pointer.
*/
- virtual UnicodeReplacer* toReplacer() const;
+ virtual UnicodeReplacer* toReplacer() const override;
/**
* UnicodeReplacer API
virtual int32_t replace(Replaceable& text,
int32_t start,
int32_t limit,
- int32_t& cursor);
+ int32_t& cursor) override;
/**
* UnicodeReplacer API
*/
virtual UnicodeString& toReplacerPattern(UnicodeString& rule,
- UBool escapeUnprintable) const;
+ UBool escapeUnprintable) const override;
/**
* Implement UnicodeReplacer
*/
- virtual void addReplacementSetTo(UnicodeSet& toUnionTo) const;
+ virtual void addReplacementSetTo(UnicodeSet& toUnionTo) const override;
/**
* UnicodeFunctor API
*/
- virtual void setData(const TransliterationRuleData*);
+ virtual void setData(const TransliterationRuleData*) override;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* @return return a polymorphic copy of this calendar.
* @internal
*/
- virtual HebrewCalendar* clone() const;
+ virtual HebrewCalendar* clone() const override;
public:
/**
* same class ID. Objects of other classes have different class IDs.
* @internal
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Return the class ID for this class. This is useful only for comparing to a return
* @return calendar type
* @internal
*/
- virtual const char * getType() const;
+ virtual const char * getType() const override;
// Calendar API
* previously set in the time field is invalid, this will be set to
* an error status.
*/
- virtual void add(UCalendarDateFields field, int32_t amount, UErrorCode& status);
+ virtual void add(UCalendarDateFields field, int32_t amount, UErrorCode& status) override;
/**
* @deprecated ICU 2.6 use UCalendarDateFields instead of EDateFields
*/
- virtual void add(EDateFields field, int32_t amount, UErrorCode& status);
+ virtual void add(EDateFields field, int32_t amount, UErrorCode& status) override;
/**
* an error status.
* @internal
*/
- virtual void roll(UCalendarDateFields field, int32_t amount, UErrorCode& status);
+ virtual void roll(UCalendarDateFields field, int32_t amount, UErrorCode& status) override;
/**
* (Overrides Calendar) Rolls up or down by the given amount in the specified field.
* an error status.
* @deprecated ICU 2.6. Use roll(UCalendarDateFields field, int32_t amount, UErrorCode& status) instead.
` */
- virtual void roll(EDateFields field, int32_t amount, UErrorCode& status);
+ virtual void roll(EDateFields field, int32_t amount, UErrorCode& status) override;
/**
* @internal
* <code>LEAST_MAXIMUM</code>, or <code>MAXIMUM</code>
* @internal
*/
- virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const;
+ virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const override;
/**
* Return the number of days in the given month of the given extended
* implementation than the default implementation in Calendar.
* @internal
*/
- virtual int32_t handleGetMonthLength(int32_t extendedYear, int32_t month) const;
+ virtual int32_t handleGetMonthLength(int32_t extendedYear, int32_t month) const override;
/**
* Return the number of days in the given extended year of this
* default implementation in Calendar.
* @stable ICU 2.0
*/
- virtual int32_t handleGetYearLength(int32_t eyear) const;
+ virtual int32_t handleGetYearLength(int32_t eyear) const override;
/**
* Subclasses may override this method to compute several fields
* specific to each calendar system. These are:
* a calendar with the specified Julian/Gregorian cutover date.
* @internal
*/
- virtual void handleComputeFields(int32_t julianDay, UErrorCode &status);
+ virtual void handleComputeFields(int32_t julianDay, UErrorCode &status) override;
/**
* Return the extended year defined by the current fields. This will
* use the UCAL_EXTENDED_YEAR field or the UCAL_YEAR and supra-year fields (such
* @return the extended year
* @internal
*/
- virtual int32_t handleGetExtendedYear();
+ virtual int32_t handleGetExtendedYear() override;
/**
* Return the Julian day number of day before the first day of the
* given month in the given extended year. Subclasses should override
* @internal
*/
virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month,
- UBool useMonth) const;
+ UBool useMonth) const override;
/**
* special handling for month validation for Hebrew calendar.
* @internal
*/
- virtual void validateField(UCalendarDateFields field, UErrorCode &status);
+ virtual void validateField(UCalendarDateFields field, UErrorCode &status) override;
protected:
* false, otherwise.
* @internal
*/
- virtual UBool inDaylightTime(UErrorCode& status) const;
+ virtual UBool inDaylightTime(UErrorCode& status) const override;
- /**
- * Returns true because the Hebrew Calendar does have a default century
- * @internal
- */
- virtual UBool haveDefaultCentury() const;
+ /**
+ * Returns true because the Hebrew Calendar does have a default century
+ * @internal
+ */
+ virtual UBool haveDefaultCentury() const override;
- /**
- * Returns the date of the start of the default century
- * @return start of century - in milliseconds since epoch, 1970
- * @internal
- */
- virtual UDate defaultCenturyStart() const;
+ /**
+ * Returns the date of the start of the default century
+ * @return start of century - in milliseconds since epoch, 1970
+ * @internal
+ */
+ virtual UDate defaultCenturyStart() const override;
- /**
- * Returns the year in which the default century begins
- * @internal
- */
- virtual int32_t defaultCenturyStartYear() const;
+ /**
+ * Returns the year in which the default century begins
+ * @internal
+ */
+ virtual int32_t defaultCenturyStartYear() const override;
private: // Calendar-specific implementation
/**
// TODO: copy c'tor, etc
// clone
- virtual IndianCalendar* clone() const;
+ virtual IndianCalendar* clone() const override;
private:
/**
/**
* @internal
*/
- virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const;
+ virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const override;
/**
* Return the length (in days) of the given month.
* @param year The month(0-based) in Indian year
* @internal
*/
- virtual int32_t handleGetMonthLength(int32_t extendedYear, int32_t month) const;
+ virtual int32_t handleGetMonthLength(int32_t extendedYear, int32_t month) const override;
/**
* Return the number of days in the given Indian year
* @internal
*/
- virtual int32_t handleGetYearLength(int32_t extendedYear) const;
+ virtual int32_t handleGetYearLength(int32_t extendedYear) const override;
//-------------------------------------------------------------------------
// Functions for converting from field values to milliseconds....
/**
* @internal
*/
- virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const;
+ virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const override;
//-------------------------------------------------------------------------
// Functions for converting from milliseconds to field values
/**
* @internal
*/
- virtual int32_t handleGetExtendedYear();
+ virtual int32_t handleGetExtendedYear() override;
/**
* Override Calendar to compute several fields specific to the Indian
* calendar equivalents for the given Julian day.
* @internal
*/
- virtual void handleComputeFields(int32_t julianDay, UErrorCode &status);
+ virtual void handleComputeFields(int32_t julianDay, UErrorCode &status) override;
// UObject stuff
public:
* same class ID. Objects of other classes have different class IDs.
* @internal
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Return the class ID for this class. This is useful only for comparing to a return
* @return calendar type
* @internal
*/
- virtual const char * getType() const;
+ virtual const char * getType() const override;
private:
IndianCalendar(); // default constructor not implemented
* false, otherwise.
* @internal
*/
- virtual UBool inDaylightTime(UErrorCode& status) const;
+ virtual UBool inDaylightTime(UErrorCode& status) const override;
/**
* Returns true because the Indian Calendar does have a default century
* @internal
*/
- virtual UBool haveDefaultCentury() const;
+ virtual UBool haveDefaultCentury() const override;
/**
* Returns the date of the start of the default century
* @return start of century - in milliseconds since epoch, 1970
* @internal
*/
- virtual UDate defaultCenturyStart() const;
+ virtual UDate defaultCenturyStart() const override;
/**
* Returns the year in which the default century begins
* @internal
*/
- virtual int32_t defaultCenturyStartYear() const;
+ virtual int32_t defaultCenturyStartYear() const override;
};
U_NAMESPACE_END
// TODO: copy c'tor, etc
// clone
- virtual IslamicCalendar* clone() const;
+ virtual IslamicCalendar* clone() const override;
private:
/**
/**
* @internal
*/
- virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const;
+ virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const override;
/**
* Return the length (in days) of the given month.
* @param year The hijri month, 0-based
* @internal
*/
- virtual int32_t handleGetMonthLength(int32_t extendedYear, int32_t month) const;
+ virtual int32_t handleGetMonthLength(int32_t extendedYear, int32_t month) const override;
/**
* Return the number of days in the given Islamic year
* @internal
*/
- virtual int32_t handleGetYearLength(int32_t extendedYear) const;
+ virtual int32_t handleGetYearLength(int32_t extendedYear) const override;
//-------------------------------------------------------------------------
// Functions for converting from field values to milliseconds....
/**
* @internal
*/
- virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const;
+ virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const override;
//-------------------------------------------------------------------------
// Functions for converting from milliseconds to field values
/**
* @internal
*/
- virtual int32_t handleGetExtendedYear();
+ virtual int32_t handleGetExtendedYear() override;
/**
* Override Calendar to compute several fields specific to the Islamic
* calendar equivalents for the given Julian day.
* @internal
*/
- virtual void handleComputeFields(int32_t julianDay, UErrorCode &status);
+ virtual void handleComputeFields(int32_t julianDay, UErrorCode &status) override;
// UObject stuff
public:
* same class ID. Objects of other classes have different class IDs.
* @internal
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Return the class ID for this class. This is useful only for comparing to a return
* @return calendar type
* @internal
*/
- virtual const char * getType() const;
+ virtual const char * getType() const override;
private:
IslamicCalendar(); // default constructor not implemented
* false, otherwise.
* @internal
*/
- virtual UBool inDaylightTime(UErrorCode& status) const;
+ virtual UBool inDaylightTime(UErrorCode& status) const override;
/**
* Returns true because the Islamic Calendar does have a default century
* @internal
*/
- virtual UBool haveDefaultCentury() const;
+ virtual UBool haveDefaultCentury() const override;
/**
* Returns the date of the start of the default century
* @return start of century - in milliseconds since epoch, 1970
* @internal
*/
- virtual UDate defaultCenturyStart() const;
+ virtual UDate defaultCenturyStart() const override;
/**
* Returns the year in which the default century begins
* @internal
*/
- virtual int32_t defaultCenturyStartYear() const;
+ virtual int32_t defaultCenturyStartYear() const override;
private:
/**
* @return return a polymorphic copy of this calendar.
* @internal
*/
- virtual JapaneseCalendar* clone() const;
+ virtual JapaneseCalendar* clone() const override;
/**
* Return the extended year defined by the current fields. In the
* Japanese calendar case, this is equal to the equivalent extended Gregorian year.
* @internal
*/
- virtual int32_t handleGetExtendedYear();
+ virtual int32_t handleGetExtendedYear() override;
/**
* Return the maximum value that this field could have, given the current date.
* @internal
*/
- virtual int32_t getActualMaximum(UCalendarDateFields field, UErrorCode& status) const;
+ virtual int32_t getActualMaximum(UCalendarDateFields field, UErrorCode& status) const override;
public:
* same class ID. Objects of other classes have different class IDs.
* @internal
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Return the class ID for this class. This is useful only for comparing to a return
* @return calendar type
* @internal
*/
- virtual const char * getType() const;
+ virtual const char * getType() const override;
/**
* @return false - no default century in Japanese
* @internal
*/
- virtual UBool haveDefaultCentury() const;
+ virtual UBool haveDefaultCentury() const override;
/**
* Not used - no default century.
* @internal
*/
- virtual UDate defaultCenturyStart() const;
+ virtual UDate defaultCenturyStart() const override;
/**
* Not used - no default century.
* @internal
*/
- virtual int32_t defaultCenturyStartYear() const;
+ virtual int32_t defaultCenturyStartYear() const override;
private:
JapaneseCalendar(); // default constructor not implemented
* Calculate the era for internal computation
* @internal
*/
- virtual int32_t internalGetEra() const;
+ virtual int32_t internalGetEra() const override;
/**
* Compute fields from the JD
* @internal
*/
- virtual void handleComputeFields(int32_t julianDay, UErrorCode& status);
+ virtual void handleComputeFields(int32_t julianDay, UErrorCode& status) override;
/**
* Calculate the limit for a specified type of limit and field
* @internal
*/
- virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const;
+ virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const override;
/***
* Called by computeJulianDay. Returns the default month (0-based) for the year,
* @param eyear the extended year
* @internal
*/
- virtual int32_t getDefaultMonthInYear(int32_t eyear);
+ virtual int32_t getDefaultMonthInYear(int32_t eyear) override;
/***
* Called by computeJulianDay. Returns the default day (1-based) for the month,
* @param mon the month in the year
* @internal
*/
- virtual int32_t getDefaultDayInMonth(int32_t eyear, int32_t month);
+ virtual int32_t getDefaultDayInMonth(int32_t eyear, int32_t month) override;
};
U_NAMESPACE_END
}
virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/,
- UErrorCode &errorCode) {
+ UErrorCode &errorCode) override {
aliasedStyle[0] = 0;
if (value.getType() == URES_ALIAS) {
setAliasedStyle(value.getAliasUnicodeString(errorCode));
* @param noFallback Ignored.
* @param status The standard ICU error code output parameter.
*/
- void put(const char * /*key*/, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) {
+ void put(const char * /*key*/, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) override {
ResourceTable table = value.getTable(status);
if (U_FAILURE(status)) return;
explicit CategoriesSink(const UChar **out, int32_t &outSize, BytesTrieBuilder &trieBuilder)
: outQuantitiesArray(out), outSize(outSize), trieBuilder(trieBuilder), outIndex(0) {}
- void put(const char * /*key*/, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) {
+ void put(const char * /*key*/, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) override {
ResourceArray array = value.getArray(status);
if (U_FAILURE(status)) {
return;
FormatNameEnumeration(UVector *fFormatNames, UErrorCode& status);
virtual ~FormatNameEnumeration();
static UClassID U_EXPORT2 getStaticClassID(void);
- virtual UClassID getDynamicClassID(void) const;
- virtual const UnicodeString* snext(UErrorCode& status);
- virtual void reset(UErrorCode& status);
- virtual int32_t count(UErrorCode& status) const;
+ virtual UClassID getDynamicClassID(void) const override;
+ virtual const UnicodeString* snext(UErrorCode& status) override;
+ virtual void reset(UErrorCode& status) override;
+ virtual int32_t count(UErrorCode& status) const override;
private:
int32_t pos;
UVector *fFormatNames;
* Transliterator API.
* @return A copy of the object.
*/
- virtual NameUnicodeTransliterator* clone() const;
+ virtual NameUnicodeTransliterator* clone() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* pos.contextLimit. Otherwise, assume the text is complete.
*/
virtual void handleTransliterate(Replaceable& text, UTransPosition& offset,
- UBool isIncremental) const;
+ UBool isIncremental) const override;
/**
* Set of characters which occur in Unicode character names.
UErrorCode& status);
virtual ~SameValueSubstitution();
- virtual int64_t transformNumber(int64_t number) const { return number; }
- virtual double transformNumber(double number) const { return number; }
- virtual double composeRuleValue(double newRuleValue, double /*oldRuleValue*/) const { return newRuleValue; }
- virtual double calcUpperBound(double oldUpperBound) const { return oldUpperBound; }
- virtual UChar tokenChar() const { return (UChar)0x003d; } // '='
+ virtual int64_t transformNumber(int64_t number) const override { return number; }
+ virtual double transformNumber(double number) const override { return number; }
+ virtual double composeRuleValue(double newRuleValue, double /*oldRuleValue*/) const override { return newRuleValue; }
+ virtual double calcUpperBound(double oldUpperBound) const override { return oldUpperBound; }
+ virtual UChar tokenChar() const override { return (UChar)0x003d; } // '='
public:
static UClassID getStaticClassID(void);
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
};
SameValueSubstitution::~SameValueSubstitution() {}
}
virtual ~MultiplierSubstitution();
- virtual void setDivisor(int32_t radix, int16_t exponent, UErrorCode& status) {
+ virtual void setDivisor(int32_t radix, int16_t exponent, UErrorCode& status) override {
divisor = util64_pow(radix, exponent);
if(divisor == 0) {
}
}
- virtual bool operator==(const NFSubstitution& rhs) const;
+ virtual bool operator==(const NFSubstitution& rhs) const override;
- virtual int64_t transformNumber(int64_t number) const {
+ virtual int64_t transformNumber(int64_t number) const override {
return number / divisor;
}
- virtual double transformNumber(double number) const {
+ virtual double transformNumber(double number) const override {
if (getRuleSet()) {
return uprv_floor(number / divisor);
} else {
}
}
- virtual double composeRuleValue(double newRuleValue, double /*oldRuleValue*/) const {
+ virtual double composeRuleValue(double newRuleValue, double /*oldRuleValue*/) const override {
return newRuleValue * divisor;
}
- virtual double calcUpperBound(double /*oldUpperBound*/) const { return static_cast<double>(divisor); }
+ virtual double calcUpperBound(double /*oldUpperBound*/) const override { return static_cast<double>(divisor); }
- virtual UChar tokenChar() const { return (UChar)0x003c; } // '<'
+ virtual UChar tokenChar() const override { return (UChar)0x003c; } // '<'
public:
static UClassID getStaticClassID(void);
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
};
MultiplierSubstitution::~MultiplierSubstitution() {}
UErrorCode& status);
virtual ~ModulusSubstitution();
- virtual void setDivisor(int32_t radix, int16_t exponent, UErrorCode& status) {
+ virtual void setDivisor(int32_t radix, int16_t exponent, UErrorCode& status) override {
divisor = util64_pow(radix, exponent);
if (divisor == 0) {
}
}
- virtual bool operator==(const NFSubstitution& rhs) const;
+ virtual bool operator==(const NFSubstitution& rhs) const override;
- 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;
+ virtual void doSubstitution(int64_t number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const override;
+ virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const override;
- virtual int64_t transformNumber(int64_t number) const { return number % divisor; }
- virtual double transformNumber(double number) const { return uprv_fmod(number, static_cast<double>(divisor)); }
+ virtual int64_t transformNumber(int64_t number) const override { return number % divisor; }
+ virtual double transformNumber(double number) const override { return uprv_fmod(number, static_cast<double>(divisor)); }
virtual UBool doParse(const UnicodeString& text,
ParsePosition& parsePosition,
double upperBound,
UBool lenientParse,
uint32_t nonNumericalExecutedRuleMask,
- Formattable& result) const;
+ Formattable& result) const override;
- virtual double composeRuleValue(double newRuleValue, double oldRuleValue) const {
+ virtual double composeRuleValue(double newRuleValue, double oldRuleValue) const override {
return oldRuleValue - uprv_fmod(oldRuleValue, static_cast<double>(divisor)) + newRuleValue;
}
- virtual double calcUpperBound(double /*oldUpperBound*/) const { return static_cast<double>(divisor); }
+ virtual double calcUpperBound(double /*oldUpperBound*/) const override { return static_cast<double>(divisor); }
- virtual UBool isModulusSubstitution() const { return TRUE; }
+ virtual UBool isModulusSubstitution() const override { return TRUE; }
- virtual UChar tokenChar() const { return (UChar)0x003e; } // '>'
+ virtual UChar tokenChar() const override { return (UChar)0x003e; } // '>'
- virtual void toString(UnicodeString& result) const;
+ virtual void toString(UnicodeString& result) const override;
public:
static UClassID getStaticClassID(void);
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
};
ModulusSubstitution::~ModulusSubstitution() {}
: NFSubstitution(_pos, _ruleSet, description, status) {}
virtual ~IntegralPartSubstitution();
- virtual int64_t transformNumber(int64_t number) const { return number; }
- virtual double transformNumber(double number) const { return uprv_floor(number); }
- virtual double composeRuleValue(double newRuleValue, double oldRuleValue) const { return newRuleValue + oldRuleValue; }
- virtual double calcUpperBound(double /*oldUpperBound*/) const { return DBL_MAX; }
- virtual UChar tokenChar() const { return (UChar)0x003c; } // '<'
+ virtual int64_t transformNumber(int64_t number) const override { return number; }
+ virtual double transformNumber(double number) const override { return uprv_floor(number); }
+ virtual double composeRuleValue(double newRuleValue, double oldRuleValue) const override { return newRuleValue + oldRuleValue; }
+ virtual double calcUpperBound(double /*oldUpperBound*/) const override { return DBL_MAX; }
+ virtual UChar tokenChar() const override { return (UChar)0x003c; } // '<'
public:
static UClassID getStaticClassID(void);
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
};
IntegralPartSubstitution::~IntegralPartSubstitution() {}
UErrorCode& status);
virtual ~FractionalPartSubstitution();
- virtual bool operator==(const NFSubstitution& rhs) const;
+ virtual bool operator==(const NFSubstitution& rhs) const override;
- 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 int64_t transformNumber(int64_t /*number*/) const { return 0; }
- virtual double transformNumber(double number) const { return number - uprv_floor(number); }
+ virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const override;
+ virtual void doSubstitution(int64_t /*number*/, UnicodeString& /*toInsertInto*/, int32_t /*_pos*/, int32_t /*recursionCount*/, UErrorCode& /*status*/) const override {}
+ virtual int64_t transformNumber(int64_t /*number*/) const override { return 0; }
+ virtual double transformNumber(double number) const override { return number - uprv_floor(number); }
virtual UBool doParse(const UnicodeString& text,
ParsePosition& parsePosition,
double upperBound,
UBool lenientParse,
uint32_t nonNumericalExecutedRuleMask,
- Formattable& result) const;
+ Formattable& result) const override;
- virtual double composeRuleValue(double newRuleValue, double oldRuleValue) const { return newRuleValue + oldRuleValue; }
- virtual double calcUpperBound(double /*oldUpperBound*/) const { return 0.0; }
- virtual UChar tokenChar() const { return (UChar)0x003e; } // '>'
+ virtual double composeRuleValue(double newRuleValue, double oldRuleValue) const override { return newRuleValue + oldRuleValue; }
+ virtual double calcUpperBound(double /*oldUpperBound*/) const override { return 0.0; }
+ virtual UChar tokenChar() const override { return (UChar)0x003e; } // '>'
public:
static UClassID getStaticClassID(void);
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
};
FractionalPartSubstitution::~FractionalPartSubstitution() {}
: NFSubstitution(_pos, _ruleSet, description, status) {}
virtual ~AbsoluteValueSubstitution();
- virtual int64_t transformNumber(int64_t number) const { return number >= 0 ? number : -number; }
- virtual double transformNumber(double number) const { return uprv_fabs(number); }
- virtual double composeRuleValue(double newRuleValue, double /*oldRuleValue*/) const { return -newRuleValue; }
- virtual double calcUpperBound(double /*oldUpperBound*/) const { return DBL_MAX; }
- virtual UChar tokenChar() const { return (UChar)0x003e; } // '>'
+ virtual int64_t transformNumber(int64_t number) const override { return number >= 0 ? number : -number; }
+ virtual double transformNumber(double number) const override { return uprv_fabs(number); }
+ virtual double composeRuleValue(double newRuleValue, double /*oldRuleValue*/) const override { return -newRuleValue; }
+ virtual double calcUpperBound(double /*oldUpperBound*/) const override { return DBL_MAX; }
+ virtual UChar tokenChar() const override { return (UChar)0x003e; } // '>'
public:
static UClassID getStaticClassID(void);
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
};
AbsoluteValueSubstitution::~AbsoluteValueSubstitution() {}
}
virtual ~NumeratorSubstitution();
- virtual bool operator==(const NFSubstitution& rhs) const;
+ virtual bool operator==(const NFSubstitution& rhs) const override;
- virtual int64_t transformNumber(int64_t number) const { return number * ldenominator; }
- virtual double transformNumber(double number) const { return uprv_round(number * denominator); }
+ virtual int64_t transformNumber(int64_t number) const override { return number * ldenominator; }
+ virtual double transformNumber(double number) const override { return uprv_round(number * denominator); }
- 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;
+ virtual void doSubstitution(int64_t /*number*/, UnicodeString& /*toInsertInto*/, int32_t /*_pos*/, int32_t /*recursionCount*/, UErrorCode& /*status*/) const override {}
+ virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const override;
virtual UBool doParse(const UnicodeString& text,
ParsePosition& parsePosition,
double baseValue,
double upperBound,
UBool /*lenientParse*/,
uint32_t nonNumericalExecutedRuleMask,
- Formattable& result) const;
+ Formattable& result) const override;
- virtual double composeRuleValue(double newRuleValue, double oldRuleValue) const { return newRuleValue / oldRuleValue; }
- virtual double calcUpperBound(double /*oldUpperBound*/) const { return denominator; }
- virtual UChar tokenChar() const { return (UChar)0x003c; } // '<'
+ virtual double composeRuleValue(double newRuleValue, double oldRuleValue) const override { return newRuleValue / oldRuleValue; }
+ virtual double calcUpperBound(double /*oldUpperBound*/) const override { return denominator; }
+ virtual UChar tokenChar() const override { return (UChar)0x003c; } // '<'
private:
static const UChar LTLT[2];
public:
static UClassID getStaticClassID(void);
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
};
NumeratorSubstitution::~NumeratorSubstitution() {}
public:
static UClassID getStaticClassID(void);
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
};
U_NAMESPACE_END
* Transliterator API.
* @return A copy of the object.
*/
- virtual NormalizationTransliterator* clone() const;
+ virtual NormalizationTransliterator* clone() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* pos.contextLimit. Otherwise, assume the text is complete.
*/
virtual void handleTransliterate(Replaceable& text, UTransPosition& offset,
- UBool isIncremental) const;
+ UBool isIncremental) const override;
public:
/**
* Transliterator API.
* @internal Use transliterator factory methods instead since this class will be removed in that release.
*/
- virtual NullTransliterator* clone() const;
+ virtual NullTransliterator* clone() const override;
/**
* Implements {@link Transliterator#handleTransliterate}.
* @internal Use transliterator factory methods instead since this class will be removed in that release.
*/
virtual void handleTransliterate(Replaceable& text, UTransPosition& offset,
- UBool isIncremental) const;
+ UBool isIncremental) const override;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
public:
virtual ~ICUNumberFormatFactory();
protected:
- virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* /* service */, UErrorCode& status) const {
+ virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* /* service */, UErrorCode& status) const override {
return NumberFormat::makeInstance(loc, (UNumberFormatStyle)kind, status);
}
};
virtual ~NFFactory();
- virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const
+ virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const override
{
if (handlesKey(key, status)) {
const LocaleKey& lkey = (const LocaleKey&)key;
* otherwise). This can be called often and might need to be
* cached if it is expensive to create.
*/
- virtual const Hashtable* getSupportedIDs(UErrorCode& status) const
+ virtual const Hashtable* getSupportedIDs(UErrorCode& status) const override
{
if (U_SUCCESS(status)) {
if (!_ids) {
virtual ~ICUNumberFormatService();
- virtual UObject* cloneInstance(UObject* instance) const {
+ virtual UObject* cloneInstance(UObject* instance) const override {
return ((NumberFormat*)instance)->clone();
}
- virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /* actualID */, UErrorCode& status) const {
+ virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /* actualID */, UErrorCode& status) const override {
LocaleKey& lkey = (LocaleKey&)key;
int32_t kind = lkey.kind();
Locale loc;
return NumberFormat::makeInstance(loc, (UNumberFormatStyle)kind, status);
}
- virtual UBool isDefault() const {
+ virtual UBool isDefault() const override {
return countFactories() == 1;
}
};
/**
* Returns true if the two TimeZone objects are equal.
*/
- virtual bool operator==(const TimeZone& other) const;
+ virtual bool operator==(const TimeZone& other) const override;
/**
* TimeZone API.
*/
- virtual OlsonTimeZone* clone() const;
+ virtual OlsonTimeZone* clone() const override;
/**
* TimeZone API.
/**
* TimeZone API.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* TimeZone API. Do not call this; prefer getOffset(UDate,...).
*/
virtual int32_t getOffset(uint8_t era, int32_t year, int32_t month,
int32_t day, uint8_t dayOfWeek,
- int32_t millis, UErrorCode& ec) const;
+ int32_t millis, UErrorCode& ec) const override;
/**
* TimeZone API. Do not call this; prefer getOffset(UDate,...).
virtual int32_t getOffset(uint8_t era, int32_t year, int32_t month,
int32_t day, uint8_t dayOfWeek,
int32_t millis, int32_t monthLength,
- UErrorCode& ec) const;
+ UErrorCode& ec) const override;
/**
* TimeZone API.
*/
virtual void getOffset(UDate date, UBool local, int32_t& rawOffset,
- int32_t& dstOffset, UErrorCode& ec) const;
+ int32_t& dstOffset, UErrorCode& ec) const override;
/**
* BasicTimeZone API.
virtual void getOffsetFromLocal(
UDate date, UTimeZoneLocalOption nonExistingTimeOpt,
UTimeZoneLocalOption duplicatedTimeOpt,
- int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) const;
+ int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) const override;
/**
* TimeZone API. This method has no effect since objects of this
* class are quasi-immutable (the base class allows the ID to be
* changed).
*/
- virtual void setRawOffset(int32_t offsetMillis);
+ virtual void setRawOffset(int32_t offsetMillis) override;
/**
* TimeZone API. For a historical zone, the raw offset can change
* expected behavior, this method returns the raw offset for the
* current moment in time.
*/
- virtual int32_t getRawOffset() const;
+ virtual int32_t getRawOffset() const override;
/**
* TimeZone API. For a historical zone, whether DST is used or
* behavior, this method returns true if DST is observed at any
* point in the current year.
*/
- virtual UBool useDaylightTime() const;
+ virtual UBool useDaylightTime() const override;
/**
* TimeZone API.
*/
- virtual UBool inDaylightTime(UDate date, UErrorCode& ec) const;
+ virtual UBool inDaylightTime(UDate date, UErrorCode& ec) const override;
/**
* TimeZone API.
*/
- virtual int32_t getDSTSavings() const;
+ virtual int32_t getDSTSavings() const override;
/**
* TimeZone API. Also comare historic transitions.
*/
- virtual UBool hasSameRules(const TimeZone& other) const;
+ virtual UBool hasSameRules(const TimeZone& other) const override;
/**
* BasicTimeZone API.
* @param result Receives the first transition after the base time.
* @return true if the transition is found.
*/
- virtual UBool getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;
+ virtual UBool getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const override;
/**
* BasicTimeZone API.
* @param result Receives the most recent transition before the base time.
* @return true if the transition is found.
*/
- virtual UBool getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;
+ virtual UBool getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const override;
/**
* BasicTimeZone API.
* @param status Receives error status code.
* @return The number of <code>TimeZoneRule</code>s representing time transitions.
*/
- virtual int32_t countTransitionRules(UErrorCode& status) const;
+ virtual int32_t countTransitionRules(UErrorCode& status) const override;
/**
* Gets the <code>InitialTimeZoneRule</code> and the set of <code>TimeZoneRule</code>
* @param status Receives error status code.
*/
virtual void getTimeZoneRules(const InitialTimeZoneRule*& initial,
- const TimeZoneRule* trsrules[], int32_t& trscount, UErrorCode& status) const;
+ const TimeZoneRule* trsrules[], int32_t& trscount, UErrorCode& status) const override;
/**
* Internal API returning the canonical ID of this zone.
// TODO: copy c'tor, etc
// clone
- virtual PersianCalendar* clone() const;
+ virtual PersianCalendar* clone() const override;
private:
/**
/**
* @internal
*/
- virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const;
+ virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const override;
/**
* Return the length (in days) of the given month.
* @param year The hijri shamsi month, 0-based
* @internal
*/
- virtual int32_t handleGetMonthLength(int32_t extendedYear, int32_t month) const;
+ virtual int32_t handleGetMonthLength(int32_t extendedYear, int32_t month) const override;
/**
* Return the number of days in the given Persian year
* @internal
*/
- virtual int32_t handleGetYearLength(int32_t extendedYear) const;
+ virtual int32_t handleGetYearLength(int32_t extendedYear) const override;
//-------------------------------------------------------------------------
// Functions for converting from field values to milliseconds....
/**
* @internal
*/
- virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const;
+ virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const override;
//-------------------------------------------------------------------------
// Functions for converting from milliseconds to field values
/**
* @internal
*/
- virtual int32_t handleGetExtendedYear();
+ virtual int32_t handleGetExtendedYear() override;
/**
* Override Calendar to compute several fields specific to the Persian
* calendar equivalents for the given Julian day.
* @internal
*/
- virtual void handleComputeFields(int32_t julianDay, UErrorCode &status);
+ virtual void handleComputeFields(int32_t julianDay, UErrorCode &status) override;
// UObject stuff
public:
* same class ID. Objects of other classes have different class IDs.
* @internal
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Return the class ID for this class. This is useful only for comparing to a return
* @return calendar type
* @internal
*/
- virtual const char * getType() const;
+ virtual const char * getType() const override;
private:
PersianCalendar(); // default constructor not implemented
* false, otherwise.
* @internal
*/
- virtual UBool inDaylightTime(UErrorCode& status) const;
+ virtual UBool inDaylightTime(UErrorCode& status) const override;
/**
* Returns true because the Persian Calendar does have a default century
* @internal
*/
- virtual UBool haveDefaultCentury() const;
+ virtual UBool haveDefaultCentury() const override;
/**
* Returns the date of the start of the default century
* @return start of century - in milliseconds since epoch, 1970
* @internal
*/
- virtual UDate defaultCenturyStart() const;
+ virtual UDate defaultCenturyStart() const override;
/**
* Returns the year in which the default century begins
* @internal
*/
- virtual int32_t defaultCenturyStartYear() const;
+ virtual int32_t defaultCenturyStartYear() const override;
};
U_NAMESPACE_END
PluralKeywordEnumeration(RuleChain *header, UErrorCode& status);
virtual ~PluralKeywordEnumeration();
static UClassID U_EXPORT2 getStaticClassID(void);
- virtual UClassID getDynamicClassID(void) const;
- virtual const UnicodeString* snext(UErrorCode& status);
- virtual void reset(UErrorCode& status);
- virtual int32_t count(UErrorCode& status) const;
+ virtual UClassID getDynamicClassID(void) const override;
+ virtual const UnicodeString* snext(UErrorCode& status) override;
+ virtual void reset(UErrorCode& status) override;
+ virtual int32_t count(UErrorCode& status) const override;
private:
int32_t pos;
UVector fKeywordNames;
public:
PluralAvailableLocalesEnumeration(UErrorCode &status);
virtual ~PluralAvailableLocalesEnumeration();
- virtual const char* next(int32_t *resultLength, UErrorCode& status);
- virtual void reset(UErrorCode& status);
- virtual int32_t count(UErrorCode& status) const;
+ virtual const char* next(int32_t *resultLength, UErrorCode& status) override;
+ virtual void reset(UErrorCode& status) override;
+ virtual int32_t count(UErrorCode& status) const override;
private:
UErrorCode fOpenStatus;
UResourceBundle *fLocales = nullptr;
* and return the pointer.
* @return the UnicodeMatcher pointer.
*/
- virtual UnicodeMatcher* toMatcher() const;
+ virtual UnicodeMatcher* toMatcher() const override;
/**
* Implement UnicodeFunctor
* @return a copy of the object.
*/
- virtual Quantifier* clone() const;
+ virtual Quantifier* clone() const override;
/**
* Implement UnicodeMatcher
virtual UMatchDegree matches(const Replaceable& text,
int32_t& offset,
int32_t limit,
- UBool incremental);
+ UBool incremental) override;
/**
* Implement UnicodeMatcher
* @return A reference to 'result'.
*/
virtual UnicodeString& toPattern(UnicodeString& result,
- UBool escapeUnprintable = false) const;
+ UBool escapeUnprintable = false) const override;
/**
* Implement UnicodeMatcher
* @param v the given index value.
* @return true if this rule matches the given index value.
*/
- virtual UBool matchesIndexValue(uint8_t v) const;
+ virtual UBool matchesIndexValue(uint8_t v) const override;
/**
* Implement UnicodeMatcher
*/
- virtual void addMatchSetTo(UnicodeSet& toUnionTo) const;
+ virtual void addMatchSetTo(UnicodeSet& toUnionTo) const override;
/**
* UnicodeFunctor API
*/
- virtual void setData(const TransliterationRuleData*);
+ virtual void setData(const TransliterationRuleData*) override;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
static StringLocalizationInfo* create(const UnicodeString& info, UParseError& perror, UErrorCode& status);
virtual ~StringLocalizationInfo();
- virtual int32_t getNumberOfRuleSets(void) const { return numRuleSets; }
- virtual const UChar* getRuleSetName(int32_t index) const;
- virtual int32_t getNumberOfDisplayLocales(void) const { return numLocales; }
- virtual const UChar* getLocaleName(int32_t index) const;
- virtual const UChar* getDisplayName(int32_t localeIndex, int32_t ruleIndex) const;
+ virtual int32_t getNumberOfRuleSets(void) const override { return numRuleSets; }
+ virtual const UChar* getRuleSetName(int32_t index) const override;
+ virtual int32_t getNumberOfDisplayLocales(void) const override { return numLocales; }
+ virtual const UChar* getLocaleName(int32_t index) const override;
+ virtual const UChar* getDisplayName(int32_t localeIndex, int32_t ruleIndex) const override;
// virtual UClassID getDynamicClassID() const;
// static UClassID getStaticClassID(void);
* Implement Transliterator API.
* @internal Use transliterator factory methods instead since this class will be removed in that release.
*/
- virtual RuleBasedTransliterator* clone() const;
+ virtual RuleBasedTransliterator* clone() const override;
protected:
/**
* @internal Use transliterator factory methods instead since this class will be removed in that release.
*/
virtual void handleTransliterate(Replaceable& text, UTransPosition& offsets,
- UBool isIncremental) const;
+ UBool isIncremental) const override;
public:
/**
* @internal Use transliterator factory methods instead since this class will be removed in that release.
*/
virtual UnicodeString& toRules(UnicodeString& result,
- UBool escapeUnprintable) const;
+ UBool escapeUnprintable) const override;
protected:
/**
* Implement Transliterator framework
*/
- virtual void handleGetSourceSet(UnicodeSet& result) const;
+ virtual void handleGetSourceSet(UnicodeSet& result) const override;
public:
/**
* Override Transliterator framework
*/
- virtual UnicodeSet& getTargetSet(UnicodeSet& result) const;
+ virtual UnicodeSet& getTargetSet(UnicodeSet& result) const override;
/**
* Return the class ID for this class. This is useful only for
* class have the same class ID. Objects of other classes have
* different class IDs.
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
private:
virtual ~ParseData();
- virtual const UnicodeString* lookup(const UnicodeString& s) const;
+ virtual const UnicodeString* lookup(const UnicodeString& s) const override;
- virtual const UnicodeFunctor* lookupMatcher(UChar32 ch) const;
+ virtual const UnicodeFunctor* lookupMatcher(UChar32 ch) const override;
virtual UnicodeString parseReference(const UnicodeString& text,
- ParsePosition& pos, int32_t limit) const;
+ ParsePosition& pos, int32_t limit) const override;
/**
* Return true if the given character is a matcher standin or a plain
* character (non standin).
RegionNameEnumeration(UVector *fNameList, UErrorCode& status);
virtual ~RegionNameEnumeration();
static UClassID U_EXPORT2 getStaticClassID(void);
- virtual UClassID getDynamicClassID(void) const;
- virtual const UnicodeString* snext(UErrorCode& status);
- virtual void reset(UErrorCode& status);
- virtual int32_t count(UErrorCode& status) const;
+ virtual UClassID getDynamicClassID(void) const override;
+ virtual const UnicodeString* snext(UErrorCode& status) override;
+ virtual void reset(UErrorCode& status) override;
+ virtual int32_t count(UErrorCode& status) const override;
private:
int32_t pos;
UVector *fRegionNames;
}
virtual void put(const char *key, ResourceValue &value,
- UBool /*noFallback*/, UErrorCode &errorCode) {
+ UBool /*noFallback*/, UErrorCode &errorCode) override {
// Main entry point to sink
ResourceTable table = value.getTable(errorCode);
if (U_FAILURE(errorCode)) { return; }
virtual ~RelDateFmtDataSink();
virtual void put(const char *key, ResourceValue &value,
- UBool /*noFallback*/, UErrorCode &errorCode) {
+ UBool /*noFallback*/, UErrorCode &errorCode) override {
ResourceTable relDayTable = value.getTable(errorCode);
int32_t n = 0;
int32_t len = 0;
* @return A copy of the object.
* @internal ICU 3.8
*/
- virtual RelativeDateFormat* clone() const;
+ virtual RelativeDateFormat* clone() const override;
/**
* Return true if the given Format objects are semantically equal. Objects
* @return true if the given Format objects are semantically equal.
* @internal ICU 3.8
*/
- virtual bool operator==(const Format& other) const;
+ virtual bool operator==(const Format& other) const override;
using DateFormat::format;
*/
virtual UnicodeString& format( Calendar& cal,
UnicodeString& appendTo,
- FieldPosition& pos) const;
+ FieldPosition& pos) const override;
/**
* Format an object to produce a string. This method handles Formattable
virtual UnicodeString& format(const Formattable& obj,
UnicodeString& appendTo,
FieldPosition& pos,
- UErrorCode& status) const;
+ UErrorCode& status) const override;
/**
*/
virtual void parse( const UnicodeString& text,
Calendar& cal,
- ParsePosition& pos) const;
+ ParsePosition& pos) const override;
/**
* Parse a date/time string starting at the given parse position. For
* @internal ICU 3.8
*/
virtual UDate parse( const UnicodeString& text,
- UErrorCode& status) const;
+ UErrorCode& status) const override;
/**
* Return a single pattern string generated by combining the patterns for the
* updated with any new status from the function.
* @internal ICU 53
*/
- virtual void setContext(UDisplayContext value, UErrorCode& status);
+ virtual void setContext(UDisplayContext value, UErrorCode& status) override;
private:
SimpleDateFormat *fDateTimeFormatter;
* other classes have different class IDs.
* @internal ICU 3.8
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
};
* Transliterator API.
* @return A copy of the object.
*/
- virtual RemoveTransliterator* clone() const;
+ virtual RemoveTransliterator* clone() const override;
/**
* Implements {@link Transliterator#handleTransliterate}.
* pos.contextLimit. Otherwise, assume the text is complete.
*/
virtual void handleTransliterate(Replaceable& text, UTransPosition& offset,
- UBool isIncremental) const;
+ UBool isIncremental) const override;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
virtual ~FixedSortKeyByteSink();
private:
- virtual void AppendBeyondCapacity(const char *bytes, int32_t n, int32_t length);
- virtual UBool Resize(int32_t appendCapacity, int32_t length);
+ virtual void AppendBeyondCapacity(const char *bytes, int32_t n, int32_t length) override;
+ virtual UBool Resize(int32_t appendCapacity, int32_t length) override;
};
FixedSortKeyByteSink::~FixedSortKeyByteSink() {}
virtual ~CollationKeyByteSink();
private:
- virtual void AppendBeyondCapacity(const char *bytes, int32_t n, int32_t length);
- virtual UBool Resize(int32_t appendCapacity, int32_t length);
+ virtual void AppendBeyondCapacity(const char *bytes, int32_t n, int32_t length) override;
+ virtual UBool Resize(int32_t appendCapacity, int32_t length) override;
CollationKey &key_;
};
public:
UTF16NFDIterator(const UChar *text, const UChar *textLimit) : s(text), limit(textLimit) {}
protected:
- virtual UChar32 nextRawCodePoint() {
+ virtual UChar32 nextRawCodePoint() override {
if(s == limit) { return U_SENTINEL; }
UChar32 c = *s++;
if(limit == NULL && c == 0) {
UTF8NFDIterator(const uint8_t *text, int32_t textLength)
: s(text), pos(0), length(textLength) {}
protected:
- virtual UChar32 nextRawCodePoint() {
+ virtual UChar32 nextRawCodePoint() override {
if(pos == length || (s[pos] == 0 && length < 0)) { return U_SENTINEL; }
UChar32 c;
U8_NEXT_OR_FFFD(s, pos, length, c);
FCDUTF8NFDIterator(const CollationData *data, const uint8_t *text, int32_t textLength)
: u8ci(data, FALSE, text, 0, textLength) {}
protected:
- virtual UChar32 nextRawCodePoint() {
+ virtual UChar32 nextRawCodePoint() override {
UErrorCode errorCode = U_ZERO_ERROR;
return u8ci.nextCodePoint(errorCode);
}
public:
UIterNFDIterator(UCharIterator &it) : iter(it) {}
protected:
- virtual UChar32 nextRawCodePoint() {
+ virtual UChar32 nextRawCodePoint() override {
return uiter_next32(&iter);
}
private:
FCDUIterNFDIterator(const CollationData *data, UCharIterator &it, int32_t startIndex)
: uici(data, FALSE, it, startIndex) {}
protected:
- virtual UChar32 nextRawCodePoint() {
+ virtual UChar32 nextRawCodePoint() override {
UErrorCode errorCode = U_ZERO_ERROR;
return uici.nextCodePoint(errorCode);
}
levelCapacity = sink.GetRemainingCapacity();
}
virtual ~PartLevelCallback() {}
- virtual UBool needToWrite(Collation::Level l) {
+ virtual UBool needToWrite(Collation::Level l) override {
if(!sink.Overflowed()) {
// Remember a level that will be at least partially written.
level = l;
* Implement UnicodeFunctor
* @return a copy of the object.
*/
- virtual StringMatcher* clone() const;
+ virtual StringMatcher* clone() const override;
/**
* UnicodeFunctor API. Cast 'this' to a UnicodeMatcher* pointer
* and return the pointer.
* @return the UnicodeMatcher point.
*/
- virtual UnicodeMatcher* toMatcher() const;
+ virtual UnicodeMatcher* toMatcher() const override;
/**
* UnicodeFunctor API. Cast 'this' to a UnicodeReplacer* pointer
* and return the pointer.
* @return the UnicodeReplacer pointer.
*/
- virtual UnicodeReplacer* toReplacer() const;
+ virtual UnicodeReplacer* toReplacer() const override;
/**
* Implement UnicodeMatcher
virtual UMatchDegree matches(const Replaceable& text,
int32_t& offset,
int32_t limit,
- UBool incremental);
+ UBool incremental) override;
/**
* Implement UnicodeMatcher
* @return A reference to 'result'.
*/
virtual UnicodeString& toPattern(UnicodeString& result,
- UBool escapeUnprintable = false) const;
+ UBool escapeUnprintable = false) const override;
/**
* Implement UnicodeMatcher
* @return true if this matcher will match a character c,
* where c & 0xFF == v
*/
- virtual UBool matchesIndexValue(uint8_t v) const;
+ virtual UBool matchesIndexValue(uint8_t v) const override;
/**
* Implement UnicodeMatcher
*/
- virtual void addMatchSetTo(UnicodeSet& toUnionTo) const;
+ virtual void addMatchSetTo(UnicodeSet& toUnionTo) const override;
/**
* Implement UnicodeFunctor
*/
- virtual void setData(const TransliterationRuleData*);
+ virtual void setData(const TransliterationRuleData*) override;
/**
* Replace characters in 'text' from 'start' to 'limit' with the
virtual int32_t replace(Replaceable& text,
int32_t start,
int32_t limit,
- int32_t& cursor);
+ int32_t& cursor) override;
/**
* Returns a string representation of this replacer. If the
* @return a reference to 'result'.
*/
virtual UnicodeString& toReplacerPattern(UnicodeString& result,
- UBool escapeUnprintable) const;
+ UBool escapeUnprintable) const override;
/**
* Remove any match data. This must be called before performing a
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* into the given set.
* @param toUnionTo the set into which to union the output characters
*/
- virtual void addReplacementSetTo(UnicodeSet& toUnionTo) const;
+ virtual void addReplacementSetTo(UnicodeSet& toUnionTo) const override;
private:
/**
* Implement UnicodeFunctor
*/
- virtual StringReplacer* clone() const;
+ virtual StringReplacer* clone() const override;
/**
* UnicodeFunctor API. Cast 'this' to a UnicodeReplacer* pointer
* and return the pointer.
*/
- virtual UnicodeReplacer* toReplacer() const;
+ virtual UnicodeReplacer* toReplacer() const override;
/**
* UnicodeReplacer API
virtual int32_t replace(Replaceable& text,
int32_t start,
int32_t limit,
- int32_t& cursor);
+ int32_t& cursor) override;
/**
* UnicodeReplacer API
*/
virtual UnicodeString& toReplacerPattern(UnicodeString& result,
- UBool escapeUnprintable) const;
+ UBool escapeUnprintable) const override;
/**
* Implement UnicodeReplacer
*/
- virtual void addReplacementSetTo(UnicodeSet& toUnionTo) const;
+ virtual void addReplacementSetTo(UnicodeSet& toUnionTo) const override;
/**
* UnicodeFunctor API
*/
- virtual void setData(const TransliterationRuleData*);
+ virtual void setData(const TransliterationRuleData*) override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
};
U_NAMESPACE_END
* @return return a polymorphic copy of this calendar.
* @internal
*/
- virtual TaiwanCalendar* clone() const;
+ virtual TaiwanCalendar* clone() const override;
public:
/**
* same class ID. Objects of other classes have different class IDs.
* @internal
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Return the class ID for this class. This is useful only for comparing to a return
* @return calendar type
* @internal
*/
- virtual const char * getType() const;
+ virtual const char * getType() const override;
private:
TaiwanCalendar(); // default constructor not implemented
* @return the extended year
* @internal
*/
- virtual int32_t handleGetExtendedYear();
+ virtual int32_t handleGetExtendedYear() override;
/**
* Subclasses may override this method to compute several fields
* specific to each calendar system.
* @internal
*/
- virtual void handleComputeFields(int32_t julianDay, UErrorCode& status);
+ virtual void handleComputeFields(int32_t julianDay, UErrorCode& status) override;
/**
* Subclass API for defining limits of different types.
* @param field one of the field numbers
* <code>LEAST_MAXIMUM</code>, or <code>MAXIMUM</code>
* @internal
*/
- virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const;
+ virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const override;
/**
* Returns true because the Taiwan Calendar does have a default century
* @internal
*/
- virtual UBool haveDefaultCentury() const;
+ virtual UBool haveDefaultCentury() const override;
/**
* Returns the date of the start of the default century
* @return start of century - in milliseconds since epoch, 1970
* @internal
*/
- virtual UDate defaultCenturyStart() const;
+ virtual UDate defaultCenturyStart() const override;
/**
* Returns the year in which the default century begins
* @internal
*/
- virtual int32_t defaultCenturyStartYear() const;
+ virtual int32_t defaultCenturyStartYear() const override;
};
U_NAMESPACE_END
virtual ~TZEnumeration();
- virtual StringEnumeration *clone() const {
+ virtual StringEnumeration *clone() const override {
return new TZEnumeration(*this);
}
- virtual int32_t count(UErrorCode& status) const {
+ virtual int32_t count(UErrorCode& status) const override {
return U_FAILURE(status) ? 0 : len;
}
- virtual const UnicodeString* snext(UErrorCode& status) {
+ virtual const UnicodeString* snext(UErrorCode& status) override {
if (U_SUCCESS(status) && map != NULL && pos < len) {
getID(map[pos], status);
++pos;
return 0;
}
- virtual void reset(UErrorCode& /*status*/) {
+ virtual void reset(UErrorCode& /*status*/) override {
pos = 0;
}
public:
static UClassID U_EXPORT2 getStaticClassID(void);
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
};
TZEnumeration::~TZEnumeration() {
* Transliterator API.
* @return a copy of the object.
*/
- virtual TitlecaseTransliterator* clone() const;
+ virtual TitlecaseTransliterator* clone() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* pos.contextLimit. Otherwise, assume the text is complete.
*/
virtual void handleTransliterate(Replaceable& text, UTransPosition& offset,
- UBool isIncremental) const;
+ UBool isIncremental) const override;
private:
/**
virtual ~TimeUnitFormatReadSink();
- virtual void put(const char *key, ResourceValue &value, UBool, UErrorCode &errorCode) {
+ virtual void put(const char *key, ResourceValue &value, UBool, UErrorCode &errorCode) override {
// Skip all put() calls except the first one -- discard all fallback data.
if (beenHere) {
return;
* Transliterator API.
* @return a copy of the object.
*/
- virtual LowercaseTransliterator* clone() const;
+ virtual LowercaseTransliterator* clone() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* Transliterator API.
* @return a copy of the object.
*/
- virtual UppercaseTransliterator* clone() const;
+ virtual UppercaseTransliterator* clone() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
public:
Enumeration(const TransliteratorRegistry& reg);
virtual ~Enumeration();
- virtual int32_t count(UErrorCode& status) const;
- virtual const UnicodeString* snext(UErrorCode& status);
- virtual void reset(UErrorCode& status);
+ virtual int32_t count(UErrorCode& status) const override;
+ virtual const UnicodeString* snext(UErrorCode& status) override;
+ virtual void reset(UErrorCode& status) override;
static UClassID U_EXPORT2 getStaticClassID();
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
private:
int32_t index;
const TransliteratorRegistry& reg;
ZoneIdMatchHandler();
virtual ~ZoneIdMatchHandler();
- UBool handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status);
+ UBool handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status) override;
const UChar* getID();
int32_t getMatchLen();
private:
GNameSearchHandler(uint32_t types);
virtual ~GNameSearchHandler();
- UBool handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status);
+ UBool handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status) override;
UVector* getMatches(int32_t& maxMatchLen);
private:
TimeZoneNamesDelegate(const Locale& locale, UErrorCode& status);
virtual ~TimeZoneNamesDelegate();
- virtual bool operator==(const TimeZoneNames& other) const;
+ virtual bool operator==(const TimeZoneNames& other) const override;
virtual bool operator!=(const TimeZoneNames& other) const {return !operator==(other);}
- virtual TimeZoneNamesDelegate* clone() const;
+ virtual TimeZoneNamesDelegate* clone() const override;
- StringEnumeration* getAvailableMetaZoneIDs(UErrorCode& status) const;
- StringEnumeration* getAvailableMetaZoneIDs(const UnicodeString& tzID, UErrorCode& status) const;
- UnicodeString& getMetaZoneID(const UnicodeString& tzID, UDate date, UnicodeString& mzID) const;
- UnicodeString& getReferenceZoneID(const UnicodeString& mzID, const char* region, UnicodeString& tzID) const;
+ StringEnumeration* getAvailableMetaZoneIDs(UErrorCode& status) const override;
+ StringEnumeration* getAvailableMetaZoneIDs(const UnicodeString& tzID, UErrorCode& status) const override;
+ UnicodeString& getMetaZoneID(const UnicodeString& tzID, UDate date, UnicodeString& mzID) const override;
+ UnicodeString& getReferenceZoneID(const UnicodeString& mzID, const char* region, UnicodeString& tzID) const override;
- UnicodeString& getMetaZoneDisplayName(const UnicodeString& mzID, UTimeZoneNameType type, UnicodeString& name) const;
- UnicodeString& getTimeZoneDisplayName(const UnicodeString& tzID, UTimeZoneNameType type, UnicodeString& name) const;
+ UnicodeString& getMetaZoneDisplayName(const UnicodeString& mzID, UTimeZoneNameType type, UnicodeString& name) const override;
+ UnicodeString& getTimeZoneDisplayName(const UnicodeString& tzID, UTimeZoneNameType type, UnicodeString& name) const override;
- UnicodeString& getExemplarLocationName(const UnicodeString& tzID, UnicodeString& name) const;
+ UnicodeString& getExemplarLocationName(const UnicodeString& tzID, UnicodeString& name) const override;
- void loadAllDisplayNames(UErrorCode& status);
- void getDisplayNames(const UnicodeString& tzID, const UTimeZoneNameType types[], int32_t numTypes, UDate date, UnicodeString dest[], UErrorCode& status) const;
+ void loadAllDisplayNames(UErrorCode& status) override;
+ void getDisplayNames(const UnicodeString& tzID, const UTimeZoneNameType types[], int32_t numTypes, UDate date, UnicodeString dest[], UErrorCode& status) const override;
- MatchInfoCollection* find(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const;
+ MatchInfoCollection* find(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const override;
private:
TimeZoneNamesDelegate();
TimeZoneNamesCacheEntry* fTZnamesCacheEntry;
}
virtual void put(const char* key, ResourceValue& value, UBool /*noFallback*/,
- UErrorCode &errorCode) {
+ UErrorCode &errorCode) override {
ResourceTable namesTable = value.getTable(errorCode);
if (U_FAILURE(errorCode)) { return; }
for (int32_t i = 0; namesTable.getKeyAndValue(i, key, value); ++i) {
MetaZoneIDsEnumeration(UVector* mzIDs);
virtual ~MetaZoneIDsEnumeration();
static UClassID U_EXPORT2 getStaticClassID(void);
- virtual UClassID getDynamicClassID(void) const;
- virtual const UnicodeString* snext(UErrorCode& status);
- virtual void reset(UErrorCode& status);
- virtual int32_t count(UErrorCode& status) const;
+ virtual UClassID getDynamicClassID(void) const override;
+ virtual const UnicodeString* snext(UErrorCode& status) override;
+ virtual void reset(UErrorCode& status) override;
+ virtual int32_t count(UErrorCode& status) const override;
private:
int32_t fLen;
int32_t fPos;
ZNameSearchHandler(uint32_t types);
virtual ~ZNameSearchHandler();
- UBool handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status);
+ UBool handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status) override;
TimeZoneNames::MatchInfoCollection* getMatches(int32_t& maxMatchLen);
private:
}
virtual void put(const char *key, ResourceValue &value, UBool noFallback,
- UErrorCode &status) {
+ UErrorCode &status) override {
ResourceTable timeZonesTable = value.getTable(status);
if (U_FAILURE(status)) { return; }
for (int32_t i = 0; timeZonesTable.getKeyAndValue(i, key, value); ++i) {
TZDBNameSearchHandler(uint32_t types, const char* region);
virtual ~TZDBNameSearchHandler();
- UBool handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status);
+ UBool handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status) override;
TimeZoneNames::MatchInfoCollection* getMatches(int32_t& maxMatchLen);
private:
virtual ~TimeZoneNamesImpl();
- virtual bool operator==(const TimeZoneNames& other) const;
- virtual TimeZoneNamesImpl* clone() const;
+ virtual bool operator==(const TimeZoneNames& other) const override;
+ virtual TimeZoneNamesImpl* clone() const override;
- StringEnumeration* getAvailableMetaZoneIDs(UErrorCode& status) const;
- StringEnumeration* getAvailableMetaZoneIDs(const UnicodeString& tzID, UErrorCode& status) const;
+ StringEnumeration* getAvailableMetaZoneIDs(UErrorCode& status) const override;
+ StringEnumeration* getAvailableMetaZoneIDs(const UnicodeString& tzID, UErrorCode& status) const override;
- UnicodeString& getMetaZoneID(const UnicodeString& tzID, UDate date, UnicodeString& mzID) const;
- UnicodeString& getReferenceZoneID(const UnicodeString& mzID, const char* region, UnicodeString& tzID) const;
+ UnicodeString& getMetaZoneID(const UnicodeString& tzID, UDate date, UnicodeString& mzID) const override;
+ UnicodeString& getReferenceZoneID(const UnicodeString& mzID, const char* region, UnicodeString& tzID) const override;
- UnicodeString& getMetaZoneDisplayName(const UnicodeString& mzID, UTimeZoneNameType type, UnicodeString& name) const;
- UnicodeString& getTimeZoneDisplayName(const UnicodeString& tzID, UTimeZoneNameType type, UnicodeString& name) const;
+ UnicodeString& getMetaZoneDisplayName(const UnicodeString& mzID, UTimeZoneNameType type, UnicodeString& name) const override;
+ UnicodeString& getTimeZoneDisplayName(const UnicodeString& tzID, UTimeZoneNameType type, UnicodeString& name) const override;
- UnicodeString& getExemplarLocationName(const UnicodeString& tzID, UnicodeString& name) const;
+ UnicodeString& getExemplarLocationName(const UnicodeString& tzID, UnicodeString& name) const override;
- TimeZoneNames::MatchInfoCollection* find(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const;
+ TimeZoneNames::MatchInfoCollection* find(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const override;
- void loadAllDisplayNames(UErrorCode& status);
- void getDisplayNames(const UnicodeString& tzID, const UTimeZoneNameType types[], int32_t numTypes, UDate date, UnicodeString dest[], UErrorCode& status) const;
+ void loadAllDisplayNames(UErrorCode& status) override;
+ void getDisplayNames(const UnicodeString& tzID, const UTimeZoneNameType types[], int32_t numTypes, UDate date, UnicodeString dest[], UErrorCode& status) const override;
static UnicodeString& getDefaultExemplarLocationName(const UnicodeString& tzID, UnicodeString& name);
TZDBTimeZoneNames(const Locale& locale);
virtual ~TZDBTimeZoneNames();
- virtual bool operator==(const TimeZoneNames& other) const;
- virtual TZDBTimeZoneNames* clone() const;
+ virtual bool operator==(const TimeZoneNames& other) const override;
+ virtual TZDBTimeZoneNames* clone() const override;
- StringEnumeration* getAvailableMetaZoneIDs(UErrorCode& status) const;
- StringEnumeration* getAvailableMetaZoneIDs(const UnicodeString& tzID, UErrorCode& status) const;
+ StringEnumeration* getAvailableMetaZoneIDs(UErrorCode& status) const override;
+ StringEnumeration* getAvailableMetaZoneIDs(const UnicodeString& tzID, UErrorCode& status) const override;
- UnicodeString& getMetaZoneID(const UnicodeString& tzID, UDate date, UnicodeString& mzID) const;
- UnicodeString& getReferenceZoneID(const UnicodeString& mzID, const char* region, UnicodeString& tzID) const;
+ UnicodeString& getMetaZoneID(const UnicodeString& tzID, UDate date, UnicodeString& mzID) const override;
+ UnicodeString& getReferenceZoneID(const UnicodeString& mzID, const char* region, UnicodeString& tzID) const override;
- UnicodeString& getMetaZoneDisplayName(const UnicodeString& mzID, UTimeZoneNameType type, UnicodeString& name) const;
- UnicodeString& getTimeZoneDisplayName(const UnicodeString& tzID, UTimeZoneNameType type, UnicodeString& name) const;
+ UnicodeString& getMetaZoneDisplayName(const UnicodeString& mzID, UTimeZoneNameType type, UnicodeString& name) const override;
+ UnicodeString& getTimeZoneDisplayName(const UnicodeString& tzID, UTimeZoneNameType type, UnicodeString& name) const override;
- TimeZoneNames::MatchInfoCollection* find(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const;
+ TimeZoneNames::MatchInfoCollection* find(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const override;
// When TZDBNames for the metazone is not available, this method returns NULL,
// but does NOT set U_MISSING_RESOURCE_ERROR to status.
virtual ~KeywordsSink();
virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/,
- UErrorCode &errorCode) {
+ UErrorCode &errorCode) override {
if (U_FAILURE(errorCode)) { return; }
ResourceTable collations = value.getTable(errorCode);
for (int32_t i = 0; collations.getKeyAndValue(i, key, value); ++i) {
virtual ~UIterCollationIterator();
- virtual void resetToOffset(int32_t newOffset);
+ virtual void resetToOffset(int32_t newOffset) override;
- virtual int32_t getOffset() const;
+ virtual int32_t getOffset() const override;
- virtual UChar32 nextCodePoint(UErrorCode &errorCode);
+ virtual UChar32 nextCodePoint(UErrorCode &errorCode) override;
- virtual UChar32 previousCodePoint(UErrorCode &errorCode);
+ virtual UChar32 previousCodePoint(UErrorCode &errorCode) override;
protected:
- virtual uint32_t handleNextCE32(UChar32 &c, UErrorCode &errorCode);
+ virtual uint32_t handleNextCE32(UChar32 &c, UErrorCode &errorCode) override;
- virtual UChar handleGetTrailSurrogate();
+ virtual UChar handleGetTrailSurrogate() override;
- virtual void forwardNumCodePoints(int32_t num, UErrorCode &errorCode);
+ virtual void forwardNumCodePoints(int32_t num, UErrorCode &errorCode) override;
- virtual void backwardNumCodePoints(int32_t num, UErrorCode &errorCode);
+ virtual void backwardNumCodePoints(int32_t num, UErrorCode &errorCode) override;
UCharIterator &iter;
};
virtual ~FCDUIterCollationIterator();
- virtual void resetToOffset(int32_t newOffset);
+ virtual void resetToOffset(int32_t newOffset) override;
- virtual int32_t getOffset() const;
+ virtual int32_t getOffset() const override;
- virtual UChar32 nextCodePoint(UErrorCode &errorCode);
+ virtual UChar32 nextCodePoint(UErrorCode &errorCode) override;
- virtual UChar32 previousCodePoint(UErrorCode &errorCode);
+ virtual UChar32 previousCodePoint(UErrorCode &errorCode) override;
protected:
- virtual uint32_t handleNextCE32(UChar32 &c, UErrorCode &errorCode);
+ virtual uint32_t handleNextCE32(UChar32 &c, UErrorCode &errorCode) override;
- virtual UChar handleGetTrailSurrogate();
+ virtual UChar handleGetTrailSurrogate() override;
- virtual void forwardNumCodePoints(int32_t num, UErrorCode &errorCode);
- virtual void backwardNumCodePoints(int32_t num, UErrorCode &errorCode);
+ virtual void forwardNumCodePoints(int32_t num, UErrorCode &errorCode) override;
+
+ virtual void backwardNumCodePoints(int32_t num, UErrorCode &errorCode) override;
private:
/**
/**
* Transliterator API.
*/
- virtual UnescapeTransliterator* clone() const;
+ virtual UnescapeTransliterator* clone() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* pos.contextLimit. Otherwise, assume the text is complete.
*/
virtual void handleTransliterate(Replaceable& text, UTransPosition& offset,
- UBool isIncremental) const;
+ UBool isIncremental) const override;
};
/**
* Transliterator API.
*/
- virtual UnicodeNameTransliterator* clone() const;
+ virtual UnicodeNameTransliterator* clone() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* pos.contextLimit. Otherwise, assume the text is complete.
*/
virtual void handleTransliterate(Replaceable& text, UTransPosition& offset,
- UBool isIncremental) const;
+ UBool isIncremental) const override;
private:
/**
* @return a copy of this object
* @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
*/
- virtual ChoiceFormat* clone() const;
+ virtual ChoiceFormat* clone() const override;
/**
* Returns true if the given Format objects are semantically equal.
* @return true if other is the same as this.
* @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
*/
- virtual bool operator==(const Format& other) const;
+ virtual bool operator==(const Format& other) const override;
/**
* Sets the pattern.
*/
virtual UnicodeString& format(double number,
UnicodeString& appendTo,
- FieldPosition& pos) const;
+ FieldPosition& pos) const override;
/**
* Formats an int32_t number using this object's choices.
*
*/
virtual UnicodeString& format(int32_t number,
UnicodeString& appendTo,
- FieldPosition& pos) const;
+ FieldPosition& pos) const override;
/**
* Formats an int64_t number using this object's choices.
*/
virtual UnicodeString& format(int64_t number,
UnicodeString& appendTo,
- FieldPosition& pos) const;
+ FieldPosition& pos) const override;
/**
* Formats an array of objects using this object's choices.
*/
virtual void parse(const UnicodeString& text,
Formattable& result,
- ParsePosition& parsePosition) const;
+ ParsePosition& parsePosition) const override;
/**
* Returns a unique class ID POLYMORPHICALLY. Part of ICU's "poor man's RTTI".
* other classes have different class IDs.
* @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Returns the class ID for this class. This is useful only for
*
* @stable ICU 2.2
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* have the same class as returned by getDynamicClassID().
* @stable ICU 3.0
*/
- virtual CurrencyAmount* clone() const;
+ virtual CurrencyAmount* clone() const override;
/**
* Destructor
* different class IDs.
* @stable ICU 3.0
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* Returns the class ID for this class. This is used to compare to
*
* @stable ICU 4.2
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* have the same class as returned by getDynamicClassID().
* @stable ICU 3.0
*/
- virtual CurrencyUnit* clone() const;
+ virtual CurrencyUnit* clone() const override;
/**
* Destructor
* different class IDs.
* @stable ICU 3.0
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* Returns the class ID for this class. This is used to compare to
*
* @stable ICU 2.2
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
*
* @stable ICU 2.2
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* @return A copy of the object.
* @stable ICU 4.0
*/
- virtual DateIntervalFormat* clone() const;
+ virtual DateIntervalFormat* clone() const override;
/**
* Return true if the given Format objects are semantically equal. Objects
* @return true if the given Format objects are semantically equal.
* @stable ICU 4.0
*/
- virtual bool operator==(const Format& other) const;
+ virtual bool operator==(const Format& other) const override;
/**
* Return true if the given Format objects are not semantically equal.
virtual UnicodeString& format(const Formattable& obj,
UnicodeString& appendTo,
FieldPosition& fieldPosition,
- UErrorCode& status) const ;
+ UErrorCode& status) const override;
*/
virtual void parseObject(const UnicodeString& source,
Formattable& result,
- ParsePosition& parse_pos) const;
+ ParsePosition& parse_pos) const override;
/**
* other classes have different class IDs.
* @stable ICU 4.0
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
protected:
*
* @stable ICU 4.0
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
*
* @stable ICU 3.8
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* other classes have different class IDs.
* @stable ICU 3.8
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
};
U_NAMESPACE_END
*
* @stable ICU 2.2
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
*
* @stable ICU 2.2
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* @return return a polymorphic copy of this calendar.
* @stable ICU 2.0
*/
- virtual GregorianCalendar* clone() const;
+ virtual GregorianCalendar* clone() const override;
/**
* Sets the GregorianCalendar change date. This is the point when the switch from
* @param other the Calendar to be compared with this Calendar
* @stable ICU 2.4
*/
- virtual UBool isEquivalentTo(const Calendar& other) const;
+ virtual UBool isEquivalentTo(const Calendar& other) const override;
#ifndef U_FORCE_HIDE_DEPRECATED_API
/**
* an error status.
* @deprecated ICU 2.6. Use roll(UCalendarDateFields field, int32_t amount, UErrorCode& status) instead.
*/
- virtual void roll(EDateFields field, int32_t amount, UErrorCode& status);
+ virtual void roll(EDateFields field, int32_t amount, UErrorCode& status) override;
#endif // U_FORCE_HIDE_DEPRECATED_API
/**
* an error status.
* @stable ICU 2.6.
*/
- virtual void roll(UCalendarDateFields field, int32_t amount, UErrorCode& status);
+ virtual void roll(UCalendarDateFields field, int32_t amount, UErrorCode& status) override;
#ifndef U_HIDE_DEPRECATED_API
/**
* @return the minimum value that this field could have, given the current date.
* @stable ICU 3.0
*/
- int32_t getActualMinimum(UCalendarDateFields field, UErrorCode &status) const;
+ int32_t getActualMinimum(UCalendarDateFields field, UErrorCode &status) const override;
#ifndef U_HIDE_DEPRECATED_API
/**
* @return the maximum value that this field could have, given the current date.
* @stable ICU 2.6
*/
- virtual int32_t getActualMaximum(UCalendarDateFields field, UErrorCode& status) const;
+ virtual int32_t getActualMaximum(UCalendarDateFields field, UErrorCode& status) const override;
/**
* (Overrides Calendar) Return true if the current date for this Calendar is in
* false, otherwise.
* @stable ICU 2.0
*/
- virtual UBool inDaylightTime(UErrorCode& status) const;
+ virtual UBool inDaylightTime(UErrorCode& status) const override;
public:
* same class ID. Objects of other classes have different class IDs.
* @stable ICU 2.0
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Return the class ID for this class. This is useful only for comparing to a return
* @return legacy calendar type name string
* @stable ICU 49
*/
- virtual const char * getType() const;
+ virtual const char * getType() const override;
private:
GregorianCalendar(); // default constructor not implemented
* @internal
*/
virtual int32_t handleComputeMonthStart(int32_t eyear, int32_t month,
- UBool useMonth) const;
+ UBool useMonth) const override;
/**
* Subclasses may override this. This method calls
* @return julian day specified by calendar fields.
* @internal
*/
- virtual int32_t handleComputeJulianDay(UCalendarDateFields bestField) ;
+ virtual int32_t handleComputeJulianDay(UCalendarDateFields bestField) override;
/**
* Return the number of days in the given month of the given extended
* implementation than the default implementation in Calendar.
* @internal
*/
- virtual int32_t handleGetMonthLength(int32_t extendedYear, int32_t month) const;
+ virtual int32_t handleGetMonthLength(int32_t extendedYear, int32_t month) const override;
/**
* Return the number of days in the given extended year of this
* default implementation in Calendar.
* @stable ICU 2.0
*/
- virtual int32_t handleGetYearLength(int32_t eyear) const;
+ virtual int32_t handleGetYearLength(int32_t eyear) const override;
/**
* return the length of the given month.
* <code>LEAST_MAXIMUM</code>, or <code>MAXIMUM</code>
* @internal
*/
- virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const;
+ virtual int32_t handleGetLimit(UCalendarDateFields field, ELimitType limitType) const override;
/**
* Return the extended year defined by the current fields. This will
* @return the extended year
* @internal
*/
- virtual int32_t handleGetExtendedYear();
+ virtual int32_t handleGetExtendedYear() override;
/**
* Subclasses may override this to convert from week fields
* @return the extended year, UCAL_EXTENDED_YEAR
* @internal
*/
- virtual int32_t handleGetExtendedYearFromWeekFields(int32_t yearWoy, int32_t woy);
+ virtual int32_t handleGetExtendedYearFromWeekFields(int32_t yearWoy, int32_t woy) override;
/**
* a calendar with the specified Julian/Gregorian cutover date.
* @internal
*/
- virtual void handleComputeFields(int32_t julianDay, UErrorCode &status);
+ virtual void handleComputeFields(int32_t julianDay, UErrorCode &status) override;
private:
/**
* @return true if this calendar has the notion of a default century
* @internal
*/
- virtual UBool haveDefaultCentury() const;
+ virtual UBool haveDefaultCentury() const override;
/**
* @return the start of the default century
* @internal
*/
- virtual UDate defaultCenturyStart() const;
+ virtual UDate defaultCenturyStart() const override;
/**
* @return the beginning year of the default century
* @internal
*/
- virtual int32_t defaultCenturyStartYear() const;
+ virtual int32_t defaultCenturyStartYear() const override;
};
U_NAMESPACE_END
* Return true if given Format objects are semantically equal.
* @stable ICU 53
*/
- virtual bool operator==(const Format &other) const;
+ virtual bool operator==(const Format &other) const override;
/**
* Clones this object polymorphically.
* @stable ICU 53
*/
- virtual MeasureFormat *clone() const;
+ virtual MeasureFormat *clone() const override;
/**
* Formats object to produce a string.
const Formattable &obj,
UnicodeString &appendTo,
FieldPosition &pos,
- UErrorCode &status) const;
+ UErrorCode &status) const override;
#ifndef U_FORCE_HIDE_DRAFT_API
/**
virtual void parseObject(
const UnicodeString &source,
Formattable &reslt,
- ParsePosition &pos) const;
+ ParsePosition &pos) const override;
#endif // U_FORCE_HIDE_DRAFT_API
/**
* other classes have different class IDs.
* @stable ICU 53
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
protected:
/**
* other classes have different class IDs.
* @stable ICU 53
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
#ifndef U_HIDE_INTERNAL_API
/**
* other classes have different class IDs.
* @stable ICU 53
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
protected:
/**
* result and should delete it when done.
* @stable ICU 2.0
*/
- virtual MessageFormat* clone() const;
+ virtual MessageFormat* clone() const override;
/**
* Returns true if the given Format objects are semantically equal.
* @return true if the given Format objects are semantically equal.
* @stable ICU 2.0
*/
- virtual bool operator==(const Format& other) const;
+ virtual bool operator==(const Format& other) const override;
/**
* Sets the locale to be used for creating argument Format objects.
virtual UnicodeString& format(const Formattable& obj,
UnicodeString& appendTo,
FieldPosition& pos,
- UErrorCode& status) const;
+ UErrorCode& status) const override;
/**
* Formats the given array of arguments into a user-defined argument name
*/
virtual void parseObject(const UnicodeString& source,
Formattable& result,
- ParsePosition& pos) const;
+ ParsePosition& pos) const override;
/**
* Convert an 'apostrophe-friendly' pattern into a standard
* other classes have different class IDs.
* @stable ICU 2.0
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Return the class ID for this class. This is useful only for
public:
PluralSelectorProvider(const MessageFormat &mf, UPluralType type);
virtual ~PluralSelectorProvider();
- virtual UnicodeString select(void *ctx, double number, UErrorCode& ec) const;
+ virtual UnicodeString select(void *ctx, double number, UErrorCode& ec) const override;
void reset();
private:
*/
class U_I18N_API DummyFormat : public Format {
public:
- virtual bool operator==(const Format&) const;
- virtual DummyFormat* clone() const;
+ virtual bool operator==(const Format&) const override;
+ virtual DummyFormat* clone() const override;
virtual UnicodeString& format(const Formattable& obj,
UnicodeString& appendTo,
UErrorCode& status) const;
virtual UnicodeString& format(const Formattable&,
UnicodeString& appendTo,
FieldPosition&,
- UErrorCode& status) const;
+ UErrorCode& status) const override;
virtual UnicodeString& format(const Formattable& obj,
UnicodeString& appendTo,
FieldPositionIterator* posIter,
- UErrorCode& status) const;
+ UErrorCode& status) const override;
virtual void parseObject(const UnicodeString&,
Formattable&,
- ParsePosition&) const;
+ ParsePosition&) const override;
};
friend class MessageFormatAdapter; // getFormatTypeList() access
*
* @stable ICU 4.2
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
private:
* @return true if other is semantically equal to this.
* @stable ICU 4.0
*/
- virtual bool operator==(const Format& other) const;
+ virtual bool operator==(const Format& other) const override;
/**
* Return true if another object is semantically unequal to this one.
* result and should delete it when done.
* @stable ICU 4.0
*/
- virtual PluralFormat* clone() const;
+ virtual PluralFormat* clone() const override;
/**
* Formats a plural message for a number taken from a Formattable object.
UnicodeString& format(const Formattable& obj,
UnicodeString& appendTo,
FieldPosition& pos,
- UErrorCode& status) const;
+ UErrorCode& status) const override;
/**
* Returns the pattern from applyPattern() or constructor().
*/
virtual void parseObject(const UnicodeString& source,
Formattable& result,
- ParsePosition& parse_pos) const;
+ ParsePosition& parse_pos) const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
*
* @stable ICU 4.0
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
private:
/**
virtual ~PluralSelectorAdapter();
- virtual UnicodeString select(void *context, double number, UErrorCode& /*ec*/) const;
+ virtual UnicodeString select(void *context, double number, UErrorCode& /*ec*/) const override;
void reset();
*
* @stable ICU 4.0
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
private:
* @return A copy of the object.
* @stable ICU 2.6
*/
- virtual RuleBasedNumberFormat* clone() const;
+ virtual RuleBasedNumberFormat* clone() const override;
/**
* Return true if the given Format objects are semantically equal.
* @return true if the given Format objects are semantically equal.
* @stable ICU 2.6
*/
- virtual bool operator==(const Format& other) const;
+ virtual bool operator==(const Format& other) const override;
//-----------------------------------------------------------------------
// public API functions
*/
virtual UnicodeString& format(int32_t number,
UnicodeString& toAppendTo,
- FieldPosition& pos) const;
+ FieldPosition& pos) const override;
/**
* Formats the specified 64-bit number using the default ruleset.
*/
virtual UnicodeString& format(int64_t number,
UnicodeString& toAppendTo,
- FieldPosition& pos) const;
+ FieldPosition& pos) const override;
/**
* Formats the specified number using the default ruleset.
* @param number The number to format.
*/
virtual UnicodeString& format(double number,
UnicodeString& toAppendTo,
- FieldPosition& pos) const;
+ FieldPosition& pos) const override;
/**
* Formats the specified number using the named ruleset.
virtual UnicodeString& format(const number::impl::DecimalQuantity &number,
UnicodeString& appendTo,
FieldPosition& pos,
- UErrorCode& status) const;
+ UErrorCode& status) const override;
public:
using NumberFormat::parse;
*/
virtual void parse(const UnicodeString& text,
Formattable& result,
- ParsePosition& parsePosition) const;
+ ParsePosition& parsePosition) const override;
#if !UCONFIG_NO_COLLATION
* @see RuleBasedCollator
* @stable ICU 2.0
*/
- virtual void setLenient(UBool enabled);
+ virtual void setLenient(UBool enabled) override;
/**
* Returns true if lenient-parse mode is turned on. Lenient parsing is off
* @see #setLenient
* @stable ICU 2.0
*/
- virtual inline UBool isLenient(void) const;
+ virtual inline UBool isLenient(void) const override;
#endif
* updated with any new status from the function.
* @stable ICU 53
*/
- virtual void setContext(UDisplayContext value, UErrorCode& status);
+ virtual void setContext(UDisplayContext value, UErrorCode& status) override;
/**
* Get the rounding mode.
* @return A rounding mode
* @stable ICU 60
*/
- virtual ERoundingMode getRoundingMode(void) const;
+ virtual ERoundingMode getRoundingMode(void) const override;
/**
* Set the rounding mode.
* @param roundingMode A rounding mode
* @stable ICU 60
*/
- virtual void setRoundingMode(ERoundingMode roundingMode);
+ virtual void setRoundingMode(ERoundingMode roundingMode) override;
public:
/**
*
* @stable ICU 2.8
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Sets the decimal format symbols, which is generally not changed
*semantically equal.
* @stable ICU 3.8
*/
- virtual bool operator==(const TimeZone& that) const;
+ virtual bool operator==(const TimeZone& that) const override;
/**
* Return true if the given <code>TimeZone</code> objects are
* @return A new copy of this TimeZone object.
* @stable ICU 3.8
*/
- virtual RuleBasedTimeZone* clone() const;
+ virtual RuleBasedTimeZone* clone() const override;
/**
* Returns the TimeZone's adjusted GMT offset (i.e., the number of milliseconds to add
* @stable ICU 3.8
*/
virtual int32_t getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
- uint8_t dayOfWeek, int32_t millis, UErrorCode& status) const;
+ uint8_t dayOfWeek, int32_t millis, UErrorCode& status) const override;
/**
* Gets the time zone offset, for current date, modified in case of
*/
virtual int32_t getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
uint8_t dayOfWeek, int32_t millis,
- int32_t monthLength, UErrorCode& status) const;
+ int32_t monthLength, UErrorCode& status) const override;
/**
* Returns the time zone raw and GMT offset for the given moment
* @stable ICU 3.8
*/
virtual void getOffset(UDate date, UBool local, int32_t& rawOffset,
- int32_t& dstOffset, UErrorCode& ec) const;
+ int32_t& dstOffset, UErrorCode& ec) const override;
/**
* Sets the TimeZone's raw GMT offset (i.e., the number of milliseconds to add
* @param offsetMillis The new raw GMT offset for this time zone.
* @stable ICU 3.8
*/
- virtual void setRawOffset(int32_t offsetMillis);
+ virtual void setRawOffset(int32_t offsetMillis) override;
/**
* Returns the TimeZone's raw GMT offset (i.e., the number of milliseconds to add
* @return The TimeZone's raw GMT offset.
* @stable ICU 3.8
*/
- virtual int32_t getRawOffset(void) const;
+ virtual int32_t getRawOffset(void) const override;
/**
* Queries if this time zone uses daylight savings time.
* false, otherwise.
* @stable ICU 3.8
*/
- virtual UBool useDaylightTime(void) const;
+ virtual UBool useDaylightTime(void) const override;
#ifndef U_FORCE_HIDE_DEPRECATED_API
/**
* false, otherwise.
* @deprecated ICU 2.4. Use Calendar::inDaylightTime() instead.
*/
- virtual UBool inDaylightTime(UDate date, UErrorCode& status) const;
+ virtual UBool inDaylightTime(UDate date, UErrorCode& status) const override;
#endif // U_FORCE_HIDE_DEPRECATED_API
/**
* with the possible exception of the ID
* @stable ICU 3.8
*/
- virtual UBool hasSameRules(const TimeZone& other) const;
+ virtual UBool hasSameRules(const TimeZone& other) const override;
/**
* Gets the first time zone transition after the base time.
* @return true if the transition is found.
* @stable ICU 3.8
*/
- virtual UBool getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;
+ virtual UBool getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const override;
/**
* Gets the most recent time zone transition before the base time.
* @return true if the transition is found.
* @stable ICU 3.8
*/
- virtual UBool getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;
+ virtual UBool getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const override;
/**
* Returns the number of <code>TimeZoneRule</code>s which represents time transitions,
* @return The number of <code>TimeZoneRule</code>s representing time transitions.
* @stable ICU 3.8
*/
- virtual int32_t countTransitionRules(UErrorCode& status) const;
+ virtual int32_t countTransitionRules(UErrorCode& status) const override;
/**
* Gets the <code>InitialTimeZoneRule</code> and the set of <code>TimeZoneRule</code>
* @stable ICU 3.8
*/
virtual void getTimeZoneRules(const InitialTimeZoneRule*& initial,
- const TimeZoneRule* trsrules[], int32_t& trscount, UErrorCode& status) const;
+ const TimeZoneRule* trsrules[], int32_t& trscount, UErrorCode& status) const override;
#ifndef U_FORCE_HIDE_DRAFT_API
/**
virtual void getOffsetFromLocal(
UDate date, UTimeZoneLocalOption nonExistingTimeOpt,
UTimeZoneLocalOption duplicatedTimeOpt,
- int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) const;
+ int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) const override;
#endif /* U_FORCE_HIDE_DRAFT_API */
private:
* other classes have different class IDs.
* @stable ICU 3.8
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
};
U_NAMESPACE_END
*
* @stable ICU 2.4
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
*
* @stable ICU 2.2
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
private:
// Constructors and other object boilerplate are private.
class U_I18N_API SuperscriptStyle : public Style {
public:
- virtual SuperscriptStyle *clone() const;
+ virtual SuperscriptStyle *clone() const override;
protected:
virtual UnicodeString &format(
const UnicodeString &original,
FieldPositionIterator &fpi,
const UnicodeString &preExponent,
UnicodeString &appendTo,
- UErrorCode &status) const;
+ UErrorCode &status) const override;
};
class U_I18N_API MarkupStyle : public Style {
: Style(),
fBeginMarkup(beginMarkup),
fEndMarkup(endMarkup) { }
- virtual MarkupStyle *clone() const;
+ virtual MarkupStyle *clone() const override;
protected:
virtual UnicodeString &format(
const UnicodeString &original,
FieldPositionIterator &fpi,
const UnicodeString &preExponent,
UnicodeString &appendTo,
- UErrorCode &status) const;
+ UErrorCode &status) const override;
private:
UnicodeString fBeginMarkup;
UnicodeString fEndMarkup;
* @return true if other is semantically equal to this.
* @stable ICU 4.4
*/
- virtual bool operator==(const Format& other) const;
+ virtual bool operator==(const Format& other) const override;
/**
* Return true if another object is semantically unequal to this one.
* result and should delete it when done.
* @stable ICU 4.4
*/
- virtual SelectFormat* clone() const;
+ virtual SelectFormat* clone() const override;
/**
* Format an object to produce a string.
UnicodeString& format(const Formattable& obj,
UnicodeString& appendTo,
FieldPosition& pos,
- UErrorCode& status) const;
+ UErrorCode& status) const override;
/**
* Returns the pattern from applyPattern() or constructor.
*/
virtual void parseObject(const UnicodeString& source,
Formattable& result,
- ParsePosition& parse_pos) const;
+ ParsePosition& parse_pos) const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* ICU "poor man's RTTI", returns a UClassID for the actual class.
* @stable ICU 4.4
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
private:
friend class MessageFormat;
* otherwise.
* @stable ICU 2.0
*/
- virtual bool operator==(const TimeZone& that) const;
+ virtual bool operator==(const TimeZone& that) const override;
/**
* Constructs a SimpleTimeZone with the given raw GMT offset and time zone ID,
* @stable ICU 2.0
*/
virtual int32_t getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
- uint8_t dayOfWeek, int32_t millis, UErrorCode& status) const;
+ uint8_t dayOfWeek, int32_t millis, UErrorCode& status) const override;
/**
* Gets the time zone offset, for current date, modified in case of
*/
virtual int32_t getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
uint8_t dayOfWeek, int32_t milliseconds,
- int32_t monthLength, UErrorCode& status) const;
+ int32_t monthLength, UErrorCode& status) const override;
/**
* Gets the time zone offset, for current date, modified in case of
* daylight savings. This is the offset to add *to* UTC to get local time.
* @stable ICU 2.8
*/
virtual void getOffset(UDate date, UBool local, int32_t& rawOffset,
- int32_t& dstOffset, UErrorCode& ec) const;
+ int32_t& dstOffset, UErrorCode& ec) const override;
#ifndef U_FORCE_HIDE_DRAFT_API
/**
virtual void getOffsetFromLocal(
UDate date, UTimeZoneLocalOption nonExistingTimeOpt,
UTimeZoneLocalOption duplicatedTimeOpt,
- int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) const;
+ int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) const override;
#endif /* U_FORCE_HIDE_DRAFT_API */
/**
* @return The TimeZone's raw GMT offset.
* @stable ICU 2.0
*/
- virtual int32_t getRawOffset(void) const;
+ virtual int32_t getRawOffset(void) const override;
/**
* Sets the TimeZone's raw GMT offset (i.e., the number of milliseconds to add
* @param offsetMillis The new raw GMT offset for this time zone.
* @stable ICU 2.0
*/
- virtual void setRawOffset(int32_t offsetMillis);
+ virtual void setRawOffset(int32_t offsetMillis) override;
/**
* Sets the amount of time in ms that the clock is advanced during DST.
* but not 0.
* @stable ICU 2.0
*/
- virtual int32_t getDSTSavings(void) const;
+ virtual int32_t getDSTSavings(void) const override;
/**
* Queries if this TimeZone uses Daylight Savings Time.
* @return True if this TimeZone uses Daylight Savings Time; false otherwise.
* @stable ICU 2.0
*/
- virtual UBool useDaylightTime(void) const;
+ virtual UBool useDaylightTime(void) const override;
#ifndef U_FORCE_HIDE_DEPRECATED_API
/**
* false otherwise.
* @deprecated ICU 2.4. Use Calendar::inDaylightTime() instead.
*/
- virtual UBool inDaylightTime(UDate date, UErrorCode& status) const;
+ virtual UBool inDaylightTime(UDate date, UErrorCode& status) const override;
#endif // U_FORCE_HIDE_DEPRECATED_API
/**
* @return true if the given zone has the same rules and offset as this one
* @stable ICU 2.0
*/
- UBool hasSameRules(const TimeZone& other) const;
+ UBool hasSameRules(const TimeZone& other) const override;
/**
* Clones TimeZone objects polymorphically. Clients are responsible for deleting
* @return A new copy of this TimeZone object.
* @stable ICU 2.0
*/
- virtual SimpleTimeZone* clone() const;
+ virtual SimpleTimeZone* clone() const override;
/**
* Gets the first time zone transition after the base time.
* @return true if the transition is found.
* @stable ICU 3.8
*/
- virtual UBool getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;
+ virtual UBool getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const override;
/**
* Gets the most recent time zone transition before the base time.
* @return true if the transition is found.
* @stable ICU 3.8
*/
- virtual UBool getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;
+ virtual UBool getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const override;
/**
* Returns the number of <code>TimeZoneRule</code>s which represents time transitions,
* @return The number of <code>TimeZoneRule</code>s representing time transitions.
* @stable ICU 3.8
*/
- virtual int32_t countTransitionRules(UErrorCode& status) const;
+ virtual int32_t countTransitionRules(UErrorCode& status) const override;
/**
* Gets the <code>InitialTimeZoneRule</code> and the set of <code>TimeZoneRule</code>
* @stable ICU 3.8
*/
virtual void getTimeZoneRules(const InitialTimeZoneRule*& initial,
- const TimeZoneRule* trsrules[], int32_t& trscount, UErrorCode& status) const;
+ const TimeZoneRule* trsrules[], int32_t& trscount, UErrorCode& status) const override;
public:
* same class ID. Objects of other classes have different class IDs.
* @stable ICU 2.0
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Return the class ID for this class. This is useful only for comparing to a return
* @return A copy of the object.
* @stable ICU 2.0
*/
- virtual SimpleDateFormat* clone() const;
+ virtual SimpleDateFormat* clone() const override;
/**
* Return true if the given Format objects are semantically equal. Objects
* @return true if the given Format objects are semantically equal.
* @stable ICU 2.0
*/
- virtual bool operator==(const Format& other) const;
+ virtual bool operator==(const Format& other) const override;
using DateFormat::format;
*/
virtual UnicodeString& format( Calendar& cal,
UnicodeString& appendTo,
- FieldPosition& pos) const;
+ FieldPosition& pos) const override;
/**
* Format a date or time, which is the standard millis since 24:00 GMT, Jan
virtual UnicodeString& format( Calendar& cal,
UnicodeString& appendTo,
FieldPositionIterator* posIter,
- UErrorCode& status) const;
+ UErrorCode& status) const override;
using DateFormat::parse;
*/
virtual void parse( const UnicodeString& text,
Calendar& cal,
- ParsePosition& pos) const;
+ ParsePosition& pos) const override;
/**
* other classes have different class IDs.
* @stable ICU 2.0
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Set the calendar to be used by this date format. Initially, the default
* @param calendarToAdopt Calendar object to be adopted.
* @stable ICU 2.0
*/
- virtual void adoptCalendar(Calendar* calendarToAdopt);
+ virtual void adoptCalendar(Calendar* calendarToAdopt) override;
/* Cannot use #ifndef U_HIDE_INTERNAL_API for the following methods since they are virtual */
/**
* updated with any new status from the function.
* @stable ICU 53
*/
- virtual void setContext(UDisplayContext value, UErrorCode& status);
+ virtual void setContext(UDisplayContext value, UErrorCode& status) override;
/**
* Overrides base class method and
* @param formatToAdopt the NumbeferFormat used
* @stable ICU 54
*/
- void adoptNumberFormat(NumberFormat *formatToAdopt);
+ void adoptNumberFormat(NumberFormat *formatToAdopt) override;
/**
* Allow the user to set the NumberFormat for several fields
* ICU "poor man's RTTI", returns a UClassID for the actual class.
* @stable ICU 2.2
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* while looking for the same pattern.
* @stable ICU 2.0
*/
- virtual bool operator==(const SearchIterator &that) const;
+ virtual bool operator==(const SearchIterator &that) const override;
// public get and set methods ----------------------------------------
* @param status for errors if it occurs
* @stable ICU 2.0
*/
- virtual void setOffset(int32_t position, UErrorCode &status);
+ virtual void setOffset(int32_t position, UErrorCode &status) override;
/**
* Return the current index in the text being searched.
* @return current index in the text being searched.
* @stable ICU 2.0
*/
- virtual int32_t getOffset(void) const;
+ virtual int32_t getOffset(void) const override;
/**
* Set the target text to be searched.
* U_ILLEGAL_ARGUMENT_ERROR is returned.
* @stable ICU 2.0
*/
- virtual void setText(const UnicodeString &text, UErrorCode &status);
+ virtual void setText(const UnicodeString &text, UErrorCode &status) override;
/**
* Set the target text to be searched.
* U_ILLEGAL_ARGUMENT_ERROR is returned.
* @stable ICU 2.0
*/
- virtual void setText(CharacterIterator &text, UErrorCode &status);
+ virtual void setText(CharacterIterator &text, UErrorCode &status) override;
/**
* Gets the collator used for the language rules.
* search will begin at the end of the text string.
* @stable ICU 2.0
*/
- virtual void reset();
+ virtual void reset() override;
/**
* Returns a copy of StringSearch with the same behavior, and
* @return cloned object
* @stable ICU 2.0
*/
- virtual StringSearch * safeClone() const;
+ virtual StringSearch * safeClone() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*
* @stable ICU 2.2
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* USEARCH_DONE if no match was found.
* @stable ICU 2.0
*/
- virtual int32_t handleNext(int32_t position, UErrorCode &status);
+ virtual int32_t handleNext(int32_t position, UErrorCode &status) override;
/**
* Search backward for matching text, starting at a given location.
* USEARCH_DONE if no match was found.
* @stable ICU 2.0
*/
- virtual int32_t handlePrev(int32_t position, UErrorCode &status);
+ virtual int32_t handlePrev(int32_t position, UErrorCode &status) override;
private :
StringSearch(); // default constructor not implemented
* @return true if arguments is the same as this object.
* @stable ICU 2.0
*/
- virtual bool operator==(const Collator& other) const;
+ virtual bool operator==(const Collator& other) const override;
/**
* Makes a copy of this object.
* @return a copy of this object, owned by the caller
* @stable ICU 2.0
*/
- virtual RuleBasedCollator* clone() const;
+ virtual RuleBasedCollator* clone() const override;
/**
* Creates a collation element iterator for the source string. The caller of
**/
virtual UCollationResult compare(const UnicodeString& source,
const UnicodeString& target,
- UErrorCode &status) const;
+ UErrorCode &status) const override;
/**
* Does the same thing as compare but limits the comparison to a specified
virtual UCollationResult compare(const UnicodeString& source,
const UnicodeString& target,
int32_t length,
- UErrorCode &status) const;
+ UErrorCode &status) const override;
/**
* The comparison function compares the character data stored in two
*/
virtual UCollationResult compare(const char16_t* source, int32_t sourceLength,
const char16_t* target, int32_t targetLength,
- UErrorCode &status) const;
+ UErrorCode &status) const override;
/**
* Compares two strings using the Collator.
*/
virtual UCollationResult compare(UCharIterator &sIter,
UCharIterator &tIter,
- UErrorCode &status) const;
+ UErrorCode &status) const override;
/**
* Compares two UTF-8 strings using the Collator.
*/
virtual UCollationResult compareUTF8(const StringPiece &source,
const StringPiece &target,
- UErrorCode &status) const;
+ UErrorCode &status) const override;
/**
* Transforms the string into a series of characters
*/
virtual CollationKey& getCollationKey(const UnicodeString& source,
CollationKey& key,
- UErrorCode& status) const;
+ UErrorCode& status) const override;
/**
* Transforms a specified region of the string into a series of characters
virtual CollationKey& getCollationKey(const char16_t *source,
int32_t sourceLength,
CollationKey& key,
- UErrorCode& status) const;
+ UErrorCode& status) const override;
/**
* Generates the hash code for the rule-based collation object.
* @return the hash code.
* @stable ICU 2.0
*/
- virtual int32_t hashCode() const;
+ virtual int32_t hashCode() const override;
#ifndef U_FORCE_HIDE_DEPRECATED_API
/**
* was instantiated from rules, locale is empty.
* @deprecated ICU 2.8 likely to change in ICU 3.0, based on feedback
*/
- virtual Locale getLocale(ULocDataLocaleType type, UErrorCode& status) const;
+ virtual Locale getLocale(ULocDataLocaleType type, UErrorCode& status) const override;
#endif // U_FORCE_HIDE_DEPRECATED_API
/**
* @param info the version # information, the result will be filled in
* @stable ICU 2.0
*/
- virtual void getVersion(UVersionInfo info) const;
+ virtual void getVersion(UVersionInfo info) const override;
#ifndef U_HIDE_DEPRECATED_API
/**
* IDs.
* @stable ICU 2.0
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* Returns the class ID for this class. This is useful only for comparing to
* @stable ICU 2.2
*/
virtual void setAttribute(UColAttribute attr, UColAttributeValue value,
- UErrorCode &status);
+ UErrorCode &status) override;
/**
* Universal attribute getter.
* @stable ICU 2.2
*/
virtual UColAttributeValue getAttribute(UColAttribute attr,
- UErrorCode &status) const;
+ UErrorCode &status) const override;
/**
* Sets the variable top to the top of the specified reordering group.
* @see getMaxVariable
* @stable ICU 53
*/
- virtual Collator &setMaxVariable(UColReorderCode group, UErrorCode &errorCode);
+ virtual Collator &setMaxVariable(UColReorderCode group, UErrorCode &errorCode) override;
/**
* Returns the maximum reordering group whose characters are affected by UCOL_ALTERNATE_HANDLING.
* @see setMaxVariable
* @stable ICU 53
*/
- virtual UColReorderCode getMaxVariable() const;
+ virtual UColReorderCode getMaxVariable() const override;
#ifndef U_FORCE_HIDE_DEPRECATED_API
/**
* @return variable top primary weight
* @deprecated ICU 53 Call setMaxVariable() instead.
*/
- virtual uint32_t setVariableTop(const char16_t *varTop, int32_t len, UErrorCode &status);
+ virtual uint32_t setVariableTop(const char16_t *varTop, int32_t len, UErrorCode &status) override;
/**
* Sets the variable top to the primary weight of the specified string.
* @return variable top primary weight
* @deprecated ICU 53 Call setMaxVariable() instead.
*/
- virtual uint32_t setVariableTop(const UnicodeString &varTop, UErrorCode &status);
+ virtual uint32_t setVariableTop(const UnicodeString &varTop, UErrorCode &status) override;
/**
* Sets the variable top to the specified primary weight.
* @param status error code
* @deprecated ICU 53 Call setMaxVariable() instead.
*/
- virtual void setVariableTop(uint32_t varTop, UErrorCode &status);
+ virtual void setVariableTop(uint32_t varTop, UErrorCode &status) override;
#endif // U_FORCE_HIDE_DEPRECATED_API
/**
* @see getMaxVariable
* @stable ICU 2.0
*/
- virtual uint32_t getVariableTop(UErrorCode &status) const;
+ virtual uint32_t getVariableTop(UErrorCode &status) const override;
/**
* Get a UnicodeSet that contains all the characters and sequences tailored in
* in the root collator. The object must be disposed of by using delete
* @stable ICU 2.4
*/
- virtual UnicodeSet *getTailoredSet(UErrorCode &status) const;
+ virtual UnicodeSet *getTailoredSet(UErrorCode &status) const override;
/**
* Get the sort key as an array of bytes from a UnicodeString.
* @stable ICU 2.0
*/
virtual int32_t getSortKey(const UnicodeString& source, uint8_t *result,
- int32_t resultLength) const;
+ int32_t resultLength) const override;
/**
* Get the sort key as an array of bytes from a char16_t buffer.
* @stable ICU 2.2
*/
virtual int32_t getSortKey(const char16_t *source, int32_t sourceLength,
- uint8_t *result, int32_t resultLength) const;
+ uint8_t *result, int32_t resultLength) const override;
/**
* Retrieves the reordering codes for this collator.
*/
virtual int32_t getReorderCodes(int32_t *dest,
int32_t destCapacity,
- UErrorCode& status) const;
+ UErrorCode& status) const override;
/**
* Sets the ordering of scripts for this collator.
*/
virtual void setReorderCodes(const int32_t* reorderCodes,
int32_t reorderCodesLength,
- UErrorCode& status) ;
+ UErrorCode& status) override;
/**
* Implements ucol_strcollUTF8().
virtual UCollationResult internalCompareUTF8(
const char *left, int32_t leftLength,
const char *right, int32_t rightLength,
- UErrorCode &errorCode) const;
+ UErrorCode &errorCode) const override;
/** Get the short definition string for a collator. This internal API harvests the collator's
* locale and the attribute set and produces a string that can be used for opening
virtual int32_t internalGetShortDefinitionString(const char *locale,
char *buffer,
int32_t capacity,
- UErrorCode &status) const;
+ UErrorCode &status) const override;
/**
* Implements ucol_nextSortKeyPart().
*/
virtual int32_t internalNextSortKeyPart(
UCharIterator *iter, uint32_t state[2],
- uint8_t *dest, int32_t count, UErrorCode &errorCode) const;
+ uint8_t *dest, int32_t count, UErrorCode &errorCode) const override;
// Do not enclose the default constructor with #ifndef U_HIDE_INTERNAL_API
/**
* @param actualLocale the actual locale
* @internal
*/
- virtual void setLocales(const Locale& requestedLocale, const Locale& validLocale, const Locale& actualLocale);
+ virtual void setLocales(const Locale& requestedLocale, const Locale& validLocale, const Locale& actualLocale) override;
private:
friend class CollationElementIterator;
* Override clone.
* @stable ICU 4.2
*/
- virtual TimeUnit* clone() const;
+ virtual TimeUnit* clone() const override;
/**
* Copy operator.
* different class IDs.
* @stable ICU 4.2
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* Returns the class ID for this class. This is used to compare to
* @return a polymorphic clone of this object. The result will have the same class as returned by getDynamicClassID().
* @stable ICU 4.2
*/
- virtual TimeUnitAmount* clone() const;
+ virtual TimeUnitAmount* clone() const override;
/**
* other classes have different class IDs.
* @stable ICU 4.2
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
/**
* @return A copy of the object.
* @deprecated ICU 53
*/
- virtual TimeUnitFormat* clone() const;
+ virtual TimeUnitFormat* clone() const override;
/**
* Assignment operator
*/
virtual void parseObject(const UnicodeString& source,
Formattable& result,
- ParsePosition& pos) const;
+ ParsePosition& pos) const override;
/**
* Return the class ID for this class. This is useful only for comparing to
* other classes have different class IDs.
* @deprecated ICU 53
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
private:
Hashtable* fTimeUnitToCountToPatterns[TimeUnit::UTIMEUNIT_FIELD_COUNT];
* Objects of different subclasses are considered unequal.
* @stable ICU 50
*/
- virtual bool operator==(const Format& other) const;
+ virtual bool operator==(const Format& other) const override;
/**
* Clone this object polymorphically. The caller is responsible
* @return A copy of the object
* @stable ICU 50
*/
- virtual TimeZoneFormat* clone() const;
+ virtual TimeZoneFormat* clone() const override;
/**
* Creates an instance of <code>TimeZoneFormat</code> for the given locale.
* @stable ICU 50
*/
virtual UnicodeString& format(const Formattable& obj, UnicodeString& appendTo,
- FieldPosition& pos, UErrorCode& status) const;
+ FieldPosition& pos, UErrorCode& status) const override;
/**
* Parse a string to produce an object. This methods handles parsing of
* delete it when done.
* @stable ICU 50
*/
- virtual void parseObject(const UnicodeString& source, Formattable& result, ParsePosition& parse_pos) const;
+ virtual void parseObject(const UnicodeString& source, Formattable& result, ParsePosition& parse_pos) const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
* ICU "poor man's RTTI", returns a UClassID for the actual class.
* @stable ICU 50
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
protected:
/**
* @return A copy of the object.
* @stable ICU 3.8
*/
- virtual InitialTimeZoneRule* clone() const;
+ virtual InitialTimeZoneRule* clone() const override;
/**
* Assignment operator.
* @return true if the given <code>TimeZoneRule</code> objects are semantically equal.
* @stable ICU 3.8
*/
- virtual bool operator==(const TimeZoneRule& that) const;
+ virtual bool operator==(const TimeZoneRule& that) const override;
/**
* 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 bool operator!=(const TimeZoneRule& that) const;
+ virtual bool operator!=(const TimeZoneRule& that) const override;
/**
* Gets the time when this rule takes effect in the given year.
* @return true if the other <code>TimeZoneRule</code> is equivalent to this one.
* @stable ICU 3.8
*/
- virtual UBool isEquivalentTo(const TimeZoneRule& that) const;
+ virtual UBool isEquivalentTo(const TimeZoneRule& that) const override;
/**
* Gets the very first time when this rule takes effect.
* "result" is unchanged.
* @stable ICU 3.8
*/
- virtual UBool getFirstStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const;
+ virtual UBool getFirstStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const override;
/**
* Gets the final time when this rule takes effect.
* "result" is unchanged.
* @stable ICU 3.8
*/
- virtual UBool getFinalStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const;
+ virtual UBool getFinalStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const override;
/**
* Gets the first time when this rule takes effect after the specified time.
* @stable ICU 3.8
*/
virtual UBool getNextStart(UDate base, int32_t prevRawOffset, int32_t prevDSTSavings,
- UBool inclusive, UDate& result) const;
+ UBool inclusive, UDate& result) const override;
/**
* Gets the most recent time when this rule takes effect before the specified time.
* @stable ICU 3.8
*/
virtual UBool getPreviousStart(UDate base, int32_t prevRawOffset, int32_t prevDSTSavings,
- UBool inclusive, UDate& result) const;
+ UBool inclusive, UDate& result) const override;
public:
/**
* other classes have different class IDs.
* @stable ICU 3.8
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
};
/**
* @return A copy of the object.
* @stable ICU 3.8
*/
- virtual AnnualTimeZoneRule* clone() const;
+ virtual AnnualTimeZoneRule* clone() const override;
/**
* Assignment operator.
* @return true if the given <code>TimeZoneRule</code> objects are semantically equal.
* @stable ICU 3.8
*/
- virtual bool operator==(const TimeZoneRule& that) const;
+ virtual bool operator==(const TimeZoneRule& that) const override;
/**
* 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 bool operator!=(const TimeZoneRule& that) const;
+ virtual bool operator!=(const TimeZoneRule& that) const override;
/**
* Gets the start date/time rule used by this rule.
* @return true if the other <code>TimeZoneRule</code> is equivalent to this one.
* @stable ICU 3.8
*/
- virtual UBool isEquivalentTo(const TimeZoneRule& that) const;
+ virtual UBool isEquivalentTo(const TimeZoneRule& that) const override;
/**
* Gets the very first time when this rule takes effect.
* "result" is unchanged.
* @stable ICU 3.8
*/
- virtual UBool getFirstStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const;
+ virtual UBool getFirstStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const override;
/**
* Gets the final time when this rule takes effect.
* "result" is unchanged.
* @stable ICU 3.8
*/
- virtual UBool getFinalStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const;
+ virtual UBool getFinalStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const override;
/**
* Gets the first time when this rule takes effect after the specified time.
* @stable ICU 3.8
*/
virtual UBool getNextStart(UDate base, int32_t prevRawOffset, int32_t prevDSTSavings,
- UBool inclusive, UDate& result) const;
+ UBool inclusive, UDate& result) const override;
/**
* Gets the most recent time when this rule takes effect before the specified time.
* @stable ICU 3.8
*/
virtual UBool getPreviousStart(UDate base, int32_t prevRawOffset, int32_t prevDSTSavings,
- UBool inclusive, UDate& result) const;
+ UBool inclusive, UDate& result) const override;
private:
* other classes have different class IDs.
* @stable ICU 3.8
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
};
/**
* @return A copy of the object.
* @stable ICU 3.8
*/
- virtual TimeArrayTimeZoneRule* clone() const;
+ virtual TimeArrayTimeZoneRule* clone() const override;
/**
* Assignment operator.
* @return true if the given <code>TimeZoneRule</code> objects are semantically equal.
* @stable ICU 3.8
*/
- virtual bool operator==(const TimeZoneRule& that) const;
+ virtual bool operator==(const TimeZoneRule& that) const override;
/**
* 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 bool operator!=(const TimeZoneRule& that) const;
+ virtual bool operator!=(const TimeZoneRule& that) const override;
/**
* Gets the time type of the start times used by this rule. The return value
* @return true if the other <code>TimeZoneRule</code> is equivalent to this one.
* @stable ICU 3.8
*/
- virtual UBool isEquivalentTo(const TimeZoneRule& that) const;
+ virtual UBool isEquivalentTo(const TimeZoneRule& that) const override;
/**
* Gets the very first time when this rule takes effect.
* "result" is unchanged.
* @stable ICU 3.8
*/
- virtual UBool getFirstStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const;
+ virtual UBool getFirstStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const override;
/**
* Gets the final time when this rule takes effect.
* "result" is unchanged.
* @stable ICU 3.8
*/
- virtual UBool getFinalStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const;
+ virtual UBool getFinalStart(int32_t prevRawOffset, int32_t prevDSTSavings, UDate& result) const override;
/**
* Gets the first time when this rule takes effect after the specified time.
* @stable ICU 3.8
*/
virtual UBool getNextStart(UDate base, int32_t prevRawOffset, int32_t prevDSTSavings,
- UBool inclusive, UDate& result) const;
+ UBool inclusive, UDate& result) const override;
/**
* Gets the most recent time when this rule takes effect before the specified time.
* @stable ICU 3.8
*/
virtual UBool getPreviousStart(UDate base, int32_t prevRawOffset, int32_t prevDSTSavings,
- UBool inclusive, UDate& result) const;
+ UBool inclusive, UDate& result) const override;
private:
* other classes have different class IDs.
* @stable ICU 3.8
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
};
* other classes have different class IDs.
* @stable ICU 3.8
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
};
U_NAMESPACE_END
*semantically equal.
* @stable ICU 3.8
*/
- virtual bool operator==(const TimeZone& that) const;
+ virtual bool operator==(const TimeZone& that) const override;
/**
* Return true if the given <code>TimeZone</code> objects are
* @return A new copy of this TimeZone object.
* @stable ICU 3.8
*/
- virtual VTimeZone* clone() const;
+ virtual VTimeZone* clone() const override;
/**
* Returns the TimeZone's adjusted GMT offset (i.e., the number of milliseconds to add
* @stable ICU 3.8
*/
virtual int32_t getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
- uint8_t dayOfWeek, int32_t millis, UErrorCode& status) const;
+ uint8_t dayOfWeek, int32_t millis, UErrorCode& status) const override;
/**
* Gets the time zone offset, for current date, modified in case of
*/
virtual int32_t getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
uint8_t dayOfWeek, int32_t millis,
- int32_t monthLength, UErrorCode& status) const;
+ int32_t monthLength, UErrorCode& status) const override;
/**
* Returns the time zone raw and GMT offset for the given moment
* @stable ICU 3.8
*/
virtual void getOffset(UDate date, UBool local, int32_t& rawOffset,
- int32_t& dstOffset, UErrorCode& ec) const;
+ int32_t& dstOffset, UErrorCode& ec) const override;
#ifndef U_FORCE_HIDE_DRAFT_API
/**
virtual void getOffsetFromLocal(
UDate date, UTimeZoneLocalOption nonExistingTimeOpt,
UTimeZoneLocalOption duplicatedTimeOpt,
- int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) const;
+ int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) const override;
#endif /* U_FORCE_HIDE_DRAFT_API */
/**
* @param offsetMillis The new raw GMT offset for this time zone.
* @stable ICU 3.8
*/
- virtual void setRawOffset(int32_t offsetMillis);
+ virtual void setRawOffset(int32_t offsetMillis) override;
/**
* Returns the TimeZone's raw GMT offset (i.e., the number of milliseconds to add
* @return The TimeZone's raw GMT offset.
* @stable ICU 3.8
*/
- virtual int32_t getRawOffset(void) const;
+ virtual int32_t getRawOffset(void) const override;
/**
* Queries if this time zone uses daylight savings time.
* false, otherwise.
* @stable ICU 3.8
*/
- virtual UBool useDaylightTime(void) const;
+ virtual UBool useDaylightTime(void) const override;
#ifndef U_FORCE_HIDE_DEPRECATED_API
/**
* false, otherwise.
* @deprecated ICU 2.4. Use Calendar::inDaylightTime() instead.
*/
- virtual UBool inDaylightTime(UDate date, UErrorCode& status) const;
+ virtual UBool inDaylightTime(UDate date, UErrorCode& status) const override;
#endif // U_FORCE_HIDE_DEPRECATED_API
/**
* with the possible exception of the ID
* @stable ICU 3.8
*/
- virtual UBool hasSameRules(const TimeZone& other) const;
+ virtual UBool hasSameRules(const TimeZone& other) const override;
/**
* Gets the first time zone transition after the base time.
* @return true if the transition is found.
* @stable ICU 3.8
*/
- virtual UBool getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;
+ virtual UBool getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const override;
/**
* Gets the most recent time zone transition before the base time.
* @return true if the transition is found.
* @stable ICU 3.8
*/
- virtual UBool getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;
+ virtual UBool getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const override;
/**
* Returns the number of <code>TimeZoneRule</code>s which represents time transitions,
* @return The number of <code>TimeZoneRule</code>s representing time transitions.
* @stable ICU 3.8
*/
- virtual int32_t countTransitionRules(UErrorCode& status) const;
+ virtual int32_t countTransitionRules(UErrorCode& status) const override;
/**
* Gets the <code>InitialTimeZoneRule</code> and the set of <code>TimeZoneRule</code>
* @stable ICU 3.8
*/
virtual void getTimeZoneRules(const InitialTimeZoneRule*& initial,
- const TimeZoneRule* trsrules[], int32_t& trscount, UErrorCode& status) const;
+ const TimeZoneRule* trsrules[], int32_t& trscount, UErrorCode& status) const override;
private:
enum { DEFAULT_VTIMEZONE_LINES = 100 };
* other classes have different class IDs.
* @stable ICU 3.8
*/
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
};
U_NAMESPACE_END
* @param noFallback Ignored.
* @param status The standard ICU error code output parameter.
*/
- void put(const char *source, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) {
+ void put(const char *source, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) override {
if (U_FAILURE(status)) { return; }
if (uprv_strcmp(source, "convertUnits") != 0) {
// This is very strict, however it is the cheapest way to be sure
* @param status The standard ICU error code output parameter. Note: if an
* error is returned, outPrefs and outMetadata may be inconsistent.
*/
- void put(const char *key, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) {
+ void put(const char *key, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) override {
if (U_FAILURE(status)) { return; }
if (uprv_strcmp(key, "unitPreferenceData") != 0) {
// This is very strict, however it is the cheapest way to be sure
static UChar32 ScanHex(const UChar *s, int32_t start, int32_t limit, UErrorCode &status);
static UClassID U_EXPORT2 getStaticClassID(void);
- virtual UClassID getDynamicClassID(void) const;
+ virtual UClassID getDynamicClassID(void) const override;
//
// Data Members
virtual ~UTF16CollationIterator();
- virtual bool operator==(const CollationIterator &other) const;
+ virtual bool operator==(const CollationIterator &other) const override;
- virtual void resetToOffset(int32_t newOffset);
+ virtual void resetToOffset(int32_t newOffset) override;
- virtual int32_t getOffset() const;
+ virtual int32_t getOffset() const override;
void setText(const UChar *s, const UChar *lim) {
reset();
limit = lim;
}
- virtual UChar32 nextCodePoint(UErrorCode &errorCode);
+ virtual UChar32 nextCodePoint(UErrorCode &errorCode) override;
- virtual UChar32 previousCodePoint(UErrorCode &errorCode);
+ virtual UChar32 previousCodePoint(UErrorCode &errorCode) override;
protected:
// Copy constructor only for subclasses which set the pointers.
: CollationIterator(other),
start(NULL), pos(NULL), limit(NULL) {}
- virtual uint32_t handleNextCE32(UChar32 &c, UErrorCode &errorCode);
+ virtual uint32_t handleNextCE32(UChar32 &c, UErrorCode &errorCode) override;
- virtual UChar handleGetTrailSurrogate();
+ virtual UChar handleGetTrailSurrogate() override;
- virtual UBool foundNULTerminator();
+ virtual UBool foundNULTerminator() override;
- virtual void forwardNumCodePoints(int32_t num, UErrorCode &errorCode);
+ virtual void forwardNumCodePoints(int32_t num, UErrorCode &errorCode) override;
- virtual void backwardNumCodePoints(int32_t num, UErrorCode &errorCode);
+ virtual void backwardNumCodePoints(int32_t num, UErrorCode &errorCode) override;
// UTF-16 string pointers.
// limit can be NULL for NUL-terminated strings.
virtual ~FCDUTF16CollationIterator();
- virtual bool operator==(const CollationIterator &other) const;
+ virtual bool operator==(const CollationIterator &other) const override;
- virtual void resetToOffset(int32_t newOffset);
+ virtual void resetToOffset(int32_t newOffset) override;
- virtual int32_t getOffset() const;
+ virtual int32_t getOffset() const override;
- virtual UChar32 nextCodePoint(UErrorCode &errorCode);
+ virtual UChar32 nextCodePoint(UErrorCode &errorCode) override;
- virtual UChar32 previousCodePoint(UErrorCode &errorCode);
+ virtual UChar32 previousCodePoint(UErrorCode &errorCode) override;
protected:
- virtual uint32_t handleNextCE32(UChar32 &c, UErrorCode &errorCode);
+ virtual uint32_t handleNextCE32(UChar32 &c, UErrorCode &errorCode) override;
- virtual UBool foundNULTerminator();
+ virtual UBool foundNULTerminator() override;
- virtual void forwardNumCodePoints(int32_t num, UErrorCode &errorCode);
+ virtual void forwardNumCodePoints(int32_t num, UErrorCode &errorCode) override;
- virtual void backwardNumCodePoints(int32_t num, UErrorCode &errorCode);
+ virtual void backwardNumCodePoints(int32_t num, UErrorCode &errorCode) override;
private:
/**
virtual ~UTF8CollationIterator();
- virtual void resetToOffset(int32_t newOffset);
+ virtual void resetToOffset(int32_t newOffset) override;
- virtual int32_t getOffset() const;
+ virtual int32_t getOffset() const override;
- virtual UChar32 nextCodePoint(UErrorCode &errorCode);
+ virtual UChar32 nextCodePoint(UErrorCode &errorCode) override;
- virtual UChar32 previousCodePoint(UErrorCode &errorCode);
+ virtual UChar32 previousCodePoint(UErrorCode &errorCode) override;
protected:
/**
* Valid lead surrogates are returned from inside a normalized text segment,
* where handleGetTrailSurrogate() will return the matching trail surrogate.
*/
- virtual uint32_t handleNextCE32(UChar32 &c, UErrorCode &errorCode);
+ virtual uint32_t handleNextCE32(UChar32 &c, UErrorCode &errorCode) override;
- virtual UBool foundNULTerminator();
+ virtual UBool foundNULTerminator() override;
- virtual UBool forbidSurrogateCodePoints() const;
+ virtual UBool forbidSurrogateCodePoints() const override;
- virtual void forwardNumCodePoints(int32_t num, UErrorCode &errorCode);
+ virtual void forwardNumCodePoints(int32_t num, UErrorCode &errorCode) override;
- virtual void backwardNumCodePoints(int32_t num, UErrorCode &errorCode);
+ virtual void backwardNumCodePoints(int32_t num, UErrorCode &errorCode) override;
const uint8_t *u8;
int32_t pos;
virtual ~FCDUTF8CollationIterator();
- virtual void resetToOffset(int32_t newOffset);
+ virtual void resetToOffset(int32_t newOffset) override;
- virtual int32_t getOffset() const;
+ virtual int32_t getOffset() const override;
- virtual UChar32 nextCodePoint(UErrorCode &errorCode);
+ virtual UChar32 nextCodePoint(UErrorCode &errorCode) override;
- virtual UChar32 previousCodePoint(UErrorCode &errorCode);
+ virtual UChar32 previousCodePoint(UErrorCode &errorCode) override;
protected:
- virtual uint32_t handleNextCE32(UChar32 &c, UErrorCode &errorCode);
+ virtual uint32_t handleNextCE32(UChar32 &c, UErrorCode &errorCode) override;
- virtual UChar handleGetTrailSurrogate();
+ virtual UChar handleGetTrailSurrogate() override;
- virtual UBool foundNULTerminator();
+ virtual UBool foundNULTerminator() override;
- virtual void forwardNumCodePoints(int32_t num, UErrorCode &errorCode);
+ virtual void forwardNumCodePoints(int32_t num, UErrorCode &errorCode) override;
- virtual void backwardNumCodePoints(int32_t num, UErrorCode &errorCode);
+ virtual void backwardNumCodePoints(int32_t num, UErrorCode &errorCode) override;
private:
UBool nextHasLccc() const;
virtual void handleReplaceBetween(int32_t start,
int32_t limit,
- const UnicodeString& text);
+ const UnicodeString& text) override;
virtual void extractBetween(int32_t start,
int32_t limit,
- UnicodeString& target) const;
+ UnicodeString& target) const override;
- virtual void copy(int32_t start, int32_t limit, int32_t dest);
+ virtual void copy(int32_t start, int32_t limit, int32_t dest) override;
// virtual Replaceable *clone() const { return NULL; } same as default
*
* @draft ICU 2.2
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
protected:
- virtual int32_t getLength() const;
+ virtual int32_t getLength() const override;
- virtual UChar getCharAt(int32_t offset) const;
+ virtual UChar getCharAt(int32_t offset) const override;
- virtual UChar32 getChar32At(int32_t offset) const;
+ virtual UChar32 getChar32At(int32_t offset) const override;
};
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ReplaceableGlue)
virtual const ResourceBundle *getItem(const char* key, UErrorCode &status) const;
- virtual const UnicodeString getString(const char* key, UErrorCode &status) const;
- virtual int32_t getInt28(const char* key, UErrorCode &status) const;
- virtual uint32_t getUInt28(const char* key, UErrorCode &status) const;
- virtual const int32_t *getIntVector(int32_t &length, const char *key, UErrorCode &status) const;
- virtual const uint8_t *getBinary(int32_t &length, const char *key, UErrorCode &status) const;
+ virtual const UnicodeString getString(const char* key, UErrorCode &status) const override;
+ virtual int32_t getInt28(const char* key, UErrorCode &status) const override;
+ virtual uint32_t getUInt28(const char* key, UErrorCode &status) const override;
+ virtual const int32_t *getIntVector(int32_t &length, const char *key, UErrorCode &status) const override;
+ virtual const uint8_t *getBinary(int32_t &length, const char *key, UErrorCode &status) const override;
- virtual int32_t getInt(const char* key, UErrorCode &status) const;
+ virtual int32_t getInt(const char* key, UErrorCode &status) const override;
- virtual const UnicodeString* getStringArray(int32_t& count, const char* key, UErrorCode &status) const;
- virtual const int32_t* getIntArray(int32_t& count, const char* key, UErrorCode &status) const;
+ virtual const UnicodeString* getStringArray(int32_t& count, const char* key, UErrorCode &status) const override;
+ virtual const int32_t* getIntArray(int32_t& count, const char* key, UErrorCode &status) const override;
// ... etc ...
};
public:
virtual ~RBTestData();
- virtual UBool getInfo(const DataMap *& info, UErrorCode &status) const;
+ virtual UBool getInfo(const DataMap *& info, UErrorCode &status) const override;
- virtual UBool nextSettings(const DataMap *& settings, UErrorCode &status);
- virtual UBool nextCase(const DataMap *& nextCase, UErrorCode &status);
+ virtual UBool nextSettings(const DataMap *& settings, UErrorCode &status) override;
+ virtual UBool nextCase(const DataMap *& nextCase, UErrorCode &status) override;
};
#endif
void setScope(const UnicodeString& message);
protected:
- virtual void handleFailure() const;
+ virtual void handleFailure() const override;
private:
TestLog &testClass;
RBTestDataModule(const char* name, TestLog& log, UErrorCode& status);
public:
- virtual UBool getInfo(const DataMap *& info, UErrorCode &status) const;
+ virtual UBool getInfo(const DataMap *& info, UErrorCode &status) const override;
- virtual TestData* createTestData(int32_t index, UErrorCode &status) const;
- virtual TestData* createTestData(const char* name, UErrorCode &status) const;
+ virtual TestData* createTestData(int32_t index, UErrorCode &status) const override;
+ virtual TestData* createTestData(const char* name, UErrorCode &status) const override;
private:
UResourceBundle *getTestBundle(const char* bundleName, UErrorCode &status);
virtual void getRules(
const char *localeID, const char *collationType,
UnicodeString &rules,
- const char *&errorReason, UErrorCode &errorCode);
+ const char *&errorReason, UErrorCode &errorCode) override;
private:
const char *inputDir;
void add(SResource *res);
- virtual void handleWrite16(SRBRoot *bundle);
- virtual void handlePreWrite(uint32_t *byteOffset);
- virtual void handleWrite(UNewDataMemory *mem, uint32_t *byteOffset);
+ virtual void handleWrite16(SRBRoot *bundle) override;
+ virtual void handlePreWrite(uint32_t *byteOffset) override;
+ virtual void handleWrite(UNewDataMemory *mem, uint32_t *byteOffset) override;
SResource *fLast;
};
void add(SResource *res);
- virtual void handleWrite16(SRBRoot *bundle);
+ virtual void handleWrite16(SRBRoot *bundle) override;
};
class StringBaseResource : public SResource {
const UChar *getBuffer() const { return icu::toUCharPtr(fString.getBuffer()); }
int32_t length() const { return fString.length(); }
- virtual void handlePreWrite(uint32_t *byteOffset);
- virtual void handleWrite(UNewDataMemory *mem, uint32_t *byteOffset);
+ virtual void handlePreWrite(uint32_t *byteOffset) override;
+ virtual void handleWrite(UNewDataMemory *mem, uint32_t *byteOffset) override;
// TODO: private with getter?
icu::UnicodeString fString;
return fNumCharsForLength + length() + 1; // +1 for the NUL
}
- virtual void handlePreflightStrings(SRBRoot *bundle, UHashtable *stringSet, UErrorCode &errorCode);
- virtual void handleWrite16(SRBRoot *bundle);
+ virtual void handlePreflightStrings(SRBRoot *bundle, UHashtable *stringSet, UErrorCode &errorCode) override;
+ virtual void handleWrite16(SRBRoot *bundle) override;
void writeUTF16v2(int32_t base, icu::UnicodeString &dest);
void add(int32_t value, UErrorCode &errorCode);
- virtual void handlePreWrite(uint32_t *byteOffset);
- virtual void handleWrite(UNewDataMemory *mem, uint32_t *byteOffset);
+ virtual void handlePreWrite(uint32_t *byteOffset) override;
+ virtual void handleWrite(UNewDataMemory *mem, uint32_t *byteOffset) override;
// TODO: UVector32
size_t fCount;
const UString* comment, UErrorCode &errorCode);
virtual ~BinaryResource();
- virtual void handlePreWrite(uint32_t *byteOffset);
- virtual void handleWrite(UNewDataMemory *mem, uint32_t *byteOffset);
+ virtual void handlePreWrite(uint32_t *byteOffset) override;
+ virtual void handleWrite(UNewDataMemory *mem, uint32_t *byteOffset) override;
// TODO: CharString?
uint32_t fLength;
IcuToolErrorCode(const char *loc) : location(loc) {}
virtual ~IcuToolErrorCode();
protected:
- virtual void handleFailure() const;
+ virtual void handleFailure() const override;
private:
const char *location;
};
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
- virtual UClassID getDynamicClassID() const;
+ virtual UClassID getDynamicClassID() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
projects / icu / commitdiff