react-native-update 10.34.3 → 10.34.5

package/harmony/pushy/src/main/cpp/lzma/CPP/Common/MyVector.h

@@ -1,14 +1,10 @@
 // Common/MyVector.h
 
-#ifndef ZIP7_INC_COMMON_MY_VECTOR_H
-#define ZIP7_INC_COMMON_MY_VECTOR_H
+#ifndef __COMMON_MY_VECTOR_H
+#define __COMMON_MY_VECTOR_H
 
 #include <string.h>
 
-#include "Common.h"
-
-const unsigned k_VectorSizeMax = ((unsigned)1 << 31) - 1;
-
 template <class T>
 class CRecordVector
 {
@@ -21,41 +17,31 @@ class CRecordVector
     memmove(_items + destIndex, _items + srcIndex, (size_t)(_size - srcIndex) * sizeof(T));
   }
 
-  void ReAllocForNewCapacity(const unsigned newCapacity)
+  void ReserveOnePosition()
   {
-    T *p;
-    Z7_ARRAY_NEW(p, T, newCapacity)
-    // p = new T[newCapacity];
-    if (_size != 0)
-      memcpy(p, _items, (size_t)_size * sizeof(T));
-    delete []_items;
-    _items = p;
-    _capacity = newCapacity;
+    if (_size == _capacity)
+    {
+      unsigned newCapacity = _capacity + (_capacity >> 2) + 1;
+      T *p;
+      MY_ARRAY_NEW(p, T, newCapacity);
+      // p = new T[newCapacity];
+      if (_size != 0)
+        memcpy(p, _items, (size_t)_size * sizeof(T));
+      delete []_items;
+      _items = p;
+      _capacity = newCapacity;
+    }
   }
 
 public:
 
-  void ReserveOnePosition()
-  {
-    if (_size != _capacity)
-      return;
-    if (_capacity >= k_VectorSizeMax)
-      throw 2021;
-    const unsigned rem = k_VectorSizeMax - _capacity;
-    unsigned add = (_capacity >> 2) + 1;
-    if (add > rem)
-      add = rem;
-    ReAllocForNewCapacity(_capacity + add);
-  }
-
-  CRecordVector(): _items(NULL), _size(0), _capacity(0) {}
+  CRecordVector(): _items(0), _size(0), _capacity(0) {}
   
-  CRecordVector(const CRecordVector &v): _items(NULL), _size(0), _capacity(0)
+  CRecordVector(const CRecordVector &v): _items(0), _size(0), _capacity(0)
   {
-    const unsigned size = v.Size();
+    unsigned size = v.Size();
     if (size != 0)
     {
-      // Z7_ARRAY_NEW(_items, T, size)
       _items = new T[size];
       _size = size;
       _capacity = size;
@@ -70,7 +56,7 @@ public:
   {
     if (size != 0)
     {
-      Z7_ARRAY_NEW(_items, T, size)
+      MY_ARRAY_NEW(_items, T, size)
       // _items = new T[size];
       _capacity = size;
     }
@@ -80,29 +66,26 @@ public:
   {
     if (newCapacity > _capacity)
     {
-      if (newCapacity > k_VectorSizeMax)
-        throw 2021;
-      ReAllocForNewCapacity(newCapacity);
+      T *p;
+      MY_ARRAY_NEW(p, T, newCapacity);
+      // p = new T[newCapacity];
+      if (_size != 0)
+        memcpy(p, _items, (size_t)_size * sizeof(T));
+      delete []_items;
+      _items = p;
+      _capacity = newCapacity;
     }
   }
 
-  void ChangeSize_KeepData(unsigned newSize)
-  {
-    Reserve(newSize);
-    _size = newSize;
-  }
-
   void ClearAndReserve(unsigned newCapacity)
   {
     Clear();
     if (newCapacity > _capacity)
     {
-      if (newCapacity > k_VectorSizeMax)
-        throw 2021;
       delete []_items;
       _items = NULL;
       _capacity = 0;
-      Z7_ARRAY_NEW(_items, T, newCapacity)
+      MY_ARRAY_NEW(_items, T, newCapacity)
       // _items = new T[newCapacity];
       _capacity = newCapacity;
     }
@@ -114,6 +97,22 @@ public:
     _size = newSize;
   }
 
+  void ChangeSize_KeepData(unsigned newSize)
+  {
+    if (newSize > _capacity)
+    {
+      T *p;
+      MY_ARRAY_NEW(p, T, newSize)
+      // p = new T[newSize];
+      if (_size != 0)
+        memcpy(p, _items, (size_t)_size * sizeof(T));
+      delete []_items;
+      _items = p;
+      _capacity = newSize;
+    }
+    _size = newSize;
+  }
+
   void ReserveDown()
   {
     if (_size == _capacity)
@@ -121,7 +120,6 @@ public:
     T *p = NULL;
     if (_size != 0)
     {
-      // Z7_ARRAY_NEW(p, T, _size)
       p = new T[_size];
       memcpy(p, _items, (size_t)_size * sizeof(T));
     }
@@ -180,7 +178,7 @@ public:
   {
     if (&v == this)
       return *this;
-    const unsigned size = v.Size();
+    unsigned size = v.Size();
     if (size > _capacity)
     {
       delete []_items;
@@ -198,45 +196,24 @@ public:
 
   CRecordVector& operator+=(const CRecordVector &v)
   {
-    const unsigned size = v.Size();
+    unsigned size = v.Size();
+    Reserve(_size + size);
     if (size != 0)
-    {
-      if (_size >= k_VectorSizeMax || size > k_VectorSizeMax - _size)
-        throw 2021;
-      const unsigned newSize = _size + size;
-      Reserve(newSize);
       memcpy(_items + _size, v._items, (size_t)size * sizeof(T));
-      _size = newSize;
-    }
+    _size += size;
     return *this;
   }
   
   unsigned Add(const T item)
   {
     ReserveOnePosition();
-    const unsigned size = _size;
-    _size = size + 1;
-    _items[size] = item;
-    return size;
+    _items[_size] = item;
+    return _size++;
   }
 
-  /*
-  unsigned Add2(const T &item)
+  void AddInReserved(const T item)
   {
-    ReserveOnePosition();
-    const unsigned size = _size;
-    _size = size + 1;
-    _items[size] = item;
-    return size;
-  }
-  */
-
-  unsigned AddInReserved(const T item)
-  {
-    const unsigned size = _size;
-    _size = size + 1;
-    _items[size] = item;
-    return size;
+    _items[_size++] = item;
   }
 
   void Insert(unsigned index, const T item)
@@ -247,18 +224,11 @@ public:
     _size++;
   }
 
-  void InsertInReserved(unsigned index, const T item)
-  {
-    MoveItems(index + 1, index);
-    _items[index] = item;
-    _size++;
-  }
-
   void MoveToFront(unsigned index)
   {
     if (index != 0)
     {
-      const T temp = _items[index];
+      T temp = _items[index];
       memmove(_items + 1, _items, (size_t)index * sizeof(T));
       _items[0] = temp;
     }
@@ -266,31 +236,15 @@ public:
 
   const T& operator[](unsigned index) const { return _items[index]; }
         T& operator[](unsigned index)       { return _items[index]; }
-  const T& operator[](int index) const { return _items[(unsigned)index]; }
-        T& operator[](int index)       { return _items[(unsigned)index]; }
-
-  const T* ConstData()    const { return _items; }
-        T* NonConstData() const { return _items; }
-        T* NonConstData()       { return _items; }
-
-  const T* Data() const         { return _items; }
-        T* Data()               { return _items; }
-
-  const T& FrontItem() const { return _items[0]; }
-        T& FrontItem()       { return _items[0]; }
-  /*
-  const T Front() const { return _items[0]; }
-        T Front()       { return _items[0]; }
   const T& Front() const { return _items[0]; }
         T& Front()       { return _items[0]; }
-  */
   const T& Back() const  { return _items[(size_t)_size - 1]; }
         T& Back()        { return _items[(size_t)_size - 1]; }
 
   /*
   void Swap(unsigned i, unsigned j)
   {
-    const T temp = _items[i];
+    T temp = _items[i];
     _items[i] = _items[j];
     _items[j] = temp;
   }
@@ -300,11 +254,10 @@ public:
   {
     while (left != right)
     {
-      // const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
-      const unsigned mid = (left + right) / 2;
+      unsigned mid = (left + right) / 2;
       const T midVal = (*this)[mid];
       if (item == midVal)
-        return (int)mid;
+        return mid;
       if (item < midVal)
         right = mid;
       else
@@ -317,12 +270,11 @@ public:
   {
     while (left != right)
     {
-      // const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
-      const unsigned mid = (left + right) / 2;
+      unsigned mid = (left + right) / 2;
       const T& midVal = (*this)[mid];
-      const int comp = item.Compare(midVal);
+      int comp = item.Compare(midVal);
       if (comp == 0)
-        return (int)mid;
+        return mid;
       if (comp < 0)
         right = mid;
       else
@@ -346,8 +298,7 @@ public:
     unsigned left = 0, right = _size;
     while (left != right)
     {
-      // const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
-      const unsigned mid = (left + right) / 2;
+      unsigned mid = (left + right) / 2;
       const T midVal = (*this)[mid];
       if (item == midVal)
         return mid;
@@ -365,10 +316,9 @@ public:
     unsigned left = 0, right = _size;
     while (left != right)
     {
-      // const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
-      const unsigned mid = (left + right) / 2;
+      unsigned mid = (left + right) / 2;
       const T& midVal = (*this)[mid];
-      const int comp = item.Compare(midVal);
+      int comp = item.Compare(midVal);
       if (comp == 0)
         return mid;
       if (comp < 0)
@@ -382,7 +332,7 @@ public:
 
   static void SortRefDown(T* p, unsigned k, unsigned size, int (*compare)(const T*, const T*, void *), void *param)
   {
-    const T temp = p[k];
+    T temp = p[k];
     for (;;)
     {
       unsigned s = (k << 1);
@@ -403,16 +353,16 @@ public:
     unsigned size = _size;
     if (size <= 1)
       return;
-    T* p = _items - 1;
+    T* p = (&Front()) - 1;
     {
       unsigned i = size >> 1;
       do
         SortRefDown(p, i, size, compare, param);
-      while (--i);
+      while (--i != 0);
     }
     do
     {
-      const T temp = p[size];
+      T temp = p[size];
       p[size--] = p[1];
       p[1] = temp;
       SortRefDown(p, 1, size, compare, param);
@@ -422,7 +372,7 @@ public:
 
   static void SortRefDown2(T* p, unsigned k, unsigned size)
   {
-    const T temp = p[k];
+    T temp = p[k];
     for (;;)
     {
       unsigned s = (k << 1);
@@ -443,16 +393,16 @@ public:
     unsigned size = _size;
     if (size <= 1)
       return;
-    T* p = _items - 1;
+    T* p = (&Front()) - 1;
     {
       unsigned i = size >> 1;
       do
         SortRefDown2(p, i, size);
-      while (--i);
+      while (--i != 0);
     }
     do
     {
-      const T temp = p[size];
+      T temp = p[size];
       p[size--] = p[1];
       p[1] = temp;
       SortRefDown2(p, 1, size);
@@ -478,45 +428,37 @@ public:
   // void Reserve(unsigned newCapacity) { _v.Reserve(newCapacity); }
   void ClearAndReserve(unsigned newCapacity) { Clear(); _v.ClearAndReserve(newCapacity); }
 
-  CObjectVector() {}
+  CObjectVector() {};
   CObjectVector(const CObjectVector &v)
   {
-    const unsigned size = v.Size();
+    unsigned size = v.Size();
     _v.ConstructReserve(size);
     for (unsigned i = 0; i < size; i++)
-      AddInReserved(v[i]);
+      _v.AddInReserved(new T(v[i]));
   }
   CObjectVector& operator=(const CObjectVector &v)
   {
     if (&v == this)
       return *this;
     Clear();
-    const unsigned size = v.Size();
+    unsigned size = v.Size();
     _v.Reserve(size);
     for (unsigned i = 0; i < size; i++)
-      AddInReserved(v[i]);
+      _v.AddInReserved(new T(v[i]));
     return *this;
   }
 
   CObjectVector& operator+=(const CObjectVector &v)
   {
-    const unsigned addSize = v.Size();
-    if (addSize != 0)
-    {
-      const unsigned size = Size();
-      if (size >= k_VectorSizeMax || addSize > k_VectorSizeMax - size)
-        throw 2021;
-      _v.Reserve(size + addSize);
-      for (unsigned i = 0; i < addSize; i++)
-        AddInReserved(v[i]);
-    }
+    unsigned size = v.Size();
+    _v.Reserve(Size() + size);
+    for (unsigned i = 0; i < size; i++)
+      _v.AddInReserved(new T(v[i]));
     return *this;
   }
   
   const T& operator[](unsigned index) const { return *((T *)_v[index]); }
         T& operator[](unsigned index)       { return *((T *)_v[index]); }
-  const T& operator[](int index) const { return *((T *)_v[(unsigned)index]); }
-        T& operator[](int index)       { return *((T *)_v[(unsigned)index]); }
   const T& Front() const { return operator[](0); }
         T& Front()       { return operator[](0); }
   const T& Back() const  { return *(T *)_v.Back(); }
@@ -524,37 +466,14 @@ public:
   
   void MoveToFront(unsigned index) { _v.MoveToFront(index); }
 
-  unsigned Add(const T& item)
-  {
-    _v.ReserveOnePosition();
-    return AddInReserved(item);
-  }
-  
-  unsigned AddInReserved(const T& item)
-  {
-    return _v.AddInReserved(new T(item));
-  }
-
-  void ReserveOnePosition()
-  {
-    _v.ReserveOnePosition();
-  }
-
-  unsigned AddInReserved_Ptr_of_new(T *ptr)
-  {
-    return _v.AddInReserved(ptr);
-  }
-
-  #define VECTOR_ADD_NEW_OBJECT(v, a) \
-    (v).ReserveOnePosition(); \
-    (v).AddInReserved_Ptr_of_new(new a);
+  unsigned Add(const T& item) { return _v.Add(new T(item)); }
   
+  void AddInReserved(const T& item) { _v.AddInReserved(new T(item)); }
   
   T& AddNew()
   {
-    _v.ReserveOnePosition();
     T *p = new T;
-    _v.AddInReserved(p);
+    _v.Add(p);
     return *p;
   }
   
@@ -565,17 +484,12 @@ public:
     return *p;
   }
   
-  void Insert(unsigned index, const T& item)
-  {
-    _v.ReserveOnePosition();
-    _v.InsertInReserved(index, new T(item));
-  }
+  void Insert(unsigned index, const T& item) { _v.Insert(index, new T(item)); }
   
   T& InsertNew(unsigned index)
   {
-    _v.ReserveOnePosition();
     T *p = new T;
-    _v.InsertInReserved(index, p);
+    _v.Insert(index, p);
     return *p;
   }
 
@@ -600,7 +514,7 @@ public:
   
   void DeleteFrom(unsigned index)
   {
-    const unsigned size = _v.Size();
+    unsigned size = _v.Size();
     for (unsigned i = index; i < size; i++)
       delete (T *)_v[i];
     _v.DeleteFrom(index);
@@ -624,7 +538,6 @@ public:
     delete (T *)_v[index];
     _v.Delete(index);
   }
-  // void Delete(int index) { Delete((unsigned)index); }
 
   /*
   void Delete(unsigned index, unsigned num)
@@ -651,12 +564,11 @@ public:
     unsigned left = 0, right = Size();
     while (left != right)
     {
-      // const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
-      const unsigned mid = (left + right) / 2;
+      unsigned mid = (left + right) / 2;
       const T& midVal = (*this)[mid];
-      const int comp = item.Compare(midVal);
+      int comp = item.Compare(midVal);
       if (comp == 0)
-        return (int)mid;
+        return mid;
       if (comp < 0)
         right = mid;
       else
@@ -670,10 +582,9 @@ public:
     unsigned left = 0, right = Size();
     while (left != right)
     {
-      // const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
-      const unsigned mid = (left + right) / 2;
+      unsigned mid = (left + right) / 2;
       const T& midVal = (*this)[mid];
-      const int comp = item.Compare(midVal);
+      int comp = item.Compare(midVal);
       if (comp == 0)
         return mid;
       if (comp < 0)
@@ -691,10 +602,9 @@ public:
     unsigned left = 0, right = Size();
     while (left != right)
     {
-      // const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
-      const unsigned mid = (left + right) / 2;
+      unsigned mid = (left + right) / 2;
       const T& midVal = (*this)[mid];
-      const int comp = item.Compare(midVal);
+      int comp = item.Compare(midVal);
       if (comp == 0)
       {
         right = mid + 1;
@@ -714,9 +624,9 @@ public:
     { _v.Sort(compare, param); }
 
   static int CompareObjectItems(void *const *a1, void *const *a2, void * /* param */)
-    { return (*(*((const T *const *)a1))).Compare(*(*((const T *const *)a2))); }
+    { return (*(*((const T **)a1))).Compare(*(*((const T **)a2))); }
 
-  void Sort() { _v.Sort(CompareObjectItems, NULL); }
+  void Sort() { _v.Sort(CompareObjectItems, 0); }
 };
 
 #define FOR_VECTOR(_i_, _v_) for (unsigned _i_ = 0; _i_ < (_v_).Size(); _i_++)