std::span -> eastl::spansb/eastl

6 files changed, 96 insertions, 96 deletions

diff --git a/src/zen/cmds/builds_cmd.cpp b/src/zen/cmds/builds_cmd.cpp
index af51ef0e7..5331c34f4 100644
--- a/src/zen/cmds/builds_cmd.cpp
+++ b/src/zen/cmds/builds_cmd.cpp
@@ -169,7 +169,7 @@ namespace {
 	}
 
 	template<typename T>
-	std::string FormatArray(std::span<const T> Items, std::string_view Prefix)
+	std::string FormatArray(eastl::span<const T> Items, std::string_view Prefix)
 	{
 		ExtendableStringBuilder<512> SB;
 		for (const T& Item : Items)
@@ -179,7 +179,7 @@ namespace {
 		return SB.ToString();
 	}
 
-	void CleanDirectory(const std::filesystem::path& Path, std::span<const std::string_view> ExcludeDirectories)
+	void CleanDirectory(const std::filesystem::path& Path, eastl::span<const std::string_view> ExcludeDirectories)
 	{
 		ZEN_TRACE_CPU("CleanDirectory");
 
@@ -234,7 +234,7 @@ namespace {
 	CompositeBuffer WriteToTempFileIfNeeded(const CompositeBuffer& Buffer, const std::filesystem::path& TempFolderPath, const IoHash& Hash)
 	{
 		// If this is a file based buffer or a compressed buffer with a memory-based header, we don't need to rewrite to disk to save memory
-		std::span<const SharedBuffer> Segments = Buffer.GetSegments();
+		eastl::span<const SharedBuffer> Segments = Buffer.GetSegments();
 		ZEN_ASSERT(Buffer.GetSegments().size() > 0);
 		IoBufferFileReference FileRef;
 		if (Segments.back().GetFileReference(FileRef))
@@ -505,11 +505,11 @@ namespace {
 		}
 	};
 
-	eastl::vector<uint32_t> CalculateAbsoluteChunkOrders(const std::span<const IoHash>							 LocalChunkHashes,
-														 const std::span<const uint32_t>						 LocalChunkOrder,
+	eastl::vector<uint32_t> CalculateAbsoluteChunkOrders(const eastl::span<const IoHash>						 LocalChunkHashes,
+														 const eastl::span<const uint32_t>						 LocalChunkOrder,
 														 const tsl::robin_map<IoHash, uint32_t, IoHash::Hasher>& ChunkHashToLocalChunkIndex,
-														 const std::span<const uint32_t>&						 LooseChunkIndexes,
-														 const std::span<const ChunkBlockDescription>&			 BlockDescriptions)
+														 const eastl::span<const uint32_t>&						 LooseChunkIndexes,
+														 const eastl::span<const ChunkBlockDescription>&		 BlockDescriptions)
 	{
 		ZEN_TRACE_CPU("CalculateAbsoluteChunkOrders");
 
@@ -571,13 +571,13 @@ namespace {
 		return AbsoluteChunkOrder;
 	}
 
-	void CalculateLocalChunkOrders(const std::span<const uint32_t>&				 AbsoluteChunkOrders,
-								   const std::span<const IoHash>				 LooseChunkHashes,
-								   const std::span<const uint64_t>				 LooseChunkRawSizes,
-								   const std::span<const ChunkBlockDescription>& BlockDescriptions,
-								   eastl::vector<IoHash>&						 OutLocalChunkHashes,
-								   eastl::vector<uint64_t>&						 OutLocalChunkRawSizes,
-								   eastl::vector<uint32_t>&						 OutLocalChunkOrders)
+	void CalculateLocalChunkOrders(const eastl::span<const uint32_t>&			   AbsoluteChunkOrders,
+								   const eastl::span<const IoHash>				   LooseChunkHashes,
+								   const eastl::span<const uint64_t>			   LooseChunkRawSizes,
+								   const eastl::span<const ChunkBlockDescription>& BlockDescriptions,
+								   eastl::vector<IoHash>&						   OutLocalChunkHashes,
+								   eastl::vector<uint64_t>&						   OutLocalChunkRawSizes,
+								   eastl::vector<uint32_t>&						   OutLocalChunkOrders)
 	{
 		ZEN_TRACE_CPU("CalculateLocalChunkOrders");
 
@@ -641,19 +641,19 @@ namespace {
 #endif	// EXTRA_VERIFY
 	}
 
-	void WriteBuildContentToCompactBinary(CbObjectWriter&						 PartManifestWriter,
-										  const SourcePlatform					 Platform,
-										  std::span<const std::filesystem::path> Paths,
-										  std::span<const IoHash>				 RawHashes,
-										  std::span<const uint64_t>				 RawSizes,
-										  std::span<const uint32_t>				 Attributes,
-										  std::span<const IoHash>				 SequenceRawHashes,
-										  std::span<const uint32_t>				 ChunkCounts,
-										  std::span<const IoHash>				 LocalChunkHashes,
-										  std::span<const uint64_t>				 LocalChunkRawSizes,
-										  eastl::vector<uint32_t>				 AbsoluteChunkOrders,
-										  const std::span<const uint32_t>		 LooseLocalChunkIndexes,
-										  const std::span<IoHash>				 BlockHashes)
+	void WriteBuildContentToCompactBinary(CbObjectWriter&						   PartManifestWriter,
+										  const SourcePlatform					   Platform,
+										  eastl::span<const std::filesystem::path> Paths,
+										  eastl::span<const IoHash>				   RawHashes,
+										  eastl::span<const uint64_t>			   RawSizes,
+										  eastl::span<const uint32_t>			   Attributes,
+										  eastl::span<const IoHash>				   SequenceRawHashes,
+										  eastl::span<const uint32_t>			   ChunkCounts,
+										  eastl::span<const IoHash>				   LocalChunkHashes,
+										  eastl::span<const uint64_t>			   LocalChunkRawSizes,
+										  eastl::vector<uint32_t>				   AbsoluteChunkOrders,
+										  const eastl::span<const uint32_t>		   LooseLocalChunkIndexes,
+										  const eastl::span<IoHash>				   BlockHashes)
 	{
 		ZEN_ASSERT(Platform != SourcePlatform::_Count);
 		PartManifestWriter.AddString("platform"sv, ToString(Platform));
@@ -832,8 +832,8 @@ namespace {
 				{
 					OutSequenceRawHashes.push_back(PathRawHash);
 					OutChunkCounts.push_back(LegacyChunkCount);
-					std::span<uint32_t> AbsoluteChunkOrder =
-						std::span<uint32_t>(LegacyAbsoluteChunkOrders).subspan(OrderIndexOffset, LegacyChunkCount);
+					eastl::span<uint32_t> AbsoluteChunkOrder =
+						eastl::span<uint32_t>(LegacyAbsoluteChunkOrders).subspan(OrderIndexOffset, LegacyChunkCount);
 					OutAbsoluteChunkOrders.insert(OutAbsoluteChunkOrders.end(), AbsoluteChunkOrder.begin(), AbsoluteChunkOrder.end());
 				}
 				OrderIndexOffset += LegacyChunkCounts[PathIndex];
@@ -911,7 +911,7 @@ namespace {
 
 	CbObject CreateStateObject(const Oid&								  BuildId,
 							   eastl::vector<std::pair<Oid, std::string>> AllBuildParts,
-							   std::span<const ChunkedFolderContent>	  PartContents,
+							   eastl::span<const ChunkedFolderContent>	  PartContents,
 							   const FolderContent&						  LocalFolderState)
 	{
 		CbObjectWriter CurrentStateWriter;
@@ -1181,8 +1181,8 @@ namespace {
 	{
 		auto It = Lookup.ChunkHashToChunkIndex.find(ChunkHash);
 		ZEN_ASSERT(It != Lookup.ChunkHashToChunkIndex.end());
-		uint32_t													 ChunkIndex		= It->second;
-		std::span<const ChunkedContentLookup::ChunkSequenceLocation> ChunkLocations = GetChunkSequenceLocations(Lookup, ChunkIndex);
+		uint32_t													   ChunkIndex	  = It->second;
+		eastl::span<const ChunkedContentLookup::ChunkSequenceLocation> ChunkLocations = GetChunkSequenceLocations(Lookup, ChunkIndex);
 		ZEN_ASSERT(!ChunkLocations.empty());
 		CompositeBuffer Chunk = OpenFileCache.GetRange(ChunkLocations[0].SequenceIndex,
 													   ChunkLocations[0].Offset,
@@ -1748,10 +1748,10 @@ namespace {
 						 const std::filesystem::path&				   Path,
 						 const ChunkedFolderContent&				   Content,
 						 const ChunkedContentLookup&				   Lookup,
-						 std::span<IoHash>							   RawHashes,
+						 eastl::span<IoHash>						   RawHashes,
 						 const eastl::vector<eastl::vector<uint32_t>>& NewBlockChunks,
 						 GeneratedBlocks&							   NewBlocks,
-						 std::span<const uint32_t>					   LooseChunkIndexes,
+						 eastl::span<const uint32_t>				   LooseChunkIndexes,
 						 const std::uint64_t						   LargeAttachmentSize,
 						 DiskStatistics&							   DiskStats,
 						 UploadStatistics&							   UploadStats,
@@ -2076,8 +2076,8 @@ namespace {
 	}
 
 	eastl::vector<size_t> FindReuseBlocks(const eastl::vector<ChunkBlockDescription>& KnownBlocks,
-										  std::span<const IoHash>					  ChunkHashes,
-										  std::span<const uint32_t>					  ChunkIndexes,
+										  eastl::span<const IoHash>					  ChunkHashes,
+										  eastl::span<const uint32_t>				  ChunkIndexes,
 										  uint8_t									  MinPercentLimit,
 										  eastl::vector<uint32_t>&					  OutUnusedChunkIndexes,
 										  FindBlocksStatistics&						  FindBlocksStats)
@@ -2806,7 +2806,7 @@ namespace {
 					PutBuildPartResult.second.size());
 		IoHash PartHash = PutBuildPartResult.first;
 
-		auto UploadAttachments = [&](std::span<IoHash> RawHashes) {
+		auto UploadAttachments = [&](eastl::span<IoHash> RawHashes) {
 			if (!AbortFlag)
 			{
 				ZEN_CONSOLE_VERBOSE("Uploading attachments: {}", FormatArray<IoHash>(RawHashes, "\n    "sv));
@@ -3339,11 +3339,11 @@ namespace {
 	};
 
 	eastl::vector<const ChunkedContentLookup::ChunkSequenceLocation*> GetRemainingChunkTargets(
-		std::span<const std::atomic<uint32_t>> SequenceIndexChunksLeftToWriteCounters,
-		const ChunkedContentLookup&			   Lookup,
-		uint32_t							   ChunkIndex)
+		eastl::span<const std::atomic<uint32_t>> SequenceIndexChunksLeftToWriteCounters,
+		const ChunkedContentLookup&				 Lookup,
+		uint32_t								 ChunkIndex)
 	{
-		std::span<const ChunkedContentLookup::ChunkSequenceLocation>	  ChunkSources = GetChunkSequenceLocations(Lookup, ChunkIndex);
+		eastl::span<const ChunkedContentLookup::ChunkSequenceLocation>	  ChunkSources = GetChunkSequenceLocations(Lookup, ChunkIndex);
 		eastl::vector<const ChunkedContentLookup::ChunkSequenceLocation*> ChunkTargetPtrs;
 		if (!ChunkSources.empty())
 		{
@@ -3359,14 +3359,14 @@ namespace {
 		return ChunkTargetPtrs;
 	};
 
-	bool WriteBlockToDisk(const std::filesystem::path&	   CacheFolderPath,
-						  const ChunkedFolderContent&	   RemoteContent,
-						  std::span<std::atomic<uint32_t>> SequenceIndexChunksLeftToWriteCounters,
-						  const CompositeBuffer&		   DecompressedBlockBuffer,
-						  const ChunkedContentLookup&	   Lookup,
-						  std::atomic<bool>*			   RemoteChunkIndexNeedsCopyFromSourceFlags,
-						  std::atomic<uint32_t>&		   OutChunksComplete,
-						  std::atomic<uint64_t>&		   OutBytesWritten)
+	bool WriteBlockToDisk(const std::filesystem::path&		 CacheFolderPath,
+						  const ChunkedFolderContent&		 RemoteContent,
+						  eastl::span<std::atomic<uint32_t>> SequenceIndexChunksLeftToWriteCounters,
+						  const CompositeBuffer&			 DecompressedBlockBuffer,
+						  const ChunkedContentLookup&		 Lookup,
+						  std::atomic<bool>*				 RemoteChunkIndexNeedsCopyFromSourceFlags,
+						  std::atomic<uint32_t>&			 OutChunksComplete,
+						  std::atomic<uint64_t>&			 OutBytesWritten)
 	{
 		ZEN_TRACE_CPU("WriteBlockToDisk");
 
@@ -3524,13 +3524,13 @@ namespace {
 		return Decompressed;
 	}
 
-	void WriteChunkToDisk(const std::filesystem::path&										  CacheFolderPath,
-						  const ChunkedFolderContent&										  Content,
-						  const ChunkedContentLookup&										  Lookup,
-						  std::span<const ChunkedContentLookup::ChunkSequenceLocation* const> ChunkTargets,
-						  const CompositeBuffer&											  ChunkData,
-						  WriteFileCache&													  OpenFileCache,
-						  std::atomic<uint64_t>&											  OutBytesWritten)
+	void WriteChunkToDisk(const std::filesystem::path&											CacheFolderPath,
+						  const ChunkedFolderContent&											Content,
+						  const ChunkedContentLookup&											Lookup,
+						  eastl::span<const ChunkedContentLookup::ChunkSequenceLocation* const> ChunkTargets,
+						  const CompositeBuffer&												ChunkData,
+						  WriteFileCache&														OpenFileCache,
+						  std::atomic<uint64_t>&												OutBytesWritten)
 	{
 		ZEN_TRACE_CPU("WriteChunkToDisk");
 
@@ -3628,7 +3628,7 @@ namespace {
 						   const IoHash&															ChunkHash,
 						   const std::uint64_t														PreferredMultipartChunkSize,
 						   const eastl::vector<const ChunkedContentLookup::ChunkSequenceLocation*>& ChunkTargetPtrs,
-						   std::span<std::atomic<uint32_t>>											SequenceIndexChunksLeftToWriteCounters,
+						   eastl::span<std::atomic<uint32_t>>										SequenceIndexChunksLeftToWriteCounters,
 						   ParallellWork&															Work,
 						   WorkerThreadPool&														WritePool,
 						   WorkerThreadPool&														NetworkPool,
@@ -4171,8 +4171,8 @@ namespace {
 							{
 								uint64_t CacheLocalFileBytesRead = 0;
 
-								size_t																	  TargetStart = 0;
-								const std::span<const ChunkedContentLookup::ChunkSequenceLocation* const> AllTargets(
+								size_t																		TargetStart = 0;
+								const eastl::span<const ChunkedContentLookup::ChunkSequenceLocation* const> AllTargets(
 									CopyData.TargetChunkLocationPtrs);
 
 								struct WriteOp
@@ -4187,7 +4187,7 @@ namespace {
 
 								for (const CacheCopyData::ChunkTarget& ChunkTarget : CopyData.ChunkTargets)
 								{
-									std::span<const ChunkedContentLookup::ChunkSequenceLocation* const> TargetRange =
+									eastl::span<const ChunkedContentLookup::ChunkSequenceLocation* const> TargetRange =
 										AllTargets.subspan(TargetStart, ChunkTarget.TargetChunkLocationCount);
 									for (const ChunkedContentLookup::ChunkSequenceLocation* Target : TargetRange)
 									{
@@ -4648,11 +4648,11 @@ namespace {
 		}
 	}
 
-	eastl::vector<std::pair<Oid, std::string>> ResolveBuildPartNames(BuildStorage&				  Storage,
-																	 const Oid&					  BuildId,
-																	 const eastl::vector<Oid>&	  BuildPartIds,
-																	 std::span<const std::string> BuildPartNames,
-																	 std::uint64_t&				  OutPreferredMultipartChunkSize)
+	eastl::vector<std::pair<Oid, std::string>> ResolveBuildPartNames(BuildStorage&					Storage,
+																	 const Oid&						BuildId,
+																	 const eastl::vector<Oid>&		BuildPartIds,
+																	 eastl::span<const std::string> BuildPartNames,
+																	 std::uint64_t&					OutPreferredMultipartChunkSize)
 	{
 		eastl::vector<std::pair<Oid, std::string>> Result;
 		{
@@ -4920,7 +4920,7 @@ namespace {
 			}
 
 			RemoteContent =
-				MergeChunkedFolderContents(OutPartContents[0], std::span<const ChunkedFolderContent>(OutPartContents).subspan(1));
+				MergeChunkedFolderContents(OutPartContents[0], eastl::span<const ChunkedFolderContent>(OutPartContents).subspan(1));
 			{
 				tsl::robin_set<IoHash> AllBlockHashes;
 				for (const ChunkBlockDescription& Description : OutBlockDescriptions)
@@ -5039,7 +5039,7 @@ namespace {
 							{
 								LocalContent =
 									MergeChunkedFolderContents(SavedPartContents[0],
-															   std::span<const ChunkedFolderContent>(SavedPartContents).subspan(1));
+															   eastl::span<const ChunkedFolderContent>(SavedPartContents).subspan(1));
 							}
 
 							if (!LocalFolderState.AreKnownFilesEqual(CurrentLocalFolderContent))
@@ -5181,14 +5181,14 @@ namespace {
 		return LocalContent;
 	}
 
-	void DownloadFolder(BuildStorage&				 Storage,
-						const Oid&					 BuildId,
-						const eastl::vector<Oid>&	 BuildPartIds,
-						std::span<const std::string> BuildPartNames,
-						const std::filesystem::path& Path,
-						bool						 AllowMultiparts,
-						bool						 WipeTargetFolder,
-						bool						 PostDownloadVerify)
+	void DownloadFolder(BuildStorage&				   Storage,
+						const Oid&					   BuildId,
+						const eastl::vector<Oid>&	   BuildPartIds,
+						eastl::span<const std::string> BuildPartNames,
+						const std::filesystem::path&   Path,
+						bool						   AllowMultiparts,
+						bool						   WipeTargetFolder,
+						bool						   PostDownloadVerify)
 	{
 		ZEN_TRACE_CPU("DownloadFolder");
 
diff --git a/src/zen/cmds/cache_cmd.cpp b/src/zen/cmds/cache_cmd.cpp
index f12dbcf63..558a69532 100644
--- a/src/zen/cmds/cache_cmd.cpp
+++ b/src/zen/cmds/cache_cmd.cpp
@@ -476,7 +476,7 @@ CacheGenerateCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 
 	HttpClient Http(m_HostName);
 
-	auto GeneratePutCacheValueRequest([this, &KeyDistribution, &Generator](std::span<std::uint64_t> BatchSizes, uint64_t RequestIndex) {
+	auto GeneratePutCacheValueRequest([this, &KeyDistribution, &Generator](eastl::span<std::uint64_t> BatchSizes, uint64_t RequestIndex) {
 		cacherequests::PutCacheValuesRequest Request({.AcceptMagic = kCbPkgMagic, .Namespace = m_Namespace});
 		for (std::uint64_t ValueSize : BatchSizes)
 		{
@@ -490,7 +490,7 @@ CacheGenerateCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 		return Request;
 	});
 
-	auto GeneratePutCacheRecordRequest([this, &KeyDistribution, &Generator](std::span<std::uint64_t> BatchSizes, uint64_t RequestIndex) {
+	auto GeneratePutCacheRecordRequest([this, &KeyDistribution, &Generator](eastl::span<std::uint64_t> BatchSizes, uint64_t RequestIndex) {
 		cacherequests::PutCacheRecordsRequest Request({.AcceptMagic = kCbPkgMagic, .Namespace = m_Namespace});
 		uint64_t							  KeyBase		  = KeyDistribution(Generator);
 		std::string							  RecordKeyString = fmt::format("{}-{}-{}", RequestIndex, KeyBase, BatchSizes.size());
@@ -514,8 +514,8 @@ CacheGenerateCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 	uint64_t	RequestIndex = 0;
 	while (Offset < Sizes.size())
 	{
-		size_t				SizeCount  = SizeCountDistribution(Generator);
-		std::span<uint64_t> BatchSizes = std::span<uint64_t>(Sizes).subspan(Offset, Min(Max(SizeCount, 1u), Sizes.size() - Offset));
+		size_t				  SizeCount	 = SizeCountDistribution(Generator);
+		eastl::span<uint64_t> BatchSizes = eastl::span<uint64_t>(Sizes).subspan(Offset, Min(Max(SizeCount, 1u), Sizes.size() - Offset));
 
 		WorkLatch.AddCount(1);
 		WorkerPool.ScheduleWork([&, BatchSizes, RequestIndex]() {
diff --git a/src/zen/cmds/print_cmd.cpp b/src/zen/cmds/print_cmd.cpp
index 469dddf55..6558296b7 100644
--- a/src/zen/cmds/print_cmd.cpp
+++ b/src/zen/cmds/print_cmd.cpp
@@ -84,8 +84,8 @@ PrintCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 	{
 		CbPackage Package = ParsePackageMessage(Data);
 
-		CbObject					  Object	  = Package.GetObject();
-		std::span<const CbAttachment> Attachments = Package.GetAttachments();
+		CbObject						Object		= Package.GetObject();
+		eastl::span<const CbAttachment> Attachments = Package.GetAttachments();
 
 		ZEN_CONSOLE("Package - {} attachments, object hash {}", Package.GetAttachments().size(), Package.GetObjectHash());
 		ZEN_CONSOLE("");
diff --git a/src/zen/cmds/workspaces_cmd.cpp b/src/zen/cmds/workspaces_cmd.cpp
index f6f86e078..2876d2fda 100644
--- a/src/zen/cmds/workspaces_cmd.cpp
+++ b/src/zen/cmds/workspaces_cmd.cpp
@@ -703,10 +703,10 @@ WorkspaceShareCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char**
 		}
 	}
 
-	auto ChunksToOidStrings = [](HttpClient&				  Http,
-								 std::string_view			  WorkspaceId,
-								 std::string_view			  ShareId,
-								 std::span<const std::string> ChunkIds) -> std::vector<std::string> {
+	auto ChunksToOidStrings = [](HttpClient&					Http,
+								 std::string_view				WorkspaceId,
+								 std::string_view				ShareId,
+								 eastl::span<const std::string> ChunkIds) -> std::vector<std::string> {
 		std::vector<std::string> Oids;
 		Oids.reserve(ChunkIds.size());
 		eastl::vector<size_t> NeedsConvertIndexes;
diff --git a/src/zen/zen.cpp b/src/zen/zen.cpp
index 4c6aa0087..598e84aad 100644
--- a/src/zen/zen.cpp
+++ b/src/zen/zen.cpp
@@ -124,11 +124,11 @@ ZenCmdBase::ParseOptions(cxxopts::Options& CmdOptions, int argc, char** argv)
 // Build an array for sub command to parse
 int
 ZenCmdBase::GetSubCommand(cxxopts::Options&,
-						  int						   argc,
-						  char**					   argv,
-						  std::span<cxxopts::Options*> SubOptions,
-						  cxxopts::Options*&		   OutSubOption,
-						  eastl::vector<char*>&		   OutSubCommandArguments)
+						  int							 argc,
+						  char**						 argv,
+						  eastl::span<cxxopts::Options*> SubOptions,
+						  cxxopts::Options*&			 OutSubOption,
+						  eastl::vector<char*>&			 OutSubCommandArguments)
 {
 	for (int i = 1; i < argc; ++i)
 	{
diff --git a/src/zen/zen.h b/src/zen/zen.h
index 510429b91..fb47fb178 100644
--- a/src/zen/zen.h
+++ b/src/zen/zen.h
@@ -52,12 +52,12 @@ public:
 
 	bool			   ParseOptions(int argc, char** argv);
 	static bool		   ParseOptions(cxxopts::Options& Options, int argc, char** argv);
-	static int		   GetSubCommand(cxxopts::Options&			  Options,
-									 int						  argc,
-									 char**						  argv,
-									 std::span<cxxopts::Options*> SubOptions,
-									 cxxopts::Options*&			  OutSubOption,
-									 eastl::vector<char*>&		  OutSubCommandArguments);
+	static int		   GetSubCommand(cxxopts::Options&				Options,
+									 int							argc,
+									 char**							argv,
+									 eastl::span<cxxopts::Options*> SubOptions,
+									 cxxopts::Options*&				OutSubOption,
+									 eastl::vector<char*>&			OutSubCommandArguments);
 	static std::string FormatHttpResponse(const cpr::Response& Response);
 	static int		   MapHttpToCommandReturnCode(const cpr::Response& Response);
 	static std::string ResolveTargetHostSpec(const std::string& InHostSpec);