ArrayList_macros.mqh

/*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* https://github.com/Roffild/RoffildLibrary
*/

// Для сравнения этот файл проще разделить на два ;)

#define CArrayListInit(Type)                                                                                 \
   class CArrayList_##Type                                                                                   \
   {                                                                                                         \
   protected:                                                                                                \
      Type elements[];                                                                                       \
      int reserve;                                                                                           \
                                                                                                             \
      bool removeList(const Type &list[], bool saveOnlyList = false)                                         \
      {                                                                                                      \
         int ltcount = ArraySize(list);                                                                      \
         if (ltcount == 0) {                                                                                 \
            return false;                                                                                    \
         }                                                                                                   \
         int elcount = ArraySize(elements);                                                                  \
         int last = 0;                                                                                       \
         for (int x = 0; x < elcount && last < elcount; x++) {                                               \
            bool found = false;                                                                              \
            for (int y = ltcount-1; y > -1; y--) {                                                           \
               if (elements[x] == list[y]) {                                                                 \
                  found = true;                                                                              \
                  break;                                                                                     \
               }                                                                                             \
            }                                                                                                \
            if (found != saveOnlyList) {                                                                     \
               continue;                                                                                     \
            }                                                                                                \
            if (x > last) {                                                                                  \
               elements[last] = elements[x];                                                                 \
            }                                                                                                \
            last++;                                                                                          \
         }                                                                                                   \
         if (last < elcount) {                                                                               \
            ArrayResize(elements, last, reserve);                                                            \
            return true;                                                                                     \
         }                                                                                                   \
         return false;                                                                                       \
      }                                                                                                      \
                                                                                                             \
   public:                                                                                                   \
      CArrayList_##Type(int _reserve = 0)                                                                    \
      {                                                                                                      \
         reserve = _reserve;                                                                                 \
      }                                                                                                      \
                                                                                                             \
      int getReserve()                                                                                       \
      {                                                                                                      \
         return reserve;                                                                                     \
      }                                                                                                      \
      void setReserve(int _reserve)                                                                          \
      {                                                                                                      \
         reserve = _reserve;                                                                                 \
      }                                                                                                      \
                                                                                                             \
\      /// Appends the specified element to the end of this list.
      bool add(const Type element)                                                                           \
      {                                                                                                      \
         return add(ArraySize(elements), element);                                                           \
      }                                                                                                      \
                                                                                                             \
\      /// Inserts the specified element at the specified position in this list.
      bool add(int index, const Type element)                                                                \
      {                                                                                                      \
         if (index < 0) {                                                                                    \
            return false;                                                                                    \
         }                                                                                                   \
                                                                                                             \
         int start = ArraySize(elements);                                                                    \
         if (ArrayResize(elements, start+1, reserve) > -1) {                                                 \
            if (index < start) {                                                                             \
               for (int x = ArraySize(elements)-1; start > index; x--, start--) {                            \
                  elements[x] = elements[start-1];                                                           \
               }                                                                                             \
            }                                                                                                \
            elements[start] = element;                                                                       \
            return true;                                                                                     \
         }                                                                                                   \
         return false;                                                                                       \
      }                                                                                                      \
                                                                                                             \
\      /// Appends all of the elements in the specified collection to the end of this list.
      bool addAll(const Type &list[])                                                                        \
      {                                                                                                      \
         return addAll(ArraySize(elements), list);                                                           \
      }                                                                                                      \
      bool addAll(const CArrayList_##Type &list)                                                             \
      {                                                                                                      \
         return addAll(ArraySize(elements), list.elements);                                                  \
      }                                                                                                      \
                                                                                                             \
\      /// Inserts all of the elements in the specified collection into this list,
\      /// starting at the specified position.
      bool addAll(int index, const Type &list[])                                                             \
      {                                                                                                      \
         if (index < 0) {                                                                                    \
            return false;                                                                                    \
         }                                                                                                   \
                                                                                                             \
         int start = ArraySize(elements);                                                                    \
         int count = ArraySize(list);                                                                        \
         if (ArrayResize(elements, start + count, reserve) > -1) {                                           \
            if (index < start) {                                                                             \
               for (int x = ArraySize(elements)-1; start > index; x--, start--) {                            \
                  elements[x] = elements[start-1];                                                           \
               }                                                                                             \
            }                                                                                                \
            return ArrayCopy(elements, list, start) > 0;                                                     \
         }                                                                                                   \
         return false;                                                                                       \
      }                                                                                                      \
      bool addAll(int index, const CArrayList_##Type &list)                                                  \
      {                                                                                                      \
         return addAll(index, list.elements);                                                                \
      }                                                                                                      \
                                                                                                             \
\      /// Removes all of the elements from this list.
      void clear()                                                                                           \
      {                                                                                                      \
         ArrayResize(elements, 0, reserve);                                                                  \
      }                                                                                                      \
                                                                                                             \
\      /// Returns a shallow copy of this ArrayList instance.
\      //Object clone()
                                                                                                             \
\      /// Returns true if this list contains the specified element.
      bool contains(const Type o)                                                                            \
      {                                                                                                      \
         return indexOf(o) > -1;                                                                             \
      }                                                                                                      \
                                                                                                             \
\      /// Increases the capacity of this ArrayList instance, if necessary,
\      /// to ensure that it can hold at least the number of elements
\      /// specified by the minimum capacity argument.
\      //void ensureCapacity(int minCapacity)
                                                                                                             \
\      /// Performs the given action for each element of the Iterable until all elements
\      /// have been processed or the action throws an exception.
\      //void forEach(Consumer<? super E> action)
                                                                                                             \
\      /// Returns the element at the specified position in this list.
      Type get(int index)                                                                                    \
      {                                                                                                      \
         return elements[index];                                                                             \
      }                                                                                                      \
      Type operator[](int index)                                                                             \
      {                                                                                                      \
         return get(index);                                                                                  \
      }                                                                                                      \
                                                                                                             \
\      /// Replaces the element at the specified position in this list with the specified element.
      Type set(int index, const Type element)                                                                \
      {                                                                                                      \
         Type oldvalue = get(index);                                                                         \
         elements[index] = element;                                                                          \
         return oldvalue;                                                                                    \
      }                                                                                                      \
                                                                                                             \
\      /// Returns the index of the first occurrence of the specified element in this list,
\      /// or -1 if this list does not contain the element.
      int indexOf(const Type o)                                                                              \
      {                                                                                                      \
         int count = ArraySize(elements);                                                                    \
         for (int x = 0; x < count; x++) {                                                                   \
            if (elements[x] == o) {                                                                          \
               return x;                                                                                     \
            }                                                                                                \
         }                                                                                                   \
         return -1;                                                                                          \
      }                                                                                                      \
                                                                                                             \
\      /// Returns the index of the last occurrence of the specified element in this list,
\      /// or -1 if this list does not contain the element.
      int lastIndexOf(const Type o)                                                                          \
      {                                                                                                      \
         int count = ArraySize(elements);                                                                    \
         for (int x = count-1; x > -1; x--) {                                                                \
            if (elements[x] == o) {                                                                          \
               return x;                                                                                     \
            }                                                                                                \
         }                                                                                                   \
         return -1;                                                                                          \
      }                                                                                                      \
                                                                                                             \
\      /// Returns true if this list contains no elements.
      bool isEmpty()                                                                                         \
      {                                                                                                      \
         return ArraySize(elements) == 0;                                                                    \
      }                                                                                                      \
                                                                                                             \
\      /// Removes the element at the specified position in this list.
      Type remove(int index)                                                                                 \
      {                                                                                                      \
         int count = ArraySize(elements);                                                                    \
         if (index < 0) {                                                                                    \
            return NULL;                                                                                     \
         }                                                                                                   \
         Type oldvalue = set(index, NULL);                                                                   \
         if (index < count-1) {                                                                              \
            ArrayCopy(elements, elements, index, index+1);                                                   \
         }                                                                                                   \
         ArrayResize(elements, count-1, reserve);                                                            \
         return oldvalue;                                                                                    \
      }                                                                                                      \
                                                                                                             \
\      /// Removes the first occurrence of the specified element from this list, if it is present.
      bool removeFirst(const Type o)                                                                         \
      {                                                                                                      \
         int index = indexOf(o);                                                                             \
         if (index == -1) {                                                                                  \
            return false;                                                                                    \
         }                                                                                                   \
         remove(index);                                                                                      \
         return true;                                                                                        \
      }                                                                                                      \
                                                                                                             \
\      /// Removes from this list all of its elements that are contained in the specified collection.
      bool removeAll(const Type &list[])                                                                     \
      {                                                                                                      \
         return removeList(list, false);                                                                     \
      }                                                                                                      \
                                                                                                             \
\      /// Retains only the elements in this list that are contained in the specified collection.
      bool retainAll(const Type &list[])                                                                     \
      {                                                                                                      \
         return removeList(list, true);                                                                      \
      }                                                                                                      \
                                                                                                             \
\      /// Removes all of the elements of this collection that satisfy the given predicate.
\      //bool removeIf(Predicate<? super E> filter)
                                                                                                             \
\      /// Removes from this list all of the elements whose index is between fromIndex,
\      /// inclusive, and toIndex, exclusive.
\      //protected void removeRange(int fromIndex, int toIndex)
                                                                                                             \
\      /// Replaces each element of this list with the result of applying the operator to that element.
\      //void replaceAll(UnaryOperator<E> operator)
                                                                                                             \
\      /// Returns the number of elements in this list.
      int size()                                                                                             \
      {                                                                                                      \
         return ArraySize(elements);                                                                         \
      }                                                                                                      \
                                                                                                             \
\      /// Sorts this list according to the order induced by the specified Comparator.
\      //void sort(Comparator<? super E> c)
                                                                                                             \
      int subList(Type &dst_array[], int dst_start = 0, int src_start = 0, int count = WHOLE_ARRAY)          \
      {                                                                                                      \
         return ArrayCopy(dst_array, elements, dst_start, src_start, count);                                 \
      }                                                                                                      \
                                                                                                             \
\      /// Returns an array containing all of the elements in this list in proper sequence
\      /// (from first to last element).
      void toArray(Type &dst_array[])                                                                        \
      {                                                                                                      \
         ArrayCopy(dst_array, elements);                                                                     \
      }                                                                                                      \
   };

#define CArrayListClassInit(Type)                                                                            \
   class CArrayListClass_##Type                                                                              \
   {                                                                                                         \
   protected:                                                                                                \
      Type *elements[];                                                                                      \
      int reserve;                                                                                           \
      bool use_delete;                                                                                       \
                                                                                                             \
\      // Всё, что требует сравнение классов мне сейчас не нужно...
\      //bool removeList(const Type *&list[], bool saveOnlyList = false)
\      //{
\      //         if (elements[x].compare(list[y])) {
\      //}
                                                                                                             \
   public:                                                                                                   \
      CArrayListClass_##Type(bool _use_delete = true, int _reserve = 0)                                      \
      {                                                                                                      \
         reserve = _reserve;                                                                                 \
         use_delete = _use_delete;                                                                           \
      }                                                                                                      \
                                                                                                             \
      ~CArrayListClass_##Type()                                                                              \
      {                                                                                                      \
         clear();                                                                                            \
      }                                                                                                      \
                                                                                                             \
      int getReserve()                                                                                       \
      {                                                                                                      \
         return reserve;                                                                                     \
      }                                                                                                      \
      void setReserve(int _reserve)                                                                          \
      {                                                                                                      \
         reserve = _reserve;                                                                                 \
      }                                                                                                      \
                                                                                                             \
      bool getUseDelete()                                                                                    \
      {                                                                                                      \
         return use_delete;                                                                                  \
      }                                                                                                      \
      void setUseDelete(bool _use_delete)                                                                    \
      {                                                                                                      \
         use_delete = _use_delete;                                                                           \
      }                                                                                                      \
                                                                                                             \
\      /// Appends the specified element to the end of this list.
      bool add(Type *element)                                                                                \
      {                                                                                                      \
         return add(ArraySize(elements), element);                                                           \
      }                                                                                                      \
                                                                                                             \
\      /// Inserts the specified element at the specified position in this list.
      bool add(int index, Type *element)                                                                     \
      {                                                                                                      \
         if (index < 0) {                                                                                    \
            return false;                                                                                    \
         }                                                                                                   \
                                                                                                             \
         int start = ArraySize(elements);                                                                    \
         if (ArrayResize(elements, start+1, reserve) > -1) {                                                 \
            if (index < start) {                                                                             \
               for (int x = ArraySize(elements)-1; start > index; x--, start--) {                            \
                  elements[x] = elements[start-1];                                                           \
               }                                                                                             \
            }                                                                                                \
            elements[start] = element;                                                                       \
            return true;                                                                                     \
         }                                                                                                   \
         return false;                                                                                       \
      }                                                                                                      \
                                                                                                             \
\      /// Appends all of the elements in the specified collection to the end of this list.
      bool addAll(const Type *&list[])                                                                       \
      {                                                                                                      \
         return addAll(ArraySize(elements), list);                                                           \
      }                                                                                                      \
      bool addAll(const CArrayListClass_##Type &list)                                                        \
      {                                                                                                      \
         return addAll(ArraySize(elements), list);                                                  \
      }                                                                                                      \
                                                                                                             \
\      /// Inserts all of the elements in the specified collection into this list,
\      /// starting at the specified position.
      bool addAll(int index, const Type *&list[])                                                            \
      {                                                                                                      \
         if (index < 0) {                                                                                    \
            return false;                                                                                    \
         }                                                                                                   \
                                                                                                             \
         int start = ArraySize(elements);                                                                    \
         int count = ArraySize(list);                                                                        \
         if (ArrayResize(elements, start + count, reserve) > -1) {                                           \
            if (index < start) {                                                                             \
               for (int x = ArraySize(elements)-1; start > index; x--, start--) {                            \
                  elements[x] = elements[start-1];                                                           \
               }                                                                                             \
            }                                                                                                \
            return ArrayCopy(elements, list, start) > 0;                                                     \
         }                                                                                                   \
         return false;                                                                                       \
      }                                                                                                      \
      bool addAll(int index, const CArrayListClass_##Type &list)                                             \
      {                                                                                                      \
         return addAll(index, list);                                                                \
      }                                                                                                      \
                                                                                                             \
\      /// Removes all of the elements from this list.
      void clear()                                                                                           \
      {                                                                                                      \
         if (use_delete) {                                                                                   \
            for (int x = ArraySize(elements) - 1; x > -1; x--) {                                             \
               delete(elements[x]);                                                                          \
            }                                                                                                \
         }                                                                                                   \
         ArrayResize(elements, 0, reserve);                                                                  \
      }                                                                                                      \
                                                                                                             \
\      /// Returns a shallow copy of this ArrayList instance.
\      //Object clone()
                                                                                                             \
\      /// Increases the capacity of this ArrayList instance, if necessary,
\      /// to ensure that it can hold at least the number of elements
\      /// specified by the minimum capacity argument.
\      //void ensureCapacity(int minCapacity)
                                                                                                             \
\      /// Performs the given action for each element of the Iterable until all elements
\      /// have been processed or the action throws an exception.
\      //void forEach(Consumer<? super E> action)
                                                                                                             \
\      /// Returns the element at the specified position in this list.
      Type* get(int index)                                                                                   \
      {                                                                                                      \
         return elements[index];                                                                             \
      }                                                                                                      \
      Type* operator[](int index)                                                                            \
      {                                                                                                      \
         return get(index);                                                                                  \
      }                                                                                                      \
                                                                                                             \
\      /// Replaces the element at the specified position in this list with the specified element.
      void set(int index, Type *element)                                                                     \
      {                                                                                                      \
         if (use_delete) {                                                                                   \
            delete(get(index));                                                                              \
         }                                                                                                   \
         elements[index] = element;                                                                          \
      }                                                                                                      \
                                                                                                             \
\      /// Returns true if this list contains no elements.
      bool isEmpty()                                                                                         \
      {                                                                                                      \
         return ArraySize(elements) == 0;                                                                    \
      }                                                                                                      \
                                                                                                             \
\      /// Removes the element at the specified position in this list.
      void remove(int index)                                                                                 \
      {                                                                                                      \
         int count = ArraySize(elements);                                                                    \
         if (index < 0) {                                                                                    \
            return;                                                                                          \
         }                                                                                                   \
         if (use_delete) {                                                                                   \
            delete(get(index));                                                                              \
         }                                                                                                   \
         if (index < count-1) {                                                                              \
            ArrayCopy(elements, elements, index, index+1);                                                   \
         }                                                                                                   \
         ArrayResize(elements, count-1, reserve);                                                            \
      }                                                                                                      \
                                                                                                             \
\      /// Returns the number of elements in this list.
      int size()                                                                                             \
      {                                                                                                      \
         return ArraySize(elements);                                                                         \
      }                                                                                                      \
                                                                                                             \
      int subList(Type *&dst_array[], int dst_start = 0, int src_start = 0, int count = WHOLE_ARRAY)         \
      {                                                                                                      \
         return ArrayCopy(dst_array, elements, dst_start, src_start, count);                                 \
      }                                                                                                      \
                                                                                                             \
\      /// Returns an array containing all of the elements in this list in proper sequence
\      /// (from first to last element).
      void toArray(Type *&dst_array[])                                                                       \
      {                                                                                                      \
         ArrayCopy(dst_array, elements);                                                                     \
      }                                                                                                      \
   };