#ifndef HX_ARRAY_H
#define HX_ARRAY_H
#include <cpp/FastIterator.h>

// --- hx::ReturnNull ------------------------------------------------------
//
// Provides an "Null<Object>" of given type.  For types that can't actually be null, Dynamic is used.

namespace hx
{

enum ArrayStore
{
   arrayNull = 0,
   arrayEmpty,
   arrayFixed,
   arrayBool,
   arrayInt,
   arrayFloat,
   arrayString,
   arrayObject,
   arrayInt64
};

enum ArrayConvertId
{
   aciAlwaysConvert = -4,
   aciVirtualArray = -3,
   aciStringArray  = -2,
   aciObjectArray  = -1,
   aciNotArray     = 0,
   aciPodBase      = 1,
};

template<typename T>
struct ReturnNull { typedef T type; };
template<> struct ReturnNull<int> { typedef Dynamic type; };
template<> struct ReturnNull<double> { typedef Dynamic type; };
template<> struct ReturnNull<float> { typedef Dynamic type; };
template<> struct ReturnNull<bool> { typedef Dynamic type; };
template<> struct ReturnNull<char> { typedef Dynamic type; };
template<> struct ReturnNull<signed char> { typedef Dynamic type; };
template<> struct ReturnNull<unsigned char> { typedef Dynamic type; };
template<> struct ReturnNull<short> { typedef Dynamic type; };
template<> struct ReturnNull<unsigned short> { typedef Dynamic type; };
template<> struct ReturnNull<unsigned int> { typedef Dynamic type; };
template<> struct ReturnNull< ::cpp::Int64> { typedef Dynamic type; };

template<typename T>
struct ArrayTraits { enum { StoreType = arrayObject }; };
template<> struct ArrayTraits<int> { enum { StoreType = arrayInt }; };
template<> struct ArrayTraits<float> { enum { StoreType = arrayFloat}; };
template<> struct ArrayTraits<double> { enum { StoreType = arrayFloat}; };
template<> struct ArrayTraits<Dynamic> { enum { StoreType = arrayObject }; };
template<> struct ArrayTraits<String> { enum { StoreType = arrayString }; };
template<> struct ArrayTraits< ::cpp::Int64> { enum { StoreType = arrayInt64 }; };

}



namespace hx
{



// --- ArrayIterator -------------------------------------------
//
// An object that conforms to the standard iterator interface for arrays
template<typename FROM,typename TO>
class ArrayIterator : public cpp::FastIterator_obj<TO>
{
public:
   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdArrayIterator };

   ArrayIterator(Array<FROM> inArray) : mArray(inArray), mIdx(0) { }

   // Fast versions ...
   bool hasNext()  { return mIdx < mArray->length; }

   inline TO toTo(const Dynamic &inD) { return inD.StaticCast<TO>(); }

   template<typename T>
   inline TO toTo(T inT) { return inT; }

   TO next() { return toTo(mArray->__get(mIdx++)); }

   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER_NAME(mArray,"mArray"); }
   #ifdef HXCPP_VISIT_ALLOCS
   void __Visit(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER_NAME(mArray,"mArray"); }
   #endif

   int      mIdx;
   Array<FROM> mArray;
};

// --- ArrayKeyValueIterator -------------------------------------------
template<typename FROM,typename TO>
class ArrayKeyValueIterator : public cpp::FastIterator_obj<Dynamic>
{
public:
   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdArrayIterator };

   ArrayKeyValueIterator(Array<FROM> inArray) : mArray(inArray), mIdx(0) { }

   bool hasNext()  { return mIdx < mArray->length; }

   inline TO toTo(const Dynamic &inD) { return inD.StaticCast<TO>(); }

   template<typename T>
   inline TO toTo(T inT) { return inT; }


   Dynamic next();

   void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER_NAME(mArray,"mArray"); }
   #ifdef HXCPP_VISIT_ALLOCS
   void __Visit(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER_NAME(mArray,"mArray"); }
   #endif

   int      mIdx;
   Array<FROM> mArray;
};

}

namespace hx
{

// Also used by cpp::VirtualArray
class HXCPP_EXTERN_CLASS_ATTRIBUTES ArrayCommon : public hx::Object
{
   protected:
      int mArrayConvertId;
   public:
      // Plain old data element size - or 0 if not plain-old-data
      int getArrayConvertId() const { return mArrayConvertId; }

      #if (HXCPP_API_LEVEL>330)
      virtual hx::Object *__GetRealObject() { return this; }
      #endif
};

// --- hx::ArrayBase ----------------------------------------------------
//
// Base class that treats array contents as a slab of bytes.
// The derived "Array_obj" adds strong typing to the "[]" operator

class HXCPP_EXTERN_CLASS_ATTRIBUTES ArrayBase : public ArrayCommon
{
public:
   ArrayBase(int inSize,int inReserve,int inElementSize,bool inAtomic);

   // Defined later so we can use "Array"
   static Array<Dynamic> __new(int inSize=0,int inReserve=0);


   static void __boot();

   typedef hx::Object super;

   HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdArrayBase };

   // Used by cpp.ArrayBase
   inline int getElementSize() const { return GetElementSize(); }
   inline int getByteCount() const { return GetElementSize()*length; }
   inline char * getBase() const { return mBase; }


   hx::Val __SetField(const String &inString,const hx::Val &inValue ,hx::PropertyAccess inCallProp) { return null(); }

   static hx::Class __mClass;
   static hx::Class &__SGetClass() { return __mClass; }
   hx::Class __GetClass() const { return __mClass; }
   String toString();
   String __ToString() const;


   #if (HXCPP_API_LEVEL>330)
   int __Compare(const hx::Object *inRHS) const;
   #endif


   void setData(void *inData, int inElements)
   {
      mBase = (char *)inData;
      length = inElements;
      mAlloc = inElements;
      HX_OBJ_WB_PESSIMISTIC_GET(this);
   }

   void setUnmanagedData(void *inData, int inElements)
   {
      mBase = (char *)inData;
      length = inElements;
      mAlloc = -1;
   }


   int __GetType() const { return vtArray; }

   inline size_t size() const { return length; }
   inline int __length() const { return (int)length; }

   virtual String ItemString(int inI)  = 0;

   const char * __CStr() const { return mBase; }
   inline const char *GetBase() const { return mBase; }
   inline char *GetBase() { return mBase; }

   virtual int GetElementSize() const = 0;

   inline void resize(int inSize)
   {
      if (inSize<length)
      {
         int s = GetElementSize();
         memset(mBase + inSize*s, 0, (length-inSize)*s);
         length = inSize;
      }
      else if (inSize>length)
      {
         EnsureSize(inSize);
         length = inSize;
      }
   }
   inline void __SetSize(int inLen) { resize(inLen); }

   void __SetSizeExact(int inLen=0);
   
   Dynamic __unsafe_get(const Dynamic &i);
   Dynamic __unsafe_set(const Dynamic &i, const Dynamic &val);

   void safeSort(Dynamic sorter, bool isString);

   inline void __unsafeStringReference(String inString)
   {
      mBase = (char *)inString.raw_ptr();
      length = inString.length / GetElementSize();
      mAlloc = length;
      HX_OBJ_WB_PESSIMISTIC_GET(this);
   }

   
   virtual hx::ArrayStore getStoreType() const = 0;


   // Dynamic interface
   hx::Val __Field(const String &inString ,hx::PropertyAccess inCallProp);

   #if (HXCPP_API_LEVEL < 330)
   virtual Dynamic __concat(const Dynamic &a0) = 0;
   virtual Dynamic __copy() = 0;
   virtual Dynamic __insert(const Dynamic &a0,const Dynamic &a1) = 0;
   virtual Dynamic __iterator() = 0;
   virtual Dynamic __keyValueIterator() = 0;
   virtual Dynamic __join(const Dynamic &a0) = 0;
   virtual Dynamic __pop() = 0;
   virtual Dynamic __push(const Dynamic &a0) = 0;
   virtual Dynamic __remove(const Dynamic &a0) = 0;
   virtual Dynamic __removeAt(const Dynamic &a0) = 0;
   virtual Dynamic __indexOf(const Dynamic &a0,const Dynamic &a1) = 0;
   virtual Dynamic __lastIndexOf(const Dynamic &a0,const Dynamic &a1) = 0;
   virtual Dynamic __reverse() = 0;
   virtual Dynamic __shift() = 0;
   virtual Dynamic __slice(const Dynamic &a0,const Dynamic &a1) = 0;
   virtual Dynamic __splice(const Dynamic &a0,const Dynamic &a1) =0;
   virtual Dynamic __sort(const Dynamic &a0) = 0;
   virtual Dynamic __toString() = 0;
   virtual Dynamic __unshift(const Dynamic &a0) = 0;
   virtual Dynamic __map(const Dynamic &func) = 0;
   virtual Dynamic __filter(const Dynamic &func) = 0;
   inline Dynamic ____SetSize(const Dynamic &len)  { resize(len); return this; } 
   inline Dynamic ____SetSizeExact(const Dynamic &len)  { __SetSizeExact(len); return this; } 
   inline Dynamic ____unsafe_set(const Dynamic &i, const Dynamic &val)  { return __SetItem(i,val); } 
   inline Dynamic ____unsafe_get(const Dynamic &i)  { return __GetItem(i); } 
   virtual Dynamic __blit(const Dynamic &a0,const Dynamic &a1,const Dynamic &a2,const Dynamic &a3) = 0;
   inline Dynamic __zero(const Dynamic &a0,const Dynamic &a1)  { zero(a0,a1); return null(); }
   virtual Dynamic __memcmp(const Dynamic &a0) = 0;
   virtual void __qsort(Dynamic inCompare) = 0;
   virtual Dynamic __resize(const Dynamic &a0) = 0;

   #else
   inline void ____SetSize(int len)  { resize(len); } 
   inline void ____SetSizeExact(int len)  { __SetSizeExact(len); } 
   inline Dynamic ____unsafe_set(const Dynamic &i, const Dynamic &val)  { return __SetItem(i,val); } 
   inline Dynamic ____unsafe_get(const Dynamic &i)  { return __GetItem(i); } 

   virtual hx::ArrayBase *__concat(const cpp::VirtualArray &a0) = 0;
   virtual hx::ArrayBase *__copy() = 0;
   virtual void __insert(int inIndex,const Dynamic &a1) = 0;
   virtual Dynamic __iterator() = 0;
   virtual Dynamic __keyValueIterator() = 0;
   virtual ::String __join(::String a0) = 0;
   virtual Dynamic __pop() = 0;
   virtual int __push(const Dynamic &a0) = 0;
   virtual bool __contains(const Dynamic &a0) = 0;
   virtual bool __remove(const Dynamic &a0) = 0;
   virtual bool __removeAt(int inIndex) = 0;
   virtual int __indexOf(const Dynamic &a0,const Dynamic &a1) = 0;
   virtual int __lastIndexOf(const Dynamic &a0,const Dynamic &a1) = 0;
   virtual void __reverse() = 0;
   virtual Dynamic __shift() = 0;
   virtual hx::ArrayBase *__slice(const Dynamic &a0,const Dynamic &a1) = 0;
   virtual hx::ArrayBase *__splice(const Dynamic &a0,const Dynamic &a1) = 0;
   virtual void __sort(const Dynamic &a0) = 0;
   virtual ::String __toString() = 0;
   virtual void  __unshift(const Dynamic &a0) = 0;
   virtual cpp::VirtualArray_obj *__map(const Dynamic &func) = 0;
   virtual hx::ArrayBase *__filter(const Dynamic &func) = 0;
   virtual void __blit(int inDestElement,const cpp::VirtualArray &inSourceArray,int inSourceElement,int inElementCount) = 0;
   virtual int __memcmp(const cpp::VirtualArray &a0) = 0;
   inline void __zero(const Dynamic &a0,const Dynamic &a1)  { zero(a0,a1); }
   virtual void __qsort(Dynamic inCompare) = 0;
   virtual void __resize(int inLen) = 0;

   virtual void set(int inIdx, const cpp::Variant &inValue) = 0;
   virtual void setUnsafe(int inIdx, const cpp::Variant &inValue) = 0;
   #endif

   Dynamic concat_dyn();
   Dynamic copy_dyn();
   Dynamic insert_dyn();
   Dynamic iterator_dyn();
   Dynamic keyValueIterator_dyn();
   Dynamic join_dyn();
   Dynamic pop_dyn();
   Dynamic push_dyn();
   Dynamic contains_dyn();
   Dynamic remove_dyn();
   Dynamic removeAt_dyn();
   Dynamic indexOf_dyn();
   Dynamic lastIndexOf_dyn();
   Dynamic reverse_dyn();
   Dynamic shift_dyn();
   Dynamic slice_dyn();
   Dynamic splice_dyn();
   Dynamic sort_dyn();
   Dynamic toString_dyn();
   Dynamic unshift_dyn();
   Dynamic map_dyn();
   Dynamic filter_dyn();
   Dynamic __SetSize_dyn();
   Dynamic __SetSizeExact_dyn();
   Dynamic __unsafe_get_dyn();
   Dynamic __unsafe_set_dyn();
   Dynamic blit_dyn();
   Dynamic zero_dyn();
   Dynamic memcmp_dyn();
   Dynamic resize_dyn();

   void Realloc(int inLen) const;

   inline void EnsureSize(int inLen) const
   {
      if (inLen>length)
      {
         if (inLen>mAlloc)
            Realloc(inLen);
         length = inLen;
      }
   }

   void RemoveElement(int inIndex);


   void Insert(int inPos);

   void Splice(hx::ArrayBase *outResult,int inPos,int inLen);

   void Slice(hx::ArrayBase *outResult,int inPos,int inEnd);

   void Concat(hx::ArrayBase *outResult,const char *inEnd, int inLen);


   void reserve(int inN) const;

   inline int capacity() const { return mAlloc; }

   // Set numeric values to 0, pointers to null, bools to false
   void zero(Dynamic inFirst, Dynamic inCount);

   int Memcmp(ArrayBase *inArray);

   // Copy section of other array.
   void Blit(int inDestElement, ArrayBase *inSourceArray, int inSourceElement, int inElementCount);

   static String joinArray(hx::ArrayBase *inBase, String inSeparator);
   static String joinArray(Array_obj<String> *inArray, String inSeparator);

   virtual bool AllocAtomic() const { return false; }

   inline bool IsByteArray() const { return getStoreType()==arrayBool; }


   inline Dynamic __get(int inIndex) const { return __GetItem(inIndex); }

   // Plain old data element size - or 0 if not plain-old-data
   int getArrayConvertId() const { return mArrayConvertId; }

   mutable int length;

   static inline int baseOffset() { return (int)offsetof(ArrayBase,mBase); }
   static inline int allocOffset() { return (int)offsetof(ArrayBase,mAlloc); }
   static inline int lengthOffset() { return (int)offsetof(ArrayBase,length); }

protected:
   mutable int mAlloc;
   mutable char  *mBase;
};

} // end namespace hx for ArrayBase

namespace cpp
{
   typedef hx::ArrayBase ArrayBase_obj;

   // Use by cpp.ArrayBase extern
   typedef hx::ObjectPtr<ArrayBase_obj> ArrayBase;
}


#if (HXCPP_API_LEVEL>=330)
#include "cpp/VirtualArray.h"
#endif




// --- Array_obj ------------------------------------------------------------------
//
// The Array_obj specialises the ArrayBase, adding typing where required


namespace hx
{
// This is to determine is we need to include our slab of bytes in garbage collection
template<typename T>
inline bool TypeContainsPointers(T *) { return true; }
template<> inline bool TypeContainsPointers(bool *) { return false; }
template<> inline bool TypeContainsPointers(int *) { return false; }
template<> inline bool TypeContainsPointers(double *) { return false; }
template<> inline bool TypeContainsPointers(float *) { return false; }
template<> inline bool TypeContainsPointers(short *) { return false; }
template<> inline bool TypeContainsPointers(unsigned char *) { return false; }
template<> inline bool TypeContainsPointers(::cpp::Int64 *) { return false; }

template<typename TYPE> inline bool ContainsPointers()
{
   return TypeContainsPointers( (TYPE *)0 );
}

struct TNonGcStringSet;

//template<typename T> inline const void *PointerOf(hx::ObjectPtr<T> &o) { return o.mPtr; }
//inline const void *PointerOf(String &s) { return s.raw_ptr(); }
inline const void *PointerOf(hx::TNonGcStringSet &set) { return 0; }
//inline const void *PointerOf(...) { return 0; }



// For returning "null" when out of bounds ...
template<typename TYPE>
inline TYPE *NewNull() { Dynamic d; return (TYPE *)hx::NewGCBytes(&d,sizeof(d)); }

template<> inline int *NewNull<int>() { int i=0; return (int *)hx::NewGCPrivate(&i,sizeof(i)); }
template<> inline bool *NewNull<bool>() { bool b=0; return (bool *)hx::NewGCPrivate(&b,sizeof(b)); }
template<> inline double *NewNull<double>() { double d=0.0; return (double *)hx::NewGCPrivate(&d,sizeof(d)); }
template<> inline float *NewNull<float>() { float d=0.0f; return (float *)hx::NewGCPrivate(&d,sizeof(d)); }
template<> inline unsigned char *NewNull<unsigned char>() { unsigned char u=0; return (unsigned char *)hx::NewGCPrivate(&u,sizeof(u)); }
template<> inline ::cpp::Int64 *NewNull< ::cpp::Int64>() { ::cpp::Int64 i=0; return (::cpp::Int64 *)hx::NewGCPrivate(&i,sizeof(i)); }


bool DynamicEq(const Dynamic &a, const Dynamic &b);

}

template<typename T> struct ArrayClassId { enum { id=hx::clsIdArrayObject }; };
template<> struct ArrayClassId<unsigned char> { enum { id=hx::clsIdArrayByte }; };
template<> struct ArrayClassId<signed char> { enum { id=hx::clsIdArrayByte }; };
template<> struct ArrayClassId<unsigned short> { enum { id=hx::clsIdArrayShort }; };
template<> struct ArrayClassId<signed short> { enum { id=hx::clsIdArrayShort }; };
template<> struct ArrayClassId<unsigned int> { enum { id=hx::clsIdArrayInt }; };
template<> struct ArrayClassId<signed int> { enum { id=hx::clsIdArrayInt }; };
template<> struct ArrayClassId<float> { enum { id=hx::clsIdArrayFloat32 }; };
template<> struct ArrayClassId<double> { enum { id=hx::clsIdArrayFloat64 }; };
template<> struct ArrayClassId<String> { enum { id=hx::clsIdArrayString }; };
template<> struct ArrayClassId< ::cpp::Int64> { enum { id=hx::clsIdArrayInt64 }; };

// sort...
#include <algorithm>

namespace hx
{
template<typename T>
inline bool arrayElemEq(const T &a, const T &b) { return a==b; }

template<>
inline bool arrayElemEq<Dynamic>(const Dynamic &a, const Dynamic &b) {
   return hx::DynamicEq(a,b);
}
}


template<typename ELEM_>
class Array_obj : public hx::ArrayBase
{
   typedef ELEM_ Elem;
   typedef hx::ObjectPtr< Array_obj<ELEM_> > ObjPtr;
   typedef typename hx::ReturnNull<ELEM_>::type NullType;

public:
   enum { _hx_ClassId = ArrayClassId<ELEM_>::id };


   Array_obj(int inSize,int inReserve) :
        hx::ArrayBase(inSize,inReserve,sizeof(ELEM_),!hx::ContainsPointers<ELEM_>()) { }


   // Defined later so we can use "Array"
   static Array<ELEM_> __new(int inSize=0,int inReserve=0);
   static Array<ELEM_> __newConstWrapper(ELEM_ *inData,int inSize);
   static Array<ELEM_> fromData(const ELEM_ *inData,int inCount);


#if (HXCPP_API_LEVEL>331)
   bool _hx_isInstanceOf(int inClassId)
   {
      return inClassId==1 || inClassId==(int)hx::clsIdArrayBase || inClassId==(int)_hx_ClassId;
   }
#endif

   virtual bool AllocAtomic() const { return !hx::ContainsPointers<ELEM_>(); }

   virtual Dynamic __GetItem(int inIndex) const { return __get(inIndex); }
   virtual Dynamic __SetItem(int inIndex,Dynamic inValue)
   {
      ELEM_ &elem = Item(inIndex);
      elem = inValue;
      if (hx::ContainsPointers<ELEM_>()) { HX_OBJ_WB_GET(this,hx::PointerOf(elem)); }
      return inValue;
   }

   inline ELEM_ *Pointer() { return (ELEM_ *)mBase; }

   inline ELEM_ &Item(int inIndex)
   {
      if (inIndex>=(int)length) EnsureSize(inIndex+1);
      else if (inIndex<0) { return * hx::NewNull<ELEM_>(); }
      return * (ELEM_ *)(mBase + inIndex*sizeof(ELEM_));
   }
   inline ELEM_ __get(int inIndex) const
   {
      if ((unsigned int)inIndex>=(unsigned int)length ) return null();
      return * (ELEM_ *)(mBase + inIndex*sizeof(ELEM_));
   }

   // Does not check for size valid - use with care
   inline ELEM_ &__unsafe_get(int inIndex) { return * (ELEM_ *)(mBase + inIndex*sizeof(ELEM_)); }


   inline ELEM_ & __unsafe_set(int inIndex, ELEM_ inValue)
   {
      ELEM_ &elem = *(ELEM_*)(mBase + inIndex*sizeof(ELEM_));
      elem = inValue;
      if (hx::ContainsPointers<ELEM_>()) { HX_OBJ_WB_GET(this, hx::PointerOf(elem)); }
      return elem;
   }


   inline int memcmp(Array<ELEM_> inOther)
   {
      return ArrayBase::Memcmp(inOther.GetPtr());
   }


   inline void memcpy(int inStart, const ELEM_ *inData, int inElements)
   {
      EnsureSize(inStart+inElements);
      int s = GetElementSize();
      ::memcpy(mBase + s*inStart, inData, s*inElements);
      if (hx::ContainsPointers<ELEM_>())
      {
         HX_OBJ_WB_PESSIMISTIC_GET(this);
      }
   }


   inline void blit(int inDestElement,  Array<ELEM_> inSourceArray,
                    int inSourceElement, int inElementCount)
   {
      ArrayBase::Blit(inDestElement, inSourceArray.GetPtr(), inSourceElement, inElementCount);
   }


   void __Mark(hx::MarkContext *__inCtx)
   {
      if (mAlloc>0) hx::MarkAlloc((void *)mBase, __inCtx );
      if (length && hx::ContainsPointers<ELEM_>())
      {
         ELEM_ *ptr = (ELEM_ *)mBase;
         HX_MARK_MEMBER_ARRAY(ptr,length);
      }
   }

   #ifdef HXCPP_VISIT_ALLOCS
   void __Visit(hx::VisitContext *__inCtx)
   {
      if (mAlloc>0) __inCtx->visitAlloc((void **)&mBase);
      if (hx::ContainsPointers<ELEM_>())
      {
         ELEM_ *ptr = (ELEM_ *)mBase;
         for(int i=0;i<length;i++)
         {
            HX_VISIT_MEMBER(ptr[i]);
         }
      }
   }
   #endif

   inline Array<ELEM_> __SetSizeExact(int inLen);

   int GetElementSize() const { return sizeof(ELEM_); }

   String ItemString(int inI)
   {
      String result(__get(inI));
      if (result==null()) return HX_CSTRING("null");
      return result;
   }

   Array_obj<ELEM_> *Add(const ELEM_ &inItem) { push(inItem); return this; }

   Array<ELEM_> init(int inIndex, ELEM_ inValue)
   {
      * (ELEM_ *)(mBase + inIndex*sizeof(ELEM_)) = inValue;
      #ifdef HXCPP_GC_GENERATIONAL
      if (hx::ContainsPointers<ELEM_>())
         { HX_OBJ_WB_GET(this, hx::PointerOf(inValue)); }
      #endif
      return this;
   }


   #ifdef HXCPP_GC_GENERATIONAL
   inline int pushCtx(hx::StackContext *_hx_ctx, ELEM_ inVal )
   {
      int l = length;
      EnsureSize((int)l+1);
      * (ELEM_ *)(mBase + l*sizeof(ELEM_)) = inVal;
      if (hx::ContainsPointers<ELEM_>()) { HX_ARRAY_WB(this,inIdx, hx::PointerOf(inVal) ); }
      return length;
   }
   #endif


   // Haxe API
   inline int push( ELEM_ inVal )
   {
      #ifdef HXCPP_GC_GENERATIONAL
      if (hx::ContainsPointers<ELEM_>())
         return pushCtx(HX_CTX_GET,inVal);
      #endif
      int l = length;
      EnsureSize((int)l+1);
      * (ELEM_ *)(mBase + l*sizeof(ELEM_)) = inVal;
      return length;
   }
   inline NullType pop( )
   {
      if (!length) return null();
      ELEM_ result = __get((int)length-1);
      resize((int)length-1);
      return result;
   }



   int Find(ELEM_ inValue)
   {
      ELEM_ *e = (ELEM_ *)mBase;
      for(int i=0;i<length;i++)
         if (hx::arrayElemEq(e[i],inValue))
            return i;
      return -1;
   }

   bool contains(ELEM_ inValue)
   {
      ELEM_ *e = (ELEM_ *)mBase;
      for(int i=0;i<length;i++)
      {
         if (hx::arrayElemEq(e[i],inValue))
            return true;
      }
      return false;
   }

   bool remove(ELEM_ inValue)
   {
      ELEM_ *e = (ELEM_ *)mBase;
      for(int i=0;i<length;i++)
      {
         if (hx::arrayElemEq(e[i],inValue))
         {
            RemoveElement((int)i);
            return true;
         }
      }
      return false;
   }

   bool removeAt( int idx )
   { 
      if( idx < 0 ) idx += length; 
      if (idx>=length || idx<0) return false; 
      RemoveElement(idx); 
      return true; 
   }


   int indexOf(ELEM_ inValue, Dynamic fromIndex = null())
   {
      int len = length;
      int i = fromIndex==null() ? 0 : fromIndex->__ToInt();
      ELEM_ *e = (ELEM_ *)mBase;
      if (i < 0)
      {
         i += len;
         if (i < 0) i = 0;
      }
      while(i<len)
      {
         if (hx::arrayElemEq(e[i],inValue))
            return i;
         i++;
      }
      return -1;
   }

   int lastIndexOf(ELEM_ inValue, Dynamic fromIndex = null())
   {
      int len = length;
      int i = fromIndex==null() ? len-1 : fromIndex->__ToInt();
      ELEM_ *e = (ELEM_ *)mBase;
      if (i >= len)
         i = len - 1;
      else if (i < 0)
         i += len;
      while(i>=0)
      {
         if (hx::arrayElemEq(e[i],inValue))
            return i;
         i--;
      }
      return -1;
   }

   NullType shift()
   {
      if (length==0) return null();
      ELEM_ result = __get(0);
      RemoveElement(0);
      return result;
   }

   String join(String inSeparator) { return ArrayBase::joinArray(this, inSeparator); }

   Array<ELEM_> concat( Array<ELEM_> inTail );
   Array<ELEM_> copy( );
   Array<ELEM_> slice(int inPos, Dynamic end = null());
   Array<ELEM_> splice(int inPos, int len);
   inline void removeRange(int inPos, int len)
   {
      hx::ArrayBase::Splice(0,inPos,len);
   }

   #if HXCPP_API_LEVEL>=330
   cpp::VirtualArray map(Dynamic inFunc);
   #else
   Dynamic map(Dynamic inFunc);
   #endif
   Array<ELEM_> filter(Dynamic inFunc);

   void insert(int inPos, ELEM_ inValue)
   {
		if (inPos<0)
		{
			inPos+=length;
			if (inPos<0) inPos = 0;
		}
		else if (inPos>length)
			inPos = length;
		hx::ArrayBase::Insert(inPos);
      Item(inPos) = inValue;
      #ifdef HXCPP_GC_GENERATIONAL
      if (hx::ContainsPointers<ELEM_>())
         { HX_OBJ_WB_GET(this,hx::PointerOf(inValue)); }
      #endif
   }

   void unshift(ELEM_ inValue)
   {
      insert(0,inValue);
   }

   void reverse()
   {
      int half = length/2;
      ELEM_ *e = (ELEM_ *)mBase;
      for(int i=0;i<half;i++)
      {
         ELEM_ tmp = e[length-i-1];
         e[length-i-1] = e[i];
         e[i] = tmp;
      }
   }

   // Will do random pointer sorting for object pointers
   inline void sortAscending()
   {
      ELEM_ *e = (ELEM_ *)mBase;
      std::sort(e, e+length);
   }
   static inline bool greaterThan(const ELEM_ &inA, const ELEM_ &inB) { return inB < inA; }
   inline void sortDescending()
   {
      ELEM_ *e = (ELEM_ *)mBase;
      std::sort(e, e+length, greaterThan);
   }


   struct Sorter
   {
      Sorter(Dynamic inFunc) : mFunc(inFunc) { }

      bool operator()(const ELEM_ &inA, const ELEM_ &inB)
      {
         return mFunc( Dynamic(inA), Dynamic(inB))->__ToInt() < 0;
      }

      Dynamic mFunc;
   };

   inline void qsort(Dynamic inSorter)
   {
      ELEM_ *e = (ELEM_ *)mBase;
      std::sort(e, e+length, Sorter(inSorter) );
   }

   void sort(Dynamic inSorter)
   {
      if ( (int)hx::ArrayTraits<ELEM_>::StoreType==(int)hx::arrayObject ||
          (int)hx::ArrayTraits<ELEM_>::StoreType==(int)hx::arrayString)
      {
         // Keep references from being hidden inside sorters buffers
         safeSort(inSorter, (int)hx::ArrayTraits<ELEM_>::StoreType==(int)hx::arrayString);
      }
      else
      {
         ELEM_ *e = (ELEM_ *)mBase;
         std::stable_sort(e, e+length, Sorter(inSorter) );
      }
   }

   Dynamic iterator() { return new hx::ArrayIterator<ELEM_,ELEM_>(this); }
   Dynamic keyValueIterator() { return new hx::ArrayKeyValueIterator<ELEM_,ELEM_>(this); }

   template<typename TO>
   Dynamic iteratorFast() { return new hx::ArrayIterator<ELEM_,TO>(this); }

   template<typename TO>
   Dynamic keyValueIteratorFast() { return new hx::ArrayKeyValueIterator<ELEM_,TO>(this); }
   
   virtual hx::ArrayStore getStoreType() const
   {
      return (hx::ArrayStore) hx::ArrayTraits<ELEM_>::StoreType;
   }

   inline ELEM_ &setCtx(hx::StackContext *_hx_ctx, int inIdx, ELEM_ inValue)
   {
      ELEM_ &elem = Item(inIdx);
      HX_ARRAY_WB(this,inIdx, hx::PointerOf(inValue) );
      return elem = inValue;
   }


   // Dynamic interface
   #if (HXCPP_API_LEVEL < 330)
   virtual Dynamic __concat(const Dynamic &a0) { return concat(a0); }
   virtual Dynamic __copy() { return copy(); }
   virtual Dynamic __insert(const Dynamic &a0,const Dynamic &a1) { insert(a0,a1); return null(); }
   virtual Dynamic __iterator() { return iterator(); }
   virtual Dynamic __keyValueIterator() { return keyValueIterator(); }
   virtual Dynamic __join(const Dynamic &a0) { return join(a0); }
   virtual Dynamic __pop() { return pop(); }
   virtual Dynamic __push(const Dynamic &a0) { return push(a0);}
   virtual Dynamic __remove(const Dynamic &a0) { return remove(a0); }
   virtual Dynamic __removeAt(const Dynamic &a0) { return removeAt(a0); }
   virtual Dynamic __indexOf(const Dynamic &a0,const Dynamic &a1) { return indexOf(a0, a1); }
   virtual Dynamic __lastIndexOf(const Dynamic &a0,const Dynamic &a1) { return lastIndexOf(a0, a1); }
   virtual Dynamic __reverse() { reverse(); return null(); }
   virtual Dynamic __shift() { return shift(); }
   virtual Dynamic __slice(const Dynamic &a0,const Dynamic &a1) { return slice(a0,a1); }
   virtual Dynamic __splice(const Dynamic &a0,const Dynamic &a1) { return splice(a0,a1); }
   virtual Dynamic __sort(const Dynamic &a0) { sort(a0); return null(); }
   virtual Dynamic __toString() { return toString(); }
   virtual Dynamic __unshift(const Dynamic &a0) { unshift(a0); return null(); }
   virtual Dynamic __map(const Dynamic &func) { return map(func); }
   virtual Dynamic __filter(const Dynamic &func) { return filter(func); }
   virtual Dynamic __blit(const Dynamic &a0,const Dynamic &a1,const Dynamic &a2,const Dynamic &a3) { blit(a0,a1,a2,a3); return null(); }
   virtual Dynamic __memcmp(const Dynamic &a0) { return memcmp(a0); }
   virtual Dynamic __resize(const Dynamic &a0) { resize(a0); return null(); }
   virtual void __qsort(Dynamic inCompare) { this->qsort(inCompare); };
   #else //(HXCPP_API_LEVEL < 330)

   virtual hx::ArrayBase *__concat(const cpp::VirtualArray &a0) { return concat(a0).mPtr; }
   virtual hx::ArrayBase *__copy() { return copy().mPtr; }
   virtual void __insert(int inIndex,const Dynamic &a1) { insert(inIndex,a1);}
   virtual Dynamic __iterator() { return iterator(); }
   virtual Dynamic __keyValueIterator() { return keyValueIterator(); }
   virtual ::String __join(::String a0) { return join(a0); }
   virtual Dynamic __pop() { return pop(); }
   virtual int __push(const Dynamic &a0) { return push(a0);}
   virtual bool __contains(const Dynamic &a0) { return contains(a0); }
   virtual bool __remove(const Dynamic &a0) { return remove(a0); }
   virtual bool __removeAt(int inIndex) { return removeAt(inIndex); }
   virtual int __indexOf(const Dynamic &a0,const Dynamic &a1) { return indexOf(a0, a1); }
   virtual int __lastIndexOf(const Dynamic &a0,const Dynamic &a1) { return lastIndexOf(a0, a1); }
   virtual void __reverse() { reverse(); }
   virtual Dynamic __shift() { return shift(); }
   virtual hx::ArrayBase *__slice(const Dynamic &a0,const Dynamic &a1) { return slice(a0,a1).mPtr; }
   virtual hx::ArrayBase *__splice(const Dynamic &a0,const Dynamic &a1) { return splice(a0,a1).mPtr; }
   virtual void __sort(const Dynamic &a0) { sort(a0); }
   virtual ::String __toString() { return toString(); }
   virtual void  __unshift(const Dynamic &a0) { unshift(a0); }
   virtual cpp::VirtualArray_obj *__map(const Dynamic &func) { return map(func).mPtr; }
   virtual void __resize(int inLen) { resize(inLen); }

   virtual hx::ArrayBase *__filter(const Dynamic &func) { return filter(func).mPtr; }
   virtual void __blit(int inDestElement,const cpp::VirtualArray &inSourceArray,int inSourceElement,int inElementCount)
   {
      blit(inDestElement,inSourceArray,inSourceElement,inElementCount);
   }
   virtual int __memcmp(const cpp::VirtualArray &a0) { return memcmp(a0); }
   virtual void __qsort(Dynamic inCompare) { this->qsort(inCompare); };

   virtual void set(int inIndex, const cpp::Variant &inValue) {
      ELEM_ &elem = Item(inIndex);
      elem = ELEM_(inValue);
      if (hx::ContainsPointers<ELEM_>()) {
         HX_OBJ_WB_GET(this, hx::PointerOf(elem));
      }
   }
   virtual void setUnsafe(int inIndex, const cpp::Variant &inValue) {
      ELEM_ &elem = *(ELEM_ *)(mBase + inIndex*sizeof(ELEM_));
      elem = ELEM_(inValue);
      if (hx::ContainsPointers<ELEM_>()) { HX_OBJ_WB_GET(this,hx::PointerOf(elem)); }
   }


   #endif
};


// --- Array ---------------------------------------------------------------
//
// The array class adds object syntax to the Array_obj pointer

template<typename ELEM_>
class Array : public hx::ObjectPtr< Array_obj<ELEM_> >
{
   typedef hx::ObjectPtr< Array_obj<ELEM_> > super;
   typedef Array_obj<ELEM_> OBJ_;

public:
   typedef ELEM_ Elem;
   typedef Array_obj<ELEM_> *Ptr;
   using super::mPtr;
   using super::GetPtr;

   Array() { }
   Array(int inSize,int inReserve) : super( OBJ_::__new(inSize,inReserve) ) { }
   Array(const null &inNull) : super(0) { }
   Array(Ptr inPtr) : super(inPtr) { }

   #ifdef HXCPP_CHECK_POINTER
   inline OBJ_ *CheckGetPtr() const
   {
      if (!mPtr) hx::NullReference("Array", true);
      // The handler might have fixed up the null value
      if (!mPtr) hx::NullReference("Array", false);
      return mPtr;
   }
   #else
   inline OBJ_ *CheckGetPtr() const { return mPtr; }
   #endif

   // Construct from our type ...
   Array ( const hx::ObjectPtr< OBJ_  > &inArray )
        :  hx::ObjectPtr< OBJ_ >(inArray) { }

   Array(const Array<ELEM_> &inArray) : super(inArray.GetPtr()) { }

   // Build dynamic array from foreign array
   template<typename SOURCE_>
   Array( const Array<SOURCE_> &inRHS ) : super(0)
   {
      Array_obj<SOURCE_> *ptr = inRHS.GetPtr(); 
      if (ptr)
      {
         OBJ_ *arr = dynamic_cast<OBJ_ *>(ptr);
         if (!arr)
         {
            // Non-identical type (syntactically, should be creating from Array<Dynamic>)
            // Copy elements one-by-one
            // Not quite right, but is the best we can do...
            int n = ptr->__length();
            *this = Array_obj<ELEM_>::__new(n);
            for(int i=0;i<n;i++)
               mPtr->__unsafe_set(i,ptr->__GetItem(i));
         }
         else
            mPtr = arr;
      }
   }

   #ifdef HX_VARRAY_DEFINED
   // From VirtualArray
   Array( const cpp::VirtualArray &inVArray) { fromVArray(inVArray.mPtr); }

   void fromVArray(cpp::VirtualArray_obj *inVArray)
   {
      if (!inVArray || inVArray->store==hx::arrayNull)
      {
         mPtr = 0;
         return;
      }
      inVArray->fixType<ELEM_>();
      // Switch on type?
      setDynamic(inVArray->base,true);
   }

   Array &operator=( const cpp::VirtualArray &inRHS )
   {
      fromVArray(inRHS.mPtr);
      return *this;
   }

   #endif

   inline void setDynamic( const Dynamic &inRHS, bool inIgnoreVirtualArray=false )
   {
      hx::Object *ptr = inRHS.GetPtr(); 
      if (ptr)
      {
         OBJ_ *arr = dynamic_cast<OBJ_ *>(ptr);
         if (!arr && ptr->__GetClass().mPtr == super::__SGetClass().mPtr )
         {
            #ifdef HX_VARRAY_DEFINED
            cpp::VirtualArray_obj *varray = inIgnoreVirtualArray ? 0 :
                                            dynamic_cast<cpp::VirtualArray_obj *>(ptr);
            if (varray)
               fromVArray(varray);
            else
            #endif
            {
               // Non-identical type.
               // Copy elements one-by-one
               // Not quite right, but is the best we can do...
               int n = ptr->__length();
               *this = Array_obj<ELEM_>::__new(n);
               for(int i=0;i<n;i++)
                  mPtr->__unsafe_set(i,ptr->__GetItem(i));
            }
         }
         else
            mPtr = arr;
      }
   }

   Array( const Dynamic &inRHS ) : super(0) { setDynamic(inRHS); }
   Array( const cpp::ArrayBase &inRHS ) : super(0) { setDynamic(inRHS); }
   inline Array(const ::cpp::Variant &inVariant) : super(0)
   {
      setDynamic(inVariant.asObject());
   }

   // operator= exact match...
   Array &operator=( Array<ELEM_> inRHS )
   {
      mPtr = inRHS.GetPtr();
      return *this;
   }

   // Foreign array
   template<typename OTHER>
   Array &operator=( const Array<OTHER> &inRHS )
   {
      *this = Array(inRHS);
      return *this;
   }

   Array &operator=( const Dynamic &inRHS )
   {
      setDynamic(inRHS);
      return *this;
   }

   Array &operator=( const cpp::ArrayBase &inRHS )
   {
      setDynamic(inRHS);
      return *this;
   }


   Array &operator=( const cpp::Variant &inRHS )
   {
      if (inRHS.type!=cpp::Variant::typeObject)
         setDynamic( null() );
      else
         setDynamic(inRHS.valObject);
      return *this;
   }


   Array &operator=( const null &inNull )
   {
      mPtr = 0;
      return *this;
   }


   #if (HXCPP_API_LEVEL >= 330)
   inline bool operator==(const cpp::VirtualArray &varray) const { return varray==*this; }
   inline bool operator!=(const cpp::VirtualArray &varray) const { return varray!=*this; }
   #endif


   inline ELEM_ &operator[](int inIdx) { return CheckGetPtr()->Item(inIdx); }
   inline ELEM_ operator[](int inIdx) const { return CheckGetPtr()->__get(inIdx); }
   //inline ELEM_ __get(int inIdx) const { return CheckGetPtr()->__get(inIdx); }
   inline int __length() const { return CheckGetPtr()->__length(); }
   inline Array<ELEM_> &Add(const ELEM_ &inElem) { CheckGetPtr()->Add(inElem); return *this; }
   inline Array<ELEM_> & operator<<(const ELEM_ &inElem) { CheckGetPtr()->Add(inElem); return *this; }
};


// Now that the "Array" object is defined, we can implement this function ....

template<typename ELEM_>
Array<ELEM_> Array_obj<ELEM_>::__new(int inSize,int inReserve)
 { return  Array<ELEM_>(new Array_obj(inSize,inReserve)); }


template<typename ELEM_>
Array<ELEM_> Array_obj<ELEM_>::__newConstWrapper(ELEM_ *inData,int inSize)
{
   Array_obj<ELEM_> temp(0,0);
   Array_obj<ELEM_> *result = (Array_obj<ELEM_> *)hx::InternalCreateConstBuffer(&temp,sizeof(temp));
   result->setUnmanagedData(inData, inSize);
   return result;
}


template<typename ELEM_>
Array<ELEM_> Array_obj<ELEM_>::fromData(const ELEM_ *inData,int inCount)
{
   Array<ELEM_> result = new Array_obj(inCount,inCount);
   if (inCount)
       result->memcpy(0, inData, inCount);
   return result;
}



template<>
inline bool Dynamic::IsClass<Array<Dynamic> >()
   { return mPtr && mPtr->__GetClass()== hx::ArrayBase::__mClass; }


template<typename ELEM_>
Array<ELEM_> Array_obj<ELEM_>::concat( Array<ELEM_> inTail )
{
   Array_obj *result = new Array_obj(inTail->__length()+(int)length,0);
   hx::ArrayBase::Concat(result,inTail->GetBase(),inTail->__length());
   return result;
}

template<typename ELEM_>
Array<ELEM_> Array_obj<ELEM_>::copy( )
{
   Array_obj *result = new Array_obj((int)length,0);
   ::memcpy(result->GetBase(),GetBase(),length*sizeof(ELEM_));
   return result;
}

// Copies the range of the array starting at pos up to, but not including, end.
// Both pos and end can be negative to count from the end: -1 is the last item in the array.
template<typename ELEM_>
Array<ELEM_> Array_obj<ELEM_>::slice(int inPos, Dynamic end)
{
   int e = end==null() ? length : end->__ToInt();
   Array_obj *result = new Array_obj(0,0);
   hx::ArrayBase::Slice(result,inPos,(int)e);
   return result;
}

template<typename ELEM_>
Array<ELEM_> Array_obj<ELEM_>::splice(int inPos, int len)
{
   Array_obj * result = new Array_obj(0,0);
   hx::ArrayBase::Splice(result,inPos,len);
   return result;
}


template<typename ELEM_>
Array<ELEM_> Array_obj<ELEM_>::filter(Dynamic inFunc)
{
   Array_obj *result = new Array_obj(0,0);
   for(int i=0;i<length;i++)
      if (inFunc(__unsafe_get(i)))
         result->push(__unsafe_get(i));
   return result;
}

template<typename ELEM_>
Array<ELEM_> Array_obj<ELEM_>::__SetSizeExact(int inLen)
{
   ArrayBase::__SetSizeExact(inLen);
   return this;
}

// Static externs 
template<typename ARRAY>
inline ARRAY _hx_array_set_size_exact(ARRAY inArray, int inLen)
{
   return inArray->__SetSizeExact(inLen);
}

template<typename ARRAY1,typename ARRAY2>
inline int _hx_array_memcmp(ARRAY1 inArray1, ARRAY2 inArray2)
{
   return inArray1->memcmp(inArray2);
}

template<typename ARRAY,typename VALUE>
inline typename ARRAY::Elem _hx_array_unsafe_set(ARRAY inArray, int inIndex, VALUE inValue)
{
   return inArray->__unsafe_set(inIndex, inValue);
}


template<typename ARRAY>
inline typename ARRAY::Elem _hx_array_unsafe_get(ARRAY inArray, int inIndex)
{
   return inArray->__unsafe_get(inIndex);
}



// Include again, for functions that required Array definition
#ifdef HX_VARRAY_DEFINED
#include "cpp/VirtualArray.h"
#endif


#if HXCPP_API_LEVEL >= 330
template<typename ELEM_>
cpp::VirtualArray Array_obj<ELEM_>::map(Dynamic inFunc)
{
   cpp::VirtualArray result = cpp::VirtualArray_obj::__new(length,0);
   for(int i=0;i<length;i++)
      result->__unsafe_set(i,inFunc(__unsafe_get(i)));
   return result;
}

#else
template<typename ELEM_>
Dynamic Array_obj<ELEM_>::map(Dynamic inFunc)
{
   Array_obj<Dynamic> *result = new Array_obj<Dynamic>(length,0);
   for(int i=0;i<length;i++)
      result->__unsafe_set(i,inFunc(__unsafe_get(i)));
   return result;
}
#endif



#endif