System.DynamicArray.Create

• Up to 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)

Properties

Type	Visibility	Source	Unit	Parent
constructor	public	sysdyn.h	System	DynamicArray

Description

Creates and initializes a System.DynamicArray object.

When called with no parameters, the constructor creates an empty dynamic array. Otherwise, it copies another System.DynamicArray.