org.handhelds.familiar/packages/gtk-webcore/osb-nrcore-0.5.0/KWQDictImpl.patch

   1 Index: NRCore/kwiq/KWQDictImpl.cpp
   2 ===================================================================
   3 --- NRCore/kwiq/KWQDictImpl.cpp 2004/10/18 18:39:48     1.3
   4 +++ NRCore/kwiq/KWQDictImpl.cpp 2004/10/25 10:08:30
   5 @@ -30,26 +30,90 @@
   6   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
   7   * OF THE POSSIBILITY OF SUCH DAMAGE.
   8   */
   9 +#include <string.h>
  10
  11  #include "KWQDictImpl.h"
  12 +#include "KWQAssertions.h"
  13 +#include "KWQMap.h"
  14  #include <CoreFoundation/CoreFoundation.h>
  15 +
  16 +typedef void (* DeleteFunction) (void *);
  17 +
  18 +class KWQDictPrivate
  19 +{
  20 +public:
  21 +    KWQDictPrivate(int size, bool caseSensitive, DeleteFunction);
  22 +    KWQDictPrivate(const KWQDictPrivate &dp);
  23 +    ~KWQDictPrivate();
  24 +
  25 +    QMap<QString,void*> map;
  26 +    DeleteFunction deleteFunc;
  27 +    bool modifyCase;
  28 +    KWQDictIteratorPrivate *iterators;
  29 +};
  30 +
  31 +class KWQDictIteratorPrivate
  32 +{
  33 +public:
  34 +    KWQDictIteratorPrivate(KWQDictPrivate *);
  35 +    ~KWQDictIteratorPrivate();
  36 +
  37 +    void remove(const QString &key);
  38 +    void dictDestroyed();
  39 +
  40 +    uint count;
  41 +    uint pos;
  42 +    QString **keys;
  43 +    void **values;
  44 +    KWQDictPrivate *dict;
  45 +    KWQDictIteratorPrivate *next;
  46 +    KWQDictIteratorPrivate *prev;
  47 +};
  48 +
  49 +KWQDictPrivate::KWQDictPrivate(int size, bool caseSensitive,
  50 +                               DeleteFunction _deleteFunc)
  51 +    : deleteFunc(_deleteFunc),
  52 +      modifyCase(!caseSensitive),
  53 +      iterators(0)
  54 +{
  55 +}
  56 +
  57 +KWQDictPrivate::KWQDictPrivate(const KWQDictPrivate &dp)
  58 +    : map(dp.map),
  59 +      deleteFunc(dp.deleteFunc),
  60 +      modifyCase(dp.modifyCase),
  61 +      iterators(0)
  62 +{
  63 +}
  64 +
  65 +KWQDictPrivate::~KWQDictPrivate()
  66 +{
  67 +    for (KWQDictIteratorPrivate *it = iterators; it; it = it->next) {
  68 +        it->dictDestroyed();
  69 +    }
  70 +}
  71 +
  72 +
  73  /*
  74   * No KWQDictImpl::~KWQDictImpl() because QDict::~QDict calls KWQDictImpl::clear()
  75   * on
  76   */
  77  KWQDictImpl::KWQDictImpl(int size, bool caseSensitive, void (*deleteFunc_)(void *))
  78 -    : deleteFunc(deleteFunc_)
  79 -    , modifyCase(!caseSensitive)
  80 +  : d(new KWQDictPrivate(size, caseSensitive, deleteFunc_))
  81  {
  82 +}
  83
  84 +KWQDictImpl::~KWQDictImpl()
  85 +{
  86 +    delete d;
  87  }
  88
  89  void KWQDictImpl::insert(const QString &key, const void *value)
  90  {
  91 -    if (modifyCase)
  92 -       map.insert(key.lower(), const_cast<void*>(value));
  93 +    if (d->modifyCase)
  94 +       d->map.insert(key.lower(), const_cast<void*>(value));
  95      else
  96 -       map.insert(key, const_cast<void*>(value) );
  97 +       d->map.insert(key, const_cast<void*>(value) );
  98  }
  99
 100  bool KWQDictImpl::remove(const QString &key, bool deleteItem)
 101 @@ -57,21 +121,26 @@
 102      QMapIterator<QString, void*> i;
 103      void* data;
 104
 105 -    if (modifyCase)
 106 -       i = map.find(key.lower());
 107 +    if (d->modifyCase)
 108 +       i = d->map.find(key.lower());
 109      else
 110 -       i = map.find(key);
 111 +       i = d->map.find(key);
 112
 113 -    if (i == map.end())
 114 +    if (i == d->map.end())
 115         return false;
 116
 117      data = *i;
 118
 119 -    map.remove(i);
 120 -    if (deleteItem && deleteFunc) {
 121 -      deleteFunc(data);
 122 +    d->map.remove(i);
 123 +    if (deleteItem && d->deleteFunc) {
 124 +      d->deleteFunc(data);
 125        return true;
 126      }
 127 +
 128 +    for (KWQDictIteratorPrivate *it = d->iterators; it; it = it->next) {
 129 +        it->remove(key);
 130 +    }
 131 +
 132      return false;
 133  }
 134
 135 @@ -79,71 +148,159 @@
 136  {
 137      if (deleteItem)
 138      {
 139 -       QMapIterator<QString,void*> i = map.begin();
 140 -       QMapIterator<QString,void*> end = map.end();
 141 +       QMapIterator<QString,void*> i = d->map.begin();
 142 +       QMapIterator<QString,void*> end = d->map.end();
 143         void *data;
 144         while (i!=end)
 145         {
 146             data=*i;
 147 -           if (deleteFunc) deleteFunc(data);
 148 +           if (d->deleteFunc) d->deleteFunc(data);
 149             ++i;
 150         }
 151      }
 152
 153 -    map.clear();
 154 +    d->map.clear();
 155  }
 156
 157  uint KWQDictImpl::count() const
 158  {
 159 -    return map.count();
 160 +    return d->map.count();
 161  }
 162
 163  void *KWQDictImpl::find(const QString &key) const
 164  {
 165      QMapConstIterator<QString,void*> i;
 166 -    if (modifyCase)
 167 -       i = map.find(key.lower());
 168 +    if (d->modifyCase)
 169 +       i = d->map.find(key.lower());
 170      else
 171 -       i = map.find(key);
 172 +       i = d->map.find(key);
 173
 174 -    if (i == map.end())
 175 +    if (i == d->map.end())
 176         return 0;
 177      return *i;
 178  }
 179
 180 +void KWQDictImpl::swap(KWQDictImpl &di)
 181 +{
 182 +    KWQDictPrivate *tmp;
 183 +
 184 +    tmp = di.d;
 185 +    di.d = d;
 186 +    d = tmp;
 187 +}
 188 +
 189 +KWQDictImpl &KWQDictImpl::assign(const KWQDictImpl &di, bool deleteItems)
 190 +{
 191 +    KWQDictImpl tmp(di);
 192 +
 193 +    if (deleteItems) {
 194 +       clear(true);
 195 +    }
 196 +
 197 +    swap(tmp);
 198 +
 199 +    return *this;
 200 +}
 201 +
 202 +
 203 +KWQDictIteratorImpl::KWQDictIteratorImpl(const KWQDictImpl &di)
 204 +    : d(new KWQDictIteratorPrivate(di.d))
 205 +{
 206 +}
 207 +
 208  uint KWQDictIteratorImpl::count() const
 209  {
 210 -    return dict->map.count();
 211 +    return d->count;
 212  }
 213
 214  void* KWQDictIteratorImpl::current() const
 215  {
 216 -    if (i == dict->map.end())
 217 -       return 0;
 218 -    return *i;
 219 +    if (d->pos >= d->count) {
 220 +       return NULL;
 221 +    }
 222 +    return d->values[d->pos];
 223  }
 224
 225  void* KWQDictIteratorImpl::toFirst()
 226  {
 227 -    i=dict->map.begin();
 228 -    if (i == dict->map.end())
 229 -       return 0;
 230 -
 231 -    return *i;
 232 +    d->pos = 0;
 233 +    return current();
 234  }
 235 +
 236  void* KWQDictIteratorImpl::operator++()
 237  {
 238 -    ++i;
 239 -    if (i==dict->map.end())
 240 -       return 0;
 241 -    return *i;
 242 +    ++d->pos;
 243 +    return current();
 244  }
 245
 246  QString KWQDictIteratorImpl::currentStringKey() const
 247 +{
 248 +    if (d->pos >= d->count) {
 249 +        return QString();
 250 +    }
 251 +    return QString(*d->keys[d->pos]);
 252 +}
 253 +
 254 +
 255 +KWQDictIteratorPrivate::KWQDictIteratorPrivate(KWQDictPrivate *d) :
 256 +    count(d->map.count()),
 257 +    pos(0),
 258 +    keys(new QString * [count]),
 259 +    values(new void * [count]),
 260 +    dict(d),
 261 +    next(d->iterators),
 262 +    prev(0)
 263 +{
 264 +    d->iterators = this;
 265 +    if (next) {
 266 +        next->prev = this;
 267 +    }
 268 +
 269 +    unsigned int i = 0;
 270 +    QMap<QString,void*>::Iterator it = d->map.begin();
 271 +    QMap<QString,void*>::Iterator end = d->map.end();
 272 +    while (it != end) {
 273 +        keys[i] = new QString(it.key());
 274 +       values[i] = it.data();
 275 +       ++i;
 276 +       ++it;
 277 +    }
 278 +    ASSERT(i==count);
 279 +}
 280 +
 281 +KWQDictIteratorPrivate::~KWQDictIteratorPrivate()
 282  {
 283 -    if (i == dict->map.end() )
 284 -       return QString();
 285 +    if (prev) {
 286 +        prev->next = next;
 287 +    } else if (dict) {
 288 +        dict->iterators = next;
 289 +    }
 290 +    if (next) {
 291 +        next->prev = prev;
 292 +    }
 293 +
 294 +    delete [] keys;
 295 +    delete [] values;
 296 +}
 297
 298 -    return QString(i.key());
 299 +void KWQDictIteratorPrivate::remove(const QString &key)
 300 +{
 301 +    for (uint i = 0; i < count; ) {
 302 +      if (*keys[i] != key) {
 303 +            ++i;
 304 +        } else {
 305 +            --count;
 306 +            if (pos > i) {
 307 +                --pos;
 308 +            }
 309 +            memmove(&keys[i], &keys[i+1], sizeof(keys[i]) * (count - i));
 310 +            memmove(&values[i], &values[i+1], sizeof(values[i]) * (count - i));
 311 +        }
 312 +    }
 313  }
 314
 315 +void KWQDictIteratorPrivate::dictDestroyed()
 316 +{
 317 +    count = 0;
 318 +    dict = 0;
 319 +}
 320 Index: NRCore/kwiq/KWQDictImpl.h
 321 ===================================================================
 322 --- NRCore/kwiq/KWQDictImpl.h   2004/09/23 08:27:53     1.1.1.1
 323 +++ NRCore/kwiq/KWQDictImpl.h   2004/10/25 10:08:30
 324 @@ -29,36 +29,42 @@
 325  #include "KWQMap.h"
 326  #include "KWQString.h"
 327
 328 +class KWQDictPrivate;
 329 +class KWQDictIteratorPrivate;
 330 +
 331  class KWQDictImpl {
 332   public:
 333      KWQDictImpl(int size, bool caseSensitive, void (*deleteFunc)(void *));
 334 +    ~KWQDictImpl();
 335      void insert(const QString &key, const void *value);
 336      bool remove(const QString &key, bool deleteItems);
 337
 338      void *find(const QString &key) const;
 339      void clear(bool deleteItem);
 340      uint count() const;
 341 - private:
 342 -    void (*deleteFunc)(void*);
 343 -    QMap<QString,void*> map;
 344 -    bool modifyCase;
 345 +
 346 +    KWQDictImpl &assign(const KWQDictImpl &pdi, bool deleteItems);
 347 +private:
 348 +    void swap(KWQDictImpl &di);
 349 +    KWQDictPrivate *d;
 350      friend class KWQDictIteratorImpl;
 351  };
 352
 353  class KWQDictIteratorImpl {
 354 -    const KWQDictImpl *dict;
 355 -    QMapConstIterator<QString,void*> i;
 356   public:
 357 -    KWQDictIteratorImpl(const KWQDictImpl &di) :dict(&di), i(di.map.begin()) { }
 358 +    KWQDictIteratorImpl(const KWQDictImpl &di);
 359      uint count() const ;
 360      void *current() const;
 361 +
 362 +    void* toFirst();
 363
 364 -    void* toFirst();
 365 -
 366      void *operator++();
 367
 368
 369      QString currentStringKey() const;
 370 +private:
 371 +    KWQDictIteratorPrivate *d;
 372 +
 373  };
 374
 375  #endif