switched std::vector -> eastl::vector

1 files changed, 71 insertions, 71 deletions

diff --git a/src/zenstore/gc.cpp b/src/zenstore/gc.cpp
index 7ac10d613..258ec80ca 100644
--- a/src/zenstore/gc.cpp
+++ b/src/zenstore/gc.cpp
@@ -536,7 +536,7 @@ CompareForGC(const IoHash& Lhs, const IoHash& Rhs)
 }
 
 bool
-FilterReferences(GcCtx& Ctx, std::string_view Context, std::vector<IoHash>& InOutReferences)
+FilterReferences(GcCtx& Ctx, std::string_view Context, eastl::vector<IoHash>& InOutReferences)
 {
 	if (InOutReferences.empty())
 	{
@@ -564,7 +564,7 @@ FilterReferences(GcCtx& Ctx, std::string_view Context, std::vector<IoHash>& InOu
 
 	if (Filter)
 	{
-		std::erase_if(InOutReferences, [&Ctx](const IoHash& Key) {
+		zen::erase_if(InOutReferences, [&Ctx](const IoHash& Key) {
 			return ((Ctx.Settings.AttachmentRangeMax < Key) || (Key < Ctx.Settings.AttachmentRangeMin));
 		});
 		RemovedCount = TotalCount - InOutReferences.size();
@@ -651,7 +651,7 @@ void
 GcManager::RemoveGcReferencer(GcReferencer& Referencer)
 {
 	RwLock::ExclusiveLockScope _(m_Lock);
-	std::erase_if(m_GcReferencers, [&](GcReferencer* $) { return $ == &Referencer; });
+	zen::erase_if(m_GcReferencers, [&](GcReferencer* $) { return $ == &Referencer; });
 }
 
 void
@@ -666,7 +666,7 @@ GcManager::RemoveGcReferenceLocker(GcReferenceLocker& ReferenceLocker)
 {
 	ZEN_MEMSCOPE(GetGcTag());
 	RwLock::ExclusiveLockScope _(m_Lock);
-	std::erase_if(m_GcReferencerLockers, [&](GcReferenceLocker* $) { return $ == &ReferenceLocker; });
+	zen::erase_if(m_GcReferencerLockers, [&](GcReferenceLocker* $) { return $ == &ReferenceLocker; });
 }
 
 void
@@ -680,7 +680,7 @@ void
 GcManager::RemoveGcReferenceStore(GcReferenceStore& ReferenceStore)
 {
 	RwLock::ExclusiveLockScope _(m_Lock);
-	std::erase_if(m_GcReferenceStores, [&](GcReferenceStore* $) { return $ == &ReferenceStore; });
+	zen::erase_if(m_GcReferenceStores, [&](GcReferenceStore* $) { return $ == &ReferenceStore; });
 }
 
 #define SCOPED_TIMER(closure)   \
@@ -892,7 +892,7 @@ GcManager::CollectGarbage(const GcSettings& Settings)
 										auto _ = MakeGuard([&WorkLeft]() { WorkLeft.CountDown(); });
 										// The Referencer will create a reference checker that guarantees that the references do not change
 										// as long as it lives
-										std::vector<GcReferenceChecker*> Checkers;
+										eastl::vector<GcReferenceChecker*> Checkers;
 										try
 										{
 											{
@@ -973,8 +973,8 @@ GcManager::CollectGarbage(const GcSettings& Settings)
 																  &ReferenceValidators]() {
 								ZEN_MEMSCOPE(GetGcTag());
 
-								auto							   _ = MakeGuard([&WorkLeft]() { WorkLeft.CountDown(); });
-								std::vector<GcReferenceValidator*> Validators;
+								auto								 _ = MakeGuard([&WorkLeft]() { WorkLeft.CountDown(); });
+								eastl::vector<GcReferenceValidator*> Validators;
 								try
 								{
 									{
@@ -1069,7 +1069,7 @@ GcManager::CollectGarbage(const GcSettings& Settings)
 				WorkerThreadPool& LockedPhaseThreadPool =
 					Settings.SingleThread ? GetSyncWorkerPool() : GetMediumWorkerPool(EWorkloadType::Background);
 
-				std::vector<RwLock::SharedLockScope> LockerScopes;
+				eastl::vector<RwLock::SharedLockScope> LockerScopes;
 				SCOPED_TIMER(uint64_t ElapsedMS = Timer.GetElapsedTimeMs(); Result.WriteBlockMS = std::chrono::milliseconds(ElapsedMS););
 				{
 					if (!ReferenceCheckers.empty())
@@ -1093,7 +1093,7 @@ GcManager::CollectGarbage(const GcSettings& Settings)
 											 });
 								for (GcReferenceLocker* ReferenceLocker : m_GcReferencerLockers)
 								{
-									std::vector<RwLock::SharedLockScope> LockScopes = ReferenceLocker->LockState(Ctx);
+									eastl::vector<RwLock::SharedLockScope> LockScopes = ReferenceLocker->LockState(Ctx);
 									for (auto It = std::make_move_iterator(LockScopes.begin());
 										 It != std::make_move_iterator(LockScopes.end());
 										 It++)
@@ -1373,7 +1373,7 @@ void
 GcManager::RemoveGcStorage(GcStorage* Storage)
 {
 	RwLock::ExclusiveLockScope _(m_Lock);
-	std::erase_if(m_GcStorage, [&](GcStorage* $) { return $ == Storage; });
+	zen::erase_if(m_GcStorage, [&](GcStorage* $) { return $ == Storage; });
 }
 
 void
@@ -1442,13 +1442,13 @@ DiskUsageWindow::KeepRange(GcClock::Tick StartTick, GcClock::Tick EndTick)
 	}
 }
 
-std::vector<uint64_t>
+eastl::vector<uint64_t>
 DiskUsageWindow::GetDiskDeltas(GcClock::Tick StartTick, GcClock::Tick EndTick, GcClock::Tick DeltaWidth, uint64_t& OutMaxDelta) const
 {
 	ZEN_ASSERT(StartTick != -1);
 	ZEN_ASSERT(DeltaWidth > 0);
 
-	std::vector<uint64_t> Result;
+	eastl::vector<uint64_t> Result;
 	Result.reserve((EndTick - StartTick + DeltaWidth - 1) / DeltaWidth);
 
 	size_t		  WindowSize	  = m_LogWindow.size();
@@ -1729,7 +1729,7 @@ GcScheduler::AppendGCLog(std::string_view Id, GcClock::TimePoint StartTime, cons
 	ZEN_MEMSCOPE(GetGcTag());
 	try
 	{
-		std::vector<uint8_t> Blob;
+		eastl::vector<uint8_t> Blob;
 		{
 			CbObjectWriter Writer;
 			Writer.BeginObject(Id);
@@ -2055,7 +2055,7 @@ GcScheduler::SchedulerThread()
 
 				const int64_t				PressureGraphLength = 30;
 				const std::chrono::duration LoadGraphTime		= PressureGraphLength * m_Config.MonitorInterval;
-				std::vector<uint64_t>		DiskDeltas;
+				eastl::vector<uint64_t>		DiskDeltas;
 				uint64_t					MaxLoad = 0;
 
 				{
@@ -2721,7 +2721,7 @@ TEST_CASE("gc.diskusagewindow")
 	{
 		uint64_t MaxDelta = 0;
 		// 0-10, 10-20, 20-30, 30-40, 40-50, 50-60, 60-70, 70-80
-		std::vector<uint64_t> DiskDeltas = Stats.GetDiskDeltas(0, 80, 10, MaxDelta);
+		eastl::vector<uint64_t> DiskDeltas = Stats.GetDiskDeltas(0, 80, 10, MaxDelta);
 		CHECK(DiskDeltas.size() == 8);
 		CHECK(MaxDelta == 15);
 		CHECK(DiskDeltas[0] == 0);
@@ -2736,8 +2736,8 @@ TEST_CASE("gc.diskusagewindow")
 
 	SUBCASE("Sub range")
 	{
-		uint64_t			  MaxDelta	 = 0;
-		std::vector<uint64_t> DiskDeltas = Stats.GetDiskDeltas(20, 40, 10, MaxDelta);
+		uint64_t				MaxDelta   = 0;
+		eastl::vector<uint64_t> DiskDeltas = Stats.GetDiskDeltas(20, 40, 10, MaxDelta);
 		CHECK(DiskDeltas.size() == 2);
 		CHECK(MaxDelta == 10);
 		CHECK(DiskDeltas[0] == 10);	 // [20:30]
@@ -2745,8 +2745,8 @@ TEST_CASE("gc.diskusagewindow")
 	}
 	SUBCASE("Unaligned sub range 1")
 	{
-		uint64_t			  MaxDelta	 = 0;
-		std::vector<uint64_t> DiskDeltas = Stats.GetDiskDeltas(21, 51, 10, MaxDelta);
+		uint64_t				MaxDelta   = 0;
+		eastl::vector<uint64_t> DiskDeltas = Stats.GetDiskDeltas(21, 51, 10, MaxDelta);
 		CHECK(DiskDeltas.size() == 3);
 		CHECK(MaxDelta == 10);
 		CHECK(DiskDeltas[0] == 0);	 // [21:31]
@@ -2755,8 +2755,8 @@ TEST_CASE("gc.diskusagewindow")
 	}
 	SUBCASE("Unaligned end range")
 	{
-		uint64_t			  MaxDelta	 = 0;
-		std::vector<uint64_t> DiskDeltas = Stats.GetDiskDeltas(29, 79, 10, MaxDelta);
+		uint64_t				MaxDelta   = 0;
+		eastl::vector<uint64_t> DiskDeltas = Stats.GetDiskDeltas(29, 79, 10, MaxDelta);
 		CHECK(DiskDeltas.size() == 5);
 		CHECK(MaxDelta == 15);
 		CHECK(DiskDeltas[0] == 0);	 // [29:39]
@@ -2767,8 +2767,8 @@ TEST_CASE("gc.diskusagewindow")
 	}
 	SUBCASE("Ahead of window")
 	{
-		uint64_t			  MaxDelta	 = 0;
-		std::vector<uint64_t> DiskDeltas = Stats.GetDiskDeltas(-40, 0, 10, MaxDelta);
+		uint64_t				MaxDelta   = 0;
+		eastl::vector<uint64_t> DiskDeltas = Stats.GetDiskDeltas(-40, 0, 10, MaxDelta);
 		CHECK(DiskDeltas.size() == 4);
 		CHECK(MaxDelta == 0);
 		CHECK(DiskDeltas[0] == 0);	// [-40:-30]
@@ -2778,8 +2778,8 @@ TEST_CASE("gc.diskusagewindow")
 	}
 	SUBCASE("After of window")
 	{
-		uint64_t			  MaxDelta	 = 0;
-		std::vector<uint64_t> DiskDeltas = Stats.GetDiskDeltas(90, 120, 10, MaxDelta);
+		uint64_t				MaxDelta   = 0;
+		eastl::vector<uint64_t> DiskDeltas = Stats.GetDiskDeltas(90, 120, 10, MaxDelta);
 		CHECK(DiskDeltas.size() == 3);
 		CHECK(MaxDelta == 0);
 		CHECK(DiskDeltas[0] == 0);	// [90:100]
@@ -2788,8 +2788,8 @@ TEST_CASE("gc.diskusagewindow")
 	}
 	SUBCASE("Encapsulating window")
 	{
-		uint64_t			  MaxDelta	 = 0;
-		std::vector<uint64_t> DiskDeltas = Stats.GetDiskDeltas(-20, 100, 10, MaxDelta);
+		uint64_t				MaxDelta   = 0;
+		eastl::vector<uint64_t> DiskDeltas = Stats.GetDiskDeltas(-20, 100, 10, MaxDelta);
 		CHECK(DiskDeltas.size() == 12);
 		CHECK(MaxDelta == 15);
 		CHECK(DiskDeltas[0] == 0);	 // [-20:-10]
@@ -2808,8 +2808,8 @@ TEST_CASE("gc.diskusagewindow")
 
 	SUBCASE("Full range half stride")
 	{
-		uint64_t			  MaxDelta	 = 0;
-		std::vector<uint64_t> DiskDeltas = Stats.GetDiskDeltas(0, 80, 20, MaxDelta);
+		uint64_t				MaxDelta   = 0;
+		eastl::vector<uint64_t> DiskDeltas = Stats.GetDiskDeltas(0, 80, 20, MaxDelta);
 		CHECK(DiskDeltas.size() == 4);
 		CHECK(MaxDelta == 20);
 		CHECK(DiskDeltas[0] == 10);	 // [0:20]
@@ -2820,8 +2820,8 @@ TEST_CASE("gc.diskusagewindow")
 
 	SUBCASE("Partial odd stride")
 	{
-		uint64_t			  MaxDelta	 = 0;
-		std::vector<uint64_t> DiskDeltas = Stats.GetDiskDeltas(13, 67, 18, MaxDelta);
+		uint64_t				MaxDelta   = 0;
+		eastl::vector<uint64_t> DiskDeltas = Stats.GetDiskDeltas(13, 67, 18, MaxDelta);
 		CHECK(DiskDeltas.size() == 3);
 		CHECK(MaxDelta == 15);
 		CHECK(DiskDeltas[0] == 10);	 // [13:31]
@@ -2850,72 +2850,72 @@ TEST_CASE("gc.keepunusedreferences")
 							 IoHash::FromHexString("ab3917854bfef7e7af2c372d795bb907a15cab15"),
 							 IoHash::FromHexString("d1df59fcab06793a5f2c372d795bb907a15cab15")};
 	{
-		std::vector<IoHash> UsedReferences;
-		std::vector<IoHash> References;
-		std::span<IoHash>	UnusedReferences = KeepUnusedReferences(UsedReferences, References);
+		eastl::vector<IoHash> UsedReferences;
+		eastl::vector<IoHash> References;
+		std::span<IoHash>	  UnusedReferences = KeepUnusedReferences(UsedReferences, References);
 		CHECK(UnusedReferences.empty());
 	}
 
 	{
-		std::vector<IoHash> UsedReferences{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
-		std::vector<IoHash> References;
-		std::span<IoHash>	UnusedReferences = KeepUnusedReferences(UsedReferences, References);
+		eastl::vector<IoHash> UsedReferences{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
+		eastl::vector<IoHash> References;
+		std::span<IoHash>	  UnusedReferences = KeepUnusedReferences(UsedReferences, References);
 		CHECK(UnusedReferences.empty());
 	}
 
 	{
-		std::vector<IoHash> UsedReferences{};
-		std::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
-		std::span<IoHash>	UnusedReferences = KeepUnusedReferences(UsedReferences, References);
+		eastl::vector<IoHash> UsedReferences{};
+		eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
+		std::span<IoHash>	  UnusedReferences = KeepUnusedReferences(UsedReferences, References);
 		CHECK(UnusedReferences.size() == 5);
 	}
 
 	{
-		std::vector<IoHash> UsedReferences{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
-		std::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
-		std::span<IoHash>	UnusedReferences = KeepUnusedReferences(UsedReferences, References);
+		eastl::vector<IoHash> UsedReferences{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
+		eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
+		std::span<IoHash>	  UnusedReferences = KeepUnusedReferences(UsedReferences, References);
 		CHECK(UnusedReferences.empty());
 	}
 
 	{
-		std::vector<IoHash> UsedReferences{Hashes[0], Hashes[2], Hashes[4]};
-		std::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
-		std::span<IoHash>	UnusedReferences = KeepUnusedReferences(UsedReferences, References);
+		eastl::vector<IoHash> UsedReferences{Hashes[0], Hashes[2], Hashes[4]};
+		eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
+		std::span<IoHash>	  UnusedReferences = KeepUnusedReferences(UsedReferences, References);
 		CHECK(UnusedReferences.size() == 2);
 		CHECK(UnusedReferences[0] == Hashes[1]);
 		CHECK(UnusedReferences[1] == Hashes[3]);
 	}
 
 	{
-		std::vector<IoHash> UsedReferences{Hashes[2], Hashes[3], Hashes[4]};
-		std::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
-		std::span<IoHash>	UnusedReferences = KeepUnusedReferences(UsedReferences, References);
+		eastl::vector<IoHash> UsedReferences{Hashes[2], Hashes[3], Hashes[4]};
+		eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
+		std::span<IoHash>	  UnusedReferences = KeepUnusedReferences(UsedReferences, References);
 		CHECK(UnusedReferences.size() == 2);
 		CHECK(UnusedReferences[0] == Hashes[0]);
 		CHECK(UnusedReferences[1] == Hashes[1]);
 	}
 
 	{
-		std::vector<IoHash> UsedReferences{Hashes[0], Hashes[1], Hashes[2]};
-		std::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
-		std::span<IoHash>	UnusedReferences = KeepUnusedReferences(UsedReferences, References);
+		eastl::vector<IoHash> UsedReferences{Hashes[0], Hashes[1], Hashes[2]};
+		eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
+		std::span<IoHash>	  UnusedReferences = KeepUnusedReferences(UsedReferences, References);
 		CHECK(UnusedReferences.size() == 2);
 		CHECK(UnusedReferences[0] == Hashes[3]);
 		CHECK(UnusedReferences[1] == Hashes[4]);
 	}
 
 	{
-		std::vector<IoHash> UsedReferences{Hashes[0], Hashes[1], Hashes[2], Hashes[4]};
-		std::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
-		std::span<IoHash>	UnusedReferences = KeepUnusedReferences(UsedReferences, References);
+		eastl::vector<IoHash> UsedReferences{Hashes[0], Hashes[1], Hashes[2], Hashes[4]};
+		eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
+		std::span<IoHash>	  UnusedReferences = KeepUnusedReferences(UsedReferences, References);
 		CHECK(UnusedReferences.size() == 1);
 		CHECK(UnusedReferences[0] == Hashes[3]);
 	}
 
 	{
-		std::vector<IoHash> UsedReferences{Hashes[1], Hashes[3]};
-		std::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
-		std::span<IoHash>	UnusedReferences = KeepUnusedReferences(UsedReferences, References);
+		eastl::vector<IoHash> UsedReferences{Hashes[1], Hashes[3]};
+		eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
+		std::span<IoHash>	  UnusedReferences = KeepUnusedReferences(UsedReferences, References);
 		CHECK(UnusedReferences.size() == 3);
 		CHECK(UnusedReferences[0] == Hashes[0]);
 		CHECK(UnusedReferences[1] == Hashes[2]);
@@ -2923,9 +2923,9 @@ TEST_CASE("gc.keepunusedreferences")
 	}
 
 	{
-		std::vector<IoHash> UsedReferences{Hashes[0]};
-		std::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
-		std::span<IoHash>	UnusedReferences = KeepUnusedReferences(UsedReferences, References);
+		eastl::vector<IoHash> UsedReferences{Hashes[0]};
+		eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
+		std::span<IoHash>	  UnusedReferences = KeepUnusedReferences(UsedReferences, References);
 		CHECK(UnusedReferences.size() == 4);
 		CHECK(UnusedReferences[0] == Hashes[1]);
 		CHECK(UnusedReferences[1] == Hashes[2]);
@@ -2934,9 +2934,9 @@ TEST_CASE("gc.keepunusedreferences")
 	}
 
 	{
-		std::vector<IoHash> UsedReferences{Hashes[1]};
-		std::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
-		std::span<IoHash>	UnusedReferences = KeepUnusedReferences(UsedReferences, References);
+		eastl::vector<IoHash> UsedReferences{Hashes[1]};
+		eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
+		std::span<IoHash>	  UnusedReferences = KeepUnusedReferences(UsedReferences, References);
 		CHECK(UnusedReferences.size() == 4);
 		CHECK(UnusedReferences[0] == Hashes[0]);
 		CHECK(UnusedReferences[1] == Hashes[2]);
@@ -2945,9 +2945,9 @@ TEST_CASE("gc.keepunusedreferences")
 	}
 
 	{
-		std::vector<IoHash> UsedReferences{Hashes[3]};
-		std::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
-		std::span<IoHash>	UnusedReferences = KeepUnusedReferences(UsedReferences, References);
+		eastl::vector<IoHash> UsedReferences{Hashes[3]};
+		eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
+		std::span<IoHash>	  UnusedReferences = KeepUnusedReferences(UsedReferences, References);
 		CHECK(UnusedReferences.size() == 4);
 		CHECK(UnusedReferences[0] == Hashes[0]);
 		CHECK(UnusedReferences[1] == Hashes[1]);
@@ -2956,9 +2956,9 @@ TEST_CASE("gc.keepunusedreferences")
 	}
 
 	{
-		std::vector<IoHash> UsedReferences{Hashes[4]};
-		std::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
-		std::span<IoHash>	UnusedReferences = KeepUnusedReferences(UsedReferences, References);
+		eastl::vector<IoHash> UsedReferences{Hashes[4]};
+		eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]};
+		std::span<IoHash>	  UnusedReferences = KeepUnusedReferences(UsedReferences, References);
 		CHECK(UnusedReferences.size() == 4);
 		CHECK(UnusedReferences[0] == Hashes[0]);
 		CHECK(UnusedReferences[1] == Hashes[1]);