fileRepository.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_FILEREPOSITORY_HPP
#define RTCTK_COMPONENTFRAMEWORK_FILEREPOSITORY_HPP
 
#include <exception>
#include <functional>
#include <mutex>
#include <thread>
 
#include <boost/filesystem.hpp>
#include <mal/utility/Uri.hpp>
 
#include <rtctk/componentFramework/exceptions.hpp>
#include <rtctk/componentFramework/repositoryIf.hpp>
 
namespace rtctk::componentFramework {
 
class PathMissingException : public RtctkException {
public:
    explicit PathMissingException(const std::string& path);
};
 
class FileFormatError : public RtctkException {
public:
    explicit FileFormatError(const boost::filesystem::path& filepath);
};
 
class InvalidUriInFileError : public RtctkException {
public:
    explicit InvalidUriInFileError(const boost::filesystem::path& filepath, const std::string& uri);
};
 
class DirCreationError : public RtctkException {
public:
    explicit DirCreationError(const boost::filesystem::path& path);
};
 
class FileRepository : virtual public RepositoryIf {
public:
    FileRepository() = delete;
    FileRepository(const FileRepository&) = delete;
    FileRepository& operator=(const FileRepository&) = delete;
    explicit FileRepository(const elt::mal::Uri& datauri, const int dirdepth);
    virtual ~FileRepository() noexcept = default;
 
    using RepositoryIf::CreateDataPoint;
    void CreateDataPoint(const DataPointPath& path, const std::type_info& type) override;
 
    void DeleteDataPoint(const DataPointPath& path) override;
    const std::type_info& GetDataPointType(const DataPointPath& path) const override;
    size_t GetDataPointSize(const DataPointPath& path) const override;
    bool DataPointExists(const DataPointPath& path) const override;
    std::pair<PathList, PathList> GetChildren(const DataPointPath& path) const override;
    Response SendReadRequest(const ReadRequest& request) const override;
    Response SendWriteRequest(const WriteRequest& request) override;
 
    inline size_t GetFitsWriteThreshold() const {
        std::scoped_lock lck(m_mutex);
        return m_fits_write_threshold;
    }
 
    inline void SetFitsWriteThreshold(size_t value) {
        std::scoped_lock lck(m_mutex);
        m_fits_write_threshold = value;
    }
 
private:
    template <typename R, typename F>
    Response ProcessRequest(const R& request, F selector) const;
 
    template <typename T>
    void ReadData(const DataPointPath& path, T& buffer, const std::string& typestr) const;
 
    template <typename T>
    void WriteData(const DataPointPath& path, const T& buffer, const std::string& typestr) const;
 
    struct IoFunctionMapEntry {
        using ReadFunction =
            std::function<void(const FileRepository*, const DataPointPath&, void*)>;
        using WriteFunction =
            std::function<void(const FileRepository*, const DataPointPath&, const void*)>;
 
        ReadFunction m_read_function;
        WriteFunction m_write_function;
    };
 
    using IoFunctionMap = std::map<std::type_index, IoFunctionMapEntry>;
 
    template <typename T>
    static auto MakeMapEntry(const std::string& typestr);
 
    mutable std::mutex m_mutex;
    boost::filesystem::path m_datapath;
    std::string m_defaultfile;
    int m_dirdepth;
    size_t m_fits_write_threshold;
 
    static const IoFunctionMap S_IO_FUNCTIONS;
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_FILEREPOSITORY_HPP