/* ********************************************************************** * Copyright (C) 2003-2008, International Business Machines * Corporation and others. All Rights Reserved. ********************************************************************** */ #ifndef __RUNARRAYS_H #define __RUNARRAYS_H #include "layout/LETypes.h" #include "layout/LEFontInstance.h" #include "unicode/utypes.h" #include "unicode/locid.h" /** * \file * \brief C++ API: base class for building classes which represent data that is associated with runs of text. */ U_NAMESPACE_BEGIN /** * The initial size of an array if it is unspecified. * * @stable ICU 3.2 */ #define INITIAL_CAPACITY 16 /** * When an array needs to grow, it will double in size until * it becomes this large, then it will grow by this amount. * * @stable ICU 3.2 */ #define CAPACITY_GROW_LIMIT 128 /** * The <code>RunArray</code> class is a base class for building classes * which represent data that is associated with runs of text. This class * maintains an array of limit indices into the text, subclasses * provide one or more arrays of data. * * @stable ICU 3.2 */ class U_LAYOUTEX_API RunArray : public UObject { public: /** * Construct a <code>RunArray</code> object from a pre-existing * array of limit indices. * * @param limits is an array of limit indices. This array must remain * valid until the <code>RunArray</code> object is destroyed. * * @param count is the number of entries in the limit array. * * @stable ICU 3.2 */ inline RunArray(const le_int32 *limits, le_int32 count); /** * Construct an empty <code>RunArray</code> object. Clients can add limit * indices array using the <code>add</code> method. * * @param initialCapacity is the initial size of the limit indices array. If * this value is zero, no array will be allocated. * * @see add * * @stable ICU 3.2 */ RunArray(le_int32 initialCapacity); /** * The destructor; virtual so that subclass destructors are invoked as well. * * @stable ICU 3.2 */ virtual ~RunArray(); /** * Get the number of entries in the limit indices array. * * @return the number of entries in the limit indices array. * * @stable ICU 3.2 */ inline le_int32 getCount() const; /** * Reset the limit indices array. This method sets the number of entries in the * limit indices array to zero. It does not delete the array. * * Note: Subclass arrays will also be reset and not deleted. * * @stable ICU 3.6 */ inline void reset(); /** * Get the last limit index. This is the number of characters in * the text. * * @return the last limit index. * * @stable ICU 3.2 */ inline le_int32 getLimit() const; /** * Get the limit index for a particular run of text. * * @param run is the run. This is an index into the limit index array. * * @return the limit index for the run, or -1 if <code>run</code> is out of bounds. * * @stable ICU 3.2 */ inline le_int32 getLimit(le_int32 run) const; /** * Add a limit index to the limit indices array and return the run index * where it was stored. If the array does not exist, it will be created by * calling the <code>init</code> method. If it is full, it will be grown by * calling the <code>grow</code> method. * * If the <code>RunArray</code> object was created with a client-supplied * limit indices array, this method will return a run index of -1. * * Subclasses should not override this method. Rather they should provide * a new <code>add</code> method which takes a limit index along with whatever * other data they implement. The new <code>add</code> method should * first call this method to grow the data arrays, and use the return value * to store the data in their own arrays. * * @param limit is the limit index to add to the array. * * @return the run index where the limit index was stored, or -1 if the limit index cannt be stored. * * @see init * @see grow * * @stable ICU 3.2 */ le_int32 add(le_int32 limit); /** * ICU "poor man's RTTI", returns a UClassID for this class. * * @stable ICU 3.2 */ static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; } /** * ICU "poor man's RTTI", returns a UClassID for the actual class. * * @stable ICU 3.2 */ virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); } protected: /** * Create a data array with the given initial size. This method will be * called by the <code>add</code> method if there is no limit indices * array. Subclasses which override this method must also call it from * the overriding method to create the limit indices array. * * @param capacity is the initial size of the data array. * * @see add * * @stable ICU 3.2 */ virtual void init(le_int32 capacity); /** * Grow a data array to the given initial size. This method will be * called by the <code>add</code> method if the limit indices * array is full. Subclasses which override this method must also call it from * the overriding method to grow the limit indices array. * * @param capacity is the initial size of the data array. * * @see add * * @stable ICU 3.2 */ virtual void grow(le_int32 capacity); /** * Set by the constructors to indicate whether * or not the client supplied the data arrays. * If they were supplied by the client, the * <code>add</code> method won't change the arrays * and the destructor won't delete them. * * @stable ICU 3.2 */ le_bool fClientArrays; private: /** * The address of this static class variable serves as this class's ID * for ICU "poor man's RTTI". */ static const char fgClassID; le_int32 ensureCapacity(); inline RunArray(); inline RunArray(const RunArray & /*other*/); inline RunArray &operator=(const RunArray & /*other*/) { return *this; }; const le_int32 *fLimits; le_int32 fCount; le_int32 fCapacity; }; inline RunArray::RunArray() : UObject(), fClientArrays(FALSE), fLimits(NULL), fCount(0), fCapacity(0) { // nothing else to do... } inline RunArray::RunArray(const RunArray & /*other*/) : UObject(), fClientArrays(FALSE), fLimits(NULL), fCount(0), fCapacity(0) { // nothing else to do... } inline RunArray::RunArray(const le_int32 *limits, le_int32 count) : UObject(), fClientArrays(TRUE), fLimits(limits), fCount(count), fCapacity(count) { // nothing else to do... } inline le_int32 RunArray::getCount() const { return fCount; } inline void RunArray::reset() { fCount = 0; } inline le_int32 RunArray::getLimit(le_int32 run) const { if (run < 0 || run >= fCount) { return -1; } return fLimits[run]; } inline le_int32 RunArray::getLimit() const { return getLimit(fCount - 1); } /** * The <code>FontRuns</code> class associates pointers to <code>LEFontInstance</code> * objects with runs of text. * * @stable ICU 3.2 */ class U_LAYOUTEX_API FontRuns : public RunArray { public: /** * Construct a <code>FontRuns</code> object from pre-existing arrays of fonts * and limit indices. * * @param fonts is the address of an array of pointers to <code>LEFontInstance</code> objects. This * array, and the <code>LEFontInstance</code> objects to which it points must remain * valid until the <code>FontRuns</code> object is destroyed. * * @param limits is the address of an array of limit indices. This array must remain valid until * the <code>FontRuns</code> object is destroyed. * * @param count is the number of entries in the two arrays. * * @stable ICU 3.2 */ inline FontRuns(const LEFontInstance **fonts, const le_int32 *limits, le_int32 count); /** * Construct an empty <code>FontRuns</code> object. Clients can add font and limit * indices arrays using the <code>add</code> method. * * @param initialCapacity is the initial size of the font and limit indices arrays. If * this value is zero, no arrays will be allocated. * * @see add * * @stable ICU 3.2 */ FontRuns(le_int32 initialCapacity); /** * The destructor; virtual so that subclass destructors are invoked as well. * * @stable ICU 3.2 */ virtual ~FontRuns(); /** * Get the <code>LEFontInstance</code> object assoicated with the given run * of text. Use <code>RunArray::getLimit(run)</code> to get the corresponding * limit index. * * @param run is the index into the font and limit indices arrays. * * @return the <code>LEFontInstance</code> associated with the given text run. * * @see RunArray::getLimit * * @stable ICU 3.2 */ const LEFontInstance *getFont(le_int32 run) const; /** * Add an <code>LEFontInstance</code> and limit index pair to the data arrays and return * the run index where the data was stored. This method calls * <code>RunArray::add(limit)</code> which will create or grow the arrays as needed. * * If the <code>FontRuns</code> object was created with a client-supplied * font and limit indices arrays, this method will return a run index of -1. * * Subclasses should not override this method. Rather they should provide a new <code>add</code> * method which takes a font and a limit index along with whatever other data they implement. * The new <code>add</code> method should first call this method to grow the font and limit indices * arrays, and use the returned run index to store data their own arrays. * * @param font is the address of the <code>LEFontInstance</code> to add. This object must * remain valid until the <code>FontRuns</code> object is destroyed. * * @param limit is the limit index to add * * @return the run index where the font and limit index were stored, or -1 if the data cannot be stored. * * @stable ICU 3.2 */ le_int32 add(const LEFontInstance *font, le_int32 limit); /** * ICU "poor man's RTTI", returns a UClassID for this class. * * @stable ICU 3.2 */ static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; } /** * ICU "poor man's RTTI", returns a UClassID for the actual class. * * @stable ICU 3.2 */ virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); } protected: virtual void init(le_int32 capacity); virtual void grow(le_int32 capacity); private: inline FontRuns(); inline FontRuns(const FontRuns &other); inline FontRuns &operator=(const FontRuns & /*other*/) { return *this; }; /** * The address of this static class variable serves as this class's ID * for ICU "poor man's RTTI". */ static const char fgClassID; const LEFontInstance **fFonts; }; inline FontRuns::FontRuns() : RunArray(0), fFonts(NULL) { // nothing else to do... } inline FontRuns::FontRuns(const FontRuns & /*other*/) : RunArray(0), fFonts(NULL) { // nothing else to do... } inline FontRuns::FontRuns(const LEFontInstance **fonts, const le_int32 *limits, le_int32 count) : RunArray(limits, count), fFonts(fonts) { // nothing else to do... } /** * The <code>LocaleRuns</code> class associates pointers to <code>Locale</code> * objects with runs of text. * * @stable ICU 3.2 */ class U_LAYOUTEX_API LocaleRuns : public RunArray { public: /** * Construct a <code>LocaleRuns</code> object from pre-existing arrays of locales * and limit indices. * * @param locales is the address of an array of pointers to <code>Locale</code> objects. This array, * and the <code>Locale</code> objects to which it points, must remain valid until * the <code>LocaleRuns</code> object is destroyed. * * @param limits is the address of an array of limit indices. This array must remain valid until the * <code>LocaleRuns</code> object is destroyed. * * @param count is the number of entries in the two arrays. * * @stable ICU 3.2 */ inline LocaleRuns(const Locale **locales, const le_int32 *limits, le_int32 count); /** * Construct an empty <code>LocaleRuns</code> object. Clients can add locale and limit * indices arrays using the <code>add</code> method. * * @param initialCapacity is the initial size of the locale and limit indices arrays. If * this value is zero, no arrays will be allocated. * * @see add * * @stable ICU 3.2 */ LocaleRuns(le_int32 initialCapacity); /** * The destructor; virtual so that subclass destructors are invoked as well. * * @stable ICU 3.2 */ virtual ~LocaleRuns(); /** * Get the <code>Locale</code> object assoicated with the given run * of text. Use <code>RunArray::getLimit(run)</code> to get the corresponding * limit index. * * @param run is the index into the font and limit indices arrays. * * @return the <code>Locale</code> associated with the given text run. * * @see RunArray::getLimit * * @stable ICU 3.2 */ const Locale *getLocale(le_int32 run) const; /** * Add a <code>Locale</code> and limit index pair to the data arrays and return * the run index where the data was stored. This method calls * <code>RunArray::add(limit)</code> which will create or grow the arrays as needed. * * If the <code>LocaleRuns</code> object was created with a client-supplied * locale and limit indices arrays, this method will return a run index of -1. * * Subclasses should not override this method. Rather they should provide a new <code>add</code> * method which takes a locale and a limit index along with whatever other data they implement. * The new <code>add</code> method should first call this method to grow the font and limit indices * arrays, and use the returned run index to store data their own arrays. * * @param locale is the address of the <code>Locale</code> to add. This object must remain valid * until the <code>LocaleRuns</code> object is destroyed. * * @param limit is the limit index to add * * @return the run index where the locale and limit index were stored, or -1 if the data cannot be stored. * * @stable ICU 3.2 */ le_int32 add(const Locale *locale, le_int32 limit); /** * ICU "poor man's RTTI", returns a UClassID for this class. * * @stable ICU 3.2 */ static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; } /** * ICU "poor man's RTTI", returns a UClassID for the actual class. * * @stable ICU 3.2 */ virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); } protected: virtual void init(le_int32 capacity); virtual void grow(le_int32 capacity); /** * @internal */ const Locale **fLocales; private: inline LocaleRuns(); inline LocaleRuns(const LocaleRuns &other); inline LocaleRuns &operator=(const LocaleRuns & /*other*/) { return *this; }; /** * The address of this static class variable serves as this class's ID * for ICU "poor man's RTTI". */ static const char fgClassID; }; inline LocaleRuns::LocaleRuns() : RunArray(0), fLocales(NULL) { // nothing else to do... } inline LocaleRuns::LocaleRuns(const LocaleRuns & /*other*/) : RunArray(0), fLocales(NULL) { // nothing else to do... } inline LocaleRuns::LocaleRuns(const Locale **locales, const le_int32 *limits, le_int32 count) : RunArray(limits, count), fLocales(locales) { // nothing else to do... } /** * The <code>ValueRuns</code> class associates integer values with runs of text. * * @stable ICU 3.2 */ class U_LAYOUTEX_API ValueRuns : public RunArray { public: /** * Construct a <code>ValueRuns</code> object from pre-existing arrays of values * and limit indices. * * @param values is the address of an array of integer. This array must remain valid until * the <code>ValueRuns</code> object is destroyed. * * @param limits is the address of an array of limit indices. This array must remain valid until * the <code>ValueRuns</code> object is destroyed. * * @param count is the number of entries in the two arrays. * * @stable ICU 3.2 */ inline ValueRuns(const le_int32 *values, const le_int32 *limits, le_int32 count); /** * Construct an empty <code>ValueRuns</code> object. Clients can add value and limit * indices arrays using the <code>add</code> method. * * @param initialCapacity is the initial size of the value and limit indices arrays. If * this value is zero, no arrays will be allocated. * * @see add * * @stable ICU 3.2 */ ValueRuns(le_int32 initialCapacity); /** * The destructor; virtual so that subclass destructors are invoked as well. * * @stable ICU 3.2 */ virtual ~ValueRuns(); /** * Get the integer value assoicated with the given run * of text. Use <code>RunArray::getLimit(run)</code> to get the corresponding * limit index. * * @param run is the index into the font and limit indices arrays. * * @return the integer value associated with the given text run. * * @see RunArray::getLimit * * @stable ICU 3.2 */ le_int32 getValue(le_int32 run) const; /** * Add an integer value and limit index pair to the data arrays and return * the run index where the data was stored. This method calls * <code>RunArray::add(limit)</code> which will create or grow the arrays as needed. * * If the <code>ValueRuns</code> object was created with a client-supplied * font and limit indices arrays, this method will return a run index of -1. * * Subclasses should not override this method. Rather they should provide a new <code>add</code> * method which takes an integer value and a limit index along with whatever other data they implement. * The new <code>add</code> method should first call this method to grow the font and limit indices * arrays, and use the returned run index to store data their own arrays. * * @param value is the integer value to add * * @param limit is the limit index to add * * @return the run index where the value and limit index were stored, or -1 if the data cannot be stored. * * @stable ICU 3.2 */ le_int32 add(le_int32 value, le_int32 limit); /** * ICU "poor man's RTTI", returns a UClassID for this class. * * @stable ICU 3.2 */ static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; } /** * ICU "poor man's RTTI", returns a UClassID for the actual class. * * @stable ICU 3.2 */ virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); } protected: virtual void init(le_int32 capacity); virtual void grow(le_int32 capacity); private: inline ValueRuns(); inline ValueRuns(const ValueRuns &other); inline ValueRuns &operator=(const ValueRuns & /*other*/) { return *this; }; /** * The address of this static class variable serves as this class's ID * for ICU "poor man's RTTI". */ static const char fgClassID; const le_int32 *fValues; }; inline ValueRuns::ValueRuns() : RunArray(0), fValues(NULL) { // nothing else to do... } inline ValueRuns::ValueRuns(const ValueRuns & /*other*/) : RunArray(0), fValues(NULL) { // nothing else to do... } inline ValueRuns::ValueRuns(const le_int32 *values, const le_int32 *limits, le_int32 count) : RunArray(limits, count), fValues(values) { // nothing else to do... } U_NAMESPACE_END #endif