IMutableFileSystem::saveFileBlob (#2427)

* #include an absolute path didn't work - because paths were taken to always be relative.

* Remove ref count for Entry in RiffFileSystem.
Free up backing Entry types (to work around Dictionary not doing this).

* Some small improvements to RiffFileSystem.

* Add testing for file systems.

* Split out MemoryFileSystem.

* Add some documentation around different FileSystems.

* Small tiry up - removing unused headers, fixing some comments.
Use StringBlob::moveCreate where appropriate.

* Small improvement to MemoryFileSystem.
Improve documentation comments a little.

* Added PathKind

* * Make MemoryFileSystem not have implicit directories
* Make RelativeFileSystem only allow access to files in file system (kind of like chroot)
* Added Path::simplifyAbsolute
* Special handling for root of MemoryFileSystem
* Improvements around paths for different impls

* More improvements around RelativeFileSystem.
Special case root handling.

* Test archive serialization.
Move testinf from compression.
Remove the implicit directory test -> doesn't work on all file systems.

* Small optimization that removes need for check for a parent unless an item is being *created*.

* Add implicit path testing.

* Add support for saveFileBlob
Add testing for saveFileBlob

* Removed TemporaryFileSet
Added PlatformUtil::outputDebugMessage

* Some small improvements around RelativeFileSystem.

* Split out ImplicitDirectoryCollector so can use without requiring compression systems.

* Split out StringSliceIndexMap into own files.

1 files changed, 2 insertions, 124 deletions

diff --git a/source/core/slang-archive-file-system.h b/source/core/slang-archive-file-system.h
index 678791245..cee119c13 100644
--- a/source/core/slang-archive-file-system.h
+++ b/source/core/slang-archive-file-system.h
@@ -1,5 +1,5 @@
-#ifndef SLANG_ARCHIVE_FILE_SYSTEM_H
-#define SLANG_ARCHIVE_FILE_SYSTEM_H
+#ifndef SLANG_CORE_ARCHIVE_FILE_SYSTEM_H
+#define SLANG_CORE_ARCHIVE_FILE_SYSTEM_H
 
 #include "slang-basic.h"
 
@@ -7,9 +7,6 @@
 
 #include "slang-compression-system.h"
 
-#include "slang-string-slice-pool.h"
-#include "slang-com-object.h"
-
 namespace Slang
 {
 
@@ -26,125 +23,6 @@ class IArchiveFileSystem : public ISlangCastable
     SLANG_NO_THROW virtual void SLANG_MCALL setCompressionStyle(const CompressionStyle& style) = 0;
 };
 
-/* Maps an UnownedStringSlice to an index. All substrings are held internally in a StringSlicePool, and so
-owned by the type. */
-class StringSliceIndexMap
-{
-public:
-        /// An index that identifies a key value pair. 
-    typedef Index CountIndex;
-
-        /// Adds a key, value pair. Returns the CountIndex of the pair.
-        /// If there is already a value stored for the key it is replaced.
-    CountIndex add(const UnownedStringSlice& key, Index valueIndex);
-
-        /// Finds or adds the slice. If the slice is added the defaultValueIndex is set.
-        /// If not the index associated with the slice remains the same.
-        /// Returns the CountIndex where the key,value pair are stored
-    CountIndex findOrAdd(const UnownedStringSlice& key, Index defaultValueIndex);
-
-        /// Gets the index associated with the key. Returns -1 if there is no associated index.
-    SLANG_FORCE_INLINE Index getValue(const UnownedStringSlice& key);
-
-        /// Get the amount of pairs in the map
-    Index getCount() const { return m_indexMap.getCount(); }
-
-        /// Get the slice and the index at the specified index
-    SLANG_INLINE KeyValuePair<UnownedStringSlice, Index> getAt(CountIndex countIndex) const;
-    
-        /// Clear the contents of the map
-    void clear();
-
-        /// Get the key at the specified index
-    UnownedStringSlice getKeyAt(CountIndex index) const { return m_pool.getSlice(StringSlicePool::Handle(index)); }
-        /// Get the value at the specified index
-    Index& getValueAt(CountIndex index) { return m_indexMap[index]; }
-
-        /// Get the amount of key,value pairs
-    Index getCount() { return m_indexMap.getCount(); }
-
-        /// Ctor
-    StringSliceIndexMap() :
-        m_pool(StringSlicePool::Style::Empty)
-    {
-    }
-
-protected:
-    StringSlicePool m_pool;     ///< Pool holds the substrings
-    List<Index> m_indexMap;     ///< Maps a pool index to the output index
-};
-
-// ---------------------------------------------------------------------------
-Index StringSliceIndexMap::getValue(const UnownedStringSlice& key)
-{
-    const Index poolIndex = m_pool.findIndex(key);
-    return (poolIndex >= 0) ? m_indexMap[poolIndex] : -1;
-}
-
-// ---------------------------------------------------------------------------
-KeyValuePair<UnownedStringSlice, Index> StringSliceIndexMap::getAt(CountIndex countIndex) const
-{
-    KeyValuePair<UnownedStringSlice, Index> pair;
-    pair.Key = m_pool.getSlice(StringSlicePool::Handle(countIndex));
-    pair.Value = m_indexMap[countIndex];
-    return pair;
-}
-
-/* This class helps to find the contents and/or existence of an implicit directory.This finds the contents of a directory.
-
-This is achieved by using a path prefix that any contained path must at least match. If the remainder of the path contains a folder
- - detectable because it's not a leaf and so contains a delimiter - that directory is added. As a sub folder may contain many
- files, and the directory itself may also be defined, it is necessary to dedup. The deduping is handled by the StringSliceIndexMap. */
-class ImplicitDirectoryCollector
-{
-public:
-    
-    enum class State
-    {
-        None,                   ///< Neither the directory or content have been found
-        DirectoryExists,        ///< The directory exists
-        HasContent,             ///< If it has content, the directory must exist
-    };
-
-        /// Get the current state
-    State getState() const { return (m_map.getCount() > 0) ? State::HasContent : (m_directoryExists ? State::DirectoryExists : State::None); }
-        /// True if collector at least has the specified state
-    bool hasState(State state) { return Index(getState()) >= Index(state); }
-
-        /// Set that it exists
-    void setDirectoryExists(bool directoryExists) { m_directoryExists = directoryExists; }
-        /// Get if it exists (implicitly or explicitly)
-    bool getDirectoryExists() const { return m_directoryExists || m_map.getCount() > 0; }
-
-        /// True if the path matches the prefix
-    bool hasPrefix(const UnownedStringSlice& path) const { return path.startsWith(m_prefix.getUnownedSlice()); }
-
-        /// True if the directory has content
-    bool hasContent() const { return m_map.getCount() > 0; }
-
-        /// Gets the remainder or path after the prefix
-    UnownedStringSlice getRemainder(const UnownedStringSlice& path) const
-    {
-        SLANG_ASSERT(hasPrefix(path));
-        return UnownedStringSlice(path.begin() + m_prefix.getLength(), path.end());
-    }
-
-        /// Add a remaining path
-    void addRemainingPath(SlangPathType pathType, const UnownedStringSlice& inPathRemainder);
-        /// Add a path
-    void addPath(SlangPathType pathType, const UnownedStringSlice& canonicalPath);
-        /// Enumerate the contents
-    SlangResult enumerate(FileSystemContentsCallBack callback, void* userData);
-
-        /// Ctor
-    ImplicitDirectoryCollector(const String& canonicalPath, bool directoryExists = false);
-
-    protected:
-    StringSliceIndexMap m_map;
-    String m_prefix;
-    bool m_directoryExists;
-};
-
 SlangResult loadArchiveFileSystem(const void* data, size_t dataSizeInBytes, ComPtr<ISlangFileSystemExt>& outFileSystem);
 SlangResult createArchiveFileSystem(SlangArchiveType type, ComPtr<ISlangMutableFileSystem>& outFileSystem);