icuSources/layoutex/RunArrays.cpp

   1 /*
   2  **********************************************************************
   3  *   Copyright (C) 2003, International Business Machines
   4  *   Corporation and others.  All Rights Reserved.
   5  **********************************************************************
   6  */
   7
   8 #include "layout/LETypes.h"
   9 #include "layout/LEFontInstance.h"
  10
  11 #include "unicode/locid.h"
  12
  13 #include "layout/RunArrays.h"
  14
  15 U_NAMESPACE_BEGIN
  16
  17 const char RunArray::fgClassID = 0;
  18
  19 RunArray::RunArray(le_int32 initialCapacity)
  20     : fClientArrays(FALSE), fLimits(NULL), fCount(0), fCapacity(initialCapacity)
  21 {
  22     if (initialCapacity > 0) {
  23         fLimits = LE_NEW_ARRAY(le_int32, fCapacity);
  24     }
  25 }
  26
  27 RunArray::~RunArray()
  28 {
  29     if (! fClientArrays) {
  30         LE_DELETE_ARRAY(fLimits);
  31         fLimits = NULL;
  32     }
  33 }
  34
  35 le_int32 RunArray::ensureCapacity()
  36 {
  37     if (fCount >= fCapacity) {
  38         if (fCapacity == 0) {
  39             fCapacity = INITIAL_CAPACITY;
  40             init(fCapacity);
  41         } else {
  42             fCapacity += (fCapacity < CAPACITY_GROW_LIMIT ? fCapacity : CAPACITY_GROW_LIMIT);
  43             grow(fCapacity);
  44         }
  45     }
  46
  47     return fCount++;
  48 }
  49
  50 void RunArray::init(le_int32 capacity)
  51 {
  52     fLimits = LE_NEW_ARRAY(le_int32, capacity);
  53 }
  54
  55 void RunArray::grow(le_int32 newCapacity)
  56 {
  57     fLimits = (le_int32 *) LE_GROW_ARRAY(fLimits, newCapacity);
  58 }
  59
  60 le_int32 RunArray::add(le_int32 limit)
  61 {
  62     if (fClientArrays) {
  63         return -1;
  64     }
  65
  66     le_int32  index  = ensureCapacity();
  67     le_int32 *limits = (le_int32 *) fLimits;
  68
  69     limits[index] = limit;
  70
  71     return index;
  72 }
  73
  74 const char FontRuns::fgClassID = 0;
  75
  76 FontRuns::FontRuns(le_int32 initialCapacity)
  77     : RunArray(initialCapacity), fFonts(NULL)
  78 {
  79     if (initialCapacity > 0) {
  80         fFonts = LE_NEW_ARRAY(const LEFontInstance *, initialCapacity);
  81     }
  82 }
  83
  84 FontRuns::~FontRuns()
  85 {
  86     if (! fClientArrays) {
  87         LE_DELETE_ARRAY(fFonts);
  88         fFonts = NULL;
  89     }
  90 }
  91
  92 void FontRuns::init(le_int32 capacity)
  93 {
  94     RunArray::init(capacity);
  95     fFonts = LE_NEW_ARRAY(const LEFontInstance *, capacity);
  96 }
  97
  98 void FontRuns::grow(le_int32 capacity)
  99 {
 100     RunArray::grow(capacity);
 101     fFonts = (const LEFontInstance **) LE_GROW_ARRAY(fFonts, capacity);
 102 }
 103
 104 le_int32 FontRuns::add(const LEFontInstance *font, le_int32 limit)
 105 {
 106     le_int32 index = RunArray::add(limit);
 107
 108     if (index >= 0) {
 109         LEFontInstance **fonts = (LEFontInstance **) fFonts;
 110
 111         fonts[index] = (LEFontInstance *) font;
 112     }
 113
 114     return index;
 115 }
 116
 117 const LEFontInstance *FontRuns::getFont(le_int32 run) const
 118 {
 119     if (run < 0 || run >= getCount()) {
 120         return NULL;
 121     }
 122
 123     return fFonts[run];
 124 }
 125
 126 const char LocaleRuns::fgClassID = 0;
 127
 128 LocaleRuns::LocaleRuns(le_int32 initialCapacity)
 129     : RunArray(initialCapacity), fLocales(NULL)
 130 {
 131     if (initialCapacity > 0) {
 132         fLocales = LE_NEW_ARRAY(const Locale *, initialCapacity);
 133     }
 134 }
 135
 136 LocaleRuns::~LocaleRuns()
 137 {
 138     if (! fClientArrays) {
 139         LE_DELETE_ARRAY(fLocales);
 140         fLocales = NULL;
 141     }
 142 }
 143
 144 void LocaleRuns::init(le_int32 capacity)
 145 {
 146     RunArray::init(capacity);
 147     fLocales = LE_NEW_ARRAY(const Locale *, capacity);
 148 }
 149
 150 void LocaleRuns::grow(le_int32 capacity)
 151 {
 152     RunArray::grow(capacity);
 153     fLocales = (const Locale **) LE_GROW_ARRAY(fLocales, capacity);
 154 }
 155
 156 le_int32 LocaleRuns::add(const Locale *locale, le_int32 limit)
 157 {
 158     le_int32 index = RunArray::add(limit);
 159
 160     if (index >= 0) {
 161         Locale **locales = (Locale **) fLocales;
 162
 163         locales[index] = (Locale *) locale;
 164     }
 165
 166     return index;
 167 }
 168
 169 const Locale *LocaleRuns::getLocale(le_int32 run) const
 170 {
 171     if (run < 0 || run >= getCount()) {
 172         return NULL;
 173     }
 174
 175     return fLocales[run];
 176 }
 177
 178 const char ValueRuns::fgClassID = 0;
 179
 180 ValueRuns::ValueRuns(le_int32 initialCapacity)
 181     : RunArray(initialCapacity), fValues(NULL)
 182 {
 183     if (initialCapacity > 0) {
 184         fValues = LE_NEW_ARRAY(le_int32, initialCapacity);
 185     }
 186 }
 187
 188 ValueRuns::~ValueRuns()
 189 {
 190     if (! fClientArrays) {
 191         LE_DELETE_ARRAY(fValues);
 192         fValues = NULL;
 193     }
 194 }
 195
 196 void ValueRuns::init(le_int32 capacity)
 197 {
 198     RunArray::init(capacity);
 199     fValues = LE_NEW_ARRAY(le_int32, capacity);
 200 }
 201
 202 void ValueRuns::grow(le_int32 capacity)
 203 {
 204     RunArray::grow(capacity);
 205     fValues = (const le_int32 *) LE_GROW_ARRAY(fValues, capacity);
 206 }
 207
 208 le_int32 ValueRuns::add(le_int32 value, le_int32 limit)
 209 {
 210     le_int32 index = RunArray::add(limit);
 211
 212     if (index >= 0) {
 213         le_int32 *values = (le_int32 *) fValues;
 214
 215         values[index] = value;
 216     }
 217
 218     return index;
 219 }
 220
 221 le_int32 ValueRuns::getValue(le_int32 run) const
 222 {
 223     if (run < 0 || run >= getCount()) {
 224         return -1;
 225     }
 226
 227     return fValues[run];
 228 }
 229
 230 U_NAMESPACE_END