diff options
author | Peter Breitenlohner <peb@mppmu.mpg.de> | 2010-12-03 09:05:05 +0000 |
---|---|---|
committer | Peter Breitenlohner <peb@mppmu.mpg.de> | 2010-12-03 09:05:05 +0000 |
commit | e04c6a878f5044d36eaa95d4c2318e0381a32998 (patch) | |
tree | 5b7c36578140e48c0114863004c8375ea55db21d /Build/source/libs/icu/icu-4.6/layoutex/plruns.cpp | |
parent | fa438554bd1a061515cd8f5f46fbe311ff08dcd6 (diff) |
icu 4.6
git-svn-id: svn://tug.org/texlive/trunk@20645 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Build/source/libs/icu/icu-4.6/layoutex/plruns.cpp')
-rw-r--r-- | Build/source/libs/icu/icu-4.6/layoutex/plruns.cpp | 502 |
1 files changed, 502 insertions, 0 deletions
diff --git a/Build/source/libs/icu/icu-4.6/layoutex/plruns.cpp b/Build/source/libs/icu/icu-4.6/layoutex/plruns.cpp new file mode 100644 index 00000000000..40e1d0bfa22 --- /dev/null +++ b/Build/source/libs/icu/icu-4.6/layoutex/plruns.cpp @@ -0,0 +1,502 @@ +/* + * + * (C) Copyright IBM Corp. 1998-2008 - All Rights Reserved + * + */ + +#include "layout/LETypes.h" +#include "layout/loengine.h" +#include "layout/plruns.h" + +#include "unicode/locid.h" + +#include "layout/LayoutEngine.h" +#include "layout/RunArrays.h" + +U_NAMESPACE_USE + +U_CAPI pl_fontRuns * U_EXPORT2 +pl_openFontRuns(const le_font **fonts, + const le_int32 *limits, + le_int32 count) +{ + return (pl_fontRuns *) new FontRuns((const LEFontInstance **) fonts, limits, count); +} + +U_CAPI pl_fontRuns * U_EXPORT2 +pl_openEmptyFontRuns(le_int32 initialCapacity) +{ + return (pl_fontRuns *) new FontRuns(initialCapacity); +} + +U_CAPI void U_EXPORT2 +pl_closeFontRuns(pl_fontRuns *fontRuns) +{ + FontRuns *fr = (FontRuns *) fontRuns; + + delete fr; +} + +U_CAPI le_int32 U_EXPORT2 +pl_getFontRunCount(const pl_fontRuns *fontRuns) +{ + const FontRuns *fr = (const FontRuns *) fontRuns; + + if (fr == NULL) { + return -1; + } + + return fr->getCount(); +} + +U_CAPI void U_EXPORT2 +pl_resetFontRuns(pl_fontRuns *fontRuns) +{ + FontRuns *fr = (FontRuns *) fontRuns; + + if (fr != NULL) { + fr->reset(); + } +} + +U_CAPI le_int32 U_EXPORT2 +pl_getFontRunLastLimit(const pl_fontRuns *fontRuns) +{ + const FontRuns *fr = (const FontRuns *) fontRuns; + + if (fr == NULL) { + return -1; + } + + return fr->getLimit(); +} + +U_CAPI le_int32 U_EXPORT2 +pl_getFontRunLimit(const pl_fontRuns *fontRuns, + le_int32 run) +{ + const FontRuns *fr = (const FontRuns *) fontRuns; + + if (fr == NULL) { + return -1; + } + + return fr->getLimit(run); +} + +U_CAPI const le_font * U_EXPORT2 +pl_getFontRunFont(const pl_fontRuns *fontRuns, + le_int32 run) +{ + const FontRuns *fr = (const FontRuns *) fontRuns; + + if (fr == NULL) { + return NULL; + } + + return (const le_font *) fr->getFont(run); +} + +U_CAPI le_int32 U_EXPORT2 +pl_addFontRun(pl_fontRuns *fontRuns, + const le_font *font, + le_int32 limit) +{ + FontRuns *fr = (FontRuns *) fontRuns; + + if (fr == NULL) { + return -1; + } + + return fr->add((const LEFontInstance *) font, limit); +} + +U_CAPI pl_valueRuns * U_EXPORT2 +pl_openValueRuns(const le_int32 *values, + const le_int32 *limits, + le_int32 count) +{ + return (pl_valueRuns *) new ValueRuns(values, limits, count); +} + +U_CAPI pl_valueRuns * U_EXPORT2 +pl_openEmptyValueRuns(le_int32 initialCapacity) +{ + return (pl_valueRuns *) new ValueRuns(initialCapacity); +} + +U_CAPI void U_EXPORT2 +pl_closeValueRuns(pl_valueRuns *valueRuns) +{ + ValueRuns *vr = (ValueRuns *) valueRuns; + + delete vr; +} + +U_CAPI le_int32 U_EXPORT2 +pl_getValueRunCount(const pl_valueRuns *valueRuns) +{ + const ValueRuns *vr = (const ValueRuns *) valueRuns; + + if (vr == NULL) { + return -1; + } + + return vr->getCount(); +} + +U_CAPI void U_EXPORT2 +pl_resetValueRuns(pl_valueRuns *valueRuns) +{ + ValueRuns *vr = (ValueRuns *) valueRuns; + + if (vr != NULL) { + vr->reset(); + } +} + +U_CAPI le_int32 U_EXPORT2 +pl_getValueRunLastLimit(const pl_valueRuns *valueRuns) +{ + const ValueRuns *vr = (const ValueRuns *) valueRuns; + + if (vr == NULL) { + return -1; + } + + return vr->getLimit(); +} + +U_CAPI le_int32 U_EXPORT2 +pl_getValueRunLimit(const pl_valueRuns *valueRuns, + le_int32 run) +{ + const ValueRuns *vr = (const ValueRuns *) valueRuns; + + if (vr == NULL) { + return -1; + } + + return vr->getLimit(run); +} + +U_CAPI le_int32 U_EXPORT2 +pl_getValueRunValue(const pl_valueRuns *valueRuns, + le_int32 run) +{ + const ValueRuns *vr = (const ValueRuns *) valueRuns; + + if (vr == NULL) { + return -1; + } + + return vr->getValue(run); +} + +U_CAPI le_int32 U_EXPORT2 +pl_addValueRun(pl_valueRuns *valueRuns, + le_int32 value, + le_int32 limit) +{ + ValueRuns *vr = (ValueRuns *) valueRuns; + + if (vr == NULL) { + return -1; + } + + return vr->add(value, limit); +} + +U_NAMESPACE_BEGIN +class ULocRuns : public LocaleRuns +{ +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 locale name strings. 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. + * + * @draft ICU 3.8 + */ + ULocRuns(const char **locales, const le_int32 *limits, le_int32 count); + + /** + * Construct an empty <code>LoIDRuns</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 + * + * @draft ICU 3.8 + */ + ULocRuns(le_int32 initialCapacity); + + /** + * The destructor; virtual so that subclass destructors are invoked as well. + * + * @draft ICU 3.8 + */ + virtual ~ULocRuns(); + + /** + * Get the name of the locale 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 locale name associated with the given text run. + * + * @see RunArray::getLimit + * + * @draft ICU 3.8 + */ + const char *getLocaleName(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>ULocRuns</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 name 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 name of the locale to add. This object must remain valid + * until the <code>ULocRuns</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. + * + * @draft ICU 3.8 + */ + le_int32 add(const char *locale, le_int32 limit); + + /** + * ICU "poor man's RTTI", returns a UClassID for this class. + * + * @draft ICU 3.8 + */ + static inline UClassID getStaticClassID(); + + /** + * ICU "poor man's RTTI", returns a UClassID for the actual class. + * + * @draft ICU 3.8 + */ + virtual inline UClassID getDynamicClassID() const; + +protected: + virtual void init(le_int32 capacity); + virtual void grow(le_int32 capacity); + +private: + + inline ULocRuns(); + inline ULocRuns(const ULocRuns &other); + inline ULocRuns &operator=(const ULocRuns & /*other*/) { return *this; }; + const char **fLocaleNames; + Locale **fLocalesCopy; +}; + +inline ULocRuns::ULocRuns() + : LocaleRuns(0), fLocaleNames(NULL) +{ + // nothing else to do... +} + +inline ULocRuns::ULocRuns(const ULocRuns & /*other*/) + : LocaleRuns(0), fLocaleNames(NULL) +{ + // nothing else to do... +} + +static const Locale **getLocales(const char **localeNames, le_int32 count) +{ + Locale **locales = LE_NEW_ARRAY(Locale *, count); + + for (int i = 0; i < count; i += 1) { + locales[i] = new Locale(Locale::createFromName(localeNames[i])); + } + + return (const Locale **) locales; +} + +ULocRuns::ULocRuns(const char **locales, const le_int32 *limits, le_int32 count) + : LocaleRuns(getLocales(locales, count), limits, count), fLocaleNames(locales) +{ + // nothing else to do... +} + +ULocRuns::ULocRuns(le_int32 initialCapacity) + : LocaleRuns(initialCapacity), fLocaleNames(NULL) +{ + if(initialCapacity > 0) { + fLocaleNames = LE_NEW_ARRAY(const char *, initialCapacity); + } +} + +ULocRuns::~ULocRuns() +{ + le_int32 count = getCount(); + + for(int i = 0; i < count; i += 1) { + delete fLocales[i]; + } + + if (fClientArrays) { + LE_DELETE_ARRAY(fLocales); + fLocales = NULL; + } else { + LE_DELETE_ARRAY(fLocaleNames); + fLocaleNames = NULL; + } +} + +void ULocRuns::init(le_int32 capacity) +{ + LocaleRuns::init(capacity); + fLocaleNames = LE_NEW_ARRAY(const char *, capacity); +} + +void ULocRuns::grow(le_int32 capacity) +{ + LocaleRuns::grow(capacity); + fLocaleNames = (const char **) LE_GROW_ARRAY(fLocaleNames, capacity); +} + +le_int32 ULocRuns::add(const char *locale, le_int32 limit) +{ + Locale *loc = new Locale(Locale::createFromName(locale)); + le_int32 index = LocaleRuns::add(loc, limit); + + if (index >= 0) { + char **localeNames = (char **) fLocaleNames; + + localeNames[index] = (char *) locale; + } + + return index; +} + +const char *ULocRuns::getLocaleName(le_int32 run) const +{ + if (run < 0 || run >= getCount()) { + return NULL; + } + + return fLocaleNames[run]; +} +UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ULocRuns) +U_NAMESPACE_END + +U_CAPI pl_localeRuns * U_EXPORT2 +pl_openLocaleRuns(const char **locales, + const le_int32 *limits, + le_int32 count) +{ + return (pl_localeRuns *) new ULocRuns(locales, limits, count); +} + +U_CAPI pl_localeRuns * U_EXPORT2 +pl_openEmptyLocaleRuns(le_int32 initialCapacity) +{ + return (pl_localeRuns *) new ULocRuns(initialCapacity); +} + +U_CAPI void U_EXPORT2 +pl_closeLocaleRuns(pl_localeRuns *localeRuns) +{ + ULocRuns *lr = (ULocRuns *) localeRuns; + + delete lr; +} + +U_CAPI le_int32 U_EXPORT2 +pl_getLocaleRunCount(const pl_localeRuns *localeRuns) +{ + const ULocRuns *lr = (const ULocRuns *) localeRuns; + + if (lr == NULL) { + return -1; + } + + return lr->getCount(); +} + +U_CAPI void U_EXPORT2 +pl_resetLocaleRuns(pl_localeRuns *localeRuns) +{ + ULocRuns *lr = (ULocRuns *) localeRuns; + + if (lr != NULL) { + lr->reset(); + } +} + +U_CAPI le_int32 U_EXPORT2 +pl_getLocaleRunLastLimit(const pl_localeRuns *localeRuns) +{ + const ULocRuns *lr = (const ULocRuns *) localeRuns; + + if (lr == NULL) { + return -1; + } + + return lr->getLimit(); +} + +U_CAPI le_int32 U_EXPORT2 +pl_getLocaleRunLimit(const pl_localeRuns *localeRuns, + le_int32 run) +{ + const ULocRuns *lr = (const ULocRuns *) localeRuns; + + if (lr == NULL) { + return -1; + } + + return lr->getLimit(run); +} + +U_CAPI const char * U_EXPORT2 +pl_getLocaleRunLocale(const pl_localeRuns *localeRuns, + le_int32 run) +{ + const ULocRuns *lr = (const ULocRuns *) localeRuns; + + if (lr == NULL) { + return NULL; + } + + return lr->getLocaleName(run); +} + +U_CAPI le_int32 U_EXPORT2 +pl_addLocaleRun(pl_localeRuns *localeRuns, + const char *locale, + le_int32 limit) +{ + ULocRuns *lr = (ULocRuns *) localeRuns; + + if (lr == NULL) { + return -1; + } + + return lr->add(locale, limit); +} |