System.DynamicArray.Create

• Aller au parent : DynamicArray

C++

DynamicArray<T>::DynamicArray() : Data(0)
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1) : Data(0)
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2) : Data(0)
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3) : Data(0)
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4) : Data(0)
{
  set_length(5);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5) : Data(0)
{
  set_length(6);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6) : Data(0)
{
  set_length(7);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7) : Data(0)
{
  set_length(8);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8) : Data(0)
{
  set_length(9);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9) : Data(0)
{
  set_length(10);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10) : Data(0)
{
  set_length(11);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11) : Data(0)
{
  set_length(12);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12) : Data(0)
{
  set_length(13);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13) : Data(0)
{
  set_length(14);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14) : Data(0)
{
  set_length(15);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15) : Data(0)
{
  set_length(16);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16) : Data(0)
{
  set_length(17);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17) : Data(0)
{
  set_length(18);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17, const T &t18) : Data(0)
{
  set_length(19);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17; Data[18] = t18;
}
#endif /* defined(SYSDYN_HAS_CXX11) */
template <class T>
template <size_t SIZE>
DynamicArray<T>::DynamicArray(T(&array)[SIZE]) : Data(0)
{
  set_length(SIZE);
  for (size_t i = 0; i < SIZE; i++)
    Data[i] = array[i];
}
template <class T>
DynamicArray<T>::~DynamicArray()
{
#ifdef __clang__
  if (_init_inst) {
    static DynamicArray<T> __force_inst1, __force_inst2 = __force_inst1;
  }
#endif
  DecRefCount();
  Data = 0;
}
template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& src) : Data(src.Data)
{
  IncRefCount();
}
template <class T> DynamicArray<T>&
DynamicArray<T>::operator =(const DynamicArray<T>& src)
{
  if (&src != this)
  {
    DecRefCount();
    Data = src.Data;
    IncRefCount();
  }
  return *this;
}
template <class T> T&
DynamicArray<T>::operator[](DynArrInt index)
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> const T&
DynamicArray<T>::operator[](DynArrInt index) const
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> bool
DynamicArray<T>::operator == (const DynamicArray<T> &other) const
{
  return Data == other.Data;
}
template <class T> DynamicArray<T>
DynamicArray<T>::Copy() const
{
  DynamicArray<T> cpy;
  Copy(cpy);
  return cpy;
}
template <class T> void
DynamicArray<T>::Copy(DynamicArray<T>& dst) const
{
  DynArrInt l = (*this).Length;
  if (dst.Length != l)
    dst.Length = l;
  for (DynArrInt i=0; i<l; i++)
    dst[i] = (*this)[i];
}
template <class T> DynamicArray<T>
DynamicArray<T>::CopyRange(DynArrInt startIndex, DynArrInt count) const
{
  DynamicArray<T> cpy;
  CopyRange(cpy, startIndex, count);
  return cpy;
}
template <class T> void
DynamicArray<T>::CopyRange(DynamicArray<T>& dst, DynArrInt startIndex,
                                                 DynArrInt count) const
{
  if (dst.Length != count)
    dst.Length = count;
  for (DynArrInt i=0; i<count; i++)
    dst[i] = (*this)[startIndex+i];
}
template <class T> DynArrInt
DynamicArray<T>::get_high() const
{
  return get_length()-1;
}
template <class T> DynArrInt
DynamicArray<T>::get_low() const
{
  return 0;
}
template <class T> DynArrInt
DynamicArray<T>::get_length() const
{
  return Data ? GetRec().Length : 0;
}
template <class T> void
DynamicArray<T>::set_length(DynArrInt l)
{
  T* p = AllocData(l);
  if (p)
  {
    DynArrInt copyLen = (*this).Length;
    if (l < copyLen)
      copyLen = l;
    while (copyLen-- > 0)
      p[copyLen] = (*this)[copyLen];
  }
  SetData(p);
}
template <class T> int
DynamicArray<T>::get_refCount() const
{
  return Data ? GetRec().RefCnt : 0;
}
template <class T> void
DynamicArray<T>::IncRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
  typedef void (__fastcall *_DynArrayAddRef_Proc)(void*);
  (reinterpret_cast<_DynArrayAddRef_Proc>(_System__DynArrayAddRef))(Data);
#else
    _DynArrayAddRef(Data);
#endif
  }
}
template <class T> void
DynamicArray<T>::DecRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
    typedef int (__fastcall *_DynArrayRelease_Proc)(void*);
    if ((reinterpret_cast<_DynArrayRelease_Proc>(_System__DynArrayRelease))(Data) == 0)
      FreeData();
#else
    if (_DynArrayRelease(Data) == 0)
      FreeData();
#endif
  }
}
template <class T> T*
DynamicArray<T>::AllocData(DynArrInt count)
{
  if (count == 0)
    return 0;
  char *pc = (char*)System::GetMemory(NativeInt(sizeof(T)*count + sizeof(TDynArrayRec)));
  reinterpret_cast<TDynArrayRec*>(pc)->RefCnt = 1;
  reinterpret_cast<TDynArrayRec*>(pc)->Length = count;
  pc += sizeof(TDynArrayRec);
  T *pt = reinterpret_cast<T*>(pc);
  T *p  = reinterpret_cast<T*>(pc);
  while (count-- > 0)
  {
    new  (pc) T;
    pc = reinterpret_cast<char*>(++p);
  }
  return pt;
}
template <class T> void
DynamicArray<T>::SetData(T* t)
{
  if (Data != t)
  {
    DecRefCount();
    Data = t;
  }
}
template <class T> void
DynamicArray<T>::FreeData()
{
  if (Data)
  {
    T*  p = Data;
    DynArrInt l = (*this).Length;
    for (; l-- > 0; p++) {
      if (p)    /* Not necessary but shuts off compiler warning */
        p->~T();
    }
    char* pc = reinterpret_cast<char*>(Data);
    pc -= sizeof(TDynArrayRec);
    System::FreeMemory(pc);
    Data = 0;
  }
}
#if defined(SYSDYN_HAS_CXX11)
template <class T> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t)
{
  Data[index] = t;
}
template <class T> template <class... Types> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t, Types && ...values)
{
  Data[index] = t;
  PushBackElement(index + 1, std::forward<Types>(values)...);
}
#endif /* defined(SYSDYN_HAS_CXX11) */
#if defined(GENERIC_ARRAY_NAMES)
typedef DynamicArray<int>             ArrayOfint;
typedef DynamicArray<AnsiString>      ArrayOfstring;
typedef DynamicArray<WideString>      ArrayOfwidestring;
typedef DynamicArray<Byte>            ArrayOfbyte;
typedef DynamicArray<short>           ArrayOfshort;
typedef DynamicArray<long>            ArrayOflong;
typedef DynamicArray<bool>            ArrayOfboolean;
typedef DynamicArray<double>          ArrayOfdouble;
#endif
typedef DynamicArray<Integer>         TIntegerDynArray;
typedef DynamicArray<Cardinal>        TCardinalDynArray;
typedef DynamicArray<Word>            TWordDynArray;
typedef DynamicArray<Smallint>        TSmallIntDynArray;
typedef DynamicArray<Byte>            TByteDynArray;
typedef DynamicArray<Int8>            TInt8DynArray;
typedef DynamicArray<Int8>            TShortIntDynArray _DEPRECATED_ATTRIBUTE0;
typedef DynamicArray<__int64>         TInt64DynArray;
typedef DynamicArray<unsigned>        TLongWordDynArray;
typedef DynamicArray<Single>          TSingleDynArray;
typedef DynamicArray<Double>          TDoubleDynArray;
typedef DynamicArray<Boolean>         TBooleanDynArray;
typedef DynamicArray<String>          TStringDynArray;
typedef DynamicArray<WideString>      TWideStringDynArray;
template <typename T>
class sPointer {
  T* ptr;
public:
  sPointer()     : ptr(0) {}
  sPointer(T* p) : ptr(p) {}
 ~sPointer()              { delete ptr; }
  T* operator& ()         { return ptr; }
  T* operator->()         { return ptr; }
private:
  sPointer(const sPointer<T>&);
  const sPointer<T>& operator=(const sPointer<T>&);
};
} // namespace System
#if defined(SYSDYN_HAS_CXX11)
# undef SYSDYN_HAS_CXX11
#endif /* defined(SYSDYN_HAS_CXX11) */
#endif
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5) : Data(0)
{
  set_length(6);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6) : Data(0)
{
  set_length(7);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7) : Data(0)
{
  set_length(8);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8) : Data(0)
{
  set_length(9);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9) : Data(0)
{
  set_length(10);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10) : Data(0)
{
  set_length(11);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11) : Data(0)
{
  set_length(12);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12) : Data(0)
{
  set_length(13);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13) : Data(0)
{
  set_length(14);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14) : Data(0)
{
  set_length(15);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15) : Data(0)
{
  set_length(16);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16) : Data(0)
{
  set_length(17);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17) : Data(0)
{
  set_length(18);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17, const T &t18) : Data(0)
{
  set_length(19);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17; Data[18] = t18;
}
#endif /* defined(SYSDYN_HAS_CXX11) */
template <class T>
template <size_t SIZE>
DynamicArray<T>::DynamicArray(T(&array)[SIZE]) : Data(0)
{
  set_length(SIZE);
  for (size_t i = 0; i < SIZE; i++)
    Data[i] = array[i];
}
template <class T>
DynamicArray<T>::~DynamicArray()
{
#ifdef __clang__
  if (_init_inst) {
    static DynamicArray<T> __force_inst1, __force_inst2 = __force_inst1;
  }
#endif
  DecRefCount();
  Data = 0;
}
template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& src) : Data(src.Data)
{
  IncRefCount();
}
template <class T> DynamicArray<T>&
DynamicArray<T>::operator =(const DynamicArray<T>& src)
{
  if (&src != this)
  {
    DecRefCount();
    Data = src.Data;
    IncRefCount();
  }
  return *this;
}
template <class T> T&
DynamicArray<T>::operator[](DynArrInt index)
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> const T&
DynamicArray<T>::operator[](DynArrInt index) const
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> bool
DynamicArray<T>::operator == (const DynamicArray<T> &other) const
{
  return Data == other.Data;
}
template <class T> DynamicArray<T>
DynamicArray<T>::Copy() const
{
  DynamicArray<T> cpy;
  Copy(cpy);
  return cpy;
}
template <class T> void
DynamicArray<T>::Copy(DynamicArray<T>& dst) const
{
  DynArrInt l = (*this).Length;
  if (dst.Length != l)
    dst.Length = l;
  for (DynArrInt i=0; i<l; i++)
    dst[i] = (*this)[i];
}
template <class T> DynamicArray<T>
DynamicArray<T>::CopyRange(DynArrInt startIndex, DynArrInt count) const
{
  DynamicArray<T> cpy;
  CopyRange(cpy, startIndex, count);
  return cpy;
}
template <class T> void
DynamicArray<T>::CopyRange(DynamicArray<T>& dst, DynArrInt startIndex,
                                                 DynArrInt count) const
{
  if (dst.Length != count)
    dst.Length = count;
  for (DynArrInt i=0; i<count; i++)
    dst[i] = (*this)[startIndex+i];
}
template <class T> DynArrInt
DynamicArray<T>::get_high() const
{
  return get_length()-1;
}
template <class T> DynArrInt
DynamicArray<T>::get_low() const
{
  return 0;
}
template <class T> DynArrInt
DynamicArray<T>::get_length() const
{
  return Data ? GetRec().Length : 0;
}
template <class T> void
DynamicArray<T>::set_length(DynArrInt l)
{
  T* p = AllocData(l);
  if (p)
  {
    DynArrInt copyLen = (*this).Length;
    if (l < copyLen)
      copyLen = l;
    while (copyLen-- > 0)
      p[copyLen] = (*this)[copyLen];
  }
  SetData(p);
}
template <class T> int
DynamicArray<T>::get_refCount() const
{
  return Data ? GetRec().RefCnt : 0;
}
template <class T> void
DynamicArray<T>::IncRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
  typedef void (__fastcall *_DynArrayAddRef_Proc)(void*);
  (reinterpret_cast<_DynArrayAddRef_Proc>(_System__DynArrayAddRef))(Data);
#else
    _DynArrayAddRef(Data);
#endif
  }
}
template <class T> void
DynamicArray<T>::DecRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
    typedef int (__fastcall *_DynArrayRelease_Proc)(void*);
    if ((reinterpret_cast<_DynArrayRelease_Proc>(_System__DynArrayRelease))(Data) == 0)
      FreeData();
#else
    if (_DynArrayRelease(Data) == 0)
      FreeData();
#endif
  }
}
template <class T> T*
DynamicArray<T>::AllocData(DynArrInt count)
{
  if (count == 0)
    return 0;
  char *pc = (char*)System::GetMemory(NativeInt(sizeof(T)*count + sizeof(TDynArrayRec)));
  reinterpret_cast<TDynArrayRec*>(pc)->RefCnt = 1;
  reinterpret_cast<TDynArrayRec*>(pc)->Length = count;
  pc += sizeof(TDynArrayRec);
  T *pt = reinterpret_cast<T*>(pc);
  T *p  = reinterpret_cast<T*>(pc);
  while (count-- > 0)
  {
    new  (pc) T;
    pc = reinterpret_cast<char*>(++p);
  }
  return pt;
}
template <class T> void
DynamicArray<T>::SetData(T* t)
{
  if (Data != t)
  {
    DecRefCount();
    Data = t;
  }
}
template <class T> void
DynamicArray<T>::FreeData()
{
  if (Data)
  {
    T*  p = Data;
    DynArrInt l = (*this).Length;
    for (; l-- > 0; p++) {
      if (p)    /* Not necessary but shuts off compiler warning */
        p->~T();
    }
    char* pc = reinterpret_cast<char*>(Data);
    pc -= sizeof(TDynArrayRec);
    System::FreeMemory(pc);
    Data = 0;
  }
}
#if defined(SYSDYN_HAS_CXX11)
template <class T> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t)
{
  Data[index] = t;
}
template <class T> template <class... Types> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t, Types && ...values)
{
  Data[index] = t;
  PushBackElement(index + 1, std::forward<Types>(values)...);
}
#endif /* defined(SYSDYN_HAS_CXX11) */
#if defined(GENERIC_ARRAY_NAMES)
typedef DynamicArray<int>             ArrayOfint;
typedef DynamicArray<AnsiString>      ArrayOfstring;
typedef DynamicArray<WideString>      ArrayOfwidestring;
typedef DynamicArray<Byte>            ArrayOfbyte;
typedef DynamicArray<short>           ArrayOfshort;
typedef DynamicArray<long>            ArrayOflong;
typedef DynamicArray<bool>            ArrayOfboolean;
typedef DynamicArray<double>          ArrayOfdouble;
#endif
typedef DynamicArray<Integer>         TIntegerDynArray;
typedef DynamicArray<Cardinal>        TCardinalDynArray;
typedef DynamicArray<Word>            TWordDynArray;
typedef DynamicArray<Smallint>        TSmallIntDynArray;
typedef DynamicArray<Byte>            TByteDynArray;
typedef DynamicArray<Int8>            TInt8DynArray;
typedef DynamicArray<Int8>            TShortIntDynArray _DEPRECATED_ATTRIBUTE0;
typedef DynamicArray<__int64>         TInt64DynArray;
typedef DynamicArray<unsigned>        TLongWordDynArray;
typedef DynamicArray<Single>          TSingleDynArray;
typedef DynamicArray<Double>          TDoubleDynArray;
typedef DynamicArray<Boolean>         TBooleanDynArray;
typedef DynamicArray<String>          TStringDynArray;
typedef DynamicArray<WideString>      TWideStringDynArray;
template <typename T>
class sPointer {
  T* ptr;
public:
  sPointer()     : ptr(0) {}
  sPointer(T* p) : ptr(p) {}
 ~sPointer()              { delete ptr; }
  T* operator& ()         { return ptr; }
  T* operator->()         { return ptr; }
private:
  sPointer(const sPointer<T>&);
  const sPointer<T>& operator=(const sPointer<T>&);
};
} // namespace System
#if defined(SYSDYN_HAS_CXX11)
# undef SYSDYN_HAS_CXX11
#endif /* defined(SYSDYN_HAS_CXX11) */
#endif
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6) : Data(0)
{
  set_length(7);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7) : Data(0)
{
  set_length(8);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8) : Data(0)
{
  set_length(9);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9) : Data(0)
{
  set_length(10);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10) : Data(0)
{
  set_length(11);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11) : Data(0)
{
  set_length(12);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12) : Data(0)
{
  set_length(13);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13) : Data(0)
{
  set_length(14);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14) : Data(0)
{
  set_length(15);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15) : Data(0)
{
  set_length(16);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16) : Data(0)
{
  set_length(17);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17) : Data(0)
{
  set_length(18);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17, const T &t18) : Data(0)
{
  set_length(19);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17; Data[18] = t18;
}
#endif /* defined(SYSDYN_HAS_CXX11) */
template <class T>
template <size_t SIZE>
DynamicArray<T>::DynamicArray(T(&array)[SIZE]) : Data(0)
{
  set_length(SIZE);
  for (size_t i = 0; i < SIZE; i++)
    Data[i] = array[i];
}
template <class T>
DynamicArray<T>::~DynamicArray()
{
#ifdef __clang__
  if (_init_inst) {
    static DynamicArray<T> __force_inst1, __force_inst2 = __force_inst1;
  }
#endif
  DecRefCount();
  Data = 0;
}
template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& src) : Data(src.Data)
{
  IncRefCount();
}
template <class T> DynamicArray<T>&
DynamicArray<T>::operator =(const DynamicArray<T>& src)
{
  if (&src != this)
  {
    DecRefCount();
    Data = src.Data;
    IncRefCount();
  }
  return *this;
}
template <class T> T&
DynamicArray<T>::operator[](DynArrInt index)
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> const T&
DynamicArray<T>::operator[](DynArrInt index) const
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> bool
DynamicArray<T>::operator == (const DynamicArray<T> &other) const
{
  return Data == other.Data;
}
template <class T> DynamicArray<T>
DynamicArray<T>::Copy() const
{
  DynamicArray<T> cpy;
  Copy(cpy);
  return cpy;
}
template <class T> void
DynamicArray<T>::Copy(DynamicArray<T>& dst) const
{
  DynArrInt l = (*this).Length;
  if (dst.Length != l)
    dst.Length = l;
  for (DynArrInt i=0; i<l; i++)
    dst[i] = (*this)[i];
}
template <class T> DynamicArray<T>
DynamicArray<T>::CopyRange(DynArrInt startIndex, DynArrInt count) const
{
  DynamicArray<T> cpy;
  CopyRange(cpy, startIndex, count);
  return cpy;
}
template <class T> void
DynamicArray<T>::CopyRange(DynamicArray<T>& dst, DynArrInt startIndex,
                                                 DynArrInt count) const
{
  if (dst.Length != count)
    dst.Length = count;
  for (DynArrInt i=0; i<count; i++)
    dst[i] = (*this)[startIndex+i];
}
template <class T> DynArrInt
DynamicArray<T>::get_high() const
{
  return get_length()-1;
}
template <class T> DynArrInt
DynamicArray<T>::get_low() const
{
  return 0;
}
template <class T> DynArrInt
DynamicArray<T>::get_length() const
{
  return Data ? GetRec().Length : 0;
}
template <class T> void
DynamicArray<T>::set_length(DynArrInt l)
{
  T* p = AllocData(l);
  if (p)
  {
    DynArrInt copyLen = (*this).Length;
    if (l < copyLen)
      copyLen = l;
    while (copyLen-- > 0)
      p[copyLen] = (*this)[copyLen];
  }
  SetData(p);
}
template <class T> int
DynamicArray<T>::get_refCount() const
{
  return Data ? GetRec().RefCnt : 0;
}
template <class T> void
DynamicArray<T>::IncRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
  typedef void (__fastcall *_DynArrayAddRef_Proc)(void*);
  (reinterpret_cast<_DynArrayAddRef_Proc>(_System__DynArrayAddRef))(Data);
#else
    _DynArrayAddRef(Data);
#endif
  }
}
template <class T> void
DynamicArray<T>::DecRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
    typedef int (__fastcall *_DynArrayRelease_Proc)(void*);
    if ((reinterpret_cast<_DynArrayRelease_Proc>(_System__DynArrayRelease))(Data) == 0)
      FreeData();
#else
    if (_DynArrayRelease(Data) == 0)
      FreeData();
#endif
  }
}
template <class T> T*
DynamicArray<T>::AllocData(DynArrInt count)
{
  if (count == 0)
    return 0;
  char *pc = (char*)System::GetMemory(NativeInt(sizeof(T)*count + sizeof(TDynArrayRec)));
  reinterpret_cast<TDynArrayRec*>(pc)->RefCnt = 1;
  reinterpret_cast<TDynArrayRec*>(pc)->Length = count;
  pc += sizeof(TDynArrayRec);
  T *pt = reinterpret_cast<T*>(pc);
  T *p  = reinterpret_cast<T*>(pc);
  while (count-- > 0)
  {
    new  (pc) T;
    pc = reinterpret_cast<char*>(++p);
  }
  return pt;
}
template <class T> void
DynamicArray<T>::SetData(T* t)
{
  if (Data != t)
  {
    DecRefCount();
    Data = t;
  }
}
template <class T> void
DynamicArray<T>::FreeData()
{
  if (Data)
  {
    T*  p = Data;
    DynArrInt l = (*this).Length;
    for (; l-- > 0; p++) {
      if (p)    /* Not necessary but shuts off compiler warning */
        p->~T();
    }
    char* pc = reinterpret_cast<char*>(Data);
    pc -= sizeof(TDynArrayRec);
    System::FreeMemory(pc);
    Data = 0;
  }
}
#if defined(SYSDYN_HAS_CXX11)
template <class T> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t)
{
  Data[index] = t;
}
template <class T> template <class... Types> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t, Types && ...values)
{
  Data[index] = t;
  PushBackElement(index + 1, std::forward<Types>(values)...);
}
#endif /* defined(SYSDYN_HAS_CXX11) */
#if defined(GENERIC_ARRAY_NAMES)
typedef DynamicArray<int>             ArrayOfint;
typedef DynamicArray<AnsiString>      ArrayOfstring;
typedef DynamicArray<WideString>      ArrayOfwidestring;
typedef DynamicArray<Byte>            ArrayOfbyte;
typedef DynamicArray<short>           ArrayOfshort;
typedef DynamicArray<long>            ArrayOflong;
typedef DynamicArray<bool>            ArrayOfboolean;
typedef DynamicArray<double>          ArrayOfdouble;
#endif
typedef DynamicArray<Integer>         TIntegerDynArray;
typedef DynamicArray<Cardinal>        TCardinalDynArray;
typedef DynamicArray<Word>            TWordDynArray;
typedef DynamicArray<Smallint>        TSmallIntDynArray;
typedef DynamicArray<Byte>            TByteDynArray;
typedef DynamicArray<Int8>            TInt8DynArray;
typedef DynamicArray<Int8>            TShortIntDynArray _DEPRECATED_ATTRIBUTE0;
typedef DynamicArray<__int64>         TInt64DynArray;
typedef DynamicArray<unsigned>        TLongWordDynArray;
typedef DynamicArray<Single>          TSingleDynArray;
typedef DynamicArray<Double>          TDoubleDynArray;
typedef DynamicArray<Boolean>         TBooleanDynArray;
typedef DynamicArray<String>          TStringDynArray;
typedef DynamicArray<WideString>      TWideStringDynArray;
template <typename T>
class sPointer {
  T* ptr;
public:
  sPointer()     : ptr(0) {}
  sPointer(T* p) : ptr(p) {}
 ~sPointer()              { delete ptr; }
  T* operator& ()         { return ptr; }
  T* operator->()         { return ptr; }
private:
  sPointer(const sPointer<T>&);
  const sPointer<T>& operator=(const sPointer<T>&);
};
} // namespace System
#if defined(SYSDYN_HAS_CXX11)
# undef SYSDYN_HAS_CXX11
#endif /* defined(SYSDYN_HAS_CXX11) */
#endif
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7) : Data(0)
{
  set_length(8);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8) : Data(0)
{
  set_length(9);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9) : Data(0)
{
  set_length(10);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10) : Data(0)
{
  set_length(11);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11) : Data(0)
{
  set_length(12);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12) : Data(0)
{
  set_length(13);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13) : Data(0)
{
  set_length(14);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14) : Data(0)
{
  set_length(15);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15) : Data(0)
{
  set_length(16);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16) : Data(0)
{
  set_length(17);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17) : Data(0)
{
  set_length(18);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17, const T &t18) : Data(0)
{
  set_length(19);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17; Data[18] = t18;
}
#endif /* defined(SYSDYN_HAS_CXX11) */
template <class T>
template <size_t SIZE>
DynamicArray<T>::DynamicArray(T(&array)[SIZE]) : Data(0)
{
  set_length(SIZE);
  for (size_t i = 0; i < SIZE; i++)
    Data[i] = array[i];
}
template <class T>
DynamicArray<T>::~DynamicArray()
{
#ifdef __clang__
  if (_init_inst) {
    static DynamicArray<T> __force_inst1, __force_inst2 = __force_inst1;
  }
#endif
  DecRefCount();
  Data = 0;
}
template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& src) : Data(src.Data)
{
  IncRefCount();
}
template <class T> DynamicArray<T>&
DynamicArray<T>::operator =(const DynamicArray<T>& src)
{
  if (&src != this)
  {
    DecRefCount();
    Data = src.Data;
    IncRefCount();
  }
  return *this;
}
template <class T> T&
DynamicArray<T>::operator[](DynArrInt index)
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> const T&
DynamicArray<T>::operator[](DynArrInt index) const
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> bool
DynamicArray<T>::operator == (const DynamicArray<T> &other) const
{
  return Data == other.Data;
}
template <class T> DynamicArray<T>
DynamicArray<T>::Copy() const
{
  DynamicArray<T> cpy;
  Copy(cpy);
  return cpy;
}
template <class T> void
DynamicArray<T>::Copy(DynamicArray<T>& dst) const
{
  DynArrInt l = (*this).Length;
  if (dst.Length != l)
    dst.Length = l;
  for (DynArrInt i=0; i<l; i++)
    dst[i] = (*this)[i];
}
template <class T> DynamicArray<T>
DynamicArray<T>::CopyRange(DynArrInt startIndex, DynArrInt count) const
{
  DynamicArray<T> cpy;
  CopyRange(cpy, startIndex, count);
  return cpy;
}
template <class T> void
DynamicArray<T>::CopyRange(DynamicArray<T>& dst, DynArrInt startIndex,
                                                 DynArrInt count) const
{
  if (dst.Length != count)
    dst.Length = count;
  for (DynArrInt i=0; i<count; i++)
    dst[i] = (*this)[startIndex+i];
}
template <class T> DynArrInt
DynamicArray<T>::get_high() const
{
  return get_length()-1;
}
template <class T> DynArrInt
DynamicArray<T>::get_low() const
{
  return 0;
}
template <class T> DynArrInt
DynamicArray<T>::get_length() const
{
  return Data ? GetRec().Length : 0;
}
template <class T> void
DynamicArray<T>::set_length(DynArrInt l)
{
  T* p = AllocData(l);
  if (p)
  {
    DynArrInt copyLen = (*this).Length;
    if (l < copyLen)
      copyLen = l;
    while (copyLen-- > 0)
      p[copyLen] = (*this)[copyLen];
  }
  SetData(p);
}
template <class T> int
DynamicArray<T>::get_refCount() const
{
  return Data ? GetRec().RefCnt : 0;
}
template <class T> void
DynamicArray<T>::IncRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
  typedef void (__fastcall *_DynArrayAddRef_Proc)(void*);
  (reinterpret_cast<_DynArrayAddRef_Proc>(_System__DynArrayAddRef))(Data);
#else
    _DynArrayAddRef(Data);
#endif
  }
}
template <class T> void
DynamicArray<T>::DecRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
    typedef int (__fastcall *_DynArrayRelease_Proc)(void*);
    if ((reinterpret_cast<_DynArrayRelease_Proc>(_System__DynArrayRelease))(Data) == 0)
      FreeData();
#else
    if (_DynArrayRelease(Data) == 0)
      FreeData();
#endif
  }
}
template <class T> T*
DynamicArray<T>::AllocData(DynArrInt count)
{
  if (count == 0)
    return 0;
  char *pc = (char*)System::GetMemory(NativeInt(sizeof(T)*count + sizeof(TDynArrayRec)));
  reinterpret_cast<TDynArrayRec*>(pc)->RefCnt = 1;
  reinterpret_cast<TDynArrayRec*>(pc)->Length = count;
  pc += sizeof(TDynArrayRec);
  T *pt = reinterpret_cast<T*>(pc);
  T *p  = reinterpret_cast<T*>(pc);
  while (count-- > 0)
  {
    new  (pc) T;
    pc = reinterpret_cast<char*>(++p);
  }
  return pt;
}
template <class T> void
DynamicArray<T>::SetData(T* t)
{
  if (Data != t)
  {
    DecRefCount();
    Data = t;
  }
}
template <class T> void
DynamicArray<T>::FreeData()
{
  if (Data)
  {
    T*  p = Data;
    DynArrInt l = (*this).Length;
    for (; l-- > 0; p++) {
      if (p)    /* Not necessary but shuts off compiler warning */
        p->~T();
    }
    char* pc = reinterpret_cast<char*>(Data);
    pc -= sizeof(TDynArrayRec);
    System::FreeMemory(pc);
    Data = 0;
  }
}
#if defined(SYSDYN_HAS_CXX11)
template <class T> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t)
{
  Data[index] = t;
}
template <class T> template <class... Types> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t, Types && ...values)
{
  Data[index] = t;
  PushBackElement(index + 1, std::forward<Types>(values)...);
}
#endif /* defined(SYSDYN_HAS_CXX11) */
#if defined(GENERIC_ARRAY_NAMES)
typedef DynamicArray<int>             ArrayOfint;
typedef DynamicArray<AnsiString>      ArrayOfstring;
typedef DynamicArray<WideString>      ArrayOfwidestring;
typedef DynamicArray<Byte>            ArrayOfbyte;
typedef DynamicArray<short>           ArrayOfshort;
typedef DynamicArray<long>            ArrayOflong;
typedef DynamicArray<bool>            ArrayOfboolean;
typedef DynamicArray<double>          ArrayOfdouble;
#endif
typedef DynamicArray<Integer>         TIntegerDynArray;
typedef DynamicArray<Cardinal>        TCardinalDynArray;
typedef DynamicArray<Word>            TWordDynArray;
typedef DynamicArray<Smallint>        TSmallIntDynArray;
typedef DynamicArray<Byte>            TByteDynArray;
typedef DynamicArray<Int8>            TInt8DynArray;
typedef DynamicArray<Int8>            TShortIntDynArray _DEPRECATED_ATTRIBUTE0;
typedef DynamicArray<__int64>         TInt64DynArray;
typedef DynamicArray<unsigned>        TLongWordDynArray;
typedef DynamicArray<Single>          TSingleDynArray;
typedef DynamicArray<Double>          TDoubleDynArray;
typedef DynamicArray<Boolean>         TBooleanDynArray;
typedef DynamicArray<String>          TStringDynArray;
typedef DynamicArray<WideString>      TWideStringDynArray;
template <typename T>
class sPointer {
  T* ptr;
public:
  sPointer()     : ptr(0) {}
  sPointer(T* p) : ptr(p) {}
 ~sPointer()              { delete ptr; }
  T* operator& ()         { return ptr; }
  T* operator->()         { return ptr; }
private:
  sPointer(const sPointer<T>&);
  const sPointer<T>& operator=(const sPointer<T>&);
};
} // namespace System
#if defined(SYSDYN_HAS_CXX11)
# undef SYSDYN_HAS_CXX11
#endif /* defined(SYSDYN_HAS_CXX11) */
#endif
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8) : Data(0)
{
  set_length(9);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9) : Data(0)
{
  set_length(10);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10) : Data(0)
{
  set_length(11);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11) : Data(0)
{
  set_length(12);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12) : Data(0)
{
  set_length(13);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13) : Data(0)
{
  set_length(14);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14) : Data(0)
{
  set_length(15);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15) : Data(0)
{
  set_length(16);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16) : Data(0)
{
  set_length(17);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17) : Data(0)
{
  set_length(18);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17, const T &t18) : Data(0)
{
  set_length(19);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17; Data[18] = t18;
}
#endif /* defined(SYSDYN_HAS_CXX11) */
template <class T>
template <size_t SIZE>
DynamicArray<T>::DynamicArray(T(&array)[SIZE]) : Data(0)
{
  set_length(SIZE);
  for (size_t i = 0; i < SIZE; i++)
    Data[i] = array[i];
}
template <class T>
DynamicArray<T>::~DynamicArray()
{
#ifdef __clang__
  if (_init_inst) {
    static DynamicArray<T> __force_inst1, __force_inst2 = __force_inst1;
  }
#endif
  DecRefCount();
  Data = 0;
}
template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& src) : Data(src.Data)
{
  IncRefCount();
}
template <class T> DynamicArray<T>&
DynamicArray<T>::operator =(const DynamicArray<T>& src)
{
  if (&src != this)
  {
    DecRefCount();
    Data = src.Data;
    IncRefCount();
  }
  return *this;
}
template <class T> T&
DynamicArray<T>::operator[](DynArrInt index)
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> const T&
DynamicArray<T>::operator[](DynArrInt index) const
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> bool
DynamicArray<T>::operator == (const DynamicArray<T> &other) const
{
  return Data == other.Data;
}
template <class T> DynamicArray<T>
DynamicArray<T>::Copy() const
{
  DynamicArray<T> cpy;
  Copy(cpy);
  return cpy;
}
template <class T> void
DynamicArray<T>::Copy(DynamicArray<T>& dst) const
{
  DynArrInt l = (*this).Length;
  if (dst.Length != l)
    dst.Length = l;
  for (DynArrInt i=0; i<l; i++)
    dst[i] = (*this)[i];
}
template <class T> DynamicArray<T>
DynamicArray<T>::CopyRange(DynArrInt startIndex, DynArrInt count) const
{
  DynamicArray<T> cpy;
  CopyRange(cpy, startIndex, count);
  return cpy;
}
template <class T> void
DynamicArray<T>::CopyRange(DynamicArray<T>& dst, DynArrInt startIndex,
                                                 DynArrInt count) const
{
  if (dst.Length != count)
    dst.Length = count;
  for (DynArrInt i=0; i<count; i++)
    dst[i] = (*this)[startIndex+i];
}
template <class T> DynArrInt
DynamicArray<T>::get_high() const
{
  return get_length()-1;
}
template <class T> DynArrInt
DynamicArray<T>::get_low() const
{
  return 0;
}
template <class T> DynArrInt
DynamicArray<T>::get_length() const
{
  return Data ? GetRec().Length : 0;
}
template <class T> void
DynamicArray<T>::set_length(DynArrInt l)
{
  T* p = AllocData(l);
  if (p)
  {
    DynArrInt copyLen = (*this).Length;
    if (l < copyLen)
      copyLen = l;
    while (copyLen-- > 0)
      p[copyLen] = (*this)[copyLen];
  }
  SetData(p);
}
template <class T> int
DynamicArray<T>::get_refCount() const
{
  return Data ? GetRec().RefCnt : 0;
}
template <class T> void
DynamicArray<T>::IncRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
  typedef void (__fastcall *_DynArrayAddRef_Proc)(void*);
  (reinterpret_cast<_DynArrayAddRef_Proc>(_System__DynArrayAddRef))(Data);
#else
    _DynArrayAddRef(Data);
#endif
  }
}
template <class T> void
DynamicArray<T>::DecRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
    typedef int (__fastcall *_DynArrayRelease_Proc)(void*);
    if ((reinterpret_cast<_DynArrayRelease_Proc>(_System__DynArrayRelease))(Data) == 0)
      FreeData();
#else
    if (_DynArrayRelease(Data) == 0)
      FreeData();
#endif
  }
}
template <class T> T*
DynamicArray<T>::AllocData(DynArrInt count)
{
  if (count == 0)
    return 0;
  char *pc = (char*)System::GetMemory(NativeInt(sizeof(T)*count + sizeof(TDynArrayRec)));
  reinterpret_cast<TDynArrayRec*>(pc)->RefCnt = 1;
  reinterpret_cast<TDynArrayRec*>(pc)->Length = count;
  pc += sizeof(TDynArrayRec);
  T *pt = reinterpret_cast<T*>(pc);
  T *p  = reinterpret_cast<T*>(pc);
  while (count-- > 0)
  {
    new  (pc) T;
    pc = reinterpret_cast<char*>(++p);
  }
  return pt;
}
template <class T> void
DynamicArray<T>::SetData(T* t)
{
  if (Data != t)
  {
    DecRefCount();
    Data = t;
  }
}
template <class T> void
DynamicArray<T>::FreeData()
{
  if (Data)
  {
    T*  p = Data;
    DynArrInt l = (*this).Length;
    for (; l-- > 0; p++) {
      if (p)    /* Not necessary but shuts off compiler warning */
        p->~T();
    }
    char* pc = reinterpret_cast<char*>(Data);
    pc -= sizeof(TDynArrayRec);
    System::FreeMemory(pc);
    Data = 0;
  }
}
#if defined(SYSDYN_HAS_CXX11)
template <class T> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t)
{
  Data[index] = t;
}
template <class T> template <class... Types> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t, Types && ...values)
{
  Data[index] = t;
  PushBackElement(index + 1, std::forward<Types>(values)...);
}
#endif /* defined(SYSDYN_HAS_CXX11) */
#if defined(GENERIC_ARRAY_NAMES)
typedef DynamicArray<int>             ArrayOfint;
typedef DynamicArray<AnsiString>      ArrayOfstring;
typedef DynamicArray<WideString>      ArrayOfwidestring;
typedef DynamicArray<Byte>            ArrayOfbyte;
typedef DynamicArray<short>           ArrayOfshort;
typedef DynamicArray<long>            ArrayOflong;
typedef DynamicArray<bool>            ArrayOfboolean;
typedef DynamicArray<double>          ArrayOfdouble;
#endif
typedef DynamicArray<Integer>         TIntegerDynArray;
typedef DynamicArray<Cardinal>        TCardinalDynArray;
typedef DynamicArray<Word>            TWordDynArray;
typedef DynamicArray<Smallint>        TSmallIntDynArray;
typedef DynamicArray<Byte>            TByteDynArray;
typedef DynamicArray<Int8>            TInt8DynArray;
typedef DynamicArray<Int8>            TShortIntDynArray _DEPRECATED_ATTRIBUTE0;
typedef DynamicArray<__int64>         TInt64DynArray;
typedef DynamicArray<unsigned>        TLongWordDynArray;
typedef DynamicArray<Single>          TSingleDynArray;
typedef DynamicArray<Double>          TDoubleDynArray;
typedef DynamicArray<Boolean>         TBooleanDynArray;
typedef DynamicArray<String>          TStringDynArray;
typedef DynamicArray<WideString>      TWideStringDynArray;
template <typename T>
class sPointer {
  T* ptr;
public:
  sPointer()     : ptr(0) {}
  sPointer(T* p) : ptr(p) {}
 ~sPointer()              { delete ptr; }
  T* operator& ()         { return ptr; }
  T* operator->()         { return ptr; }
private:
  sPointer(const sPointer<T>&);
  const sPointer<T>& operator=(const sPointer<T>&);
};
} // namespace System
#if defined(SYSDYN_HAS_CXX11)
# undef SYSDYN_HAS_CXX11
#endif /* defined(SYSDYN_HAS_CXX11) */
#endif
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9) : Data(0)
{
  set_length(10);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10) : Data(0)
{
  set_length(11);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11) : Data(0)
{
  set_length(12);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12) : Data(0)
{
  set_length(13);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13) : Data(0)
{
  set_length(14);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14) : Data(0)
{
  set_length(15);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15) : Data(0)
{
  set_length(16);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16) : Data(0)
{
  set_length(17);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17) : Data(0)
{
  set_length(18);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17, const T &t18) : Data(0)
{
  set_length(19);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17; Data[18] = t18;
}
#endif /* defined(SYSDYN_HAS_CXX11) */
template <class T>
template <size_t SIZE>
DynamicArray<T>::DynamicArray(T(&array)[SIZE]) : Data(0)
{
  set_length(SIZE);
  for (size_t i = 0; i < SIZE; i++)
    Data[i] = array[i];
}
template <class T>
DynamicArray<T>::~DynamicArray()
{
#ifdef __clang__
  if (_init_inst) {
    static DynamicArray<T> __force_inst1, __force_inst2 = __force_inst1;
  }
#endif
  DecRefCount();
  Data = 0;
}
template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& src) : Data(src.Data)
{
  IncRefCount();
}
template <class T> DynamicArray<T>&
DynamicArray<T>::operator =(const DynamicArray<T>& src)
{
  if (&src != this)
  {
    DecRefCount();
    Data = src.Data;
    IncRefCount();
  }
  return *this;
}
template <class T> T&
DynamicArray<T>::operator[](DynArrInt index)
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> const T&
DynamicArray<T>::operator[](DynArrInt index) const
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> bool
DynamicArray<T>::operator == (const DynamicArray<T> &other) const
{
  return Data == other.Data;
}
template <class T> DynamicArray<T>
DynamicArray<T>::Copy() const
{
  DynamicArray<T> cpy;
  Copy(cpy);
  return cpy;
}
template <class T> void
DynamicArray<T>::Copy(DynamicArray<T>& dst) const
{
  DynArrInt l = (*this).Length;
  if (dst.Length != l)
    dst.Length = l;
  for (DynArrInt i=0; i<l; i++)
    dst[i] = (*this)[i];
}
template <class T> DynamicArray<T>
DynamicArray<T>::CopyRange(DynArrInt startIndex, DynArrInt count) const
{
  DynamicArray<T> cpy;
  CopyRange(cpy, startIndex, count);
  return cpy;
}
template <class T> void
DynamicArray<T>::CopyRange(DynamicArray<T>& dst, DynArrInt startIndex,
                                                 DynArrInt count) const
{
  if (dst.Length != count)
    dst.Length = count;
  for (DynArrInt i=0; i<count; i++)
    dst[i] = (*this)[startIndex+i];
}
template <class T> DynArrInt
DynamicArray<T>::get_high() const
{
  return get_length()-1;
}
template <class T> DynArrInt
DynamicArray<T>::get_low() const
{
  return 0;
}
template <class T> DynArrInt
DynamicArray<T>::get_length() const
{
  return Data ? GetRec().Length : 0;
}
template <class T> void
DynamicArray<T>::set_length(DynArrInt l)
{
  T* p = AllocData(l);
  if (p)
  {
    DynArrInt copyLen = (*this).Length;
    if (l < copyLen)
      copyLen = l;
    while (copyLen-- > 0)
      p[copyLen] = (*this)[copyLen];
  }
  SetData(p);
}
template <class T> int
DynamicArray<T>::get_refCount() const
{
  return Data ? GetRec().RefCnt : 0;
}
template <class T> void
DynamicArray<T>::IncRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
  typedef void (__fastcall *_DynArrayAddRef_Proc)(void*);
  (reinterpret_cast<_DynArrayAddRef_Proc>(_System__DynArrayAddRef))(Data);
#else
    _DynArrayAddRef(Data);
#endif
  }
}
template <class T> void
DynamicArray<T>::DecRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
    typedef int (__fastcall *_DynArrayRelease_Proc)(void*);
    if ((reinterpret_cast<_DynArrayRelease_Proc>(_System__DynArrayRelease))(Data) == 0)
      FreeData();
#else
    if (_DynArrayRelease(Data) == 0)
      FreeData();
#endif
  }
}
template <class T> T*
DynamicArray<T>::AllocData(DynArrInt count)
{
  if (count == 0)
    return 0;
  char *pc = (char*)System::GetMemory(NativeInt(sizeof(T)*count + sizeof(TDynArrayRec)));
  reinterpret_cast<TDynArrayRec*>(pc)->RefCnt = 1;
  reinterpret_cast<TDynArrayRec*>(pc)->Length = count;
  pc += sizeof(TDynArrayRec);
  T *pt = reinterpret_cast<T*>(pc);
  T *p  = reinterpret_cast<T*>(pc);
  while (count-- > 0)
  {
    new  (pc) T;
    pc = reinterpret_cast<char*>(++p);
  }
  return pt;
}
template <class T> void
DynamicArray<T>::SetData(T* t)
{
  if (Data != t)
  {
    DecRefCount();
    Data = t;
  }
}
template <class T> void
DynamicArray<T>::FreeData()
{
  if (Data)
  {
    T*  p = Data;
    DynArrInt l = (*this).Length;
    for (; l-- > 0; p++) {
      if (p)    /* Not necessary but shuts off compiler warning */
        p->~T();
    }
    char* pc = reinterpret_cast<char*>(Data);
    pc -= sizeof(TDynArrayRec);
    System::FreeMemory(pc);
    Data = 0;
  }
}
#if defined(SYSDYN_HAS_CXX11)
template <class T> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t)
{
  Data[index] = t;
}
template <class T> template <class... Types> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t, Types && ...values)
{
  Data[index] = t;
  PushBackElement(index + 1, std::forward<Types>(values)...);
}
#endif /* defined(SYSDYN_HAS_CXX11) */
#if defined(GENERIC_ARRAY_NAMES)
typedef DynamicArray<int>             ArrayOfint;
typedef DynamicArray<AnsiString>      ArrayOfstring;
typedef DynamicArray<WideString>      ArrayOfwidestring;
typedef DynamicArray<Byte>            ArrayOfbyte;
typedef DynamicArray<short>           ArrayOfshort;
typedef DynamicArray<long>            ArrayOflong;
typedef DynamicArray<bool>            ArrayOfboolean;
typedef DynamicArray<double>          ArrayOfdouble;
#endif
typedef DynamicArray<Integer>         TIntegerDynArray;
typedef DynamicArray<Cardinal>        TCardinalDynArray;
typedef DynamicArray<Word>            TWordDynArray;
typedef DynamicArray<Smallint>        TSmallIntDynArray;
typedef DynamicArray<Byte>            TByteDynArray;
typedef DynamicArray<Int8>            TInt8DynArray;
typedef DynamicArray<Int8>            TShortIntDynArray _DEPRECATED_ATTRIBUTE0;
typedef DynamicArray<__int64>         TInt64DynArray;
typedef DynamicArray<unsigned>        TLongWordDynArray;
typedef DynamicArray<Single>          TSingleDynArray;
typedef DynamicArray<Double>          TDoubleDynArray;
typedef DynamicArray<Boolean>         TBooleanDynArray;
typedef DynamicArray<String>          TStringDynArray;
typedef DynamicArray<WideString>      TWideStringDynArray;
template <typename T>
class sPointer {
  T* ptr;
public:
  sPointer()     : ptr(0) {}
  sPointer(T* p) : ptr(p) {}
 ~sPointer()              { delete ptr; }
  T* operator& ()         { return ptr; }
  T* operator->()         { return ptr; }
private:
  sPointer(const sPointer<T>&);
  const sPointer<T>& operator=(const sPointer<T>&);
};
} // namespace System
#if defined(SYSDYN_HAS_CXX11)
# undef SYSDYN_HAS_CXX11
#endif /* defined(SYSDYN_HAS_CXX11) */
#endif
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10) : Data(0)
{
  set_length(11);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11) : Data(0)
{
  set_length(12);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12) : Data(0)
{
  set_length(13);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13) : Data(0)
{
  set_length(14);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14) : Data(0)
{
  set_length(15);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15) : Data(0)
{
  set_length(16);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16) : Data(0)
{
  set_length(17);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17) : Data(0)
{
  set_length(18);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17, const T &t18) : Data(0)
{
  set_length(19);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17; Data[18] = t18;
}
#endif /* defined(SYSDYN_HAS_CXX11) */
template <class T>
template <size_t SIZE>
DynamicArray<T>::DynamicArray(T(&array)[SIZE]) : Data(0)
{
  set_length(SIZE);
  for (size_t i = 0; i < SIZE; i++)
    Data[i] = array[i];
}
template <class T>
DynamicArray<T>::~DynamicArray()
{
#ifdef __clang__
  if (_init_inst) {
    static DynamicArray<T> __force_inst1, __force_inst2 = __force_inst1;
  }
#endif
  DecRefCount();
  Data = 0;
}
template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& src) : Data(src.Data)
{
  IncRefCount();
}
template <class T> DynamicArray<T>&
DynamicArray<T>::operator =(const DynamicArray<T>& src)
{
  if (&src != this)
  {
    DecRefCount();
    Data = src.Data;
    IncRefCount();
  }
  return *this;
}
template <class T> T&
DynamicArray<T>::operator[](DynArrInt index)
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> const T&
DynamicArray<T>::operator[](DynArrInt index) const
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> bool
DynamicArray<T>::operator == (const DynamicArray<T> &other) const
{
  return Data == other.Data;
}
template <class T> DynamicArray<T>
DynamicArray<T>::Copy() const
{
  DynamicArray<T> cpy;
  Copy(cpy);
  return cpy;
}
template <class T> void
DynamicArray<T>::Copy(DynamicArray<T>& dst) const
{
  DynArrInt l = (*this).Length;
  if (dst.Length != l)
    dst.Length = l;
  for (DynArrInt i=0; i<l; i++)
    dst[i] = (*this)[i];
}
template <class T> DynamicArray<T>
DynamicArray<T>::CopyRange(DynArrInt startIndex, DynArrInt count) const
{
  DynamicArray<T> cpy;
  CopyRange(cpy, startIndex, count);
  return cpy;
}
template <class T> void
DynamicArray<T>::CopyRange(DynamicArray<T>& dst, DynArrInt startIndex,
                                                 DynArrInt count) const
{
  if (dst.Length != count)
    dst.Length = count;
  for (DynArrInt i=0; i<count; i++)
    dst[i] = (*this)[startIndex+i];
}
template <class T> DynArrInt
DynamicArray<T>::get_high() const
{
  return get_length()-1;
}
template <class T> DynArrInt
DynamicArray<T>::get_low() const
{
  return 0;
}
template <class T> DynArrInt
DynamicArray<T>::get_length() const
{
  return Data ? GetRec().Length : 0;
}
template <class T> void
DynamicArray<T>::set_length(DynArrInt l)
{
  T* p = AllocData(l);
  if (p)
  {
    DynArrInt copyLen = (*this).Length;
    if (l < copyLen)
      copyLen = l;
    while (copyLen-- > 0)
      p[copyLen] = (*this)[copyLen];
  }
  SetData(p);
}
template <class T> int
DynamicArray<T>::get_refCount() const
{
  return Data ? GetRec().RefCnt : 0;
}
template <class T> void
DynamicArray<T>::IncRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
  typedef void (__fastcall *_DynArrayAddRef_Proc)(void*);
  (reinterpret_cast<_DynArrayAddRef_Proc>(_System__DynArrayAddRef))(Data);
#else
    _DynArrayAddRef(Data);
#endif
  }
}
template <class T> void
DynamicArray<T>::DecRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
    typedef int (__fastcall *_DynArrayRelease_Proc)(void*);
    if ((reinterpret_cast<_DynArrayRelease_Proc>(_System__DynArrayRelease))(Data) == 0)
      FreeData();
#else
    if (_DynArrayRelease(Data) == 0)
      FreeData();
#endif
  }
}
template <class T> T*
DynamicArray<T>::AllocData(DynArrInt count)
{
  if (count == 0)
    return 0;
  char *pc = (char*)System::GetMemory(NativeInt(sizeof(T)*count + sizeof(TDynArrayRec)));
  reinterpret_cast<TDynArrayRec*>(pc)->RefCnt = 1;
  reinterpret_cast<TDynArrayRec*>(pc)->Length = count;
  pc += sizeof(TDynArrayRec);
  T *pt = reinterpret_cast<T*>(pc);
  T *p  = reinterpret_cast<T*>(pc);
  while (count-- > 0)
  {
    new  (pc) T;
    pc = reinterpret_cast<char*>(++p);
  }
  return pt;
}
template <class T> void
DynamicArray<T>::SetData(T* t)
{
  if (Data != t)
  {
    DecRefCount();
    Data = t;
  }
}
template <class T> void
DynamicArray<T>::FreeData()
{
  if (Data)
  {
    T*  p = Data;
    DynArrInt l = (*this).Length;
    for (; l-- > 0; p++) {
      if (p)    /* Not necessary but shuts off compiler warning */
        p->~T();
    }
    char* pc = reinterpret_cast<char*>(Data);
    pc -= sizeof(TDynArrayRec);
    System::FreeMemory(pc);
    Data = 0;
  }
}
#if defined(SYSDYN_HAS_CXX11)
template <class T> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t)
{
  Data[index] = t;
}
template <class T> template <class... Types> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t, Types && ...values)
{
  Data[index] = t;
  PushBackElement(index + 1, std::forward<Types>(values)...);
}
#endif /* defined(SYSDYN_HAS_CXX11) */
#if defined(GENERIC_ARRAY_NAMES)
typedef DynamicArray<int>             ArrayOfint;
typedef DynamicArray<AnsiString>      ArrayOfstring;
typedef DynamicArray<WideString>      ArrayOfwidestring;
typedef DynamicArray<Byte>            ArrayOfbyte;
typedef DynamicArray<short>           ArrayOfshort;
typedef DynamicArray<long>            ArrayOflong;
typedef DynamicArray<bool>            ArrayOfboolean;
typedef DynamicArray<double>          ArrayOfdouble;
#endif
typedef DynamicArray<Integer>         TIntegerDynArray;
typedef DynamicArray<Cardinal>        TCardinalDynArray;
typedef DynamicArray<Word>            TWordDynArray;
typedef DynamicArray<Smallint>        TSmallIntDynArray;
typedef DynamicArray<Byte>            TByteDynArray;
typedef DynamicArray<Int8>            TInt8DynArray;
typedef DynamicArray<Int8>            TShortIntDynArray _DEPRECATED_ATTRIBUTE0;
typedef DynamicArray<__int64>         TInt64DynArray;
typedef DynamicArray<unsigned>        TLongWordDynArray;
typedef DynamicArray<Single>          TSingleDynArray;
typedef DynamicArray<Double>          TDoubleDynArray;
typedef DynamicArray<Boolean>         TBooleanDynArray;
typedef DynamicArray<String>          TStringDynArray;
typedef DynamicArray<WideString>      TWideStringDynArray;
template <typename T>
class sPointer {
  T* ptr;
public:
  sPointer()     : ptr(0) {}
  sPointer(T* p) : ptr(p) {}
 ~sPointer()              { delete ptr; }
  T* operator& ()         { return ptr; }
  T* operator->()         { return ptr; }
private:
  sPointer(const sPointer<T>&);
  const sPointer<T>& operator=(const sPointer<T>&);
};
} // namespace System
#if defined(SYSDYN_HAS_CXX11)
# undef SYSDYN_HAS_CXX11
#endif /* defined(SYSDYN_HAS_CXX11) */
#endif
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11) : Data(0)
{
  set_length(12);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12) : Data(0)
{
  set_length(13);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13) : Data(0)
{
  set_length(14);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14) : Data(0)
{
  set_length(15);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15) : Data(0)
{
  set_length(16);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16) : Data(0)
{
  set_length(17);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17) : Data(0)
{
  set_length(18);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17, const T &t18) : Data(0)
{
  set_length(19);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17; Data[18] = t18;
}
#endif /* defined(SYSDYN_HAS_CXX11) */
template <class T>
template <size_t SIZE>
DynamicArray<T>::DynamicArray(T(&array)[SIZE]) : Data(0)
{
  set_length(SIZE);
  for (size_t i = 0; i < SIZE; i++)
    Data[i] = array[i];
}
template <class T>
DynamicArray<T>::~DynamicArray()
{
#ifdef __clang__
  if (_init_inst) {
    static DynamicArray<T> __force_inst1, __force_inst2 = __force_inst1;
  }
#endif
  DecRefCount();
  Data = 0;
}
template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& src) : Data(src.Data)
{
  IncRefCount();
}
template <class T> DynamicArray<T>&
DynamicArray<T>::operator =(const DynamicArray<T>& src)
{
  if (&src != this)
  {
    DecRefCount();
    Data = src.Data;
    IncRefCount();
  }
  return *this;
}
template <class T> T&
DynamicArray<T>::operator[](DynArrInt index)
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> const T&
DynamicArray<T>::operator[](DynArrInt index) const
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> bool
DynamicArray<T>::operator == (const DynamicArray<T> &other) const
{
  return Data == other.Data;
}
template <class T> DynamicArray<T>
DynamicArray<T>::Copy() const
{
  DynamicArray<T> cpy;
  Copy(cpy);
  return cpy;
}
template <class T> void
DynamicArray<T>::Copy(DynamicArray<T>& dst) const
{
  DynArrInt l = (*this).Length;
  if (dst.Length != l)
    dst.Length = l;
  for (DynArrInt i=0; i<l; i++)
    dst[i] = (*this)[i];
}
template <class T> DynamicArray<T>
DynamicArray<T>::CopyRange(DynArrInt startIndex, DynArrInt count) const
{
  DynamicArray<T> cpy;
  CopyRange(cpy, startIndex, count);
  return cpy;
}
template <class T> void
DynamicArray<T>::CopyRange(DynamicArray<T>& dst, DynArrInt startIndex,
                                                 DynArrInt count) const
{
  if (dst.Length != count)
    dst.Length = count;
  for (DynArrInt i=0; i<count; i++)
    dst[i] = (*this)[startIndex+i];
}
template <class T> DynArrInt
DynamicArray<T>::get_high() const
{
  return get_length()-1;
}
template <class T> DynArrInt
DynamicArray<T>::get_low() const
{
  return 0;
}
template <class T> DynArrInt
DynamicArray<T>::get_length() const
{
  return Data ? GetRec().Length : 0;
}
template <class T> void
DynamicArray<T>::set_length(DynArrInt l)
{
  T* p = AllocData(l);
  if (p)
  {
    DynArrInt copyLen = (*this).Length;
    if (l < copyLen)
      copyLen = l;
    while (copyLen-- > 0)
      p[copyLen] = (*this)[copyLen];
  }
  SetData(p);
}
template <class T> int
DynamicArray<T>::get_refCount() const
{
  return Data ? GetRec().RefCnt : 0;
}
template <class T> void
DynamicArray<T>::IncRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
  typedef void (__fastcall *_DynArrayAddRef_Proc)(void*);
  (reinterpret_cast<_DynArrayAddRef_Proc>(_System__DynArrayAddRef))(Data);
#else
    _DynArrayAddRef(Data);
#endif
  }
}
template <class T> void
DynamicArray<T>::DecRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
    typedef int (__fastcall *_DynArrayRelease_Proc)(void*);
    if ((reinterpret_cast<_DynArrayRelease_Proc>(_System__DynArrayRelease))(Data) == 0)
      FreeData();
#else
    if (_DynArrayRelease(Data) == 0)
      FreeData();
#endif
  }
}
template <class T> T*
DynamicArray<T>::AllocData(DynArrInt count)
{
  if (count == 0)
    return 0;
  char *pc = (char*)System::GetMemory(NativeInt(sizeof(T)*count + sizeof(TDynArrayRec)));
  reinterpret_cast<TDynArrayRec*>(pc)->RefCnt = 1;
  reinterpret_cast<TDynArrayRec*>(pc)->Length = count;
  pc += sizeof(TDynArrayRec);
  T *pt = reinterpret_cast<T*>(pc);
  T *p  = reinterpret_cast<T*>(pc);
  while (count-- > 0)
  {
    new  (pc) T;
    pc = reinterpret_cast<char*>(++p);
  }
  return pt;
}
template <class T> void
DynamicArray<T>::SetData(T* t)
{
  if (Data != t)
  {
    DecRefCount();
    Data = t;
  }
}
template <class T> void
DynamicArray<T>::FreeData()
{
  if (Data)
  {
    T*  p = Data;
    DynArrInt l = (*this).Length;
    for (; l-- > 0; p++) {
      if (p)    /* Not necessary but shuts off compiler warning */
        p->~T();
    }
    char* pc = reinterpret_cast<char*>(Data);
    pc -= sizeof(TDynArrayRec);
    System::FreeMemory(pc);
    Data = 0;
  }
}
#if defined(SYSDYN_HAS_CXX11)
template <class T> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t)
{
  Data[index] = t;
}
template <class T> template <class... Types> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t, Types && ...values)
{
  Data[index] = t;
  PushBackElement(index + 1, std::forward<Types>(values)...);
}
#endif /* defined(SYSDYN_HAS_CXX11) */
#if defined(GENERIC_ARRAY_NAMES)
typedef DynamicArray<int>             ArrayOfint;
typedef DynamicArray<AnsiString>      ArrayOfstring;
typedef DynamicArray<WideString>      ArrayOfwidestring;
typedef DynamicArray<Byte>            ArrayOfbyte;
typedef DynamicArray<short>           ArrayOfshort;
typedef DynamicArray<long>            ArrayOflong;
typedef DynamicArray<bool>            ArrayOfboolean;
typedef DynamicArray<double>          ArrayOfdouble;
#endif
typedef DynamicArray<Integer>         TIntegerDynArray;
typedef DynamicArray<Cardinal>        TCardinalDynArray;
typedef DynamicArray<Word>            TWordDynArray;
typedef DynamicArray<Smallint>        TSmallIntDynArray;
typedef DynamicArray<Byte>            TByteDynArray;
typedef DynamicArray<Int8>            TInt8DynArray;
typedef DynamicArray<Int8>            TShortIntDynArray _DEPRECATED_ATTRIBUTE0;
typedef DynamicArray<__int64>         TInt64DynArray;
typedef DynamicArray<unsigned>        TLongWordDynArray;
typedef DynamicArray<Single>          TSingleDynArray;
typedef DynamicArray<Double>          TDoubleDynArray;
typedef DynamicArray<Boolean>         TBooleanDynArray;
typedef DynamicArray<String>          TStringDynArray;
typedef DynamicArray<WideString>      TWideStringDynArray;
template <typename T>
class sPointer {
  T* ptr;
public:
  sPointer()     : ptr(0) {}
  sPointer(T* p) : ptr(p) {}
 ~sPointer()              { delete ptr; }
  T* operator& ()         { return ptr; }
  T* operator->()         { return ptr; }
private:
  sPointer(const sPointer<T>&);
  const sPointer<T>& operator=(const sPointer<T>&);
};
} // namespace System
#if defined(SYSDYN_HAS_CXX11)
# undef SYSDYN_HAS_CXX11
#endif /* defined(SYSDYN_HAS_CXX11) */
#endif
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12) : Data(0)
{
  set_length(13);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13) : Data(0)
{
  set_length(14);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14) : Data(0)
{
  set_length(15);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15) : Data(0)
{
  set_length(16);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16) : Data(0)
{
  set_length(17);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17) : Data(0)
{
  set_length(18);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17, const T &t18) : Data(0)
{
  set_length(19);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17; Data[18] = t18;
}
#endif /* defined(SYSDYN_HAS_CXX11) */
template <class T>
template <size_t SIZE>
DynamicArray<T>::DynamicArray(T(&array)[SIZE]) : Data(0)
{
  set_length(SIZE);
  for (size_t i = 0; i < SIZE; i++)
    Data[i] = array[i];
}
template <class T>
DynamicArray<T>::~DynamicArray()
{
#ifdef __clang__
  if (_init_inst) {
    static DynamicArray<T> __force_inst1, __force_inst2 = __force_inst1;
  }
#endif
  DecRefCount();
  Data = 0;
}
template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& src) : Data(src.Data)
{
  IncRefCount();
}
template <class T> DynamicArray<T>&
DynamicArray<T>::operator =(const DynamicArray<T>& src)
{
  if (&src != this)
  {
    DecRefCount();
    Data = src.Data;
    IncRefCount();
  }
  return *this;
}
template <class T> T&
DynamicArray<T>::operator[](DynArrInt index)
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> const T&
DynamicArray<T>::operator[](DynArrInt index) const
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> bool
DynamicArray<T>::operator == (const DynamicArray<T> &other) const
{
  return Data == other.Data;
}
template <class T> DynamicArray<T>
DynamicArray<T>::Copy() const
{
  DynamicArray<T> cpy;
  Copy(cpy);
  return cpy;
}
template <class T> void
DynamicArray<T>::Copy(DynamicArray<T>& dst) const
{
  DynArrInt l = (*this).Length;
  if (dst.Length != l)
    dst.Length = l;
  for (DynArrInt i=0; i<l; i++)
    dst[i] = (*this)[i];
}
template <class T> DynamicArray<T>
DynamicArray<T>::CopyRange(DynArrInt startIndex, DynArrInt count) const
{
  DynamicArray<T> cpy;
  CopyRange(cpy, startIndex, count);
  return cpy;
}
template <class T> void
DynamicArray<T>::CopyRange(DynamicArray<T>& dst, DynArrInt startIndex,
                                                 DynArrInt count) const
{
  if (dst.Length != count)
    dst.Length = count;
  for (DynArrInt i=0; i<count; i++)
    dst[i] = (*this)[startIndex+i];
}
template <class T> DynArrInt
DynamicArray<T>::get_high() const
{
  return get_length()-1;
}
template <class T> DynArrInt
DynamicArray<T>::get_low() const
{
  return 0;
}
template <class T> DynArrInt
DynamicArray<T>::get_length() const
{
  return Data ? GetRec().Length : 0;
}
template <class T> void
DynamicArray<T>::set_length(DynArrInt l)
{
  T* p = AllocData(l);
  if (p)
  {
    DynArrInt copyLen = (*this).Length;
    if (l < copyLen)
      copyLen = l;
    while (copyLen-- > 0)
      p[copyLen] = (*this)[copyLen];
  }
  SetData(p);
}
template <class T> int
DynamicArray<T>::get_refCount() const
{
  return Data ? GetRec().RefCnt : 0;
}
template <class T> void
DynamicArray<T>::IncRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
  typedef void (__fastcall *_DynArrayAddRef_Proc)(void*);
  (reinterpret_cast<_DynArrayAddRef_Proc>(_System__DynArrayAddRef))(Data);
#else
    _DynArrayAddRef(Data);
#endif
  }
}
template <class T> void
DynamicArray<T>::DecRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
    typedef int (__fastcall *_DynArrayRelease_Proc)(void*);
    if ((reinterpret_cast<_DynArrayRelease_Proc>(_System__DynArrayRelease))(Data) == 0)
      FreeData();
#else
    if (_DynArrayRelease(Data) == 0)
      FreeData();
#endif
  }
}
template <class T> T*
DynamicArray<T>::AllocData(DynArrInt count)
{
  if (count == 0)
    return 0;
  char *pc = (char*)System::GetMemory(NativeInt(sizeof(T)*count + sizeof(TDynArrayRec)));
  reinterpret_cast<TDynArrayRec*>(pc)->RefCnt = 1;
  reinterpret_cast<TDynArrayRec*>(pc)->Length = count;
  pc += sizeof(TDynArrayRec);
  T *pt = reinterpret_cast<T*>(pc);
  T *p  = reinterpret_cast<T*>(pc);
  while (count-- > 0)
  {
    new  (pc) T;
    pc = reinterpret_cast<char*>(++p);
  }
  return pt;
}
template <class T> void
DynamicArray<T>::SetData(T* t)
{
  if (Data != t)
  {
    DecRefCount();
    Data = t;
  }
}
template <class T> void
DynamicArray<T>::FreeData()
{
  if (Data)
  {
    T*  p = Data;
    DynArrInt l = (*this).Length;
    for (; l-- > 0; p++) {
      if (p)    /* Not necessary but shuts off compiler warning */
        p->~T();
    }
    char* pc = reinterpret_cast<char*>(Data);
    pc -= sizeof(TDynArrayRec);
    System::FreeMemory(pc);
    Data = 0;
  }
}
#if defined(SYSDYN_HAS_CXX11)
template <class T> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t)
{
  Data[index] = t;
}
template <class T> template <class... Types> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t, Types && ...values)
{
  Data[index] = t;
  PushBackElement(index + 1, std::forward<Types>(values)...);
}
#endif /* defined(SYSDYN_HAS_CXX11) */
#if defined(GENERIC_ARRAY_NAMES)
typedef DynamicArray<int>             ArrayOfint;
typedef DynamicArray<AnsiString>      ArrayOfstring;
typedef DynamicArray<WideString>      ArrayOfwidestring;
typedef DynamicArray<Byte>            ArrayOfbyte;
typedef DynamicArray<short>           ArrayOfshort;
typedef DynamicArray<long>            ArrayOflong;
typedef DynamicArray<bool>            ArrayOfboolean;
typedef DynamicArray<double>          ArrayOfdouble;
#endif
typedef DynamicArray<Integer>         TIntegerDynArray;
typedef DynamicArray<Cardinal>        TCardinalDynArray;
typedef DynamicArray<Word>            TWordDynArray;
typedef DynamicArray<Smallint>        TSmallIntDynArray;
typedef DynamicArray<Byte>            TByteDynArray;
typedef DynamicArray<Int8>            TInt8DynArray;
typedef DynamicArray<Int8>            TShortIntDynArray _DEPRECATED_ATTRIBUTE0;
typedef DynamicArray<__int64>         TInt64DynArray;
typedef DynamicArray<unsigned>        TLongWordDynArray;
typedef DynamicArray<Single>          TSingleDynArray;
typedef DynamicArray<Double>          TDoubleDynArray;
typedef DynamicArray<Boolean>         TBooleanDynArray;
typedef DynamicArray<String>          TStringDynArray;
typedef DynamicArray<WideString>      TWideStringDynArray;
template <typename T>
class sPointer {
  T* ptr;
public:
  sPointer()     : ptr(0) {}
  sPointer(T* p) : ptr(p) {}
 ~sPointer()              { delete ptr; }
  T* operator& ()         { return ptr; }
  T* operator->()         { return ptr; }
private:
  sPointer(const sPointer<T>&);
  const sPointer<T>& operator=(const sPointer<T>&);
};
} // namespace System
#if defined(SYSDYN_HAS_CXX11)
# undef SYSDYN_HAS_CXX11
#endif /* defined(SYSDYN_HAS_CXX11) */
#endif
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13) : Data(0)
{
  set_length(14);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14) : Data(0)
{
  set_length(15);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15) : Data(0)
{
  set_length(16);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16) : Data(0)
{
  set_length(17);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17) : Data(0)
{
  set_length(18);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17, const T &t18) : Data(0)
{
  set_length(19);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17; Data[18] = t18;
}
#endif /* defined(SYSDYN_HAS_CXX11) */
template <class T>
template <size_t SIZE>
DynamicArray<T>::DynamicArray(T(&array)[SIZE]) : Data(0)
{
  set_length(SIZE);
  for (size_t i = 0; i < SIZE; i++)
    Data[i] = array[i];
}
template <class T>
DynamicArray<T>::~DynamicArray()
{
#ifdef __clang__
  if (_init_inst) {
    static DynamicArray<T> __force_inst1, __force_inst2 = __force_inst1;
  }
#endif
  DecRefCount();
  Data = 0;
}
template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& src) : Data(src.Data)
{
  IncRefCount();
}
template <class T> DynamicArray<T>&
DynamicArray<T>::operator =(const DynamicArray<T>& src)
{
  if (&src != this)
  {
    DecRefCount();
    Data = src.Data;
    IncRefCount();
  }
  return *this;
}
template <class T> T&
DynamicArray<T>::operator[](DynArrInt index)
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> const T&
DynamicArray<T>::operator[](DynArrInt index) const
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> bool
DynamicArray<T>::operator == (const DynamicArray<T> &other) const
{
  return Data == other.Data;
}
template <class T> DynamicArray<T>
DynamicArray<T>::Copy() const
{
  DynamicArray<T> cpy;
  Copy(cpy);
  return cpy;
}
template <class T> void
DynamicArray<T>::Copy(DynamicArray<T>& dst) const
{
  DynArrInt l = (*this).Length;
  if (dst.Length != l)
    dst.Length = l;
  for (DynArrInt i=0; i<l; i++)
    dst[i] = (*this)[i];
}
template <class T> DynamicArray<T>
DynamicArray<T>::CopyRange(DynArrInt startIndex, DynArrInt count) const
{
  DynamicArray<T> cpy;
  CopyRange(cpy, startIndex, count);
  return cpy;
}
template <class T> void
DynamicArray<T>::CopyRange(DynamicArray<T>& dst, DynArrInt startIndex,
                                                 DynArrInt count) const
{
  if (dst.Length != count)
    dst.Length = count;
  for (DynArrInt i=0; i<count; i++)
    dst[i] = (*this)[startIndex+i];
}
template <class T> DynArrInt
DynamicArray<T>::get_high() const
{
  return get_length()-1;
}
template <class T> DynArrInt
DynamicArray<T>::get_low() const
{
  return 0;
}
template <class T> DynArrInt
DynamicArray<T>::get_length() const
{
  return Data ? GetRec().Length : 0;
}
template <class T> void
DynamicArray<T>::set_length(DynArrInt l)
{
  T* p = AllocData(l);
  if (p)
  {
    DynArrInt copyLen = (*this).Length;
    if (l < copyLen)
      copyLen = l;
    while (copyLen-- > 0)
      p[copyLen] = (*this)[copyLen];
  }
  SetData(p);
}
template <class T> int
DynamicArray<T>::get_refCount() const
{
  return Data ? GetRec().RefCnt : 0;
}
template <class T> void
DynamicArray<T>::IncRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
  typedef void (__fastcall *_DynArrayAddRef_Proc)(void*);
  (reinterpret_cast<_DynArrayAddRef_Proc>(_System__DynArrayAddRef))(Data);
#else
    _DynArrayAddRef(Data);
#endif
  }
}
template <class T> void
DynamicArray<T>::DecRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
    typedef int (__fastcall *_DynArrayRelease_Proc)(void*);
    if ((reinterpret_cast<_DynArrayRelease_Proc>(_System__DynArrayRelease))(Data) == 0)
      FreeData();
#else
    if (_DynArrayRelease(Data) == 0)
      FreeData();
#endif
  }
}
template <class T> T*
DynamicArray<T>::AllocData(DynArrInt count)
{
  if (count == 0)
    return 0;
  char *pc = (char*)System::GetMemory(NativeInt(sizeof(T)*count + sizeof(TDynArrayRec)));
  reinterpret_cast<TDynArrayRec*>(pc)->RefCnt = 1;
  reinterpret_cast<TDynArrayRec*>(pc)->Length = count;
  pc += sizeof(TDynArrayRec);
  T *pt = reinterpret_cast<T*>(pc);
  T *p  = reinterpret_cast<T*>(pc);
  while (count-- > 0)
  {
    new  (pc) T;
    pc = reinterpret_cast<char*>(++p);
  }
  return pt;
}
template <class T> void
DynamicArray<T>::SetData(T* t)
{
  if (Data != t)
  {
    DecRefCount();
    Data = t;
  }
}
template <class T> void
DynamicArray<T>::FreeData()
{
  if (Data)
  {
    T*  p = Data;
    DynArrInt l = (*this).Length;
    for (; l-- > 0; p++) {
      if (p)    /* Not necessary but shuts off compiler warning */
        p->~T();
    }
    char* pc = reinterpret_cast<char*>(Data);
    pc -= sizeof(TDynArrayRec);
    System::FreeMemory(pc);
    Data = 0;
  }
}
#if defined(SYSDYN_HAS_CXX11)
template <class T> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t)
{
  Data[index] = t;
}
template <class T> template <class... Types> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t, Types && ...values)
{
  Data[index] = t;
  PushBackElement(index + 1, std::forward<Types>(values)...);
}
#endif /* defined(SYSDYN_HAS_CXX11) */
#if defined(GENERIC_ARRAY_NAMES)
typedef DynamicArray<int>             ArrayOfint;
typedef DynamicArray<AnsiString>      ArrayOfstring;
typedef DynamicArray<WideString>      ArrayOfwidestring;
typedef DynamicArray<Byte>            ArrayOfbyte;
typedef DynamicArray<short>           ArrayOfshort;
typedef DynamicArray<long>            ArrayOflong;
typedef DynamicArray<bool>            ArrayOfboolean;
typedef DynamicArray<double>          ArrayOfdouble;
#endif
typedef DynamicArray<Integer>         TIntegerDynArray;
typedef DynamicArray<Cardinal>        TCardinalDynArray;
typedef DynamicArray<Word>            TWordDynArray;
typedef DynamicArray<Smallint>        TSmallIntDynArray;
typedef DynamicArray<Byte>            TByteDynArray;
typedef DynamicArray<Int8>            TInt8DynArray;
typedef DynamicArray<Int8>            TShortIntDynArray _DEPRECATED_ATTRIBUTE0;
typedef DynamicArray<__int64>         TInt64DynArray;
typedef DynamicArray<unsigned>        TLongWordDynArray;
typedef DynamicArray<Single>          TSingleDynArray;
typedef DynamicArray<Double>          TDoubleDynArray;
typedef DynamicArray<Boolean>         TBooleanDynArray;
typedef DynamicArray<String>          TStringDynArray;
typedef DynamicArray<WideString>      TWideStringDynArray;
template <typename T>
class sPointer {
  T* ptr;
public:
  sPointer()     : ptr(0) {}
  sPointer(T* p) : ptr(p) {}
 ~sPointer()              { delete ptr; }
  T* operator& ()         { return ptr; }
  T* operator->()         { return ptr; }
private:
  sPointer(const sPointer<T>&);
  const sPointer<T>& operator=(const sPointer<T>&);
};
} // namespace System
#if defined(SYSDYN_HAS_CXX11)
# undef SYSDYN_HAS_CXX11
#endif /* defined(SYSDYN_HAS_CXX11) */
#endif
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14) : Data(0)
{
  set_length(15);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15) : Data(0)
{
  set_length(16);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16) : Data(0)
{
  set_length(17);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17) : Data(0)
{
  set_length(18);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17, const T &t18) : Data(0)
{
  set_length(19);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17; Data[18] = t18;
}
#endif /* defined(SYSDYN_HAS_CXX11) */
template <class T>
template <size_t SIZE>
DynamicArray<T>::DynamicArray(T(&array)[SIZE]) : Data(0)
{
  set_length(SIZE);
  for (size_t i = 0; i < SIZE; i++)
    Data[i] = array[i];
}
template <class T>
DynamicArray<T>::~DynamicArray()
{
#ifdef __clang__
  if (_init_inst) {
    static DynamicArray<T> __force_inst1, __force_inst2 = __force_inst1;
  }
#endif
  DecRefCount();
  Data = 0;
}
template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& src) : Data(src.Data)
{
  IncRefCount();
}
template <class T> DynamicArray<T>&
DynamicArray<T>::operator =(const DynamicArray<T>& src)
{
  if (&src != this)
  {
    DecRefCount();
    Data = src.Data;
    IncRefCount();
  }
  return *this;
}
template <class T> T&
DynamicArray<T>::operator[](DynArrInt index)
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> const T&
DynamicArray<T>::operator[](DynArrInt index) const
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> bool
DynamicArray<T>::operator == (const DynamicArray<T> &other) const
{
  return Data == other.Data;
}
template <class T> DynamicArray<T>
DynamicArray<T>::Copy() const
{
  DynamicArray<T> cpy;
  Copy(cpy);
  return cpy;
}
template <class T> void
DynamicArray<T>::Copy(DynamicArray<T>& dst) const
{
  DynArrInt l = (*this).Length;
  if (dst.Length != l)
    dst.Length = l;
  for (DynArrInt i=0; i<l; i++)
    dst[i] = (*this)[i];
}
template <class T> DynamicArray<T>
DynamicArray<T>::CopyRange(DynArrInt startIndex, DynArrInt count) const
{
  DynamicArray<T> cpy;
  CopyRange(cpy, startIndex, count);
  return cpy;
}
template <class T> void
DynamicArray<T>::CopyRange(DynamicArray<T>& dst, DynArrInt startIndex,
                                                 DynArrInt count) const
{
  if (dst.Length != count)
    dst.Length = count;
  for (DynArrInt i=0; i<count; i++)
    dst[i] = (*this)[startIndex+i];
}
template <class T> DynArrInt
DynamicArray<T>::get_high() const
{
  return get_length()-1;
}
template <class T> DynArrInt
DynamicArray<T>::get_low() const
{
  return 0;
}
template <class T> DynArrInt
DynamicArray<T>::get_length() const
{
  return Data ? GetRec().Length : 0;
}
template <class T> void
DynamicArray<T>::set_length(DynArrInt l)
{
  T* p = AllocData(l);
  if (p)
  {
    DynArrInt copyLen = (*this).Length;
    if (l < copyLen)
      copyLen = l;
    while (copyLen-- > 0)
      p[copyLen] = (*this)[copyLen];
  }
  SetData(p);
}
template <class T> int
DynamicArray<T>::get_refCount() const
{
  return Data ? GetRec().RefCnt : 0;
}
template <class T> void
DynamicArray<T>::IncRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
  typedef void (__fastcall *_DynArrayAddRef_Proc)(void*);
  (reinterpret_cast<_DynArrayAddRef_Proc>(_System__DynArrayAddRef))(Data);
#else
    _DynArrayAddRef(Data);
#endif
  }
}
template <class T> void
DynamicArray<T>::DecRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
    typedef int (__fastcall *_DynArrayRelease_Proc)(void*);
    if ((reinterpret_cast<_DynArrayRelease_Proc>(_System__DynArrayRelease))(Data) == 0)
      FreeData();
#else
    if (_DynArrayRelease(Data) == 0)
      FreeData();
#endif
  }
}
template <class T> T*
DynamicArray<T>::AllocData(DynArrInt count)
{
  if (count == 0)
    return 0;
  char *pc = (char*)System::GetMemory(NativeInt(sizeof(T)*count + sizeof(TDynArrayRec)));
  reinterpret_cast<TDynArrayRec*>(pc)->RefCnt = 1;
  reinterpret_cast<TDynArrayRec*>(pc)->Length = count;
  pc += sizeof(TDynArrayRec);
  T *pt = reinterpret_cast<T*>(pc);
  T *p  = reinterpret_cast<T*>(pc);
  while (count-- > 0)
  {
    new  (pc) T;
    pc = reinterpret_cast<char*>(++p);
  }
  return pt;
}
template <class T> void
DynamicArray<T>::SetData(T* t)
{
  if (Data != t)
  {
    DecRefCount();
    Data = t;
  }
}
template <class T> void
DynamicArray<T>::FreeData()
{
  if (Data)
  {
    T*  p = Data;
    DynArrInt l = (*this).Length;
    for (; l-- > 0; p++) {
      if (p)    /* Not necessary but shuts off compiler warning */
        p->~T();
    }
    char* pc = reinterpret_cast<char*>(Data);
    pc -= sizeof(TDynArrayRec);
    System::FreeMemory(pc);
    Data = 0;
  }
}
#if defined(SYSDYN_HAS_CXX11)
template <class T> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t)
{
  Data[index] = t;
}
template <class T> template <class... Types> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t, Types && ...values)
{
  Data[index] = t;
  PushBackElement(index + 1, std::forward<Types>(values)...);
}
#endif /* defined(SYSDYN_HAS_CXX11) */
#if defined(GENERIC_ARRAY_NAMES)
typedef DynamicArray<int>             ArrayOfint;
typedef DynamicArray<AnsiString>      ArrayOfstring;
typedef DynamicArray<WideString>      ArrayOfwidestring;
typedef DynamicArray<Byte>            ArrayOfbyte;
typedef DynamicArray<short>           ArrayOfshort;
typedef DynamicArray<long>            ArrayOflong;
typedef DynamicArray<bool>            ArrayOfboolean;
typedef DynamicArray<double>          ArrayOfdouble;
#endif
typedef DynamicArray<Integer>         TIntegerDynArray;
typedef DynamicArray<Cardinal>        TCardinalDynArray;
typedef DynamicArray<Word>            TWordDynArray;
typedef DynamicArray<Smallint>        TSmallIntDynArray;
typedef DynamicArray<Byte>            TByteDynArray;
typedef DynamicArray<Int8>            TInt8DynArray;
typedef DynamicArray<Int8>            TShortIntDynArray _DEPRECATED_ATTRIBUTE0;
typedef DynamicArray<__int64>         TInt64DynArray;
typedef DynamicArray<unsigned>        TLongWordDynArray;
typedef DynamicArray<Single>          TSingleDynArray;
typedef DynamicArray<Double>          TDoubleDynArray;
typedef DynamicArray<Boolean>         TBooleanDynArray;
typedef DynamicArray<String>          TStringDynArray;
typedef DynamicArray<WideString>      TWideStringDynArray;
template <typename T>
class sPointer {
  T* ptr;
public:
  sPointer()     : ptr(0) {}
  sPointer(T* p) : ptr(p) {}
 ~sPointer()              { delete ptr; }
  T* operator& ()         { return ptr; }
  T* operator->()         { return ptr; }
private:
  sPointer(const sPointer<T>&);
  const sPointer<T>& operator=(const sPointer<T>&);
};
} // namespace System
#if defined(SYSDYN_HAS_CXX11)
# undef SYSDYN_HAS_CXX11
#endif /* defined(SYSDYN_HAS_CXX11) */
#endif
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15) : Data(0)
{
  set_length(16);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16) : Data(0)
{
  set_length(17);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17) : Data(0)
{
  set_length(18);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17, const T &t18) : Data(0)
{
  set_length(19);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17; Data[18] = t18;
}
#endif /* defined(SYSDYN_HAS_CXX11) */
template <class T>
template <size_t SIZE>
DynamicArray<T>::DynamicArray(T(&array)[SIZE]) : Data(0)
{
  set_length(SIZE);
  for (size_t i = 0; i < SIZE; i++)
    Data[i] = array[i];
}
template <class T>
DynamicArray<T>::~DynamicArray()
{
#ifdef __clang__
  if (_init_inst) {
    static DynamicArray<T> __force_inst1, __force_inst2 = __force_inst1;
  }
#endif
  DecRefCount();
  Data = 0;
}
template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& src) : Data(src.Data)
{
  IncRefCount();
}
template <class T> DynamicArray<T>&
DynamicArray<T>::operator =(const DynamicArray<T>& src)
{
  if (&src != this)
  {
    DecRefCount();
    Data = src.Data;
    IncRefCount();
  }
  return *this;
}
template <class T> T&
DynamicArray<T>::operator[](DynArrInt index)
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> const T&
DynamicArray<T>::operator[](DynArrInt index) const
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> bool
DynamicArray<T>::operator == (const DynamicArray<T> &other) const
{
  return Data == other.Data;
}
template <class T> DynamicArray<T>
DynamicArray<T>::Copy() const
{
  DynamicArray<T> cpy;
  Copy(cpy);
  return cpy;
}
template <class T> void
DynamicArray<T>::Copy(DynamicArray<T>& dst) const
{
  DynArrInt l = (*this).Length;
  if (dst.Length != l)
    dst.Length = l;
  for (DynArrInt i=0; i<l; i++)
    dst[i] = (*this)[i];
}
template <class T> DynamicArray<T>
DynamicArray<T>::CopyRange(DynArrInt startIndex, DynArrInt count) const
{
  DynamicArray<T> cpy;
  CopyRange(cpy, startIndex, count);
  return cpy;
}
template <class T> void
DynamicArray<T>::CopyRange(DynamicArray<T>& dst, DynArrInt startIndex,
                                                 DynArrInt count) const
{
  if (dst.Length != count)
    dst.Length = count;
  for (DynArrInt i=0; i<count; i++)
    dst[i] = (*this)[startIndex+i];
}
template <class T> DynArrInt
DynamicArray<T>::get_high() const
{
  return get_length()-1;
}
template <class T> DynArrInt
DynamicArray<T>::get_low() const
{
  return 0;
}
template <class T> DynArrInt
DynamicArray<T>::get_length() const
{
  return Data ? GetRec().Length : 0;
}
template <class T> void
DynamicArray<T>::set_length(DynArrInt l)
{
  T* p = AllocData(l);
  if (p)
  {
    DynArrInt copyLen = (*this).Length;
    if (l < copyLen)
      copyLen = l;
    while (copyLen-- > 0)
      p[copyLen] = (*this)[copyLen];
  }
  SetData(p);
}
template <class T> int
DynamicArray<T>::get_refCount() const
{
  return Data ? GetRec().RefCnt : 0;
}
template <class T> void
DynamicArray<T>::IncRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
  typedef void (__fastcall *_DynArrayAddRef_Proc)(void*);
  (reinterpret_cast<_DynArrayAddRef_Proc>(_System__DynArrayAddRef))(Data);
#else
    _DynArrayAddRef(Data);
#endif
  }
}
template <class T> void
DynamicArray<T>::DecRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
    typedef int (__fastcall *_DynArrayRelease_Proc)(void*);
    if ((reinterpret_cast<_DynArrayRelease_Proc>(_System__DynArrayRelease))(Data) == 0)
      FreeData();
#else
    if (_DynArrayRelease(Data) == 0)
      FreeData();
#endif
  }
}
template <class T> T*
DynamicArray<T>::AllocData(DynArrInt count)
{
  if (count == 0)
    return 0;
  char *pc = (char*)System::GetMemory(NativeInt(sizeof(T)*count + sizeof(TDynArrayRec)));
  reinterpret_cast<TDynArrayRec*>(pc)->RefCnt = 1;
  reinterpret_cast<TDynArrayRec*>(pc)->Length = count;
  pc += sizeof(TDynArrayRec);
  T *pt = reinterpret_cast<T*>(pc);
  T *p  = reinterpret_cast<T*>(pc);
  while (count-- > 0)
  {
    new  (pc) T;
    pc = reinterpret_cast<char*>(++p);
  }
  return pt;
}
template <class T> void
DynamicArray<T>::SetData(T* t)
{
  if (Data != t)
  {
    DecRefCount();
    Data = t;
  }
}
template <class T> void
DynamicArray<T>::FreeData()
{
  if (Data)
  {
    T*  p = Data;
    DynArrInt l = (*this).Length;
    for (; l-- > 0; p++) {
      if (p)    /* Not necessary but shuts off compiler warning */
        p->~T();
    }
    char* pc = reinterpret_cast<char*>(Data);
    pc -= sizeof(TDynArrayRec);
    System::FreeMemory(pc);
    Data = 0;
  }
}
#if defined(SYSDYN_HAS_CXX11)
template <class T> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t)
{
  Data[index] = t;
}
template <class T> template <class... Types> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t, Types && ...values)
{
  Data[index] = t;
  PushBackElement(index + 1, std::forward<Types>(values)...);
}
#endif /* defined(SYSDYN_HAS_CXX11) */
#if defined(GENERIC_ARRAY_NAMES)
typedef DynamicArray<int>             ArrayOfint;
typedef DynamicArray<AnsiString>      ArrayOfstring;
typedef DynamicArray<WideString>      ArrayOfwidestring;
typedef DynamicArray<Byte>            ArrayOfbyte;
typedef DynamicArray<short>           ArrayOfshort;
typedef DynamicArray<long>            ArrayOflong;
typedef DynamicArray<bool>            ArrayOfboolean;
typedef DynamicArray<double>          ArrayOfdouble;
#endif
typedef DynamicArray<Integer>         TIntegerDynArray;
typedef DynamicArray<Cardinal>        TCardinalDynArray;
typedef DynamicArray<Word>            TWordDynArray;
typedef DynamicArray<Smallint>        TSmallIntDynArray;
typedef DynamicArray<Byte>            TByteDynArray;
typedef DynamicArray<Int8>            TInt8DynArray;
typedef DynamicArray<Int8>            TShortIntDynArray _DEPRECATED_ATTRIBUTE0;
typedef DynamicArray<__int64>         TInt64DynArray;
typedef DynamicArray<unsigned>        TLongWordDynArray;
typedef DynamicArray<Single>          TSingleDynArray;
typedef DynamicArray<Double>          TDoubleDynArray;
typedef DynamicArray<Boolean>         TBooleanDynArray;
typedef DynamicArray<String>          TStringDynArray;
typedef DynamicArray<WideString>      TWideStringDynArray;
template <typename T>
class sPointer {
  T* ptr;
public:
  sPointer()     : ptr(0) {}
  sPointer(T* p) : ptr(p) {}
 ~sPointer()              { delete ptr; }
  T* operator& ()         { return ptr; }
  T* operator->()         { return ptr; }
private:
  sPointer(const sPointer<T>&);
  const sPointer<T>& operator=(const sPointer<T>&);
};
} // namespace System
#if defined(SYSDYN_HAS_CXX11)
# undef SYSDYN_HAS_CXX11
#endif /* defined(SYSDYN_HAS_CXX11) */
#endif
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16) : Data(0)
{
  set_length(17);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17) : Data(0)
{
  set_length(18);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17, const T &t18) : Data(0)
{
  set_length(19);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17; Data[18] = t18;
}
#endif /* defined(SYSDYN_HAS_CXX11) */
template <class T>
template <size_t SIZE>
DynamicArray<T>::DynamicArray(T(&array)[SIZE]) : Data(0)
{
  set_length(SIZE);
  for (size_t i = 0; i < SIZE; i++)
    Data[i] = array[i];
}
template <class T>
DynamicArray<T>::~DynamicArray()
{
#ifdef __clang__
  if (_init_inst) {
    static DynamicArray<T> __force_inst1, __force_inst2 = __force_inst1;
  }
#endif
  DecRefCount();
  Data = 0;
}
template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& src) : Data(src.Data)
{
  IncRefCount();
}
template <class T> DynamicArray<T>&
DynamicArray<T>::operator =(const DynamicArray<T>& src)
{
  if (&src != this)
  {
    DecRefCount();
    Data = src.Data;
    IncRefCount();
  }
  return *this;
}
template <class T> T&
DynamicArray<T>::operator[](DynArrInt index)
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> const T&
DynamicArray<T>::operator[](DynArrInt index) const
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> bool
DynamicArray<T>::operator == (const DynamicArray<T> &other) const
{
  return Data == other.Data;
}
template <class T> DynamicArray<T>
DynamicArray<T>::Copy() const
{
  DynamicArray<T> cpy;
  Copy(cpy);
  return cpy;
}
template <class T> void
DynamicArray<T>::Copy(DynamicArray<T>& dst) const
{
  DynArrInt l = (*this).Length;
  if (dst.Length != l)
    dst.Length = l;
  for (DynArrInt i=0; i<l; i++)
    dst[i] = (*this)[i];
}
template <class T> DynamicArray<T>
DynamicArray<T>::CopyRange(DynArrInt startIndex, DynArrInt count) const
{
  DynamicArray<T> cpy;
  CopyRange(cpy, startIndex, count);
  return cpy;
}
template <class T> void
DynamicArray<T>::CopyRange(DynamicArray<T>& dst, DynArrInt startIndex,
                                                 DynArrInt count) const
{
  if (dst.Length != count)
    dst.Length = count;
  for (DynArrInt i=0; i<count; i++)
    dst[i] = (*this)[startIndex+i];
}
template <class T> DynArrInt
DynamicArray<T>::get_high() const
{
  return get_length()-1;
}
template <class T> DynArrInt
DynamicArray<T>::get_low() const
{
  return 0;
}
template <class T> DynArrInt
DynamicArray<T>::get_length() const
{
  return Data ? GetRec().Length : 0;
}
template <class T> void
DynamicArray<T>::set_length(DynArrInt l)
{
  T* p = AllocData(l);
  if (p)
  {
    DynArrInt copyLen = (*this).Length;
    if (l < copyLen)
      copyLen = l;
    while (copyLen-- > 0)
      p[copyLen] = (*this)[copyLen];
  }
  SetData(p);
}
template <class T> int
DynamicArray<T>::get_refCount() const
{
  return Data ? GetRec().RefCnt : 0;
}
template <class T> void
DynamicArray<T>::IncRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
  typedef void (__fastcall *_DynArrayAddRef_Proc)(void*);
  (reinterpret_cast<_DynArrayAddRef_Proc>(_System__DynArrayAddRef))(Data);
#else
    _DynArrayAddRef(Data);
#endif
  }
}
template <class T> void
DynamicArray<T>::DecRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
    typedef int (__fastcall *_DynArrayRelease_Proc)(void*);
    if ((reinterpret_cast<_DynArrayRelease_Proc>(_System__DynArrayRelease))(Data) == 0)
      FreeData();
#else
    if (_DynArrayRelease(Data) == 0)
      FreeData();
#endif
  }
}
template <class T> T*
DynamicArray<T>::AllocData(DynArrInt count)
{
  if (count == 0)
    return 0;
  char *pc = (char*)System::GetMemory(NativeInt(sizeof(T)*count + sizeof(TDynArrayRec)));
  reinterpret_cast<TDynArrayRec*>(pc)->RefCnt = 1;
  reinterpret_cast<TDynArrayRec*>(pc)->Length = count;
  pc += sizeof(TDynArrayRec);
  T *pt = reinterpret_cast<T*>(pc);
  T *p  = reinterpret_cast<T*>(pc);
  while (count-- > 0)
  {
    new  (pc) T;
    pc = reinterpret_cast<char*>(++p);
  }
  return pt;
}
template <class T> void
DynamicArray<T>::SetData(T* t)
{
  if (Data != t)
  {
    DecRefCount();
    Data = t;
  }
}
template <class T> void
DynamicArray<T>::FreeData()
{
  if (Data)
  {
    T*  p = Data;
    DynArrInt l = (*this).Length;
    for (; l-- > 0; p++) {
      if (p)    /* Not necessary but shuts off compiler warning */
        p->~T();
    }
    char* pc = reinterpret_cast<char*>(Data);
    pc -= sizeof(TDynArrayRec);
    System::FreeMemory(pc);
    Data = 0;
  }
}
#if defined(SYSDYN_HAS_CXX11)
template <class T> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t)
{
  Data[index] = t;
}
template <class T> template <class... Types> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t, Types && ...values)
{
  Data[index] = t;
  PushBackElement(index + 1, std::forward<Types>(values)...);
}
#endif /* defined(SYSDYN_HAS_CXX11) */
#if defined(GENERIC_ARRAY_NAMES)
typedef DynamicArray<int>             ArrayOfint;
typedef DynamicArray<AnsiString>      ArrayOfstring;
typedef DynamicArray<WideString>      ArrayOfwidestring;
typedef DynamicArray<Byte>            ArrayOfbyte;
typedef DynamicArray<short>           ArrayOfshort;
typedef DynamicArray<long>            ArrayOflong;
typedef DynamicArray<bool>            ArrayOfboolean;
typedef DynamicArray<double>          ArrayOfdouble;
#endif
typedef DynamicArray<Integer>         TIntegerDynArray;
typedef DynamicArray<Cardinal>        TCardinalDynArray;
typedef DynamicArray<Word>            TWordDynArray;
typedef DynamicArray<Smallint>        TSmallIntDynArray;
typedef DynamicArray<Byte>            TByteDynArray;
typedef DynamicArray<Int8>            TInt8DynArray;
typedef DynamicArray<Int8>            TShortIntDynArray _DEPRECATED_ATTRIBUTE0;
typedef DynamicArray<__int64>         TInt64DynArray;
typedef DynamicArray<unsigned>        TLongWordDynArray;
typedef DynamicArray<Single>          TSingleDynArray;
typedef DynamicArray<Double>          TDoubleDynArray;
typedef DynamicArray<Boolean>         TBooleanDynArray;
typedef DynamicArray<String>          TStringDynArray;
typedef DynamicArray<WideString>      TWideStringDynArray;
template <typename T>
class sPointer {
  T* ptr;
public:
  sPointer()     : ptr(0) {}
  sPointer(T* p) : ptr(p) {}
 ~sPointer()              { delete ptr; }
  T* operator& ()         { return ptr; }
  T* operator->()         { return ptr; }
private:
  sPointer(const sPointer<T>&);
  const sPointer<T>& operator=(const sPointer<T>&);
};
} // namespace System
#if defined(SYSDYN_HAS_CXX11)
# undef SYSDYN_HAS_CXX11
#endif /* defined(SYSDYN_HAS_CXX11) */
#endif
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17) : Data(0)
{
  set_length(18);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17;
}
template <class T>
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17, const T &t18) : Data(0)
{
  set_length(19);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17; Data[18] = t18;
}
#endif /* defined(SYSDYN_HAS_CXX11) */
template <class T>
template <size_t SIZE>
DynamicArray<T>::DynamicArray(T(&array)[SIZE]) : Data(0)
{
  set_length(SIZE);
  for (size_t i = 0; i < SIZE; i++)
    Data[i] = array[i];
}
template <class T>
DynamicArray<T>::~DynamicArray()
{
#ifdef __clang__
  if (_init_inst) {
    static DynamicArray<T> __force_inst1, __force_inst2 = __force_inst1;
  }
#endif
  DecRefCount();
  Data = 0;
}
template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& src) : Data(src.Data)
{
  IncRefCount();
}
template <class T> DynamicArray<T>&
DynamicArray<T>::operator =(const DynamicArray<T>& src)
{
  if (&src != this)
  {
    DecRefCount();
    Data = src.Data;
    IncRefCount();
  }
  return *this;
}
template <class T> T&
DynamicArray<T>::operator[](DynArrInt index)
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> const T&
DynamicArray<T>::operator[](DynArrInt index) const
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> bool
DynamicArray<T>::operator == (const DynamicArray<T> &other) const
{
  return Data == other.Data;
}
template <class T> DynamicArray<T>
DynamicArray<T>::Copy() const
{
  DynamicArray<T> cpy;
  Copy(cpy);
  return cpy;
}
template <class T> void
DynamicArray<T>::Copy(DynamicArray<T>& dst) const
{
  DynArrInt l = (*this).Length;
  if (dst.Length != l)
    dst.Length = l;
  for (DynArrInt i=0; i<l; i++)
    dst[i] = (*this)[i];
}
template <class T> DynamicArray<T>
DynamicArray<T>::CopyRange(DynArrInt startIndex, DynArrInt count) const
{
  DynamicArray<T> cpy;
  CopyRange(cpy, startIndex, count);
  return cpy;
}
template <class T> void
DynamicArray<T>::CopyRange(DynamicArray<T>& dst, DynArrInt startIndex,
                                                 DynArrInt count) const
{
  if (dst.Length != count)
    dst.Length = count;
  for (DynArrInt i=0; i<count; i++)
    dst[i] = (*this)[startIndex+i];
}
template <class T> DynArrInt
DynamicArray<T>::get_high() const
{
  return get_length()-1;
}
template <class T> DynArrInt
DynamicArray<T>::get_low() const
{
  return 0;
}
template <class T> DynArrInt
DynamicArray<T>::get_length() const
{
  return Data ? GetRec().Length : 0;
}
template <class T> void
DynamicArray<T>::set_length(DynArrInt l)
{
  T* p = AllocData(l);
  if (p)
  {
    DynArrInt copyLen = (*this).Length;
    if (l < copyLen)
      copyLen = l;
    while (copyLen-- > 0)
      p[copyLen] = (*this)[copyLen];
  }
  SetData(p);
}
template <class T> int
DynamicArray<T>::get_refCount() const
{
  return Data ? GetRec().RefCnt : 0;
}
template <class T> void
DynamicArray<T>::IncRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
  typedef void (__fastcall *_DynArrayAddRef_Proc)(void*);
  (reinterpret_cast<_DynArrayAddRef_Proc>(_System__DynArrayAddRef))(Data);
#else
    _DynArrayAddRef(Data);
#endif
  }
}
template <class T> void
DynamicArray<T>::DecRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
    typedef int (__fastcall *_DynArrayRelease_Proc)(void*);
    if ((reinterpret_cast<_DynArrayRelease_Proc>(_System__DynArrayRelease))(Data) == 0)
      FreeData();
#else
    if (_DynArrayRelease(Data) == 0)
      FreeData();
#endif
  }
}
template <class T> T*
DynamicArray<T>::AllocData(DynArrInt count)
{
  if (count == 0)
    return 0;
  char *pc = (char*)System::GetMemory(NativeInt(sizeof(T)*count + sizeof(TDynArrayRec)));
  reinterpret_cast<TDynArrayRec*>(pc)->RefCnt = 1;
  reinterpret_cast<TDynArrayRec*>(pc)->Length = count;
  pc += sizeof(TDynArrayRec);
  T *pt = reinterpret_cast<T*>(pc);
  T *p  = reinterpret_cast<T*>(pc);
  while (count-- > 0)
  {
    new  (pc) T;
    pc = reinterpret_cast<char*>(++p);
  }
  return pt;
}
template <class T> void
DynamicArray<T>::SetData(T* t)
{
  if (Data != t)
  {
    DecRefCount();
    Data = t;
  }
}
template <class T> void
DynamicArray<T>::FreeData()
{
  if (Data)
  {
    T*  p = Data;
    DynArrInt l = (*this).Length;
    for (; l-- > 0; p++) {
      if (p)    /* Not necessary but shuts off compiler warning */
        p->~T();
    }
    char* pc = reinterpret_cast<char*>(Data);
    pc -= sizeof(TDynArrayRec);
    System::FreeMemory(pc);
    Data = 0;
  }
}
#if defined(SYSDYN_HAS_CXX11)
template <class T> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t)
{
  Data[index] = t;
}
template <class T> template <class... Types> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t, Types && ...values)
{
  Data[index] = t;
  PushBackElement(index + 1, std::forward<Types>(values)...);
}
#endif /* defined(SYSDYN_HAS_CXX11) */
#if defined(GENERIC_ARRAY_NAMES)
typedef DynamicArray<int>             ArrayOfint;
typedef DynamicArray<AnsiString>      ArrayOfstring;
typedef DynamicArray<WideString>      ArrayOfwidestring;
typedef DynamicArray<Byte>            ArrayOfbyte;
typedef DynamicArray<short>           ArrayOfshort;
typedef DynamicArray<long>            ArrayOflong;
typedef DynamicArray<bool>            ArrayOfboolean;
typedef DynamicArray<double>          ArrayOfdouble;
#endif
typedef DynamicArray<Integer>         TIntegerDynArray;
typedef DynamicArray<Cardinal>        TCardinalDynArray;
typedef DynamicArray<Word>            TWordDynArray;
typedef DynamicArray<Smallint>        TSmallIntDynArray;
typedef DynamicArray<Byte>            TByteDynArray;
typedef DynamicArray<Int8>            TInt8DynArray;
typedef DynamicArray<Int8>            TShortIntDynArray _DEPRECATED_ATTRIBUTE0;
typedef DynamicArray<__int64>         TInt64DynArray;
typedef DynamicArray<unsigned>        TLongWordDynArray;
typedef DynamicArray<Single>          TSingleDynArray;
typedef DynamicArray<Double>          TDoubleDynArray;
typedef DynamicArray<Boolean>         TBooleanDynArray;
typedef DynamicArray<String>          TStringDynArray;
typedef DynamicArray<WideString>      TWideStringDynArray;
template <typename T>
class sPointer {
  T* ptr;
public:
  sPointer()     : ptr(0) {}
  sPointer(T* p) : ptr(p) {}
 ~sPointer()              { delete ptr; }
  T* operator& ()         { return ptr; }
  T* operator->()         { return ptr; }
private:
  sPointer(const sPointer<T>&);
  const sPointer<T>& operator=(const sPointer<T>&);
};
} // namespace System
#if defined(SYSDYN_HAS_CXX11)
# undef SYSDYN_HAS_CXX11
#endif /* defined(SYSDYN_HAS_CXX11) */
#endif
DynamicArray<T>::DynamicArray(const T &t0,  const T &t1,  const T &t2,  const T &t3,
                              const T &t4,  const T &t5,  const T &t6,  const T &t7,
                              const T &t8,  const T &t9,  const T &t10, const T &t11,
                              const T &t12, const T &t13, const T &t14, const T &t15,
                              const T &t16, const T &t17, const T &t18) : Data(0)
{
  set_length(19);
  Data[0] = t0;   Data[1] = t1;   Data[2] = t2;   Data[3] = t3;
  Data[4] = t4;   Data[5] = t5;   Data[6] = t6;   Data[7] = t7;
  Data[8] = t8;   Data[9] = t9;   Data[10] = t10; Data[11] = t11;
  Data[12] = t12; Data[13] = t13; Data[14] = t14; Data[15] = t15;
  Data[16] = t16; Data[17] = t17; Data[18] = t18;
}
#endif /* defined(SYSDYN_HAS_CXX11) */
template <class T>
template <size_t SIZE>
DynamicArray<T>::DynamicArray(T(&array)[SIZE]) : Data(0)
{
  set_length(SIZE);
  for (size_t i = 0; i < SIZE; i++)
    Data[i] = array[i];
}
template <class T>
DynamicArray<T>::~DynamicArray()
{
#ifdef __clang__
  if (_init_inst) {
    static DynamicArray<T> __force_inst1, __force_inst2 = __force_inst1;
  }
#endif
  DecRefCount();
  Data = 0;
}
template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& src) : Data(src.Data)
{
  IncRefCount();
}
template <class T> DynamicArray<T>&
DynamicArray<T>::operator =(const DynamicArray<T>& src)
{
  if (&src != this)
  {
    DecRefCount();
    Data = src.Data;
    IncRefCount();
  }
  return *this;
}
template <class T> T&
DynamicArray<T>::operator[](DynArrInt index)
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> const T&
DynamicArray<T>::operator[](DynArrInt index) const
{
  if (index < 0 || index >= this->Length)
    throw DynArrayOutOfRange(index, this->Length);
  if (!Data)
    throw DynArrayNullData();
  return *(Data + index);
}
template <class T> bool
DynamicArray<T>::operator == (const DynamicArray<T> &other) const
{
  return Data == other.Data;
}
template <class T> DynamicArray<T>
DynamicArray<T>::Copy() const
{
  DynamicArray<T> cpy;
  Copy(cpy);
  return cpy;
}
template <class T> void
DynamicArray<T>::Copy(DynamicArray<T>& dst) const
{
  DynArrInt l = (*this).Length;
  if (dst.Length != l)
    dst.Length = l;
  for (DynArrInt i=0; i<l; i++)
    dst[i] = (*this)[i];
}
template <class T> DynamicArray<T>
DynamicArray<T>::CopyRange(DynArrInt startIndex, DynArrInt count) const
{
  DynamicArray<T> cpy;
  CopyRange(cpy, startIndex, count);
  return cpy;
}
template <class T> void
DynamicArray<T>::CopyRange(DynamicArray<T>& dst, DynArrInt startIndex,
                                                 DynArrInt count) const
{
  if (dst.Length != count)
    dst.Length = count;
  for (DynArrInt i=0; i<count; i++)
    dst[i] = (*this)[startIndex+i];
}
template <class T> DynArrInt
DynamicArray<T>::get_high() const
{
  return get_length()-1;
}
template <class T> DynArrInt
DynamicArray<T>::get_low() const
{
  return 0;
}
template <class T> DynArrInt
DynamicArray<T>::get_length() const
{
  return Data ? GetRec().Length : 0;
}
template <class T> void
DynamicArray<T>::set_length(DynArrInt l)
{
  T* p = AllocData(l);
  if (p)
  {
    DynArrInt copyLen = (*this).Length;
    if (l < copyLen)
      copyLen = l;
    while (copyLen-- > 0)
      p[copyLen] = (*this)[copyLen];
  }
  SetData(p);
}
template <class T> int
DynamicArray<T>::get_refCount() const
{
  return Data ? GetRec().RefCnt : 0;
}
template <class T> void
DynamicArray<T>::IncRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
  typedef void (__fastcall *_DynArrayAddRef_Proc)(void*);
  (reinterpret_cast<_DynArrayAddRef_Proc>(_System__DynArrayAddRef))(Data);
#else
    _DynArrayAddRef(Data);
#endif
  }
}
template <class T> void
DynamicArray<T>::DecRefCount()
{
  if (Data)
  {
#if !defined(__clang__) || (defined(_WIN32) && !defined(_WIN64))
    typedef int (__fastcall *_DynArrayRelease_Proc)(void*);
    if ((reinterpret_cast<_DynArrayRelease_Proc>(_System__DynArrayRelease))(Data) == 0)
      FreeData();
#else
    if (_DynArrayRelease(Data) == 0)
      FreeData();
#endif
  }
}
template <class T> T*
DynamicArray<T>::AllocData(DynArrInt count)
{
  if (count == 0)
    return 0;
  char *pc = (char*)System::GetMemory(NativeInt(sizeof(T)*count + sizeof(TDynArrayRec)));
  reinterpret_cast<TDynArrayRec*>(pc)->RefCnt = 1;
  reinterpret_cast<TDynArrayRec*>(pc)->Length = count;
  pc += sizeof(TDynArrayRec);
  T *pt = reinterpret_cast<T*>(pc);
  T *p  = reinterpret_cast<T*>(pc);
  while (count-- > 0)
  {
    new  (pc) T;
    pc = reinterpret_cast<char*>(++p);
  }
  return pt;
}
template <class T> void
DynamicArray<T>::SetData(T* t)
{
  if (Data != t)
  {
    DecRefCount();
    Data = t;
  }
}
template <class T> void
DynamicArray<T>::FreeData()
{
  if (Data)
  {
    T*  p = Data;
    DynArrInt l = (*this).Length;
    for (; l-- > 0; p++) {
      if (p)    /* Not necessary but shuts off compiler warning */
        p->~T();
    }
    char* pc = reinterpret_cast<char*>(Data);
    pc -= sizeof(TDynArrayRec);
    System::FreeMemory(pc);
    Data = 0;
  }
}
#if defined(SYSDYN_HAS_CXX11)
template <class T> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t)
{
  Data[index] = t;
}
template <class T> template <class... Types> void
DynamicArray<T>::PushBackElement(DynArrInt index, const T &t, Types && ...values)
{
  Data[index] = t;
  PushBackElement(index + 1, std::forward<Types>(values)...);
}
#endif /* defined(SYSDYN_HAS_CXX11) */
#if defined(GENERIC_ARRAY_NAMES)
typedef DynamicArray<int>             ArrayOfint;
typedef DynamicArray<AnsiString>      ArrayOfstring;
typedef DynamicArray<WideString>      ArrayOfwidestring;
typedef DynamicArray<Byte>            ArrayOfbyte;
typedef DynamicArray<short>           ArrayOfshort;
typedef DynamicArray<long>            ArrayOflong;
typedef DynamicArray<bool>            ArrayOfboolean;
typedef DynamicArray<double>          ArrayOfdouble;
#endif
typedef DynamicArray<Integer>         TIntegerDynArray;
typedef DynamicArray<Cardinal>        TCardinalDynArray;
typedef DynamicArray<Word>            TWordDynArray;
typedef DynamicArray<Smallint>        TSmallIntDynArray;
typedef DynamicArray<Byte>            TByteDynArray;
typedef DynamicArray<Int8>            TInt8DynArray;
typedef DynamicArray<Int8>            TShortIntDynArray _DEPRECATED_ATTRIBUTE0;
typedef DynamicArray<__int64>         TInt64DynArray;
typedef DynamicArray<unsigned>        TLongWordDynArray;
typedef DynamicArray<Single>          TSingleDynArray;
typedef DynamicArray<Double>          TDoubleDynArray;
typedef DynamicArray<Boolean>         TBooleanDynArray;
typedef DynamicArray<String>          TStringDynArray;
typedef DynamicArray<WideString>      TWideStringDynArray;
template <typename T>
class sPointer {
  T* ptr;
public:
  sPointer()     : ptr(0) {}
  sPointer(T* p) : ptr(p) {}
 ~sPointer()              { delete ptr; }
  T* operator& ()         { return ptr; }
  T* operator->()         { return ptr; }
private:
  sPointer(const sPointer<T>&);
  const sPointer<T>& operator=(const sPointer<T>&);
};
} // namespace System
#if defined(SYSDYN_HAS_CXX11)
# undef SYSDYN_HAS_CXX11
#endif /* defined(SYSDYN_HAS_CXX11) */
#endif
DynamicArray<T>::DynamicArray(T(&array)[SIZE]) : Data(0)
DynamicArray<T>::DynamicArray(const DynamicArray<T>& src) : Data(src.Data)

Propriétés

Type	Visibilité	Source	Unité	Parent
constructor	public	sysdyn.h	System	DynamicArray

Description

Crée et initialise un objet System.DynamicArray.

Appelé sans paramètre, le constructeur crée un tableau dynamique vide. Sinon, il copie un autre System.DynamicArray.