source/i18n/nfrlist.h

   1 /*
   2 ******************************************************************************
   3 *   Copyright (C) 1997-2011, International Business Machines
   4 *   Corporation and others.  All Rights Reserved.
   5 ******************************************************************************
   6 *   file name:  nfrlist.h
   7 *   encoding:   US-ASCII
   8 *   tab size:   8 (not used)
   9 *   indentation:4
  10 *
  11 * Modification history
  12 * Date        Name      Comments
  13 * 10/11/2001  Doug      Ported from ICU4J
  14 */
  15
  16 #ifndef NFRLIST_H
  17 #define NFRLIST_H
  18
  19 #include "unicode/rbnf.h"
  20
  21 #if U_HAVE_RBNF
  22
  23 #include "unicode/uobject.h"
  24 #include "nfrule.h"
  25
  26 #include "cmemory.h"
  27
  28 U_NAMESPACE_BEGIN
  29
  30 // unsafe class for internal use only.  assume memory allocations succeed, indexes are valid.
  31 // should be a template, but we can't use them
  32
  33 class NFRuleList : public UMemory {
  34 protected:
  35     NFRule** fStuff;
  36     uint32_t fCount;
  37     uint32_t fCapacity;
  38 public:
  39     NFRuleList(uint32_t capacity = 10)
  40         : fStuff(capacity ? (NFRule**)uprv_malloc(capacity * sizeof(NFRule*)) : NULL)
  41         , fCount(0)
  42         , fCapacity(capacity) {}
  43     ~NFRuleList() {
  44         if (fStuff) {
  45             for(uint32_t i = 0; i < fCount; ++i) {
  46                 delete fStuff[i];
  47             }
  48             uprv_free(fStuff);
  49         }
  50     }
  51     NFRule* operator[](uint32_t index) const { return fStuff != NULL ? fStuff[index] : NULL; }
  52     NFRule* remove(uint32_t index) {
  53         if (fStuff == NULL) {
  54                 return NULL;
  55         }
  56         NFRule* result = fStuff[index];
  57         fCount -= 1;
  58         for (uint32_t i = index; i < fCount; ++i) { // assumes small arrays
  59             fStuff[i] = fStuff[i+1];
  60         }
  61         return result;
  62     }
  63     void add(NFRule* thing) {
  64         if (fCount == fCapacity) {
  65             fCapacity += 10;
  66             fStuff = (NFRule**)uprv_realloc(fStuff, fCapacity * sizeof(NFRule*)); // assume success
  67         }
  68         if (fStuff != NULL) {
  69                 fStuff[fCount++] = thing;
  70         } else {
  71                 fCapacity = 0;
  72                 fCount = 0;
  73         }
  74     }
  75     uint32_t size() const { return fCount; }
  76     NFRule* last() const { return (fCount > 0 && fStuff != NULL) ? fStuff[fCount-1] : NULL; }
  77     NFRule** release() {
  78         add(NULL); // ensure null termination
  79         NFRule** result = fStuff;
  80         fStuff = NULL;
  81         fCount = 0;
  82         fCapacity = 0;
  83         return result;
  84     }
  85
  86 private:
  87     NFRuleList(const NFRuleList &other); // forbid copying of this class
  88     NFRuleList &operator=(const NFRuleList &other); // forbid copying of this class
  89 };
  90
  91 U_NAMESPACE_END
  92
  93 /* U_HAVE_RBNF */
  94 #endif
  95
  96 // NFRLIST_H
  97 #endif