ICU 59.1  59.1
RunArrays.h
Go to the documentation of this file.
1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4  **********************************************************************
5  * Copyright (C) 2003-2008, International Business Machines
6  * Corporation and others. All Rights Reserved.
7  **********************************************************************
8  */
9 
10 #ifndef __RUNARRAYS_H
11 
12 #define __RUNARRAYS_H
13 
14 #include "layout/LETypes.h"
15 #include "layout/LEFontInstance.h"
16 
17 #include "unicode/utypes.h"
18 #include "unicode/locid.h"
19 
26 
32 #define INITIAL_CAPACITY 16
33 
40 #define CAPACITY_GROW_LIMIT 128
41 
51 {
52 public:
64  inline RunArray(const le_int32 *limits, le_int32 count);
65 
77  RunArray(le_int32 initialCapacity);
78 
84  virtual ~RunArray();
85 
93  inline le_int32 getCount() const;
94 
103  inline void reset();
104 
113  inline le_int32 getLimit() const;
114 
124  inline le_int32 getLimit(le_int32 run) const;
125 
150  le_int32 add(le_int32 limit);
151 
157  static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
158 
164  virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }
165 
166 protected:
179  virtual void init(le_int32 capacity);
180 
193  virtual void grow(le_int32 capacity);
194 
204  le_bool fClientArrays;
205 
206 private:
211  static const char fgClassID;
212 
213  le_int32 ensureCapacity();
214 
215  inline RunArray();
216  inline RunArray(const RunArray & /*other*/);
217  inline RunArray &operator=(const RunArray & /*other*/) { return *this; };
218 
219  const le_int32 *fLimits;
220  le_int32 fCount;
221  le_int32 fCapacity;
222 };
223 
224 inline RunArray::RunArray()
225  : UObject(), fClientArrays(FALSE), fLimits(NULL), fCount(0), fCapacity(0)
226 {
227  // nothing else to do...
228 }
229 
230 inline RunArray::RunArray(const RunArray & /*other*/)
231  : UObject(), fClientArrays(FALSE), fLimits(NULL), fCount(0), fCapacity(0)
232 {
233  // nothing else to do...
234 }
235 
236 inline RunArray::RunArray(const le_int32 *limits, le_int32 count)
237  : UObject(), fClientArrays(TRUE), fLimits(limits), fCount(count), fCapacity(count)
238 {
239  // nothing else to do...
240 }
241 
242 inline le_int32 RunArray::getCount() const
243 {
244  return fCount;
245 }
246 
247 inline void RunArray::reset()
248 {
249  fCount = 0;
250 }
251 
252 inline le_int32 RunArray::getLimit(le_int32 run) const
253 {
254  if (run < 0 || run >= fCount) {
255  return -1;
256  }
257 
258  return fLimits[run];
259 }
260 
261 inline le_int32 RunArray::getLimit() const
262 {
263  return getLimit(fCount - 1);
264 }
265 
273 {
274 public:
290  inline FontRuns(const LEFontInstance **fonts, const le_int32 *limits, le_int32 count);
291 
303  FontRuns(le_int32 initialCapacity);
304 
310  virtual ~FontRuns();
311 
325  const LEFontInstance *getFont(le_int32 run) const;
326 
327 
350  le_int32 add(const LEFontInstance *font, le_int32 limit);
351 
357  static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
358 
364  virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }
365 
366 protected:
367  virtual void init(le_int32 capacity);
368  virtual void grow(le_int32 capacity);
369 
370 private:
371 
372  inline FontRuns();
373  inline FontRuns(const FontRuns &other);
374  inline FontRuns &operator=(const FontRuns & /*other*/) { return *this; };
375 
380  static const char fgClassID;
381 
382  const LEFontInstance **fFonts;
383 };
384 
385 inline FontRuns::FontRuns()
386  : RunArray(0), fFonts(NULL)
387 {
388  // nothing else to do...
389 }
390 
391 inline FontRuns::FontRuns(const FontRuns & /*other*/)
392  : RunArray(0), fFonts(NULL)
393 {
394  // nothing else to do...
395 }
396 
397 inline FontRuns::FontRuns(const LEFontInstance **fonts, const le_int32 *limits, le_int32 count)
398  : RunArray(limits, count), fFonts(fonts)
399 {
400  // nothing else to do...
401 }
402 
410 {
411 public:
427  inline LocaleRuns(const Locale **locales, const le_int32 *limits, le_int32 count);
428 
440  LocaleRuns(le_int32 initialCapacity);
441 
447  virtual ~LocaleRuns();
448 
462  const Locale *getLocale(le_int32 run) const;
463 
464 
487  le_int32 add(const Locale *locale, le_int32 limit);
488 
494  static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
495 
501  virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }
502 
503 protected:
504  virtual void init(le_int32 capacity);
505  virtual void grow(le_int32 capacity);
506 
510  const Locale **fLocales;
511 
512 private:
513 
514  inline LocaleRuns();
515  inline LocaleRuns(const LocaleRuns &other);
516  inline LocaleRuns &operator=(const LocaleRuns & /*other*/) { return *this; };
517 
522  static const char fgClassID;
523 };
524 
525 inline LocaleRuns::LocaleRuns()
526  : RunArray(0), fLocales(NULL)
527 {
528  // nothing else to do...
529 }
530 
531 inline LocaleRuns::LocaleRuns(const LocaleRuns & /*other*/)
532  : RunArray(0), fLocales(NULL)
533 {
534  // nothing else to do...
535 }
536 
537 inline LocaleRuns::LocaleRuns(const Locale **locales, const le_int32 *limits, le_int32 count)
538  : RunArray(limits, count), fLocales(locales)
539 {
540  // nothing else to do...
541 }
542 
549 {
550 public:
565  inline ValueRuns(const le_int32 *values, const le_int32 *limits, le_int32 count);
566 
578  ValueRuns(le_int32 initialCapacity);
579 
585  virtual ~ValueRuns();
586 
600  le_int32 getValue(le_int32 run) const;
601 
602 
624  le_int32 add(le_int32 value, le_int32 limit);
625 
631  static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
632 
638  virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }
639 
640 protected:
641  virtual void init(le_int32 capacity);
642  virtual void grow(le_int32 capacity);
643 
644 private:
645 
646  inline ValueRuns();
647  inline ValueRuns(const ValueRuns &other);
648  inline ValueRuns &operator=(const ValueRuns & /*other*/) { return *this; };
649 
654  static const char fgClassID;
655 
656  const le_int32 *fValues;
657 };
658 
659 inline ValueRuns::ValueRuns()
660  : RunArray(0), fValues(NULL)
661 {
662  // nothing else to do...
663 }
664 
665 inline ValueRuns::ValueRuns(const ValueRuns & /*other*/)
666  : RunArray(0), fValues(NULL)
667 {
668  // nothing else to do...
669 }
670 
671 inline ValueRuns::ValueRuns(const le_int32 *values, const le_int32 *limits, le_int32 count)
672  : RunArray(limits, count), fValues(values)
673 {
674  // nothing else to do...
675 }
676 
678 #endif
virtual void grow(le_int32 capacity)
Grow a data array to the given initial size.
static UClassID getStaticClassID()
ICU "poor man&#39;s RTTI", returns a UClassID for this class.
Definition: RunArrays.h:157
static UClassID getStaticClassID()
ICU "poor man&#39;s RTTI", returns a UClassID for this class.
Definition: RunArrays.h:357
const Locale ** fLocales
Definition: RunArrays.h:510
virtual UClassID getDynamicClassID() const
ICU "poor man&#39;s RTTI", returns a UClassID for the actual class.
Definition: RunArrays.h:638
virtual void init(le_int32 capacity)
Create a data array with the given initial size.
void * UClassID
UClassID is used to identify classes without using the compiler&#39;s RTTI.
Definition: uobject.h:93
virtual UClassID getDynamicClassID() const
ICU "poor man&#39;s RTTI", returns a UClassID for the actual class.
Definition: RunArrays.h:364
static UClassID getStaticClassID()
ICU "poor man&#39;s RTTI", returns a UClassID for this class.
Definition: RunArrays.h:494
The FontRuns class associates pointers to LEFontInstance objects with runs of text.
Definition: RunArrays.h:272
The LocaleRuns class associates pointers to Locale objects with runs of text.
Definition: RunArrays.h:409
le_int32 add(const Locale *locale, le_int32 limit)
Add a Locale and limit index pair to the data arrays and return the run index where the data was stor...
le_int32 getCount() const
Get the number of entries in the limit indices array.
Definition: RunArrays.h:242
#define U_NAMESPACE_BEGIN
This is used to begin a declaration of a public ICU C++ API.
Definition: uversion.h:131
virtual void grow(le_int32 capacity)
Grow a data array to the given initial size.
virtual void init(le_int32 capacity)
Create a data array with the given initial size.
#define NULL
Define NULL if necessary, to nullptr for C++ and to ((void *)0) for C.
Definition: utypes.h:188
le_bool fClientArrays
Set by the constructors to indicate whether or not the client supplied the data arrays.
Definition: RunArrays.h:204
void reset()
Reset the limit indices array.
Definition: RunArrays.h:247
#define TRUE
The TRUE value of a UBool.
Definition: umachine.h:240
le_int32 add(const LEFontInstance *font, le_int32 limit)
Add an LEFontInstance and limit index pair to the data arrays and return the run index where the data...
#define U_NAMESPACE_END
This is used to end a declaration of a public ICU C++ API.
Definition: uversion.h:132
#define U_LAYOUTEX_API
Set to export library symbols from inside the layout extensions library, and to import them from outs...
Definition: utypes.h:362
The ValueRuns class associates integer values with runs of text.
Definition: RunArrays.h:548
virtual UClassID getDynamicClassID() const
ICU "poor man&#39;s RTTI", returns a UClassID for the actual class.
Definition: RunArrays.h:501
static UClassID getStaticClassID()
ICU "poor man&#39;s RTTI", returns a UClassID for this class.
Definition: RunArrays.h:631
C++ API: Locale ID object.
le_int32 add(le_int32 limit)
Add a limit index to the limit indices array and return the run index where it was stored...
virtual void init(le_int32 capacity)
Create a data array with the given initial size.
Basic definitions for ICU, for both C and C++ APIs.
#define FALSE
The FALSE value of a UBool.
Definition: umachine.h:244
le_int32 getLimit() const
Get the last limit index.
Definition: RunArrays.h:261
UObject is the common ICU "boilerplate" class.
Definition: uobject.h:223
virtual void grow(le_int32 capacity)
Grow a data array to the given initial size.
virtual UClassID getDynamicClassID() const
ICU "poor man&#39;s RTTI", returns a UClassID for the actual class.
Definition: RunArrays.h:164
The RunArray class is a base class for building classes which represent data that is associated with ...
Definition: RunArrays.h:50
A Locale object represents a specific geographical, political, or cultural region.
Definition: locid.h:188