428 void reduce(RES& res, ::std::function<
void(RES&,
const TYPE&)> fn)
const;
430 void reduce(RES& res, ::std::function<
void(RES&, TYPE&)> fn);
437 CONTAINER *m_Container;
439 CONTAINER * EnsureCapacity(
const int Capacity,
const bool SkipDelete);
440 CONTAINER * Resize(
const int Capacity,
const bool SkipDelete);
446class cArray :
public cList<TYPE, cList_TrivialContainer<TYPE> >{
451template<
class TYPE,
class CONTAINER>
453 m_Container =
nullptr;
458template<
class TYPE,
class CONTAINER>
464template<
class TYPE,
class CONTAINER>
471template<
class TYPE,
class CONTAINER>
478template<
class TYPE,
class CONTAINER>
485template<
class TYPE,
class CONTAINER>
488 SetCount(Count, Fill);
492template<
class TYPE,
class CONTAINER>
498template<
class TYPE,
class CONTAINER>
500 int CurCount = (
nullptr == m_Container) ? 0 : m_Container->Count;
501 return CurCount *
sizeof(TYPE);
505template<
class TYPE,
class CONTAINER>
507 int CurCapacity = (
nullptr == m_Container) ? 0 : m_Container->Capacity;
508 return CurCapacity *
sizeof(TYPE);
512template<
class TYPE,
class CONTAINER>
515 int SrcCount = (
nullptr == Src.m_Container) ? 0 : Src.m_Container->Count;
516 EnsureCapacity(SrcCount,
false);
517 if(m_Container !=
nullptr) {
518 m_Container->Count = SrcCount;
519 for(i = 0; i < m_Container->Count; i++) {
520 m_Container->List[i] = Src.m_Container->List[i];
526template<
class TYPE,
class CONTAINER>
530 CONTAINER *OldContainer = EnsureCapacity(Count,
true);
531 if(m_Container !=
nullptr) {
532 m_Container->Count = Count;
533 for(i = 0; i < m_Container->Count; i++) {
534 m_Container->List[i] = Src[i];
537 if(OldContainer !=
nullptr) {
538 if (!std::is_trivially_copy_constructible<TYPE>()){
539 OldContainer->DestroyElements();
541 CONTAINER::Free(OldContainer);
546template<
class TYPE,
class CONTAINER>
549 Dest.m_Container = m_Container;
550 m_Container =
nullptr;
554template<
class TYPE,
class CONTAINER>
556 const int n = Count();
557 if ( from >= n ) from = n - 1;
else if ( from < 0 ) from = 0;
558 if ( to >= n ) to = n - 1;
else if ( to < 0 ) to = 0;
559 if ( from == to )
return false;
560 const TYPE t = m_Container->List[ from ];
563 m_Container->List + from,
564 m_Container->List + from + 1,
565 (to - from) *
sizeof( TYPE ) );
568 m_Container->List + to + 1,
569 m_Container->List + to,
570 (from - to) *
sizeof( TYPE ) );
572 m_Container->List[ to ] = t;
576template <
class TYPE,
class CONTAINER>
582template<
class TYPE,
class CONTAINER>
584 cAssert((
nullptr == m_Container) || (m_Container != Src->m_Container));
587 m_Container = Src->m_Container;
588 Src->m_Container =
nullptr;
592template<
class TYPE,
class CONTAINER>
598template<
class TYPE,
class CONTAINER>
600 cMath::Swap(m_Container, With->m_Container);
603template <
class TYPE,
class CONTAINER>
604template <
class Reader>
609 BS.Read(ToPtr(), Count() *
sizeof(TYPE));
613template <
class TYPE,
class CONTAINER>
614template <
class Writer>
616 BS.Write(ToPtr(), Count() *
sizeof(TYPE));
620template<
class TYPE,
class CONTAINER>
623 cAssert(m_Container !=
nullptr);
624 cAssert(Index < m_Container->Count);
625 return m_Container->List[Index];
629template<
class TYPE,
class CONTAINER>
632 cAssert(m_Container !=
nullptr);
633 cAssert(Index < m_Container->Count);
634 return m_Container->List[Index];
638template<
class TYPE,
class CONTAINER>
641 cAssert(m_Container !=
nullptr);
642 cAssert(Index < m_Container->Count);
643 return m_Container->List[Index];
647template<
class TYPE,
class CONTAINER>
650 cAssert(m_Container !=
nullptr);
651 cAssert(Index < m_Container->Count);
652 return m_Container->List[Index];
656template<
class TYPE,
class CONTAINER>
658 cAssert(m_Container !=
nullptr);
659 cAssert(m_Container->Count >= 1);
660 return m_Container->List[0];
664template<
class TYPE,
class CONTAINER>
666 cAssert(m_Container !=
nullptr);
667 cAssert(m_Container->Count >= 1);
668 return m_Container->List[0];
672template<
class TYPE,
class CONTAINER>
674 cAssert(m_Container !=
nullptr);
675 cAssert(m_Container->Count >= 1);
676 return m_Container->List[m_Container->Count - 1];
680template<
class TYPE,
class CONTAINER>
682 cAssert(m_Container !=
nullptr);
683 cAssert(m_Container->Count >= 1);
684 return m_Container->List[m_Container->Count - 1];
688template<
class TYPE,
class CONTAINER>
691 cAssert(m_Container !=
nullptr);
692 cAssert(Index < m_Container->Count);
693 m_Container->List[Index] = Value;
697template<
class TYPE,
class CONTAINER>
699 return (
nullptr == m_Container) ? nullptr : m_Container->List;
703template<
class TYPE,
class CONTAINER>
705 return (
nullptr == m_Container) ? nullptr : m_Container->List;
711template<
class TYPE,
class CONTAINER>
715 int CurCount = (
nullptr == m_Container) ? 0 : m_Container->Count;
716 cAssert(Index + Count <= CurCount);
722 for(i = Index; i < Index + Count; i++) {
723 To->Add(m_Container->List[i]);
728template<
class TYPE,
class CONTAINER>
730 if(m_Container !=
nullptr) {
731 m_Container->DestroyElements();
732 CONTAINER::Free(m_Container);
733 m_Container =
nullptr;
737template<
class TYPE,
class CONTAINER>
739 if (Index >= 0 && Index < Count())
return (*
this)[Index];
743template<
class TYPE,
class CONTAINER>
747 if (Index >= n)Add(defvalue, Index - n + 1);
748 (*this)[Index] = value;
753template<
class TYPE,
class CONTAINER>
755 if(m_Container !=
nullptr) {
757 for(i = 0; i < m_Container->Count; i++) {
758 delete m_Container->List[i];
759 m_Container->List[i] =
nullptr;
765template<
class TYPE,
class CONTAINER>
767 if(m_Container !=
nullptr) {
768 Resize(m_Container->Count,
false);
773template<
class TYPE,
class CONTAINER>
775 if(m_Container !=
nullptr) {
776 m_Container->Count = 0;
781template<
class TYPE,
class CONTAINER>
784 static_assert( mod % 8 == 0,
785 "`mod` must be an integral of multiple of 8" );
786 const int ncap = Count() * mod / 8;
791template<
class TYPE,
class CONTAINER>
793 return (
nullptr == m_Container) ? 0 : m_Container->Count;
797template<
class TYPE,
class CONTAINER>
799 return (
nullptr == m_Container) || (m_Container->Count < 1);
803template<
class TYPE,
class CONTAINER>
805 return (
nullptr == m_Container) ? 0 : m_Container->Capacity;
809template<
class TYPE,
class CONTAINER>
811 Resize(Capacity,
false);
817template<
class TYPE,
class CONTAINER>
821 int CurCount = (
nullptr == m_Container) ? 0 : m_Container->Count;
822 CONTAINER *OldContainer = EnsureCapacity(CurCount + Count,
true);
823 for(i = 0; i < Count; i++) {
824 m_Container->List[m_Container->Count] = Value;
825 m_Container->Count++;
827 if(OldContainer !=
nullptr) {
828 if (!std::is_trivially_copy_constructible<TYPE>()){
829 OldContainer->DestroyElements();
831 CONTAINER::Free(OldContainer);
833 return ((
nullptr == m_Container) ? 0 : m_Container->Count) - 1;
836template <
class TYPE,
class CONTAINER>
837template <
class array>
840 int CurCount = (
nullptr == m_Container) ? 0 : m_Container->Count;
841 int SrcCount = Src.Count();
842 EnsureCapacity(CurCount + SrcCount,
false);
843 for (i = 0; i < SrcCount; i++) {
844 m_Container->List[m_Container->Count] = Src[i];
845 m_Container->Count++;
852template<
class TYPE,
class CONTAINER>
856 int CurCount = (
nullptr == m_Container) ? 0 : m_Container->Count;
857 CONTAINER *OldContainer = EnsureCapacity(CurCount + Count,
true);
858 for(i = 0; i < Count; i++) {
859 m_Container->List[m_Container->Count] = Src[i];
860 m_Container->Count++;
862 if(OldContainer !=
nullptr) {
863 if (!std::is_trivially_copy_constructible<TYPE>()){
864 OldContainer->DestroyElements();
866 CONTAINER::Free(OldContainer);
873template<
class TYPE,
class CONTAINER>
875 cAssert(StartIndex >= 0);
877 cAssert(StartIndex + Count <= ((
nullptr == m_Container) ? 0 : m_Container->Count));
881 for(i = StartIndex; i < StartIndex + Count; i++) {
882 if(E(&m_Container->List[i], &Value)) {
890template<
class TYPE,
class CONTAINER>
892 return IndexOf(Value, StartIndex, Count() - StartIndex, E);
895template<
class TYPE,
class CONTAINER>
897 return IndexOf(Value, 0, Count(), E);
904template<
class TYPE,
class CONTAINER>
906 return LastIndexOf(Value, Count() - 1, Count(), E);
909template<
class TYPE,
class CONTAINER>
911 return LastIndexOf(Value, StartIndex, StartIndex + 1, E);
914template<
class TYPE,
class CONTAINER>
916 int CurCount = (
nullptr == m_Container) ? 0 : m_Container->Count;
918 cAssert(StartIndex >= -1);
919 cAssert(StartIndex <= 0);
924 cAssert(StartIndex >= 0);
925 cAssert(StartIndex < CurCount);
927 cAssert(Count <= StartIndex + 1);
931 i0 = StartIndex - Count + 1;
932 for(i = StartIndex; i >= i0; i--) {
933 if(E(&m_Container->List[i], &Value)) {
944template<
class TYPE,
class CONTAINER>
948 cAssert(Index + Count <= ((
nullptr == m_Container) ? 0 : m_Container->Count));
954 r = Index + Count - 1;
957 if(C(&Value, &GetAt(m)) <= 0) {
963 if(C(&Value, &GetAt(l)) == 0) {
971template<
class TYPE,
class CONTAINER>
973 return BinarySearch(0, Count(), Value, C);
978template<
class TYPE,
class CONTAINER>
981 int CurCount = (
nullptr == m_Container) ? 0 : m_Container->Count;
982 for(i = 0; i < CurCount; i++) {
983 if(E(&m_Container->List[i], &Value)) {
991template<
class TYPE,
class CONTAINER>
993 int i = IndexOf(Value, E);
1001template<
class TYPE,
class CONTAINER>
1003 const int i = IndexOf( Value, E );
1014template<
class TYPE,
class CONTAINER>
1016 cAssert(Index >= 0);
1017 cAssert(Count >= 0);
1018 cAssert(Index + Count <= ((
nullptr == m_Container) ? 0 : m_Container->Count));
1020 if(m_Container !=
nullptr) {
1022 if (Index + lcount > m_Container->Count){
1023 lcount = m_Container->Count - Index;
1025 m_Container->Count -= lcount;
1026 for(i = Index; i < m_Container->Count; i++) {
1027 m_Container->List[i] = m_Container->List[i + lcount];
1033template<
class TYPE,
class CONTAINER>
1035 cAssert(m_Container !=
nullptr);
1036 cAssert(m_Container->Count >= 1);
1037 m_Container->Count--;
1043template<
class TYPE,
class CONTAINER>
1045 int Index = IndexOf(Value, E);
1056template<
class TYPE,
class CONTAINER>
1058 cAssert(Index >= 0);
1059 int CurCount = (
nullptr == m_Container) ? 0 : m_Container->Count;
1060 cAssert(Index <= CurCount);
1061 cAssert(Count >= 0);
1065 CONTAINER *OldContainer = EnsureCapacity(CurCount + Count,
true);
1066 for(i = CurCount - 1 + Count; i >= Index + Count; i--) {
1067 m_Container->List[i] = m_Container->List[i - Count];
1069 if(m_Container !=
nullptr) {
1070 m_Container->Count += Count;
1071 cAssert(Index + Count <= m_Container->Count);
1073 for(i = 0; i < Count; i++) {
1074 m_Container->List[Index + i] = Value;
1076 if(OldContainer !=
nullptr) {
1077 if (!std::is_trivially_copy_constructible<TYPE>()){
1078 OldContainer->DestroyElements();
1080 CONTAINER::Free(OldContainer);
1087template<
class TYPE,
class CONTAINER>
1089 cAssert(Index >= 0);
1090 int CurCount = (
nullptr == m_Container) ? 0 : m_Container->Count;
1091 cAssert(Index <= CurCount);
1092 int SrcCount = (
nullptr == Src.m_Container) ? 0 : Src.m_Container->Count;
1096 EnsureCapacity(CurCount + SrcCount,
false);
1097 for(i = CurCount - 1 + SrcCount; i >= Index + SrcCount; i--) {
1098 m_Container->List[i] = m_Container->List[i - SrcCount];
1100 if(m_Container !=
nullptr) {
1101 m_Container->Count += SrcCount;
1102 cAssert(Index + SrcCount <= m_Container->Count);
1104 for(i = 0; i < SrcCount; i++) {
1105 m_Container->List[Index + i] = Src.m_Container->List[i];
1112template<
class TYPE,
class CONTAINER>
1114 cAssert(Index >= 0);
1115 int CurCount = (
nullptr == m_Container) ? 0 : m_Container->Count;
1116 cAssert(Index <= CurCount);
1117 cAssert(Count >= 0);
1121 CONTAINER *OldContainer = EnsureCapacity(CurCount + Count,
true);
1122 for(i = CurCount - 1 + Count; i >= Index + Count; i--) {
1123 m_Container->List[i] = m_Container->List[i - Count];
1125 if(m_Container !=
nullptr) {
1126 m_Container->Count += Count;
1127 cAssert(Index + Count <= m_Container->Count);
1129 for(i = 0; i < Count; i++) {
1130 m_Container->List[Index + i] = Src[i];
1132 if(OldContainer !=
nullptr) {
1133 if (!std::is_trivially_copy_constructible<TYPE>()){
1134 OldContainer->DestroyElements();
1136 CONTAINER::Free(OldContainer);
1144template<
class TYPE,
class CONTAINER>
1146 if ( Index >= Count() ) {
1147 Add( Value, Index - Count() + 1 );
1149 return (*
this)[ Index ];
1155template<
class TYPE,
class CONTAINER>
1157 const int i = find( Value );
1158 (i == -1) ? Insert( 0, Value ) : RemoveAt( i, 1 );
1165template<
class TYPE,
class CONTAINER>
1167 cAssert(Index >= 0);
1168 cAssert(Count >= 0);
1169 int CurCount = (
nullptr == m_Container) ? 0 : m_Container->Count;
1170 cAssert(Index + Count <= CurCount);
1176 for(i = 0; i < h; i++) {
1177 cMath::Swap(m_Container->List[Index + i], m_Container->List[Index + Count - 1 - i]);
1182template<
class TYPE,
class CONTAINER>
1184 if(m_Container !=
nullptr) {
1185 Reverse(0, m_Container->Count);
1193template<
class TYPE,
class CONTAINER>
1195 cAssert(Capacity >= 0);
1202 int OldCapacity = (
nullptr == m_Container) ? 0 : m_Container->Capacity;
1203 if(Capacity == OldCapacity) {
1207 CONTAINER *OldContainer = m_Container;
1208 m_Container = CONTAINER::New(Capacity);
1209 m_Container->Count = (
nullptr == OldContainer) ? 0 : OldContainer->Count;
1210 m_Container->Capacity = Capacity;
1212 if(Capacity < m_Container->Count) {
1213 m_Container->Count = Capacity;
1216 if(OldContainer !=
nullptr) {
1217 OldContainer->Copy(m_Container, m_Container->Count);
1219 return OldContainer;
1221 if (!std::is_trivially_copy_constructible<TYPE>()){
1222 OldContainer->DestroyElements();
1224 CONTAINER::Free(OldContainer);
1233template<
class TYPE,
class CONTAINER>
1235 int OldCapacity = (
nullptr == m_Container) ? 0 : m_Container->Capacity;
1236 if(Capacity > OldCapacity) {
1237 int S = Capacity + OldCapacity / 2;
1239 return Resize(S, SkipDelete);
1244template<
class TYPE,
class CONTAINER>
1246 EnsureCapacity(size,
false);
1250template<
class TYPE,
class CONTAINER>
1252 cAssert(Count >= 0);
1253 EnsureCapacity(Count,
false);
1254 if(m_Container !=
nullptr) {
1255 m_Container->Count = Count;
1260template<
class TYPE,
class CONTAINER>
1263 int CurCount = (
nullptr == m_Container) ? 0 : m_Container->Count;
1264 for(i = 0; i < CurCount; i++) {
1265 m_Container->List[i] = Value;
1270template<
class TYPE,
class CONTAINER>
1274 for (
int i = n0; i < _Count; i++)SetAt(i, Value);
1280template<
class TYPE,
class CONTAINER>
1282 cAssert(Index >= 0);
1283 cAssert(Count >= 0);
1284 cAssert(Index + Count <= ((
nullptr == m_Container) ? 0 : m_Container->Count));
1286 int i = 0, j = 0, M = 0;
1292 for(i = M; i < Count; i++) {
1293 K = GetAt(i + Index);
1296 while(j >= 0 && !f) {
1297 if(C(&K, &GetAt(j + Index)) < 0) {
1298 SetAt(j + M + Index, GetAt(j + Index));
1304 SetAt(j + M + Index, K);
1313template<
class TYPE,
class CONTAINER>
1315 cAssert(Index >= 0);
1316 cAssert(Count >= 0);
1317 int CurCount = (
nullptr == m_Container) ? 0 : m_Container->Count;
1318 cAssert(Index + Count <= CurCount);
1320 int i = 0, j = 0, M = 0;
1326 for(i = M; i < Count; i++) {
1327 K = GetAt(i + Index);
1330 while(j >= 0 && !f) {
1331 if(C(K, GetAt(j + Index))) {
1334 SetAt(j + M + Index, GetAt(j + Index));
1338 SetAt(j + M + Index, K);
1345template<
class TYPE,
class CONTAINER>
1347 Sort(0, Count(), C);
1350template<
class TYPE,
class CONTAINER>
1352 Sort(0, Count(), C);
1356template<
class TYPE,
class CONTAINER>
1358 int CurCount = (
nullptr == m_Container) ? 0 : m_Container->Count;
1359 for(
int i = 0; i < CurCount; i++) {
1360 m_Container->List[i] += u;
1365template<
class TYPE,
class CONTAINER>
1367 int CurCount = (
nullptr == m_Container) ? 0 : m_Container->Count;
1368 for(
int i = 0; i < CurCount; i++) {
1369 m_Container->List[i] -= u;
1374template<
class TYPE,
class CONTAINER>
1376 int CurCount = (
nullptr == m_Container) ? 0 : m_Container->Count;
1377 for(
int i = 0; i < CurCount; i++) {
1378 m_Container->List[i] *= u;
1383template<
class TYPE,
class CONTAINER>
1385 int CurCount = (
nullptr == m_Container) ? 0 : m_Container->Count;
1386 for(
int i = 0; i < CurCount; i++) {
1387 m_Container->List[i] /= u;
1392template<
class TYPE,
class CONTAINER>
1394 int CurCount = (
nullptr == m_Container) ? 0 : m_Container->Count;
1395 int OtherCount = (
nullptr == Other.m_Container) ? 0 : Other.m_Container->Count;
1396 if(CurCount != OtherCount) {
1399 for(
int i = 0; i < CurCount; i++) {
1400 if(m_Container->List[i] != Other.m_Container->List[i]) {
1408template<
class TYPE,
class CONTAINER>
1410 return !(*
this == Other);
1413template<
class TYPE,
class CONTAINER>
1415 for(
int i = 0; i < l.Count(); ++i) {
1416 const bool needSeparator = ((i + 1) != l.Count());
1417 out << l[i] << (needSeparator ?
" " :
"");
1422template<
class TYPE,
class CONTAINER>
1424 for (
int i = 0; i < Count(); i++)
if (fn((*
this)[i]))
return true;
1428template<
class TYPE,
class CONTAINER>
1430 for (
int i = 0; i < Count(); i++)
if (fn((*
this)[i]))
return true;
1434template<
class TYPE,
class CONTAINER>
1436 for (
int i = 0; i < Count(); i++)
if (fn((*
this)[i]))
return i;
1440template<
class TYPE,
class CONTAINER>
1442 for (
int i = 0; i < Count(); i++)
if (fn((*
this)[i]))
return i;
1446template<
class TYPE,
class CONTAINER>
1448 for (
int i = 0; i < Count(); i++)
if (!fn((*
this)[i]))
return false;
1452template<
class TYPE,
class CONTAINER>
1454 for (
int i = 0; i < Count(); i++) fn((*
this)[i]);
1457template<
class TYPE,
class CONTAINER>
1459 for (
int i = 0; i < Count(); i++) fn((*
this)[i]);
1462template<
class TYPE,
class CONTAINER>
1465 for (
int i = 0; i < Count(); i++)
if (fn((*
this)[i])) result.Add((*
this)[i]);
1468template<
class TYPE,
class CONTAINER>
1471 for (
int i = 0; i < Count(); i++) fn(res, (*
this)[i]);