source/layoutex/RunArrays.cpp

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