TArrayEx<T> = record
  public
    // Доступ к элементам напрямую (unsafe)
    Items      : array of T;
    // Пользовательский Тэг
    Tag        : integer;
    // Признак необходимости освобождать элементы при удалении
    DoFreeData : Boolean;
    FEnumInit  : string;
  private
{$IFDEF ArrayExEnumerator}
    type
      TCollection = class;

      TEnumerator = class(TEnumerator<T>)
      private
        FParent : TCollection;
        FIndex  : Integer;
        function GetCurrent: T;
      protected
        function DoGetCurrent: T; override;
        function DoMoveNext: Boolean; override;
      public
        constructor Create(Parent: TCollection);
        property Current: T read GetCurrent;
        function MoveNext: Boolean;
      end;

      TCollection = class(TEnumerable<T>)
      private
        FParent : pointer;
        function GetCount: Integer;
      protected
        function DoGetEnumerator: TEnumerator<T>; override;
      public
        constructor Create(const ArrayEx: TArrayEx<T>);
        function GetEnumerator: TEnumerator<T>; reintroduce;
        property Count: Integer read GetCount;
      end;
{$ENDIF}

    var
      FIndexMod     : integer;                      // Размер индекса
      FIndexArray   : array of array of integer;    // Элементы индекса
      FComparer     : IEqualityComparer<T>;         // Компаратор
{$IFDEF ArrayExEnumerator}
      FCollection   : TCollection;                  // Коллекция для энуметратора
{$ENDIF}

    function GetItems(Index: integer): T; inline;
    procedure SetItems(Index: integer; const Value: T); inline;
    procedure QuickSortA(const Comparer: IComparer<T>; L, R: Integer);
    procedure QuickSortB(L, R: Integer; CompareEvt: TCompareValue<T>; Less, More: TCompareResult);
    function GetIndexMod: integer; inline;
    procedure SetIndexMod(Value: integer); inline;
    procedure HashClear(NewIndexMod: integer); inline;
    procedure HashAdd(const Value: T; Index: integer); inline;
    function GetHash(const Value: T): integer; inline;
    procedure SetIndex(Index: Integer; const Value: T); inline;
    procedure SetCount(const Value: integer); inline;
    function GetCount: integer; inline;
    function GetHigh: integer; inline;
    procedure SetHigh(const Value: integer); inline;
    function GetLow: integer; inline;
    procedure FreeElement(Num: integer); inline;
  public
    // Конструкторы
    constructor Create(DoFreeData: boolean);

    // Доступ к элементам по умолчанию
    property Elements[Index: integer]: T read GetItems write SetItems; default;

    // Очистка массива
    procedure Clear; overload;

    // Добавление элемента(ов) в конец
    function Add(Value: T): integer; overload; inline;
    function Add(Values: array of T): integer; overload;
    function AddUnique(Value: T): integer;

    // Вставка элемента по индексу
    procedure Insert(Index: integer; Value: T); overload; inline;
    procedure Insert(Index: integer; Values: array of T); overload;

    // Удаление элемента по индексу
    procedure Delete(Index: integer); inline;
    procedure DeleteRange(Index, Count: integer); inline;

    // Создание индекса по массиву
    procedure CreateIndex(IndexMod: integer = -1);
    // Уничтожение индекса по массиву
    procedure DropIndex;

    // Кол-во элементов массива
    property Count: integer read GetCount write SetCount;
    // Индекс нижнего элемента массива
    property Low: integer read GetLow;
    // Индекс верхнего элемента массива
    property High: integer read GetHigh write SetHigh;

    // Поиск значения(ий) в массиве
    function Exists(Value: T): boolean; overload;
    function Exists(Values: array of T; NeedAllValues: boolean = False): boolean; overload;
    // Индекс(ы) значения в массиве
    function IndexOf(Value: T): integer;
    function IndexesOf(Value: T): TArrayEx<integer>;

    // Сортировка
    procedure Sort(Comparer: IComparer<T> = nil); overload;
    procedure Sort(CompareEvt: TCompareValue<T>; Mode: TCompareMode = cmAscending); overload;

    // Сериализатор в строку
    function ToString: string; overload;
    function ToString(Delimeter : string): string; overload;

{$IFDEF ArrayExEnumerator}
    function Collection: TCollection;
{$ENDIF}

    class operator Add(const A,B: TArrayEx<T>): TArrayEx<T>; overload;
    class operator Add(const A: TArrayEx<T>; const B: array of T): TArrayEx<T>; overload;
    class operator Add(const A: array of T; const B: TArrayEx<T>): TArrayEx<T>; overload;
    class operator Implicit(const A: TArrayEx<T>): TArray<T>;
{$IF CompilerVersion>27}
    class operator In(const A,B: TArrayEx<T>): Boolean; overload;
    class operator In(const A: array of T; B: TArrayEx<T>): Boolean; overload;
{$ENDIF}
    class operator Equal(const A,B: TArrayEx<T>): Boolean;
    class operator NotEqual(const A,B: TArrayEx<T>): Boolean;
  end;
  {$ENDREGION}