U_NAMESPACE_BEGIN
+Appendable::~Appendable() {}
+
UBool
Appendable::appendCodePoint(UChar32 c) {
if(c<=0xffff) {
// -------------------------------------
class ICUBreakIteratorFactory : public ICUResourceBundleFactory {
+public:
+ virtual ~ICUBreakIteratorFactory();
protected:
virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* /*service*/, UErrorCode& status) const {
return BreakIterator::makeInstance(loc, kind, status);
}
};
+ICUBreakIteratorFactory::~ICUBreakIteratorFactory() {}
+
// -------------------------------------
class ICUBreakIteratorService : public ICULocaleService {
registerFactory(new ICUBreakIteratorFactory(), status);
}
+ virtual ~ICUBreakIteratorService();
+
virtual UObject* cloneInstance(UObject* instance) const {
return ((BreakIterator*)instance)->clone();
}
}
};
+ICUBreakIteratorService::~ICUBreakIteratorService() {}
+
// -------------------------------------
U_NAMESPACE_END
-// Copyright (C) 2009-2010, International Business Machines
+// Copyright (C) 2009-2011, International Business Machines
// Corporation and others. All Rights Reserved.
//
// Copyright 2007 Google Inc. All Rights Reserved.
U_NAMESPACE_BEGIN
+ByteSink::~ByteSink() {}
+
char* ByteSink::GetAppendBuffer(int32_t min_capacity,
int32_t /*desired_capacity_hint*/,
char* scratch, int32_t scratch_capacity,
size_(0), appended_(0), overflowed_(FALSE) {
}
+CheckedArrayByteSink::~CheckedArrayByteSink() {}
+
CheckedArrayByteSink& CheckedArrayByteSink::Reset() {
size_ = appended_ = 0;
overflowed_ = FALSE;
/*
**********************************************************************
-* Copyright (C) 1999-2004, International Business Machines
+* Copyright (C) 1999-2011, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
*/
}
}
+CharacterIterator::~CharacterIterator() {}
+
CharacterIterator::CharacterIterator(const CharacterIterator &that) :
ForwardCharacterIterator(that),
textLength(that.textLength), pos(that.pos), begin(that.begin), end(that.end)
/*
*******************************************************************************
*
-* Copyright (C) 2009, International Business Machines
+* Copyright (C) 2009-2011, International Business Machines
* Corporation and others. All Rights Reserved.
*
*******************************************************************************
U_NAMESPACE_BEGIN
+ErrorCode::~ErrorCode() {}
+
UErrorCode ErrorCode::reset() {
UErrorCode code = errorCode;
errorCode = U_ZERO_ERROR;
U_NAMESPACE_BEGIN
+FilteredNormalizer2::~FilteredNormalizer2() {}
+
UnicodeString &
FilteredNormalizer2::normalize(const UnicodeString &src,
UnicodeString &dest,
}
}
- virtual ~KeywordEnumeration() {
- uprv_free(keywords);
- }
+ virtual ~KeywordEnumeration();
virtual StringEnumeration * clone() const
{
const char KeywordEnumeration::fgClassID = '\0';
+KeywordEnumeration::~KeywordEnumeration() {
+ uprv_free(keywords);
+}
+
StringEnumeration *
Locale::createKeywords(UErrorCode &status) const
{
// Public API dispatch via Normalizer2 subclasses -------------------------- ***
+Normalizer2::~Normalizer2() {}
+
// Normalizer2 implementation for the old UNORM_NONE.
class NoopNormalizer2 : public Normalizer2 {
+ virtual ~NoopNormalizer2();
+
virtual UnicodeString &
normalize(const UnicodeString &src,
UnicodeString &dest,
virtual UBool isInert(UChar32) const { return TRUE; }
};
+NoopNormalizer2::~NoopNormalizer2() {}
+
// Intermediate class:
// Has Normalizer2Impl and does boilerplate argument checking and setup.
class Normalizer2WithImpl : public Normalizer2 {
public:
Normalizer2WithImpl(const Normalizer2Impl &ni) : impl(ni) {}
+ virtual ~Normalizer2WithImpl();
// normalize
virtual UnicodeString &
const Normalizer2Impl &impl;
};
+Normalizer2WithImpl::~Normalizer2WithImpl() {}
+
class DecomposeNormalizer2 : public Normalizer2WithImpl {
public:
DecomposeNormalizer2(const Normalizer2Impl &ni) : Normalizer2WithImpl(ni) {}
+ virtual ~DecomposeNormalizer2();
private:
virtual void
virtual UBool isInert(UChar32 c) const { return impl.isDecompInert(c); }
};
+DecomposeNormalizer2::~DecomposeNormalizer2() {}
+
class ComposeNormalizer2 : public Normalizer2WithImpl {
public:
ComposeNormalizer2(const Normalizer2Impl &ni, UBool fcc) :
Normalizer2WithImpl(ni), onlyContiguous(fcc) {}
+ virtual ~ComposeNormalizer2();
private:
virtual void
const UBool onlyContiguous;
};
+ComposeNormalizer2::~ComposeNormalizer2() {}
+
class FCDNormalizer2 : public Normalizer2WithImpl {
public:
FCDNormalizer2(const Normalizer2Impl &ni) : Normalizer2WithImpl(ni) {}
+ virtual ~FCDNormalizer2();
private:
virtual void
virtual UBool isInert(UChar32 c) const { return impl.isFCDInert(c); }
};
+FCDNormalizer2::~FCDNormalizer2() {}
+
// instance cache ---------------------------------------------------------- ***
struct Norm2AllModes : public UMemory {
******************************************************************
*/
+ICUServiceFactory::~ICUServiceFactory() {}
+
SimpleFactory::SimpleFactory(UObject* instanceToAdopt, const UnicodeString& id, UBool visible)
: _instance(instanceToAdopt), _id(id), _visible(visible)
{
******************************************************************
*/
+ServiceListener::~ServiceListener() {}
+
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ServiceListener)
/*
*/
class U_COMMON_API ICUServiceFactory : public UObject {
public:
+ virtual ~ICUServiceFactory();
/**
* <p>Create a service object from the key, if this factory
*/
class U_COMMON_API ServiceListener : public EventListener {
public:
+ virtual ~ServiceListener();
+
/**
* <p>This method is called when the service changes. At the time of the
* call this listener is registered with the service. It must
return NULL;
}
- virtual ~ServiceEnumeration() {}
+ virtual ~ServiceEnumeration();
virtual StringEnumeration *clone() const {
UErrorCode status = U_ZERO_ERROR;
virtual UClassID getDynamicClassID(void) const;
};
+ServiceEnumeration::~ServiceEnumeration() {}
+
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ServiceEnumeration)
StringEnumeration*
/**
*******************************************************************************
- * Copyright (C) 2006-2008, International Business Machines Corporation *
+ * Copyright (C) 2006-2011, International Business Machines Corporation *
* and others. All Rights Reserved. *
*******************************************************************************
*/
fBranchStack.push(kLessThan, status);
unistr.remove();
}
-
- virtual ~MutableTrieEnumeration() {
- }
-
+
+ virtual ~MutableTrieEnumeration();
+
virtual StringEnumeration *clone() const {
UErrorCode status = U_ZERO_ERROR;
return new MutableTrieEnumeration(fRoot, status);
}
};
+MutableTrieEnumeration::~MutableTrieEnumeration() {}
+
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(MutableTrieEnumeration)
StringEnumeration *
fIndexStack.push(0, status);
unistr.remove();
}
-
- virtual ~CompactTrieEnumeration() {
- }
-
+
+ virtual ~CompactTrieEnumeration();
+
virtual StringEnumeration *clone() const {
UErrorCode status = U_ZERO_ERROR;
return new CompactTrieEnumeration(fHeader, status);
}
};
+CompactTrieEnumeration::~CompactTrieEnumeration() {}
+
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(CompactTrieEnumeration)
const UnicodeString *
fNodeID = nodes.size();
nodes.push(this, status);
}
-
- virtual ~BuildCompactTrieNode() {
- }
-
+
+ virtual ~BuildCompactTrieNode();
+
virtual uint32_t size() {
return sizeof(uint16_t);
}
}
};
+BuildCompactTrieNode::~BuildCompactTrieNode() {}
+
class BuildCompactTrieHorizontalNode: public BuildCompactTrieNode {
public:
UStack fLinks;
BuildCompactTrieHorizontalNode(UBool parentEndsWord, UStack &nodes, UErrorCode &status)
: BuildCompactTrieNode(parentEndsWord, FALSE, nodes, status), fLinks(status) {
}
-
- virtual ~BuildCompactTrieHorizontalNode() {
- }
-
+
+ virtual ~BuildCompactTrieHorizontalNode();
+
virtual uint32_t size() {
return offsetof(CompactTrieHorizontalNode,entries) +
(fChars.length()*sizeof(CompactTrieHorizontalEntry));
}
};
+BuildCompactTrieHorizontalNode::~BuildCompactTrieHorizontalNode() {}
+
class BuildCompactTrieVerticalNode: public BuildCompactTrieNode {
public:
BuildCompactTrieNode *fEqual;
: BuildCompactTrieNode(parentEndsWord, TRUE, nodes, status) {
fEqual = NULL;
}
-
- virtual ~BuildCompactTrieVerticalNode() {
- }
-
+
+ virtual ~BuildCompactTrieVerticalNode();
+
virtual uint32_t size() {
return offsetof(CompactTrieVerticalNode,chars) + (fChars.length()*sizeof(uint16_t));
}
}
};
+BuildCompactTrieVerticalNode::~BuildCompactTrieVerticalNode() {}
+
// Forward declaration
static void walkHorizontal(const TernaryNode *node,
BuildCompactTrieHorizontalNode *building,
*/
class U_COMMON_API Appendable : public UObject {
public:
+ /**
+ * Destructor.
+ * @draft ICU 4.8
+ */
+ ~Appendable();
+
/**
* Appends a 16-bit code unit.
* @param c code unit
*/
explicit UnicodeStringAppendable(UnicodeString &s) : str(s) {}
+ /**
+ * Destructor.
+ * @draft ICU 4.8
+ */
+ ~UnicodeStringAppendable();
+
/**
* Appends a 16-bit code unit to the string.
* @param c code unit
-// Copyright (C) 2009-2010, International Business Machines
+// Copyright (C) 2009-2011, International Business Machines
// Corporation and others. All Rights Reserved.
//
// Copyright 2007 Google Inc. All Rights Reserved.
* Virtual destructor.
* @stable ICU 4.2
*/
- virtual ~ByteSink() { }
+ virtual ~ByteSink();
/**
* Append "bytes[0,n-1]" to this.
* @stable ICU 4.2
*/
CheckedArrayByteSink(char* outbuf, int32_t capacity);
+ /**
+ * Destructor.
+ * @stable ICU 4.2
+ */
+ virtual ~CheckedArrayByteSink();
/**
* Returns the sink to its original state, without modifying the buffer.
* Useful for reusing both the buffer and the sink for multiple streams.
/*
********************************************************************
*
-* Copyright (C) 1997-2005, International Business Machines
+* Copyright (C) 1997-2011, International Business Machines
* Corporation and others. All Rights Reserved.
*
********************************************************************
*/
enum EOrigin { kStart, kCurrent, kEnd };
+ /**
+ * Destructor.
+ * @stable ICU 2.0
+ */
+ virtual ~CharacterIterator();
+
/**
* Returns a pointer to a new CharacterIterator of the same
* concrete class as this one, and referring to the same
/*
*******************************************************************************
*
-* Copyright (C) 2009-2010, International Business Machines
+* Copyright (C) 2009-2011, International Business Machines
* Corporation and others. All Rights Reserved.
*
*******************************************************************************
* \code
* class IcuErrorCode: public icu::ErrorCode {
* public:
- * virtual ~IcuErrorCode() {
+ * virtual ~IcuErrorCode() { // should be defined in .cpp as "key function"
* // Safe because our handleFailure() does not throw exceptions.
* if(isFailure()) { handleFailure(); }
* }
*/
ErrorCode() : errorCode(U_ZERO_ERROR) {}
/** Destructor, does nothing. See class documentation for details. @stable ICU 4.2 */
- virtual ~ErrorCode() {}
+ virtual ~ErrorCode();
/** Conversion operator, returns a reference. @stable ICU 4.2 */
operator UErrorCode & () { return errorCode; }
/** Conversion operator, returns a pointer. @stable ICU 4.2 */
/*
*******************************************************************************
-* Copyright (C) 2010, International Business Machines
+* Copyright (C) 2010-2011, International Business Machines
* Corporation and others. All Rights Reserved.
*******************************************************************************
* file name: idna.h
*/
class U_COMMON_API IDNA : public UObject {
public:
+ /**
+ * Destructor.
+ * @draft ICU 4.6
+ */
+ ~IDNA();
+
/**
* Returns an IDNA instance which implements UTS #46.
* Returns an unmodifiable instance, owned by the caller.
*/
class U_COMMON_API Normalizer2 : public UObject {
public:
+ /**
+ * Destructor.
+ * @stable ICU 4.4
+ */
+ ~Normalizer2();
+
/**
* Returns a Normalizer2 instance which uses the specified data file
* (packageName/name similar to ucnv_openPackage() and ures_open()/ResourceBundle)
FilteredNormalizer2(const Normalizer2 &n2, const UnicodeSet &filterSet) :
norm2(n2), set(filterSet) {}
+ /**
+ * Destructor.
+ * @stable ICU 4.4
+ */
+ ~FilteredNormalizer2();
+
/**
* Writes the normalized form of the source string to the destination string
* (replacing its contents) and returns the destination string.
// UnicodeStringAppendable ------------------------------------------------- ***
+UnicodeStringAppendable::~UnicodeStringAppendable() {}
+
UBool
UnicodeStringAppendable::appendCodeUnit(UChar c) {
return str.doReplace(str.length(), 0, &c, 0, 1).isWritable();
// IDNA class default implementations -------------------------------------- ***
+IDNA::~IDNA() {}
+
void
IDNA::labelToASCII_UTF8(const StringPiece &label, ByteSink &dest,
IDNAInfo &info, UErrorCode &errorCode) const {
/************************************************************************
- * Copyright (C) 1996-2008, International Business Machines Corporation *
- * and others. All Rights Reserved. *
+ * Copyright (C) 1996-2011, International Business Machines Corporation
+ * and others. All Rights Reserved.
************************************************************************
* 2003-nov-07 srl Port from Java
*/
*/
class SunTimeAngleFunc : public CalendarAstronomer::AngleFunc {
public:
+ virtual ~SunTimeAngleFunc();
virtual double eval(CalendarAstronomer& a) { return a.getSunLongitude(); }
};
+SunTimeAngleFunc::~SunTimeAngleFunc() {}
+
UDate CalendarAstronomer::getSunTime(double desired, UBool next)
{
SunTimeAngleFunc func;
class RiseSetCoordFunc : public CalendarAstronomer::CoordFunc {
public:
+ virtual ~RiseSetCoordFunc();
virtual void eval(CalendarAstronomer::Equatorial& result, CalendarAstronomer&a) { a.getSunPosition(result); }
};
+RiseSetCoordFunc::~RiseSetCoordFunc() {}
+
UDate CalendarAstronomer::getSunRiseSet(UBool rise)
{
UDate t0 = fTime;
class MoonTimeAngleFunc : public CalendarAstronomer::AngleFunc {
public:
+ virtual ~MoonTimeAngleFunc();
virtual double eval(CalendarAstronomer&a) { return a.getMoonAge(); }
};
+MoonTimeAngleFunc::~MoonTimeAngleFunc() {}
+
/*const CalendarAstronomer::MoonAge CalendarAstronomer::LAST_QUARTER() {
return CalendarAstronomer::MoonAge((CalendarAstronomer::PI*3)/2);
}*/
class MoonRiseSetCoordFunc : public CalendarAstronomer::CoordFunc {
public:
+ virtual ~MoonRiseSetCoordFunc();
virtual void eval(CalendarAstronomer::Equatorial& result, CalendarAstronomer&a) { result = a.getMoonPosition(); }
};
+MoonRiseSetCoordFunc::~MoonRiseSetCoordFunc() {}
+
/**
* Returns the time (GMT) of sunrise or sunset on the local date to which
* this calendar is currently set.
BasicCalendarFactory()
: LocaleKeyFactory(LocaleKeyFactory::INVISIBLE) { }
- virtual ~BasicCalendarFactory() {}
+ virtual ~BasicCalendarFactory();
protected:
//virtual UBool isSupportedID( const UnicodeString& id, UErrorCode& status) const {
}
};
+BasicCalendarFactory::~BasicCalendarFactory() {}
/**
* A factory which looks up the DefaultCalendar resource to determine which class of calendar to use
class DefaultCalendarFactory : public ICUResourceBundleFactory {
public:
- DefaultCalendarFactory(): ICUResourceBundleFactory() { }
+ DefaultCalendarFactory() : ICUResourceBundleFactory() { }
+ virtual ~DefaultCalendarFactory();
protected:
virtual UObject* create(const ICUServiceKey& key, const ICUService* /*service*/, UErrorCode& status) const {
}
};
+DefaultCalendarFactory::~DefaultCalendarFactory() {}
+
// -------------------------------------
class CalendarService : public ICULocaleService {
public:
registerFactory(new DefaultCalendarFactory(), status);
}
+ virtual ~CalendarService();
+
virtual UObject* cloneInstance(UObject* instance) const {
UnicodeString *s = dynamic_cast<UnicodeString *>(instance);
if(s != NULL) {
}
};
+CalendarService::~CalendarService() {}
+
// -------------------------------------
static inline UBool
class ICUCollatorFactory : public ICUResourceBundleFactory {
public:
- ICUCollatorFactory(): ICUResourceBundleFactory(UnicodeString(U_ICUDATA_COLL, -1, US_INV)) { }
+ ICUCollatorFactory() : ICUResourceBundleFactory(UnicodeString(U_ICUDATA_COLL, -1, US_INV)) { }
+ virtual ~ICUCollatorFactory();
protected:
virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const;
};
+ICUCollatorFactory::~ICUCollatorFactory() {}
+
UObject*
ICUCollatorFactory::create(const ICUServiceKey& key, const ICUService* /* service */, UErrorCode& status) const {
if (handlesKey(key, status)) {
UErrorCode status = U_ZERO_ERROR;
registerFactory(new ICUCollatorFactory(), status);
}
-
+
+ virtual ~ICUCollatorService();
+
virtual UObject* cloneInstance(UObject* instance) const {
return ((Collator*)instance)->clone();
}
}
};
+ICUCollatorService::~ICUCollatorService() {}
+
// -------------------------------------
static ICULocaleService*
}
}
}
-
- virtual ~CFactory()
- {
- delete _delegate;
- delete _ids;
- }
-
+
+ virtual ~CFactory();
+
virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const;
protected:
getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const;
};
+CFactory::~CFactory()
+{
+ delete _delegate;
+ delete _ids;
+}
+
UObject*
CFactory::create(const ICUServiceKey& key, const ICUService* /* service */, UErrorCode& status) const
{
//isAvailableLocaleListInitialized(status);
}
- virtual ~CollationLocaleListEnumeration() {
- }
+ virtual ~CollationLocaleListEnumeration();
virtual StringEnumeration * clone() const
{
}
};
+CollationLocaleListEnumeration::~CollationLocaleListEnumeration() {}
+
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(CollationLocaleListEnumeration)
/*
**********************************************************************
- * Copyright (C) 2005-2009, International Business Machines
+ * Copyright (C) 2005-2011, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
*/
{0x1b, 0x4f, 0x00, 0x00, 0x00}, // SS3
};
+CharsetRecog_2022JP::~CharsetRecog_2022JP() {}
+
const char *CharsetRecog_2022JP::getName() const
{
return "ISO-2022-JP";
return match_2022(textIn->fInputBytes, textIn->fInputLen, escapeSequences_2022JP, ARRAY_SIZE(escapeSequences_2022JP));
}
+CharsetRecog_2022KR::~CharsetRecog_2022KR() {}
+
const char *CharsetRecog_2022KR::getName() const
{
return "ISO-2022-KR";
return match_2022(textIn->fInputBytes, textIn->fInputLen, escapeSequences_2022KR, ARRAY_SIZE(escapeSequences_2022KR));
}
+CharsetRecog_2022CN::~CharsetRecog_2022CN() {}
+
const char *CharsetRecog_2022CN::getName() const
{
return "ISO-2022-CN";
/*
**********************************************************************
- * Copyright (C) 2005-2006, International Business Machines
+ * Copyright (C) 2005-2011, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
*/
class CharsetRecog_2022JP :public CharsetRecog_2022
{
-public:
- virtual ~CharsetRecog_2022JP() {}
+public:
+ virtual ~CharsetRecog_2022JP();
const char *getName() const;
};
class CharsetRecog_2022KR :public CharsetRecog_2022 {
-public:
- virtual ~CharsetRecog_2022KR() {}
+public:
+ virtual ~CharsetRecog_2022KR();
const char *getName() const;
class CharsetRecog_2022CN :public CharsetRecog_2022
{
-public:
- virtual ~CharsetRecog_2022CN() {}
+public:
+ virtual ~CharsetRecog_2022CN();
const char* getName() const;
DateTimeMatcher::DateTimeMatcher(void) {
}
+DateTimeMatcher::~DateTimeMatcher() {}
+
DateTimeMatcher::DateTimeMatcher(const DateTimeMatcher& other) {
copyFrom(other.skeleton);
}
return TRUE;
}
+DistanceInfo::~DistanceInfo() {}
+
void
DistanceInfo::setTo(DistanceInfo &other) {
missingFieldMask = other.missingFieldMask;
int32_t extraFieldMask;
DistanceInfo() {}
- virtual ~DistanceInfo() {}
+ virtual ~DistanceInfo();
void clear() { missingFieldMask = extraFieldMask = 0; }
void setTo(DistanceInfo& other);
void addMissing(int32_t field) { missingFieldMask |= (1<<field); }
int32_t getDistance(const DateTimeMatcher& other, int32_t includeMask, DistanceInfo& distanceInfo);
DateTimeMatcher();
DateTimeMatcher(const DateTimeMatcher& other);
- virtual ~DateTimeMatcher() {}
+ virtual ~DateTimeMatcher();
int32_t getFieldMask();
};
////////////////////////////////////////////////////////////////////////////////////////////////////
+LocaleDisplayNames::~LocaleDisplayNames() {}
+
UOBJECT_DEFINE_NO_RTTI_IMPLEMENTATION(LocaleDisplayNames)
////////////////////////////////////////////////////////////////////////////////////////////////////
/*
**********************************************************************
-* Copyright (c) 2004, International Business Machines
+* Copyright (c) 2004-2011, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
* Author: Alan Liu
MeasureFormat::MeasureFormat() {}
+MeasureFormat::~MeasureFormat() {}
+
MeasureFormat* U_EXPORT2 MeasureFormat::createCurrencyFormat(const Locale& locale,
UErrorCode& ec) {
CurrencyFormat* fmt = NULL;
const RuleBasedNumberFormat* formatter,
const UnicodeString& description,
UErrorCode& status);
+ virtual ~SameValueSubstitution();
virtual int64_t transformNumber(int64_t number) const { return number; }
virtual double transformNumber(double number) const { return number; }
virtual UClassID getDynamicClassID(void) const;
};
+SameValueSubstitution::~SameValueSubstitution() {}
+
class MultiplierSubstitution : public NFSubstitution {
double divisor;
int64_t ldivisor;
status = U_PARSE_ERROR;
}
}
+ virtual ~MultiplierSubstitution();
virtual void setDivisor(int32_t radix, int32_t exponent, UErrorCode& status) {
divisor = uprv_pow(radix, exponent);
virtual UClassID getDynamicClassID(void) const;
};
+MultiplierSubstitution::~MultiplierSubstitution() {}
+
class ModulusSubstitution : public NFSubstitution {
double divisor;
int64_t ldivisor;
const RuleBasedNumberFormat* formatter,
const UnicodeString& description,
UErrorCode& status);
+ virtual ~ModulusSubstitution();
virtual void setDivisor(int32_t radix, int32_t exponent, UErrorCode& status) {
divisor = uprv_pow(radix, exponent);
virtual UClassID getDynamicClassID(void) const;
};
+ModulusSubstitution::~ModulusSubstitution() {}
+
class IntegralPartSubstitution : public NFSubstitution {
public:
IntegralPartSubstitution(int32_t _pos,
const UnicodeString& description,
UErrorCode& status)
: NFSubstitution(_pos, _ruleSet, formatter, 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 UClassID getDynamicClassID(void) const;
};
+IntegralPartSubstitution::~IntegralPartSubstitution() {}
+
class FractionalPartSubstitution : public NFSubstitution {
UBool byDigits;
UBool useSpaces;
const RuleBasedNumberFormat* formatter,
const UnicodeString& description,
UErrorCode& status);
+ virtual ~FractionalPartSubstitution();
virtual UBool operator==(const NFSubstitution& rhs) const;
virtual UClassID getDynamicClassID(void) const;
};
+FractionalPartSubstitution::~FractionalPartSubstitution() {}
+
class AbsoluteValueSubstitution : public NFSubstitution {
public:
AbsoluteValueSubstitution(int32_t _pos,
const UnicodeString& description,
UErrorCode& status)
: NFSubstitution(_pos, _ruleSet, formatter, 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 UClassID getDynamicClassID(void) const;
};
+AbsoluteValueSubstitution::~AbsoluteValueSubstitution() {}
+
class NumeratorSubstitution : public NFSubstitution {
double denominator;
int64_t ldenominator;
ldenominator = util64_fromDouble(denominator);
withZeros = description.endsWith(LTLT, 2);
}
+ virtual ~NumeratorSubstitution();
virtual UBool operator==(const NFSubstitution& rhs) const;
virtual UClassID getDynamicClassID(void) const;
};
+NumeratorSubstitution::~NumeratorSubstitution() {}
+
class NullSubstitution : public NFSubstitution {
public:
NullSubstitution(int32_t _pos,
const UnicodeString& description,
UErrorCode& status)
: NFSubstitution(_pos, _ruleSet, formatter, description, status) {}
+ virtual ~NullSubstitution();
virtual void toString(UnicodeString& /*result*/) const {}
virtual void doSubstitution(double /*number*/, UnicodeString& /*toInsertInto*/, int32_t /*_pos*/) const {}
virtual UClassID getDynamicClassID(void) const;
};
+NullSubstitution::~NullSubstitution() {}
+
NFSubstitution*
NFSubstitution::makeSubstitution(int32_t pos,
const NFRule* rule,
// -------------------------------------
class ICUNumberFormatFactory : public ICUResourceBundleFactory {
+public:
+ virtual ~ICUNumberFormatFactory();
protected:
virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* /* service */, UErrorCode& status) const {
return NumberFormat::makeInstance(loc, (UNumberFormatStyle)kind, status);
}
};
+ICUNumberFormatFactory::~ICUNumberFormatFactory() {}
+
// -------------------------------------
class NFFactory : public LocaleKeyFactory {
{
}
- virtual ~NFFactory()
- {
- delete _delegate;
- delete _ids;
- }
+ virtual ~NFFactory();
virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const
{
}
};
+NFFactory::~NFFactory()
+{
+ delete _delegate;
+ delete _ids;
+}
+
class ICUNumberFormatService : public ICULocaleService {
public:
ICUNumberFormatService()
registerFactory(new ICUNumberFormatFactory(), status);
}
+ virtual ~ICUNumberFormatService();
+
virtual UObject* cloneInstance(UObject* instance) const {
return ((NumberFormat*)instance)->clone();
}
}
};
+ICUNumberFormatService::~ICUNumberFormatService() {}
+
// -------------------------------------
static ICULocaleService*
*/
class LocalizationInfo : public UMemory {
protected:
- virtual ~LocalizationInfo() {}
+ virtual ~LocalizationInfo();
uint32_t refcount;
public:
// static UClassID getStaticClassID(void);
};
+LocalizationInfo::~LocalizationInfo() {}
+
//UOBJECT_DEFINE_ABSTRACT_RTTI_IMPLEMENTATION(LocalizationInfo)
// if both strings are NULL, this returns TRUE
const UVector* variablesVector = 0,
const Hashtable* variableNames = 0);
+ virtual ~ParseData();
+
virtual const UnicodeString* lookup(const UnicodeString& s) const;
virtual const UnicodeFunctor* lookupMatcher(UChar32 ch) const;
const Hashtable* vNames) :
data(d), variablesVector(sets), variableNames(vNames) {}
+ParseData::~ParseData() {}
+
/**
* Implement SymbolTable API.
*/
}
}
- virtual ~TZEnumeration() {
- if (localMap != NULL) {
- uprv_free(localMap);
- }
- }
+ virtual ~TZEnumeration();
virtual StringEnumeration *clone() const {
return new TZEnumeration(*this);
virtual UClassID getDynamicClassID(void) const;
};
+TZEnumeration::~TZEnumeration() {
+ if (localMap != NULL) {
+ uprv_free(localMap);
+ }
+}
+
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TZEnumeration)
StringEnumeration* U_EXPORT2
}
}
+TimeZoneNameMatchInfo::~TimeZoneNameMatchInfo() {
+}
+
class TimeZoneNamesDelegate : public TimeZoneNames {
public:
TimeZoneNamesDelegate(const Locale& locale, UErrorCode& status);
+TimeZoneNames::~TimeZoneNames() {
+}
+
TimeZoneNames*
TimeZoneNames::createInstance(const Locale& locale, UErrorCode& status) {
return new TimeZoneNamesDelegate(locale, status);
virtual UnicodeString& getMetaZoneID(int32_t index, UnicodeString& mzID) const = 0;
};
-inline
-TimeZoneNameMatchInfo::~TimeZoneNameMatchInfo() {
-}
-
class U_I18N_API TimeZoneNames : public UMemory {
public:
virtual ~TimeZoneNames();
virtual TimeZoneNameMatchInfo* find(const UnicodeString& text, int32_t start, uint32_t types, UErrorCode& status) const = 0;
};
-inline
-TimeZoneNames::~TimeZoneNames() {
-}
-
U_NAMESPACE_END
#endif
#endif
capacity_ = 0;
}
}
- virtual ~SortKeyByteSink() { uprv_free(ownedBuffer_); }
+ virtual ~SortKeyByteSink();
virtual void Append(const char *bytes, int32_t n);
void Append(const uint8_t *bytes, int32_t n) { Append(reinterpret_cast<const char *>(bytes), n); }
uint8_t SortKeyByteSink::lastResortByte_ = 0;
+SortKeyByteSink::~SortKeyByteSink() {
+ uprv_free(ownedBuffer_);
+}
+
void
SortKeyByteSink::Append(const char *bytes, int32_t n) {
if (n <= 0) {
/*
******************************************************************************
-* Copyright (C) 2010-2011, International Business Machines Corporation and *
-* others. All Rights Reserved. *
+* Copyright (C) 2010-2011, International Business Machines Corporation and
+* others. All Rights Reserved.
******************************************************************************
*/
virtual UClassID getDynamicClassID() const;
};
-inline LocaleDisplayNames::~LocaleDisplayNames() {
-}
-
inline LocaleDisplayNames* LocaleDisplayNames::createInstance(const Locale& locale) {
return LocaleDisplayNames::createInstance(locale, ULDN_STANDARD_NAMES);
}
/*
**********************************************************************
-* Copyright (c) 2004-2006, International Business Machines
+* Copyright (c) 2004-2011, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
* Author: Alan Liu
* @stable ICU 3.0
*/
class U_I18N_API MeasureFormat : public Format {
-
public:
+ /**
+ * Destructor.
+ * @stable ICU 3.0
+ */
+ virtual ~MeasureFormat();
/**
* Return a formatter for CurrencyAmount objects in the given
errorcode.o
deps
utypes
- PIC
+ platform
group: utypes # u_errorName()
utypes.o
_symbols_to_files = {}
_return_value = 0
+# Classes with vtables (and thus virtual methods).
+_virtual_classes = set()
+# Classes with weakly defined destructors.
+# nm shows a symbol class of "W" rather than "T".
+_weak_destructors = set()
+
def _ReadObjFile(root_path, library_name, obj_name):
global _ignored_symbols, _obj_files, _symbols_to_files
+ global _virtual_classes, _weak_destructors
lib_obj_name = library_name + "/" + obj_name
if lib_obj_name in _obj_files:
print "Warning: duplicate .o file " + lib_obj_name
if type == "U":
obj_imports.add(name)
else:
- # TODO: Investigate weak symbols (V, W) with or without values.
obj_exports.add(name)
_symbols_to_files[name] = lib_obj_name
+ # Is this a vtable? E.g., "vtable for icu_49::ByteSink".
+ if name.startswith("vtable for icu"):
+ _virtual_classes.add(name[name.index("::") + 2:])
+ # Is this a destructor? E.g., "icu_49::ByteSink::~ByteSink()".
+ index = name.find("::~")
+ if index >= 0 and type == "W":
+ _weak_destructors.add(name[index + 3:name.index("(", index)])
_obj_files[lib_obj_name] = {"imports": obj_imports, "exports": obj_exports}
def _ReadLibrary(root_path, library_name):
Modifies dependencies.items: Recursively builds each item's system_symbols and exports.
"""
global _ignored_symbols, _obj_files, _return_value
+ global _virtual_classes, _weak_destructors
dependencies.Load()
for name_and_item in dependencies.items.iteritems():
name = name_and_item[0]
if not _return_value:
for library_name in dependencies.libraries:
_Resolve(library_name, [])
+ if not _return_value:
+ virtual_classes_with_weak_destructors = _virtual_classes & _weak_destructors
+ if virtual_classes_with_weak_destructors:
+ sys.stderr.write("Error: Some classes have virtual methods, and "
+ "an implicit or inline destructor "
+ "(see ICU ticket #8454 for details):\n%s\n" %
+ sorted(virtual_classes_with_weak_destructors))
+ _return_value = 1
def main():
global _return_value
#include "umutex.h"
#include "threadtest.h"
+AbstractThreadTest::~AbstractThreadTest() {}
//------------------------------------------------------------------------------
//
//
//********************************************************************
-// Copyright (C) 2002, International Business Machines
+// Copyright (C) 2002-2011, International Business Machines
// Corporation and others. All Rights Reserved.
//********************************************************************
//
class AbstractThreadTest {
public:
AbstractThreadTest() {};
- virtual ~AbstractThreadTest() {};
+ virtual ~AbstractThreadTest();
virtual void check() = 0;
virtual void runOnce() = 0;
};
#endif // ABSTRACTTHREADTEST_H
-
/*
**********************************************************************
-* Copyright (c) 2002-2007, International Business Machines
+* Copyright (c) 2002-2011, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
*/
*/
class T_CTEST_EXPORT_API UPerfFunction {
public:
+ /**
+ * destructor
+ */
+ virtual ~UPerfFunction();
+
/**
* Subclasses must implement this method to do the action to be
* measured.
virtual long getEventsPerIteration(){
return -1;
}
- /**
- * destructor
- */
- virtual ~UPerfFunction() {}
-
/**
* Call call() n times in a tight loop and return the elapsed
* milliseconds. If n is small and call() is fast the return
#include <stdlib.h>
#if !UCONFIG_NO_CONVERSION
+
+UPerfFunction::~UPerfFunction() {}
+
static const char delim = '/';
static int32_t execCount = 0;
UPerfTest* UPerfTest::gTest = NULL;
projects / icu / commitdiff