icu/source/layoutex/layout/RunArrays.h - nest-learning-thermostat/5.0.1/icu - Git at Google

 /*
  **********************************************************************
  *   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
	/*
	**********************************************************************
	* 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