"Fossies" - the Fresh Open Source Software Archive

Member "RunArrays_8h_source.html" (3 Oct 2019, 61132 Bytes) of package /linux/misc/icu4c-65_1-docs.zip:


Caution: In this restricted "Fossies" environment the current HTML page may not be correctly presentated and may have some non-functional links. You can here alternatively try to browse the pure source code or just view or download the uninterpreted raw source code. If the rendering is insufficient you may try to find and view the page on the project site itself.

ICU 65.1  65.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 
25 U_NAMESPACE_BEGIN
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 
677 U_NAMESPACE_END
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:96
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
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:265
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_LAYOUTEX_API
Set to export library symbols from inside the layout extensions library, and to import them from outs...
Definition: utypes.h:303
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:269
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:195