Movatterモバイル変換

Go to the documentation of this file.

2 // License & terms of use: http://www.unicode.org/copyright.html

3 /*

4 ******************************************************************************

5 *

8 *

9 ******************************************************************************

10 * file name: uobject.h

11 * encoding: UTF-8

12 * tab size: 8 (not used)

13 * indentation:4

14 *

15 * created on: 2002jun26

16 * created by: Markus W. Scherer

17 */

19 #ifndef __UOBJECT_H__

20 #define __UOBJECT_H__

22 #include "unicode/utypes.h"

24 #if U_SHOW_CPLUSPLUS_API

26 #include "unicode/platform.h"

48 #ifndef U_NO_THROW

49 #define U_NO_THROW noexcept

50 #endif

52 /*===========================================================================*/

53 /* UClassID-based RTTI */

54 /*===========================================================================*/

96 typedefvoid*UClassID;

98 U_NAMESPACE_BEGIN

115 classU_COMMON_API UMemory {

116 public:

117

118 /* test versions for debugging shaper heap memory problems */

119 #ifdef SHAPER_MEMORY_DEBUG

120 staticvoid * NewArray(int size,int count);

121 staticvoid * GrowArray(void * array,int newSize );

122 staticvoid FreeArray(void * array );

123 #endif

124

125 #if U_OVERRIDE_CXX_ALLOCATION

134 staticvoid * U_EXPORT2operatornew(size_t size) noexcept;

135

141 staticvoid * U_EXPORT2operatornew[](size_t size) noexcept;

142

151 staticvoid U_EXPORT2operatordelete(void *p) noexcept;

152

158 staticvoid U_EXPORT2operatordelete[](void *p) noexcept;

159

160 #if U_HAVE_PLACEMENT_NEW

166 staticinlinevoid * U_EXPORT2operatornew(size_t,void *ptr) noexcept {return ptr; }

167

173 staticinlinevoid U_EXPORT2operatordelete(void *,void *) noexcept {}

174 #endif/* U_HAVE_PLACEMENT_NEW */

175 #if U_HAVE_DEBUG_LOCATION_NEW

183 staticvoid * U_EXPORT2operatornew(size_t size,constchar* file,int line) noexcept;

191 staticvoid U_EXPORT2operatordelete(void* p,constchar* file,int line) noexcept;

192 #endif/* U_HAVE_DEBUG_LOCATION_NEW */

193 #endif/* U_OVERRIDE_CXX_ALLOCATION */

194

195 /*

196 * Assignment operator not declared. The compiler will provide one

197 * which does nothing since this class does not contain any data members.

198 * API/code coverage may show the assignment operator as present and

199 * untested - ignore.

200 * Subclasses need this assignment operator if they use compiler-provided

201 * assignment operators of their own. An alternative to not declaring one

202 * here would be to declare and empty-implement a protected or public one.

203 UMemory &UMemory::operator=(const UMemory &);

204 */

205 };

206

223 classU_COMMON_API UObject :publicUMemory {

224 public:

230 virtual~UObject();

231

241 virtualUClassID getDynamicClassID()const;

242

243 protected:

244 // the following functions are protected to prevent instantiation and

245 // direct use of UObject itself

246

247 // default constructor

248 // inline UObject() {}

249

250 // copy constructor

251 // inline UObject(const UObject &other) {}

252

253 #if 0

254 // TODO Sometime in the future. Implement operator==().

255 // (This comment inserted in 2.2)

256 // some or all of the following "boilerplate" functions may be made public

257 // in a future ICU4C release when all subclasses implement them

258

259 // assignment operator

260 // (not virtual, see "Taligent's Guide to Designing Programs" pp.73..74)

261 // commented out because the implementation is the same as a compiler's default

262 // UObject &operator=(const UObject &other) { return *this; }

263

264 // comparison operators

265 virtualinlinebooloperator==(constUObject &other) const{returnthis==&other; }

266 inlinebooloperator!=(constUObject &other) const{return !operator==(other); }

267

268 // clone() commented out from the base class:

269 // some compilers do not support co-variant return types

270 // (i.e., subclasses would have to return UObject * as well, instead of SubClass *)

271 // see also UObject class documentation.

272 // virtual UObject *clone() const;

273 #endif

274

275 /*

276 * Assignment operator not declared. The compiler will provide one

277 * which does nothing since this class does not contain any data members.

278 * API/code coverage may show the assignment operator as present and

279 * untested - ignore.

280 * Subclasses need this assignment operator if they use compiler-provided

281 * assignment operators of their own. An alternative to not declaring one

282 * here would be to declare and empty-implement a protected or public one.

283 UObject &UObject::operator=(const UObject &);

284 */

285 };

286

287 #ifndef U_HIDE_INTERNAL_API

295 #define UOBJECT_DEFINE_RTTI_IMPLEMENTATION(myClass) \

296 UClassID U_EXPORT2 myClass::getStaticClassID() { \

297 static char classID = 0; \

298 return (UClassID)&classID; \

299 } \

300 UClassID myClass::getDynamicClassID() const \

301 { return myClass::getStaticClassID(); }

302

303

312 #define UOBJECT_DEFINE_ABSTRACT_RTTI_IMPLEMENTATION(myClass) \

313 UClassID U_EXPORT2 myClass::getStaticClassID() { \

314 static char classID = 0; \

315 return (UClassID)&classID; \

316 }

317

318 #endif/* U_HIDE_INTERNAL_API */

319

320 U_NAMESPACE_END

321

322 #endif/* U_SHOW_CPLUSPLUS_API */

323

324 #endif

icu::UMemory

UMemory is the common ICU base class.

Definition:uobject.h:115

icu::UObject

UObject is the common ICU "boilerplate" class.

Definition:uobject.h:223

icu::UObject::getDynamicClassID

virtual UClassID getDynamicClassID() const

ICU4C "poor man's RTTI", returns a UClassID for the actual ICU class.

icu::UObject::~UObject

virtual ~UObject()

Destructor.

icu::operator==

U_EXPORT UBool operator==(const StringPiece &x, const StringPiece &y)

Global operator == for StringPiece.

icu::operator!=

bool operator!=(const StringPiece &x, const StringPiece &y)

Global operator != for StringPiece.

Definition:stringpiece.h:346

platform.h

Basic types for the platform.

UClassID

void * UClassID

UClassID is used to identify classes without using the compiler's RTTI.

Definition:uobject.h:96

utypes.h

Basic definitions for ICU, for both C and C++ APIs.

U_COMMON_API

#define U_COMMON_API

Set to export library symbols from inside the common library, and to import them from outside.

Definition:utypes.h:315