Components/IFS/src/include/IFS/FWFS/ArchiveStream.h

Go to the documentation of this file.

/****
 * ArchiveStream.h
 *
 * Copyright 2021 mikee47 <mike@sillyhouse.net>
 *
 * This file is part of the IFS Library
 *
 * This library is free software: you can redistribute it and/or modify it under the terms of the
 * GNU General Public License as published by the Free Software Foundation, version 3 or later.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with this library.
 * If not, see <https://www.gnu.org/licenses/>.
 *
 */
 
#pragma once
 
#include <IFS/FileSystem.h>
#include <IFS/FsBase.h>
#include "ObjectBuffer.h"
#include "BlockEncoder.h"
 
namespace IFS::FWFS
{
class ArchiveStream : public FsBase, public IDataSourceStream
{
    struct DirInfo;
 
public:
    enum class Flag {
        IncludeMountPoints, 
    };
 
    using Flags = BitSet<uint8_t, Flag, 1>;
 
    struct VolumeInfo {
        String name;               
        uint32_t id{0};            
        TimeStamp creationTime{0}; 
 
        VolumeInfo& operator=(const IFileSystem::Info& fsinfo)
        {
            name = fsinfo.name.c_str();
            id = fsinfo.volumeID;
            creationTime = fsinfo.creationTime;
            return *this;
        }
    };
 
    class FileInfo
    {
    public:
        FileInfo(ArchiveStream& stream, DirInfo& dir, FileHandle handle, const Stat& stat)
            : handle(handle), stat(stat), stream(stream), dir(dir)
        {
        }
 
        FileSystem* getFileSystem() const
        {
            return stream.getFileSystem();
        }
 
        int setAttribute(AttributeTag tag, const void* data, size_t size);
 
        int setAttribute(AttributeTag tag, const String& data)
        {
            return setAttribute(tag, data.c_str(), data.length());
        }
 
        template <typename... ParamTypes> int setUserAttribute(uint8_t tagValue, const ParamTypes&... params)
        {
            return setAttribute(getUserAttributeTag(tagValue), params...);
        }
 
        const FileHandle handle;
        const Stat& stat;
 
    private:
        ArchiveStream& stream;
        DirInfo& dir;
    };
 
    using FilterStatCallback = Delegate<bool(const Stat& stat)>;
    using CreateEncoderCallback = Delegate<IBlockEncoder*(FileInfo& file)>;
 
    ArchiveStream(FileSystem* fileSystem, const VolumeInfo& volumeInfo, const String& rootPath = nullptr,
                  Flags flags = 0)
        : FsBase(fileSystem), currentPath(rootPath), volumeInfo(volumeInfo), flags(flags)
    {
    }
 
    ~ArchiveStream()
    {
        reset();
    }
 
    virtual bool filterStat(const Stat& stat)
    {
        return filterStatCallback ? filterStatCallback(stat) : true;
    }
 
    void onFilterStat(FilterStatCallback callback)
    {
        filterStatCallback = callback;
    }
 
    virtual IBlockEncoder* createEncoder(FileInfo& file)
    {
        return createEncoderCallback ? createEncoderCallback(file) : nullptr;
    }
 
    void onCreateEncoder(CreateEncoderCallback callback)
    {
        createEncoderCallback = callback;
    }
 
    const String& getCurrentPath() const
    {
        return currentPath;
    }
 
    uint16_t readMemoryBlock(char* data, int bufSize) override;
 
    int seekFrom(int offset, SeekOrigin origin) override;
 
    bool isFinished() override
    {
        return state >= State::done;
    }
 
    MimeType getMimeType() const override
    {
        return MimeType::BINARY;
    }
 
    bool isSuccess() const
    {
        return state == State::done;
    }
 
    void reset();
 
private:
    enum class State {
        idle,         
        start,        
        dataHeader,   
        dataContent,  
        fileHeader,   
        dirHeader,  
        volumeHeader, 
        end,          
        done,         
        error,        
    };
 
    struct DirInfo {
        DirHandle handle;
        std::unique_ptr<ObjectBuffer> content; // Directory or object content
        Object::Type type;                     // Differentiate between e.g. Directory and MountPoint
        uint8_t namelen;                       // Used to track current path
 
        void reset()
        {
            assert(handle == nullptr);
            namelen = 0;
            handle = nullptr;
            content.reset();
        }
 
        void createContent()
        {
            content = std::make_unique<ObjectBuffer>();
        }
 
        int addAttribute(AttributeTag tag, const void* data, size_t size);
    };
 
    bool fillBuffers();
    void queueStream(IDataSourceStream* stream, State newState);
    bool openRootDirectory();
    void openDirectory(const Stat& stat);
    bool readDirectory();
    bool readFileEntry(const Stat& stat);
    void sendDataHeader();
    void sendDataContent();
    void sendFileHeader();
    int getAttributes(FileHandle file, DirInfo& entry);
    void closeDirectory();
    void getVolume();
 
    String currentPath;
    VolumeInfo volumeInfo;
    FilterStatCallback filterStatCallback;
    CreateEncoderCallback createEncoderCallback;
    ObjectBuffer buffer;
    std::unique_ptr<IBlockEncoder> encoder;
    IDataSourceStream* dataBlock{nullptr};
    IDataSourceStream* source{nullptr};
    unsigned level{0}; 
    static constexpr size_t maxLevels{16};
    DirInfo directories[maxLevels]{};
    uint32_t streamOffset{0}; 
    uint32_t queuedSize{0};
    Flags flags{};
    State state{};
};
 
} // namespace IFS::FWFS