switched std::vector -> eastl::vector

1 files changed, 63 insertions, 62 deletions

diff --git a/src/zenserver-test/zenserver-test.cpp b/src/zenserver-test/zenserver-test.cpp
index 6259c0f37..0dbe2cb4b 100644
--- a/src/zenserver-test/zenserver-test.cpp
+++ b/src/zenserver-test/zenserver-test.cpp
@@ -585,11 +585,11 @@ namespace utils {
 	{
 		// Convoluted way to get a compressed buffer whose result it large enough to be a separate file
 		// but also does actually compress
-		const size_t			  PartCount = (AttachmentSize / (1u * 1024u * 64)) + 1;
-		const size_t			  PartSize	= AttachmentSize / PartCount;
-		auto					  Part		= SharedBuffer(CreateRandomBlob(PartSize));
-		std::vector<SharedBuffer> Parts(PartCount, Part);
-		size_t					  RemainPartSize = AttachmentSize - (PartSize * PartCount);
+		const size_t				PartCount = (AttachmentSize / (1u * 1024u * 64)) + 1;
+		const size_t				PartSize  = AttachmentSize / PartCount;
+		auto						Part	  = SharedBuffer(CreateRandomBlob(PartSize));
+		eastl::vector<SharedBuffer> Parts(PartCount, Part);
+		size_t						RemainPartSize = AttachmentSize - (PartSize * PartCount);
 		if (RemainPartSize > 0)
 		{
 			Parts.push_back(SharedBuffer(CreateRandomBlob(RemainPartSize)));
@@ -598,9 +598,9 @@ namespace utils {
 		return Value;
 	};
 
-	std::vector<std::pair<Oid, CompressedBuffer>> CreateAttachments(const std::span<const size_t>& Sizes)
+	eastl::vector<std::pair<Oid, CompressedBuffer>> CreateAttachments(const std::span<const size_t>& Sizes)
 	{
-		std::vector<std::pair<Oid, CompressedBuffer>> Result;
+		eastl::vector<std::pair<Oid, CompressedBuffer>> Result;
 		Result.reserve(Sizes.size());
 		for (size_t Size : Sizes)
 		{
@@ -610,9 +610,9 @@ namespace utils {
 		return Result;
 	}
 
-	std::vector<std::pair<Oid, CompressedBuffer>> CreateSemiRandomAttachments(const std::span<const size_t>& Sizes)
+	eastl::vector<std::pair<Oid, CompressedBuffer>> CreateSemiRandomAttachments(const std::span<const size_t>& Sizes)
 	{
-		std::vector<std::pair<Oid, CompressedBuffer>> Result;
+		eastl::vector<std::pair<Oid, CompressedBuffer>> Result;
 		Result.reserve(Sizes.size());
 		for (size_t Size : Sizes)
 		{
@@ -1277,7 +1277,7 @@ TEST_CASE("zcache.rpc")
 								const zen::CacheKey&				   CacheKey,
 								size_t								   PayloadSize,
 								CachePolicy							   RecordPolicy) {
-		std::vector<uint8_t> Data;
+		eastl::vector<uint8_t> Data;
 		Data.resize(PayloadSize);
 		uint32_t  DataSeed = *reinterpret_cast<const uint32_t*>(&CacheKey.Hash.Hash[0]);
 		uint16_t* DataPtr  = reinterpret_cast<uint16_t*>(Data.data());
@@ -1298,8 +1298,8 @@ TEST_CASE("zcache.rpc")
 												std::string_view Bucket,
 												size_t			 Num,
 												size_t			 PayloadSize = 1024,
-												size_t			 KeyOffset	 = 1) -> std::vector<CacheKey> {
-		std::vector<zen::CacheKey> OutKeys;
+												size_t			 KeyOffset	 = 1) -> eastl::vector<CacheKey> {
+		eastl::vector<zen::CacheKey> OutKeys;
 
 		for (uint32_t Key = 1; Key <= Num; ++Key)
 		{
@@ -1382,9 +1382,9 @@ TEST_CASE("zcache.rpc")
 		const uint16_t	  BasePort = Inst.SpawnServerAndWaitUntilReady();
 		const std::string BaseUri  = fmt::format("http://localhost:{}/z$", BasePort);
 
-		CachePolicy				   Policy = CachePolicy::Default;
-		std::vector<zen::CacheKey> Keys	  = PutCacheRecords(BaseUri, "ue4.ddc"sv, "mastodon"sv, 128);
-		GetCacheRecordResult	   Result = GetCacheRecords(BaseUri, "ue4.ddc"sv, Keys, Policy);
+		CachePolicy					 Policy = CachePolicy::Default;
+		eastl::vector<zen::CacheKey> Keys	= PutCacheRecords(BaseUri, "ue4.ddc"sv, "mastodon"sv, 128);
+		GetCacheRecordResult		 Result = GetCacheRecords(BaseUri, "ue4.ddc"sv, Keys, Policy);
 
 		CHECK(Result.Result.Results.size() == Keys.size());
 
@@ -1411,9 +1411,9 @@ TEST_CASE("zcache.rpc")
 		const uint16_t	  BasePort = Inst.SpawnServerAndWaitUntilReady();
 		const std::string BaseUri  = fmt::format("http://localhost:{}/z$", BasePort);
 
-		CachePolicy				   Policy		= CachePolicy::Default;
-		std::vector<zen::CacheKey> ExistingKeys = PutCacheRecords(BaseUri, "ue4.ddc"sv, "mastodon"sv, 128);
-		std::vector<zen::CacheKey> Keys;
+		CachePolicy					 Policy		  = CachePolicy::Default;
+		eastl::vector<zen::CacheKey> ExistingKeys = PutCacheRecords(BaseUri, "ue4.ddc"sv, "mastodon"sv, 128);
+		eastl::vector<zen::CacheKey> Keys;
 
 		for (const zen::CacheKey& Key : ExistingKeys)
 		{
@@ -1458,7 +1458,7 @@ TEST_CASE("zcache.rpc")
 		ZenServerInstance LocalServer(TestEnv);
 		SpawnServer(LocalServer, LocalCfg);
 
-		std::vector<zen::CacheKey> Keys = PutCacheRecords(UpstreamCfg.BaseUri, "ue4.ddc"sv, "mastodon"sv, 4);
+		eastl::vector<zen::CacheKey> Keys = PutCacheRecords(UpstreamCfg.BaseUri, "ue4.ddc"sv, "mastodon"sv, 4);
 
 		CachePolicy			 Policy = CachePolicy::QueryLocal;
 		GetCacheRecordResult Result = GetCacheRecords(LocalCfg.BaseUri, "ue4.ddc"sv, Keys, Policy);
@@ -1483,7 +1483,7 @@ TEST_CASE("zcache.rpc")
 		ZenServerInstance LocalServer(TestEnv);
 		SpawnServer(LocalServer, LocalCfg);
 
-		std::vector<zen::CacheKey> Keys = PutCacheRecords(UpstreamCfg.BaseUri, "ue4.ddc"sv, "mastodon"sv, 4);
+		eastl::vector<zen::CacheKey> Keys = PutCacheRecords(UpstreamCfg.BaseUri, "ue4.ddc"sv, "mastodon"sv, 4);
 
 		CachePolicy			 Policy = (CachePolicy::QueryLocal | CachePolicy::QueryRemote);
 		GetCacheRecordResult Result = GetCacheRecords(LocalCfg.BaseUri, "ue4.ddc"sv, Keys, Policy);
@@ -1510,10 +1510,10 @@ TEST_CASE("zcache.rpc")
 		const uint16_t	  BasePort = Inst.SpawnServerAndWaitUntilReady();
 		const std::string BaseUri  = fmt::format("http://localhost:{}/z$", BasePort);
 
-		std::vector<zen::CacheKey> SmallKeys = PutCacheRecords(BaseUri, "ue4.ddc"sv, "mastodon"sv, 4, 1024);
-		std::vector<zen::CacheKey> LargeKeys = PutCacheRecords(BaseUri, "ue4.ddc"sv, "mastodon"sv, 4, 1024 * 1024 * 16, SmallKeys.size());
+		eastl::vector<zen::CacheKey> SmallKeys = PutCacheRecords(BaseUri, "ue4.ddc"sv, "mastodon"sv, 4, 1024);
+		eastl::vector<zen::CacheKey> LargeKeys = PutCacheRecords(BaseUri, "ue4.ddc"sv, "mastodon"sv, 4, 1024 * 1024 * 16, SmallKeys.size());
 
-		std::vector<zen::CacheKey> Keys(SmallKeys.begin(), SmallKeys.end());
+		eastl::vector<zen::CacheKey> Keys(SmallKeys.begin(), SmallKeys.end());
 		Keys.insert(Keys.end(), LargeKeys.begin(), LargeKeys.end());
 
 		{
@@ -1658,8 +1658,8 @@ TEST_CASE("zcache.failing.upstream")
 	ZenServerInstance Upstream2Server(TestEnv);
 	SpawnServer(Upstream2Server, Upstream2Cfg);
 
-	std::vector<std::uint16_t> UpstreamPorts = {Upstream1Cfg.Port, Upstream2Cfg.Port};
-	ZenConfig				   LocalCfg		 = ZenConfig::NewWithThreadedUpstreams(TestEnv.GetNewPortNumber(), UpstreamPorts, false);
+	eastl::vector<std::uint16_t> UpstreamPorts = {Upstream1Cfg.Port, Upstream2Cfg.Port};
+	ZenConfig					 LocalCfg	   = ZenConfig::NewWithThreadedUpstreams(TestEnv.GetNewPortNumber(), UpstreamPorts, false);
 	LocalCfg.Args += (" --upstream-thread-count 2");
 	ZenServerInstance LocalServer(TestEnv);
 	SpawnServer(LocalServer, LocalCfg);
@@ -1678,7 +1678,7 @@ TEST_CASE("zcache.failing.upstream")
 								const zen::CacheKey&				   CacheKey,
 								size_t								   PayloadSize,
 								CachePolicy							   RecordPolicy) {
-		std::vector<uint32_t> Data;
+		eastl::vector<uint32_t> Data;
 		Data.resize(PayloadSize / 4);
 		for (uint32_t Idx = 0; Idx < PayloadSize / 4; ++Idx)
 		{
@@ -1694,8 +1694,8 @@ TEST_CASE("zcache.failing.upstream")
 												std::string_view Bucket,
 												size_t			 Num,
 												size_t			 KeyOffset,
-												size_t			 PayloadSize = 8192) -> std::vector<CacheKey> {
-		std::vector<zen::CacheKey> OutKeys;
+												size_t			 PayloadSize = 8192) -> eastl::vector<CacheKey> {
+		eastl::vector<zen::CacheKey> OutKeys;
 
 		cacherequests::PutCacheRecordsRequest Request = {.AcceptMagic = kCbPkgMagic, .Namespace = std::string(Namespace)};
 		for (size_t Key = 1; Key <= Num; ++Key)
@@ -1785,14 +1785,15 @@ TEST_CASE("zcache.failing.upstream")
 
 	std::atomic_size_t Completed = 0;
 
-	auto   Keys = new std::vector<CacheKey>[ThreadCount * KeyMultiplier];
+	auto   Keys = new eastl::vector<CacheKey>[ThreadCount * KeyMultiplier];
 	RwLock KeysLock;
 
 	for (size_t I = 0; I < ThreadCount * KeyMultiplier; I++)
 	{
 		size_t Iteration = I;
 		Pool.ScheduleWork([&] {
-			std::vector<CacheKey> NewKeys = PutCacheRecords(LocalUri, "ue4.ddc"sv, "mastodon"sv, RecordsPerRequest, I * RecordsPerRequest);
+			eastl::vector<CacheKey> NewKeys =
+				PutCacheRecords(LocalUri, "ue4.ddc"sv, "mastodon"sv, RecordsPerRequest, I * RecordsPerRequest);
 			if (NewKeys.size() != RecordsPerRequest)
 			{
 				ZEN_DEBUG("PutCacheRecords iteration {} failed", Iteration);
@@ -1848,8 +1849,8 @@ TEST_CASE("zcache.failing.upstream")
 	Completed = 0;
 	for (size_t I = 0; I < ThreadCount * KeyMultiplier; I++)
 	{
-		size_t				   Iteration = I;
-		std::vector<CacheKey>& LocalKeys = Keys[Iteration];
+		size_t					 Iteration = I;
+		eastl::vector<CacheKey>& LocalKeys = Keys[Iteration];
 		if (LocalKeys.empty())
 		{
 			Completed.fetch_add(1);
@@ -1913,7 +1914,7 @@ TEST_CASE("zcache.rpc.partialchunks")
 	ZenServerInstance Server(TestEnv);
 	SpawnServer(Server, LocalCfg);
 
-	std::vector<CompressedBuffer> Attachments;
+	eastl::vector<CompressedBuffer> Attachments;
 
 	const auto BaseUri = fmt::format("http://localhost:{}/z$", Server.GetBasePort());
 
@@ -1927,9 +1928,9 @@ TEST_CASE("zcache.rpc.partialchunks")
 								const CacheKey&						   CacheKey,
 								size_t								   AttachmentCount,
 								size_t								   AttachmentsSize,
-								CachePolicy							   RecordPolicy) -> std::vector<std::pair<Oid, CompressedBuffer>> {
-		std::vector<std::pair<Oid, CompressedBuffer>>		   AttachmentBuffers;
-		std::vector<cacherequests::PutCacheRecordRequestValue> Attachments;
+								CachePolicy							   RecordPolicy) -> eastl::vector<std::pair<Oid, CompressedBuffer>> {
+		eastl::vector<std::pair<Oid, CompressedBuffer>>			 AttachmentBuffers;
+		eastl::vector<cacherequests::PutCacheRecordRequestValue> Attachments;
 		for (size_t AttachmentIndex = 0; AttachmentIndex < AttachmentCount; AttachmentIndex++)
 		{
 			CompressedBuffer Value = CreateSemiRandomBlob(AttachmentsSize);
@@ -1948,14 +1949,14 @@ TEST_CASE("zcache.rpc.partialchunks")
 							   size_t			Num,
 							   size_t			AttachmentCount,
 							   size_t			AttachmentsSize =
-								   8192) -> std::vector<std::pair<CacheKey, std::vector<std::pair<Oid, CompressedBuffer>>>> {
-		std::vector<std::pair<CacheKey, std::vector<std::pair<Oid, CompressedBuffer>>>> Keys;
+								   8192) -> eastl::vector<std::pair<CacheKey, eastl::vector<std::pair<Oid, CompressedBuffer>>>> {
+		eastl::vector<std::pair<CacheKey, eastl::vector<std::pair<Oid, CompressedBuffer>>>> Keys;
 
 		cacherequests::PutCacheRecordsRequest Request = {.AcceptMagic = kCbPkgMagic, .Namespace = std::string(Namespace)};
 		for (size_t Key = 1; Key <= Num; ++Key)
 		{
-			const CacheKey								  NewCacheKey = GenerateKey(Bucket, KeyOffset + Key);
-			std::vector<std::pair<Oid, CompressedBuffer>> Attachments =
+			const CacheKey									NewCacheKey = GenerateKey(Bucket, KeyOffset + Key);
+			eastl::vector<std::pair<Oid, CompressedBuffer>> Attachments =
 				AppendCacheRecord(Request, NewCacheKey, AttachmentCount, AttachmentsSize, CachePolicy::Default);
 			Keys.push_back(std::make_pair(NewCacheKey, std::move(Attachments)));
 		}
@@ -2209,12 +2210,12 @@ TEST_CASE("zcache.rpc.allpolicies")
 		UserData*	Data;
 	};
 
-	KeyData							  KeyDatas[NumKeys];
-	std::vector<CachePutRequest>	  PutRequests;
-	std::vector<CachePutValueRequest> PutValueRequests;
-	std::vector<CacheGetRequest>	  GetRequests;
-	std::vector<CacheGetValueRequest> GetValueRequests;
-	std::vector<CacheGetChunkRequest> ChunkRequests;
+	KeyData								KeyDatas[NumKeys];
+	eastl::vector<CachePutRequest>		PutRequests;
+	eastl::vector<CachePutValueRequest> PutValueRequests;
+	eastl::vector<CacheGetRequest>		GetRequests;
+	eastl::vector<CacheGetValueRequest> GetValueRequests;
+	eastl::vector<CacheGetChunkRequest> ChunkRequests;
 
 	for (uint32_t KeyIndex = 0; KeyIndex < NumKeys; ++KeyIndex)
 	{
@@ -2667,9 +2668,9 @@ public:
 	ZenServerInstance& GetInstance(int Index) { return *m_Instances[Index]; }
 
 private:
-	std::string										m_HelperId;
-	int												m_ServerCount = 0;
-	std::vector<std::unique_ptr<ZenServerInstance>> m_Instances;
+	std::string										  m_HelperId;
+	int												  m_ServerCount = 0;
+	eastl::vector<std::unique_ptr<ZenServerInstance>> m_Instances;
 };
 
 TEST_CASE("http.basics")
@@ -2822,17 +2823,17 @@ TEST_CASE("project.remote")
 	ZenServerTestHelper Servers("remote", 3);
 	Servers.SpawnServers("--debug");
 
-	std::vector<Oid> OpIds;
-	const size_t	 OpCount = 24;
+	eastl::vector<Oid> OpIds;
+	const size_t	   OpCount = 24;
 	OpIds.reserve(OpCount);
 	for (size_t I = 0; I < OpCount; ++I)
 	{
 		OpIds.emplace_back(Oid::NewOid());
 	}
 
-	std::unordered_map<Oid, std::vector<std::pair<Oid, CompressedBuffer>>, Oid::Hasher> Attachments;
+	std::unordered_map<Oid, eastl::vector<std::pair<Oid, CompressedBuffer>>, Oid::Hasher> Attachments;
 	{
-		std::vector<std::size_t> AttachmentSizes(
+		eastl::vector<std::size_t> AttachmentSizes(
 			{7633,	6825,  5738, 8031,	 7225, 566,	 3656, 6006,  24,	33466, 1093, 4269,	 2257,	3685, 13489, 97194,
 			 6151,	5482,  6217, 3511,	 6738, 5061, 7537, 2759,  1916, 8210,  2235, 224024, 51582, 5251, 491,	 2u * 1024u * 1024u + 124u,
 			 74607, 18135, 3767, 154045, 4415, 5007, 8876, 96761, 3359, 8526,  4097, 4855,	 48225});
@@ -2935,7 +2936,7 @@ TEST_CASE("project.remote")
 		MakeOp(Session, Servers.GetInstance(0).GetBaseUri(), "proj0", "oplog0", OpPackage);
 	}
 
-	std::vector<IoHash> AttachmentHashes;
+	eastl::vector<IoHash> AttachmentHashes;
 	AttachmentHashes.reserve(Attachments.size());
 	for (const auto& AttachmentOplog : Attachments)
 	{
@@ -2982,7 +2983,7 @@ TEST_CASE("project.remote")
 
 	auto ValidateOplog = [&SourceOps, &AddOp, &Servers, &Session](int ServerIndex, std::string_view Project, std::string_view Oplog) {
 		std::unordered_map<Oid, uint32_t, Oid::Hasher> TargetOps;
-		std::vector<CbObject>						   ResultingOplog;
+		eastl::vector<CbObject>						   ResultingOplog;
 
 		std::string GetOpsRequest =
 			fmt::format("{}/prj/{}/oplog/{}/entries", Servers.GetInstance(ServerIndex).GetBaseUri(), Project, Oplog);
@@ -3295,11 +3296,11 @@ TEST_CASE("project.remote")
 	}
 }
 
-std::vector<std::pair<std::filesystem::path, IoBuffer>>
+eastl::vector<std::pair<std::filesystem::path, IoBuffer>>
 GenerateFolderContent(const std::filesystem::path& RootPath)
 {
 	CreateDirectories(RootPath);
-	std::vector<std::pair<std::filesystem::path, IoBuffer>> Result;
+	eastl::vector<std::pair<std::filesystem::path, IoBuffer>> Result;
 	Result.push_back(std::make_pair(RootPath / "root_blob_1.bin", CreateRandomBlob(4122)));
 	Result.push_back(std::make_pair(RootPath / "root_blob_2.bin", CreateRandomBlob(2122)));
 
@@ -3328,10 +3329,10 @@ GenerateFolderContent(const std::filesystem::path& RootPath)
 	return Result;
 }
 
-std::vector<std::pair<std::filesystem::path, IoBuffer>>
+eastl::vector<std::pair<std::filesystem::path, IoBuffer>>
 GenerateFolderContent2(const std::filesystem::path& RootPath)
 {
-	std::vector<std::pair<std::filesystem::path, IoBuffer>> Result;
+	eastl::vector<std::pair<std::filesystem::path, IoBuffer>> Result;
 	Result.push_back(std::make_pair(RootPath / "root_blob_3.bin", CreateRandomBlob(312)));
 	std::filesystem::path FirstFolder(RootPath / "first_folder");
 	Result.push_back(std::make_pair(FirstFolder / "first_folder_blob3.bin", CreateRandomBlob(722)));
@@ -3777,8 +3778,8 @@ TEST_CASE("workspaces.share")
 	}
 
 	{
-		uint32_t					   CorrelationId = gsl::narrow<uint32_t>(Files.size());
-		std::vector<RequestChunkEntry> BatchEntries;
+		uint32_t						 CorrelationId = gsl::narrow<uint32_t>(Files.size());
+		eastl::vector<RequestChunkEntry> BatchEntries;
 		for (auto It : Files)
 		{
 			const Oid&	   ChunkId = It.first;
@@ -3790,7 +3791,7 @@ TEST_CASE("workspaces.share")
 		IoBuffer BatchResponse =
 			Client.Post(fmt::format("/ws/{}/{}/batch", WorkspaceId, ShareId), BuildChunkBatchRequest(BatchEntries)).ResponsePayload;
 		CHECK(BatchResponse);
-		std::vector<IoBuffer> BatchResult = ParseChunkBatchResponse(BatchResponse);
+		eastl::vector<IoBuffer> BatchResult = ParseChunkBatchResponse(BatchResponse);
 		CHECK(BatchResult.size() == Files.size());
 		for (const RequestChunkEntry& Request : BatchEntries)
 		{