17 #ifndef INC_KY_Kernel_Array_H
18 #define INC_KY_Kernel_Array_H
33 struct ArrayDefaultPolicy
35 ArrayDefaultPolicy() : Capacity(0) {}
36 ArrayDefaultPolicy(
const ArrayDefaultPolicy&) : Capacity(0) {}
38 UPInt GetMinCapacity()
const {
return 0; }
39 UPInt GetGranularity()
const {
return 4; }
40 bool NeverShrinking()
const {
return 0; }
42 UPInt GetCapacity()
const {
return Capacity; }
43 void SetCapacity(UPInt capacity) { Capacity = capacity; }
54 template<
int MinCapacity=0,
int Granularity=4,
bool NeverShrink=false>
55 struct ArrayConstPolicy
57 typedef ArrayConstPolicy<MinCapacity, Granularity, NeverShrink> SelfType;
59 ArrayConstPolicy() : Capacity(0) {}
60 ArrayConstPolicy(
const SelfType&) : Capacity(0) {}
62 UPInt GetMinCapacity()
const {
return MinCapacity; }
63 UPInt GetGranularity()
const {
return Granularity; }
64 bool NeverShrinking()
const {
return NeverShrink; }
66 UPInt GetCapacity()
const {
return Capacity; }
67 void SetCapacity(UPInt capacity) { Capacity = capacity; }
78 template<
class T,
class Allocator,
class SizePolicy>
struct ArrayDataBase
81 typedef Allocator AllocatorType;
82 typedef SizePolicy SizePolicyType;
83 typedef ArrayDataBase<T, Allocator, SizePolicy> SelfType;
86 : Data(0), Size(0), Policy() {}
88 ArrayDataBase(
const SizePolicy& p)
89 : Data(0), Size(0), Policy(p) {}
93 Allocator::DestructArray(Data, Size);
94 Allocator::Free(Data);
97 UPInt GetCapacity()
const
99 return Policy.GetCapacity();
102 void ClearAndRelease()
104 Allocator::DestructArray(Data, Size);
105 Allocator::Free(Data);
108 Policy.SetCapacity(0);
111 void Reserve(
const void* pheapAddr, UPInt newCapacity)
113 if (Policy.NeverShrinking() && newCapacity < GetCapacity())
116 if (newCapacity < Policy.GetMinCapacity())
117 newCapacity = Policy.GetMinCapacity();
120 if (newCapacity == 0)
124 Allocator::Free(Data);
127 Policy.SetCapacity(0);
131 UPInt gran = Policy.GetGranularity();
132 newCapacity = (newCapacity + gran - 1) / gran * gran;
135 if (Allocator::IsMovable())
140 Data = (T*)Allocator::Realloc(pheapAddr, Data,
sizeof(T) * newCapacity, __FILE__, __LINE__);
144 T* newData = (T*)Allocator::Alloc(pheapAddr,
sizeof(T) * newCapacity, __FILE__, __LINE__);
146 s = (Size < newCapacity) ? Size : newCapacity;
147 for (i = 0; i < s; ++i)
149 Allocator::Construct(&newData[i], Data[i]);
150 Allocator::Destruct(&Data[i]);
152 for (i = s; i < Size; ++i)
154 Allocator::Destruct(&Data[i]);
156 Allocator::Free(Data);
162 Data = (T*)Allocator::Alloc(pheapAddr,
sizeof(T) * newCapacity, __FILE__, __LINE__);
165 Policy.SetCapacity(newCapacity);
173 void ResizeNoConstruct(
const void* pheapAddr, UPInt newSize)
175 UPInt oldSize = Size;
177 if (newSize < oldSize)
179 Allocator::DestructArray(Data + newSize, oldSize - newSize);
180 if (newSize < (Policy.GetCapacity() >> 1))
182 Reserve(pheapAddr, newSize);
185 else if(newSize > Policy.GetCapacity())
187 Reserve(pheapAddr, newSize + (newSize >> 2));
208 template<
class T,
class Allocator,
class SizePolicy>
struct ArrayData :
209 ArrayDataBase<T, Allocator, SizePolicy>
212 typedef Allocator AllocatorType;
213 typedef SizePolicy SizePolicyType;
214 typedef ArrayDataBase<T, Allocator, SizePolicy> BaseType;
215 typedef ArrayData <T, Allocator, SizePolicy> SelfType;
221 : BaseType() { Resize(size); }
223 ArrayData(
const SelfType& a)
224 : BaseType(a.Policy) { Append(a.Data, a.Size); }
226 void Reserve(UPInt newCapacity)
228 BaseType::Reserve(
this, newCapacity);
231 void Resize(UPInt newSize)
233 UPInt oldSize = this->Size;
234 BaseType::ResizeNoConstruct(
this, newSize);
235 if(newSize > oldSize)
236 Allocator::ConstructArray(this->Data + oldSize, newSize - oldSize);
239 void PushBack(
const ValueType& val)
241 BaseType::ResizeNoConstruct(
this, this->Size + 1);
242 Allocator::Construct(this->Data + this->Size - 1, val);
246 void PushBackAlt(
const S& val)
248 BaseType::ResizeNoConstruct(
this, this->Size + 1);
249 Allocator::ConstructAlt(this->Data + this->Size - 1, val);
253 void Append(
const ValueType other[], UPInt count)
257 UPInt oldSize = this->Size;
258 BaseType::ResizeNoConstruct(
this, this->Size + count);
259 Allocator::ConstructArray(this->Data + oldSize, count, other);
272 template<
class T,
class Allocator,
class SizePolicy>
struct ArrayDataDH :
273 ArrayDataBase<T, Allocator, SizePolicy>
276 typedef Allocator AllocatorType;
277 typedef SizePolicy SizePolicyType;
278 typedef ArrayDataBase<T, Allocator, SizePolicy> BaseType;
279 typedef ArrayDataDH <T, Allocator, SizePolicy> SelfType;
281 ArrayDataDH(MemoryHeap* heap)
282 : BaseType(), pHeap(heap) { }
284 ArrayDataDH(MemoryHeap* heap,
int size)
285 : BaseType(), pHeap(heap) { Resize(size); }
287 ArrayDataDH(
const SelfType& a)
288 : BaseType(a.Policy), pHeap(a.pHeap) { Append(a.Data, a.Size); }
290 void Reserve(UPInt newCapacity)
292 BaseType::Reserve(pHeap, newCapacity);
295 void Resize(UPInt newSize)
297 UPInt oldSize = this->Size;
298 BaseType::ResizeNoConstruct(pHeap, newSize);
299 if(newSize > oldSize)
300 Allocator::ConstructArray(this->Data + oldSize, newSize - oldSize);
303 void PushBack(
const ValueType& val)
305 BaseType::ResizeNoConstruct(pHeap, this->Size + 1);
306 Allocator::Construct(this->Data + this->Size - 1, val);
310 void PushBackAlt(
const S& val)
312 BaseType::ResizeNoConstruct(pHeap, this->Size + 1);
313 Allocator::ConstructAlt(this->Data + this->Size - 1, val);
317 void Append(
const ValueType other[], UPInt count)
321 UPInt oldSize = this->Size;
322 BaseType::ResizeNoConstruct(pHeap, this->Size + count);
323 Allocator::ConstructArray(this->Data + oldSize, count, other);
327 const MemoryHeap* pHeap;
338 template<
class T,
class Allocator,
class SizePolicy>
struct ArrayDataCC :
339 ArrayDataBase<T, Allocator, SizePolicy>
342 typedef Allocator AllocatorType;
343 typedef SizePolicy SizePolicyType;
344 typedef ArrayDataBase<T, Allocator, SizePolicy> BaseType;
345 typedef ArrayDataCC <T, Allocator, SizePolicy> SelfType;
347 ArrayDataCC(
const ValueType& defval)
348 : BaseType(), DefaultValue(defval) { }
350 ArrayDataCC(
const ValueType& defval,
int size)
351 : BaseType(), DefaultValue(defval) { Resize(size); }
353 ArrayDataCC(
const SelfType& a)
354 : BaseType(a.Policy), DefaultValue(a.DefaultValue) { Append(a.Data, a.Size); }
356 void Reserve(UPInt newCapacity)
358 BaseType::Reserve(
this, newCapacity);
361 void Resize(UPInt newSize)
363 UPInt oldSize = this->Size;
364 BaseType::ResizeNoConstruct(
this, newSize);
365 if(newSize > oldSize)
366 Allocator::ConstructArray(this->Data + oldSize, newSize - oldSize, DefaultValue);
369 void PushBack(
const ValueType& val)
371 BaseType::ResizeNoConstruct(
this, this->Size + 1);
372 Allocator::Construct(this->Data + this->Size - 1, val);
376 void PushBackAlt(
const S& val)
378 BaseType::ResizeNoConstruct(
this, this->Size + 1);
379 Allocator::ConstructAlt(this->Data + this->Size - 1, val);
383 void Append(
const ValueType other[], UPInt count)
387 UPInt oldSize = this->Size;
388 BaseType::ResizeNoConstruct(
this, this->Size + count);
389 Allocator::ConstructArray(this->Data + oldSize, count, other);
393 ValueType DefaultValue;
418 template<
class ArrayData>
class ArrayBase
421 typedef typename ArrayData::ValueType ValueType;
422 typedef typename ArrayData::AllocatorType AllocatorType;
423 typedef typename ArrayData::SizePolicyType SizePolicyType;
424 typedef ArrayBase<ArrayData> SelfType;
426 KY_MEMORY_REDEFINE_NEW(ArrayBase, AllocatorType::StatId)
432 ArrayBase(
const SelfType& a)
435 ArrayBase(MemoryHeap* heap)
437 ArrayBase(MemoryHeap* heap,
int size)
438 : Data(heap, size) {}
440 ArrayBase(
const ValueType& defval)
442 ArrayBase(
const ValueType& defval,
int size)
443 : Data(defval, size) {}
445 SizePolicyType* GetSizePolicy()
const {
return Data.Policy; }
446 void SetSizePolicy(
const SizePolicyType& p) { Data.Policy = p; }
448 bool NeverShrinking()
const {
return Data.Policy.NeverShrinking(); }
449 UPInt GetSize()
const {
return Data.Size; }
450 bool IsEmpty()
const {
return Data.Size == 0; }
451 UPInt GetCapacity()
const {
return Data.GetCapacity(); }
452 UPInt GetNumBytes()
const {
return Data.GetCapacity() *
sizeof(ValueType); }
454 void ClearAndRelease() { Data.ClearAndRelease(); }
455 void Clear() { Data.Resize(0); }
456 void Resize(UPInt newSize) { Data.Resize(newSize); }
459 void Reserve(UPInt newCapacity)
461 if (newCapacity > Data.GetCapacity())
462 Data.Reserve(newCapacity);
466 ValueType& At(UPInt index)
468 KY_ASSERT(index < Data.Size);
469 return Data.Data[index];
471 const ValueType& At(UPInt index)
const
473 KY_ASSERT(index < Data.Size);
474 return Data.Data[index];
477 ValueType ValueAt(UPInt index)
const
479 KY_ASSERT(index < Data.Size);
480 return Data.Data[index];
484 ValueType& operator [] (UPInt index)
486 KY_ASSERT(index < Data.Size);
487 return Data.Data[index];
489 const ValueType& operator [] (UPInt index)
const
491 KY_ASSERT(index < Data.Size);
492 return Data.Data[index];
496 const ValueType* GetDataPtr()
const {
return Data.Data; }
497 ValueType* GetDataPtr() {
return Data.Data; }
500 void PushBack(
const ValueType& val)
510 void PushBackAlt(
const S& val)
512 Data.PushBackAlt(val);
516 void PopBack(UPInt count = 1)
518 KY_ASSERT(Data.Size >= count);
519 Data.Resize(Data.Size - count);
522 ValueType& PushDefault()
524 Data.PushBack(ValueType());
530 ValueType t = Back();
537 ValueType& Front() {
return At(0); }
538 const ValueType& Front()
const {
return At(0); }
541 ValueType& Back() {
return At(Data.Size - 1); }
542 const ValueType& Back()
const {
return At(Data.Size - 1); }
545 const SelfType& operator = (
const SelfType& a)
548 for (UPInt i = 0; i < Data.Size; i++) {
549 *(Data.Data + i) = a[i];
555 void RemoveMultipleAt(UPInt index, UPInt num)
557 KY_ASSERT(index + num <= Data.Size);
558 if (Data.Size == num)
564 AllocatorType::DestructArray(Data.Data + index, num);
565 AllocatorType::CopyArrayForward(
567 Data.Data + index + num,
568 Data.Size - num - index);
575 void RemoveAt(UPInt index)
577 KY_ASSERT(index < Data.Size);
584 AllocatorType::Destruct(Data.Data + index);
585 AllocatorType::CopyArrayForward(
587 Data.Data + index + 1,
588 Data.Size - 1 - index);
594 void InsertAt(UPInt index,
const ValueType& val = ValueType())
596 KY_ASSERT(index <= Data.Size);
598 Data.Resize(Data.Size + 1);
599 if (index < Data.Size - 1)
601 AllocatorType::CopyArrayBackward(
602 Data.Data + index + 1,
604 Data.Size - 1 - index);
606 AllocatorType::Construct(Data.Data + index, val);
610 void InsertMultipleAt(UPInt index, UPInt num,
const ValueType& val = ValueType())
612 KY_ASSERT(index <= Data.Size);
614 Data.Resize(Data.Size + num);
615 if (index < Data.Size - num)
617 AllocatorType::CopyArrayBackward(
618 Data.Data + index + num,
620 Data.Size - num - index);
622 for (UPInt i = 0; i < num; ++i)
623 AllocatorType::Construct(Data.Data + index + i, val);
627 void Append(
const SelfType& other)
629 Append(other.Data.Data, other.GetSize());
633 void Append(
const ValueType other[], UPInt count)
635 Data.Append(other, count);
644 Iterator() : pArray(0), CurIndex(-1) {}
645 Iterator(SelfType* parr, SPInt idx = 0) : pArray(parr), CurIndex(idx) {}
647 bool operator==(
const Iterator& it)
const {
return pArray == it.pArray && CurIndex == it.CurIndex; }
648 bool operator!=(
const Iterator& it)
const {
return pArray != it.pArray || CurIndex != it.CurIndex; }
650 Iterator& operator++()
654 if (CurIndex < (SPInt)pArray->GetSize())
659 Iterator operator++(
int)
665 Iterator& operator--()
674 Iterator operator--(
int)
680 Iterator operator+(
int delta)
const
682 return Iterator(pArray, CurIndex + delta);
684 Iterator operator-(
int delta)
const
686 return Iterator(pArray, CurIndex - delta);
688 SPInt operator-(
const Iterator& right)
const
690 KY_ASSERT(pArray == right.pArray);
691 return CurIndex - right.CurIndex;
693 ValueType&
operator*()
const { KY_ASSERT(pArray);
return (*pArray)[CurIndex]; }
694 ValueType* operator->()
const { KY_ASSERT(pArray);
return &(*pArray)[CurIndex]; }
695 ValueType* GetPtr()
const { KY_ASSERT(pArray);
return &(*pArray)[CurIndex]; }
697 bool IsFinished()
const {
return !pArray || CurIndex < 0 || CurIndex >= (int)pArray->GetSize(); }
702 pArray->RemoveAt(CurIndex);
705 SPInt GetIndex()
const {
return CurIndex; }
708 Iterator Begin() {
return Iterator(
this); }
709 Iterator End() {
return Iterator(
this, (SPInt)GetSize()); }
710 Iterator Last() {
return Iterator(
this, (SPInt)GetSize() - 1); }
714 const SelfType* pArray;
718 ConstIterator() : pArray(0), CurIndex(-1) {}
719 ConstIterator(
const SelfType* parr, SPInt idx = 0) : pArray(parr), CurIndex(idx) {}
721 bool operator==(
const ConstIterator& it)
const {
return pArray == it.pArray && CurIndex == it.CurIndex; }
722 bool operator!=(
const ConstIterator& it)
const {
return pArray != it.pArray || CurIndex != it.CurIndex; }
724 ConstIterator& operator++()
728 if (CurIndex < (
int)pArray->GetSize())
733 ConstIterator operator++(
int)
735 ConstIterator it(*
this);
739 ConstIterator& operator--()
748 ConstIterator operator--(
int)
750 ConstIterator it(*
this);
754 ConstIterator operator+(
int delta)
const
756 return ConstIterator(pArray, CurIndex + delta);
758 ConstIterator operator-(
int delta)
const
760 return ConstIterator(pArray, CurIndex - delta);
762 SPInt operator-(
const ConstIterator& right)
const
764 KY_ASSERT(pArray == right.pArray);
765 return CurIndex - right.CurIndex;
767 const ValueType&
operator*()
const { KY_ASSERT(pArray);
return (*pArray)[CurIndex]; }
768 const ValueType* operator->()
const { KY_ASSERT(pArray);
return &(*pArray)[CurIndex]; }
769 const ValueType* GetPtr()
const { KY_ASSERT(pArray);
return &(*pArray)[CurIndex]; }
771 bool IsFinished()
const {
return !pArray || CurIndex < 0 || CurIndex >= (int)pArray->GetSize(); }
773 SPInt GetIndex()
const {
return CurIndex; }
775 ConstIterator Begin()
const {
return ConstIterator(
this); }
776 ConstIterator End()
const {
return ConstIterator(
this, (SPInt)GetSize()); }
777 ConstIterator Last()
const {
return ConstIterator(
this, (SPInt)GetSize() - 1); }
791 template<
class T,
int SID=Stat_Default_Mem,
class SizePolicy=ArrayDefaultPolicy>
792 class Array :
public ArrayBase<ArrayData<T, AllocatorGH<T, SID>, SizePolicy> >
796 typedef AllocatorGH<T, SID> AllocatorType;
797 typedef SizePolicy SizePolicyType;
798 typedef Array<T, SID, SizePolicy> SelfType;
799 typedef ArrayBase<ArrayData<T, AllocatorGH<T, SID>, SizePolicy> > BaseType;
801 Array() : BaseType() {}
802 Array(
int size) : BaseType(size) {}
803 Array(
const SizePolicyType& p) : BaseType() { SetSizePolicy(p); }
804 Array(
const SelfType& a) : BaseType(a) {}
805 const SelfType& operator=(
const SelfType& a) { BaseType::operator=(a);
return *
this; }
815 template<
class T,
int SID=Stat_Default_Mem,
class SizePolicy=ArrayDefaultPolicy>
816 class ArrayPOD :
public ArrayBase<ArrayData<T, AllocatorGH_POD<T, SID>, SizePolicy> >
820 typedef AllocatorGH<T, SID> AllocatorType;
821 typedef SizePolicy SizePolicyType;
822 typedef ArrayPOD<T, SID, SizePolicy> SelfType;
823 typedef ArrayBase<ArrayData<T, AllocatorGH_POD<T, SID>, SizePolicy> > BaseType;
825 ArrayPOD() : BaseType() {}
826 ArrayPOD(
int size) : BaseType(size) {}
827 ArrayPOD(
const SizePolicyType& p) : BaseType() { SetSizePolicy(p); }
828 ArrayPOD(
const SelfType& a) : BaseType(a) {}
829 const SelfType& operator=(
const SelfType& a) { BaseType::operator=(a);
return *
this; }
838 template<
class T,
int SID=Stat_Default_Mem,
class SizePolicy=ArrayDefaultPolicy>
839 class ArrayCPP :
public ArrayBase<ArrayData<T, AllocatorGH_CPP<T, SID>, SizePolicy> >
843 typedef AllocatorGH<T, SID> AllocatorType;
844 typedef SizePolicy SizePolicyType;
845 typedef ArrayCPP<T, SID, SizePolicy> SelfType;
846 typedef ArrayBase<ArrayData<T, AllocatorGH_CPP<T, SID>, SizePolicy> > BaseType;
848 ArrayCPP() : BaseType() {}
849 ArrayCPP(
int size) : BaseType(size) {}
850 ArrayCPP(
const SizePolicyType& p) : BaseType() { SetSizePolicy(p); }
851 ArrayCPP(
const SelfType& a) : BaseType(a) {}
852 const SelfType& operator=(
const SelfType& a) { BaseType::operator=(a);
return *
this; }
861 template<
class T,
int SID=Stat_Default_Mem,
class SizePolicy=ArrayDefaultPolicy>
862 class ArrayLH :
public ArrayBase<ArrayData<T, AllocatorLH<T, SID>, SizePolicy> >
866 typedef AllocatorLH<T, SID> AllocatorType;
867 typedef SizePolicy SizePolicyType;
868 typedef ArrayLH<T, SID, SizePolicy> SelfType;
869 typedef ArrayBase<ArrayData<T, AllocatorLH<T, SID>, SizePolicy> > BaseType;
871 ArrayLH() : BaseType() {}
872 ArrayLH(
int size) : BaseType(size) {}
873 ArrayLH(
const SizePolicyType& p) : BaseType() { SetSizePolicy(p); }
874 ArrayLH(
const SelfType& a) : BaseType(a) {}
875 const SelfType& operator=(
const SelfType& a) { BaseType::operator=(a);
return *
this; }
883 template<
class T,
int SID=Stat_Default_Mem,
class SizePolicy=ArrayDefaultPolicy>
884 class ArrayLH_CPP :
public ArrayBase<ArrayData<T, AllocatorLH_CPP<T, SID>, SizePolicy> >
888 typedef AllocatorLH<T, SID> AllocatorType;
889 typedef SizePolicy SizePolicyType;
890 typedef ArrayLH_CPP<T, SID, SizePolicy> SelfType;
891 typedef ArrayBase<ArrayData<T, AllocatorLH_CPP<T, SID>, SizePolicy> > BaseType;
893 ArrayLH_CPP() : BaseType() {}
894 ArrayLH_CPP(
int size) : BaseType(size) {}
895 ArrayLH_CPP(
const SizePolicyType& p) : BaseType() { SetSizePolicy(p); }
896 ArrayLH_CPP(
const SelfType& a) : BaseType(a) {}
897 const SelfType& operator=(
const SelfType& a) { BaseType::operator=(a);
return *
this; }
906 template<
class T,
int SID=Stat_Default_Mem,
class SizePolicy=ArrayDefaultPolicy>
907 class ArrayLH_POD :
public ArrayBase<ArrayData<T, AllocatorLH_POD<T, SID>, SizePolicy> >
911 typedef AllocatorLH<T, SID> AllocatorType;
912 typedef SizePolicy SizePolicyType;
913 typedef ArrayLH_POD<T, SID, SizePolicy> SelfType;
914 typedef ArrayBase<ArrayData<T, AllocatorLH_POD<T, SID>, SizePolicy> > BaseType;
916 ArrayLH_POD() : BaseType() {}
917 ArrayLH_POD(
int size) : BaseType(size) {}
918 ArrayLH_POD(
const SizePolicyType& p) : BaseType() { SetSizePolicy(p); }
919 ArrayLH_POD(
const SelfType& a) : BaseType(a) {}
920 const SelfType& operator=(
const SelfType& a) { BaseType::operator=(a);
return *
this; }
928 template<
class T,
int SID=Stat_Default_Mem,
class SizePolicy=ArrayDefaultPolicy>
929 class ArrayDH :
public ArrayBase<ArrayDataDH<T, AllocatorDH<T, SID>, SizePolicy> >
933 typedef AllocatorDH<T, SID> AllocatorType;
934 typedef SizePolicy SizePolicyType;
935 typedef ArrayDH<T, SID, SizePolicy> SelfType;
936 typedef ArrayBase<ArrayDataDH<T, AllocatorDH<T, SID>, SizePolicy> > BaseType;
938 ArrayDH(MemoryHeap* heap) : BaseType(heap) {}
939 ArrayDH(MemoryHeap* heap,
int size) : BaseType(heap, size) {}
940 ArrayDH(MemoryHeap* heap,
const SizePolicyType& p) : BaseType(heap) { SetSizePolicy(p); }
941 ArrayDH(
const SelfType& a) : BaseType(a) {}
942 const SelfType& operator=(
const SelfType& a) { BaseType::operator=(a);
return *
this; }
951 template<
class T,
int SID=Stat_Default_Mem,
class SizePolicy=ArrayDefaultPolicy>
952 class ArrayDH_CPP :
public ArrayBase<ArrayDataDH<T, AllocatorDH_CPP<T, SID>, SizePolicy> >
956 typedef AllocatorDH_CPP<T, SID> AllocatorType;
957 typedef SizePolicy SizePolicyType;
958 typedef ArrayDH_CPP<T, SID, SizePolicy> SelfType;
959 typedef ArrayBase<ArrayDataDH<T, AllocatorDH_CPP<T, SID>, SizePolicy> > BaseType;
961 ArrayDH_CPP(MemoryHeap* heap) : BaseType(heap) {}
962 ArrayDH_CPP(MemoryHeap* heap,
int size) : BaseType(heap, size) {}
963 ArrayDH_CPP(MemoryHeap* heap,
const SizePolicyType& p) : BaseType(heap) { SetSizePolicy(p); }
964 ArrayDH_CPP(
const SelfType& a) : BaseType(a) {}
965 const SelfType& operator=(
const SelfType& a) { BaseType::operator=(a);
return *
this; }
974 template<
class T,
int SID=Stat_Default_Mem,
class SizePolicy=ArrayDefaultPolicy>
975 class ArrayDH_POD :
public ArrayBase<ArrayDataDH<T, AllocatorDH_POD<T, SID>, SizePolicy> >
979 typedef AllocatorDH<T, SID> AllocatorType;
980 typedef SizePolicy SizePolicyType;
981 typedef ArrayDH_POD<T, SID, SizePolicy> SelfType;
982 typedef ArrayBase<ArrayDataDH<T, AllocatorDH_POD<T, SID>, SizePolicy> > BaseType;
984 ArrayDH_POD(MemoryHeap* heap) : BaseType(heap) {}
985 ArrayDH_POD(MemoryHeap* heap,
int size) : BaseType(heap, size) {}
986 ArrayDH_POD(MemoryHeap* heap,
const SizePolicyType& p) : BaseType(heap) { SetSizePolicy(p); }
987 ArrayDH_POD(
const SelfType& a) : BaseType(a) {}
988 const SelfType& operator=(
const SelfType& a) { BaseType::operator=(a);
return *
this; }
999 template<
class T,
int SID=Stat_Default_Mem,
class SizePolicy=ArrayDefaultPolicy>
1000 class ArrayCC :
public ArrayBase<ArrayDataCC<T, AllocatorLH<T, SID>, SizePolicy> >
1003 typedef T ValueType;
1004 typedef AllocatorLH<T, SID> AllocatorType;
1005 typedef SizePolicy SizePolicyType;
1006 typedef ArrayCC<T, SID, SizePolicy> SelfType;
1007 typedef ArrayBase<ArrayDataCC<T, AllocatorLH<T, SID>, SizePolicy> > BaseType;
1009 ArrayCC(
const ValueType& defval) : BaseType(defval) {}
1010 ArrayCC(
const ValueType& defval,
int size) : BaseType(defval, size) {}
1011 ArrayCC(
const ValueType& defval,
const SizePolicyType& p) : BaseType(defval) { SetSizePolicy(p); }
1012 ArrayCC(
const SelfType& a) : BaseType(a) {}
1013 const SelfType& operator=(
const SelfType& a) { BaseType::operator=(a);
return *
this; }
1019 #if defined(KY_DEFINE_NEW)
1020 #define new KY_DEFINE_NEW
Definition: gamekitcrowddispersion.h:20
Vec2f operator*(KyFloat32 s, const Vec2f &v)
Multiplies the X and Y coordinates of v by s.
Definition: vec2f.h:184