Added GetDirectoryContent utility

5 files changed, 77 insertions, 137 deletions

diff --git a/zencore/filesystem.cpp b/zencore/filesystem.cpp
index 437741161..bd85f5a11 100644
--- a/zencore/filesystem.cpp
+++ b/zencore/filesystem.cpp
@@ -1022,6 +1022,40 @@ MaximizeOpenFileCount()
 #endif
 }
 
+void
+GetDirectoryContent(const std::filesystem::path& RootDir, uint8_t Flags, DirectoryContent& OutContent)
+{
+	FileSystemTraversal Traversal;
+	struct Visitor : public FileSystemTraversal::TreeVisitor
+	{
+		Visitor(uint8_t Flags, DirectoryContent& OutContent) : Flags(Flags), Content(OutContent) {}
+
+		virtual void VisitFile([[maybe_unused]] const std::filesystem::path& Parent,
+							   [[maybe_unused]] const path_view&			 File,
+							   [[maybe_unused]] uint64_t					 FileSize) override
+		{
+			if (Flags & DirectoryContent::IncludeFilesFlag)
+			{
+				Content.Files.push_back(Parent / File);
+			}
+		}
+
+		virtual bool VisitDirectory([[maybe_unused]] const std::filesystem::path& Parent, const path_view& DirectoryName) override
+		{
+			if (Flags & DirectoryContent::IncludeDirsFlag)
+			{
+				Content.Directories.push_back(Parent / DirectoryName);
+			}
+			return (Flags & DirectoryContent::RecursiveFlag) != 0;
+		}
+
+		const uint8_t	  Flags;
+		DirectoryContent& Content;
+	} Visit(Flags, OutContent);
+
+	Traversal.TraverseFileSystem(RootDir, Visit);
+}
+
 //////////////////////////////////////////////////////////////////////////
 //
 // Testing related code follows...
diff --git a/zencore/include/zencore/filesystem.h b/zencore/include/zencore/filesystem.h
index a6e76eaa0..6d07a79b4 100644
--- a/zencore/include/zencore/filesystem.h
+++ b/zencore/include/zencore/filesystem.h
@@ -169,6 +169,17 @@ public:
 	void TraverseFileSystem(const std::filesystem::path& RootDir, TreeVisitor& Visitor);
 };
 
+struct DirectoryContent
+{
+	static const uint8_t			   IncludeDirsFlag	= 1u << 0;
+	static const uint8_t			   IncludeFilesFlag = 1u << 1;
+	static const uint8_t			   RecursiveFlag	= 1u << 2;
+	std::vector<std::filesystem::path> Files;
+	std::vector<std::filesystem::path> Directories;
+};
+
+void GetDirectoryContent(const std::filesystem::path& RootDir, uint8_t Flags, DirectoryContent& OutContent);
+
 //////////////////////////////////////////////////////////////////////////
 
 void filesystem_forcelink();  // internal
diff --git a/zenserver/cache/structuredcachestore.cpp b/zenserver/cache/structuredcachestore.cpp
index a734e9eb1..da48253e2 100644
--- a/zenserver/cache/structuredcachestore.cpp
+++ b/zenserver/cache/structuredcachestore.cpp
@@ -1956,49 +1956,23 @@ ZenCacheDiskLayer::Put(std::string_view InBucket, const IoHash& HashKey, const Z
 void
 ZenCacheDiskLayer::DiscoverBuckets()
 {
-	FileSystemTraversal Traversal;
-	struct Visitor : public FileSystemTraversal::TreeVisitor
-	{
-		virtual void VisitFile([[maybe_unused]] const std::filesystem::path& Parent,
-							   [[maybe_unused]] const path_view&			 File,
-							   [[maybe_unused]] uint64_t					 FileSize) override
-		{
-		}
-
-		virtual bool VisitDirectory([[maybe_unused]] const std::filesystem::path& Parent, const path_view& DirectoryName) override
-		{
-			Dirs.push_back((decltype(Dirs)::value_type)(DirectoryName));
-			return false;
-		}
-
-		std::vector<std::filesystem::path::string_type> Dirs;
-	} Visit;
-
-	Traversal.TraverseFileSystem(m_RootDir, Visit);
+	DirectoryContent DirContent;
+	GetDirectoryContent(m_RootDir, DirectoryContent::IncludeDirsFlag, DirContent);
 
 	// Initialize buckets
 
 	RwLock::ExclusiveLockScope _(m_Lock);
 
-	for (const auto& BucketName : Visit.Dirs)
+	for (const std::filesystem::path& BucketPath : DirContent.Directories)
 	{
+		std::string BucketName = PathToUtf8(BucketPath.stem());
 		// New bucket needs to be created
-
-#if ZEN_PLATFORM_WINDOWS
-		std::string BucketName8 = WideToUtf8(BucketName);
-#else
-		const auto& BucketName8 = BucketName;
-#endif
-
-		if (auto It = m_Buckets.find(BucketName8); It != m_Buckets.end())
+		if (auto It = m_Buckets.find(BucketName); It != m_Buckets.end())
 		{
 		}
 		else
 		{
-			auto InsertResult = m_Buckets.try_emplace(BucketName8, BucketName8);
-
-			std::filesystem::path BucketPath = m_RootDir;
-			BucketPath /= BucketName8;
+			auto InsertResult = m_Buckets.try_emplace(BucketName, BucketName);
 
 			CacheBucket& Bucket = InsertResult.first->second;
 
@@ -2006,11 +1980,11 @@ ZenCacheDiskLayer::DiscoverBuckets()
 
 			if (Bucket.IsOk())
 			{
-				ZEN_INFO("Discovered bucket '{}'", BucketName8);
+				ZEN_INFO("Discovered bucket '{}'", BucketName);
 			}
 			else
 			{
-				ZEN_WARN("Found directory '{}' in our base directory '{}' but it is not a valid bucket", BucketName8, m_RootDir);
+				ZEN_WARN("Found directory '{}' in our base directory '{}' but it is not a valid bucket", BucketName, m_RootDir);
 
 				m_Buckets.erase(InsertResult.first);
 			}
@@ -2102,44 +2076,18 @@ ZenCacheDiskLayer::TotalSize() const
 
 static constexpr std::string_view ZenCacheNamespaceDirPrefix = "ns_";
 
-namespace {
-
-	std::vector<std::string> FindExistingFolders(const std::filesystem::path& RootPath)
-	{
-		FileSystemTraversal Traversal;
-		struct Visitor : public FileSystemTraversal::TreeVisitor
-		{
-			virtual void VisitFile(const std::filesystem::path&, const path_view&, uint64_t) override {}
-
-			virtual bool VisitDirectory(const std::filesystem::path&, const path_view& DirectoryName) override
-			{
-#if ZEN_PLATFORM_WINDOWS
-				std::string DirectoryName8 = WideToUtf8(DirectoryName);
-#else
-				std::string DirectoryName8 = std::string(DirectoryName);
-#endif
-				Dirs.push_back(DirectoryName8);
-				return false;
-			}
-
-			std::vector<std::string> Dirs;
-		} Visit;
-
-		Traversal.TraverseFileSystem(RootPath, Visit);
-		return Visit.Dirs;
-	}
-
-}  // namespace
-
 ZenCacheStore::ZenCacheStore(CasGc& Gc, std::filesystem::path BasePath) : GcStorage(Gc), GcContributor(Gc)
 {
 	CreateDirectories(BasePath);
-	std::vector<std::string> ExistingFolders = FindExistingFolders(BasePath);
+
+	DirectoryContent DirContent;
+	GetDirectoryContent(BasePath, DirectoryContent::IncludeDirsFlag, DirContent);
 
 	std::vector<std::string> LegacyBuckets;
 	std::vector<std::string> Namespaces;
-	for (const std::string& DirName : ExistingFolders)
+	for (const std::filesystem::path& DirPath : DirContent.Directories)
 	{
+		std::string DirName = PathToUtf8(DirPath.stem());
 		if (DirName.starts_with(ZenCacheNamespaceDirPrefix))
 		{
 			Namespaces.push_back(DirName.substr(3));
diff --git a/zenserver/projectstore.cpp b/zenserver/projectstore.cpp
index aceb2df00..d18ae9e1a 100644
--- a/zenserver/projectstore.cpp
+++ b/zenserver/projectstore.cpp
@@ -804,29 +804,12 @@ ProjectStore::Project::DeleteOplog(std::string_view OplogId)
 void
 ProjectStore::Project::DiscoverOplogs()
 {
-	FileSystemTraversal Traversal;
-	struct Visitor : public FileSystemTraversal::TreeVisitor
-	{
-		virtual void VisitFile([[maybe_unused]] const std::filesystem::path& Parent,
-							   [[maybe_unused]] const path_view&			 File,
-							   [[maybe_unused]] uint64_t					 FileSize) override
-		{
-		}
-
-		virtual bool VisitDirectory([[maybe_unused]] const std::filesystem::path& Parent, const path_view& DirectoryName) override
-		{
-			Dirs.push_back(PathToUtf8(DirectoryName));
-			return false;
-		}
-
-		std::vector<std::string> Dirs;
-	} Visit;
-
-	Traversal.TraverseFileSystem(m_OplogStoragePath, Visit);
+	DirectoryContent DirContent;
+	GetDirectoryContent(m_OplogStoragePath, DirectoryContent::IncludeDirsFlag, DirContent);
 
-	for (const std::string& Dir : Visit.Dirs)
+	for (const std::filesystem::path& DirPath : DirContent.Directories)
 	{
-		OpenOplog(Dir);
+		OpenOplog(PathToUtf8(DirPath.stem()));
 	}
 }
 
@@ -900,34 +883,18 @@ ProjectStore::BasePathForProject(std::string_view ProjectId)
 void
 ProjectStore::DiscoverProjects()
 {
-	FileSystemTraversal Traversal;
-	struct Visitor : public FileSystemTraversal::TreeVisitor
-	{
-		virtual void VisitFile([[maybe_unused]] const std::filesystem::path& Parent,
-							   [[maybe_unused]] const path_view&			 File,
-							   [[maybe_unused]] uint64_t					 FileSize) override
-		{
-		}
-
-		virtual bool VisitDirectory([[maybe_unused]] const std::filesystem::path& Parent, const path_view& DirectoryName) override
-		{
-			Dirs.push_back(PathToUtf8(DirectoryName));
-			return false;
-		}
-
-		std::vector<std::string> Dirs;
-	} Visit;
-
 	if (!std::filesystem::exists(m_ProjectBasePath))
 	{
 		return;
 	}
 
-	Traversal.TraverseFileSystem(m_ProjectBasePath, Visit);
+	DirectoryContent DirContent;
+	GetDirectoryContent(m_ProjectBasePath, DirectoryContent::IncludeDirsFlag, DirContent);
 
-	for (const auto& Dir : Visit.Dirs)
+	for (const std::filesystem::path& DirPath : DirContent.Directories)
 	{
-		Project* Project = OpenProject(Dir);
+		std::string DirName = PathToUtf8(DirPath.stem());
+		Project*	Project = OpenProject(DirName);
 
 		if (Project)
 		{
diff --git a/zenstore/blockstore.cpp b/zenstore/blockstore.cpp
index 54a8eb9df..bfd2d63a5 100644
--- a/zenstore/blockstore.cpp
+++ b/zenstore/blockstore.cpp
@@ -162,7 +162,7 @@ BlockStore::Initialize(const std::filesystem::path&			  BlocksBasePath,
 					{
 						continue;
 					}
-					std::string FileName = Path.stem().string();
+					std::string FileName = PathToUtf8(Path.stem());
 					uint32_t	BlockIndex;
 					bool		OK = ParseHexNumber(FileName, BlockIndex);
 					if (!OK)
@@ -1074,35 +1074,15 @@ namespace {
 
 	std::vector<std::filesystem::path> GetDirectoryContent(std::filesystem::path RootDir, bool Files, bool Directories)
 	{
-		FileSystemTraversal Traversal;
-		struct Visitor : public FileSystemTraversal::TreeVisitor
-		{
-			virtual void VisitFile(const std::filesystem::path& Parent, const path_view& File, uint64_t) override
-			{
-				if (Files)
-				{
-					Items.push_back(Parent / File);
-				}
-			}
-
-			virtual bool VisitDirectory(const std::filesystem::path& Parent, const path_view& Dir) override
-			{
-				if (Directories)
-				{
-					Items.push_back(Parent / Dir);
-				}
-				return true;
-			}
-
-			bool							   Files;
-			bool							   Directories;
-			std::vector<std::filesystem::path> Items;
-		} Visit;
-		Visit.Files		  = Files;
-		Visit.Directories = Directories;
-
-		Traversal.TraverseFileSystem(RootDir, Visit);
-		return Visit.Items;
+		DirectoryContent DirectoryContent;
+		GetDirectoryContent(RootDir,
+							DirectoryContent::RecursiveFlag | (Files ? DirectoryContent::IncludeFilesFlag : 0) |
+								(Directories ? DirectoryContent::IncludeDirsFlag : 0),
+							DirectoryContent);
+		std::vector<std::filesystem::path> Result;
+		Result.insert(Result.end(), DirectoryContent.Directories.begin(), DirectoryContent.Directories.end());
+		Result.insert(Result.end(), DirectoryContent.Files.begin(), DirectoryContent.Files.end());
+		return Result;
 	};
 
 	static IoBuffer CreateChunk(uint64_t Size)