peak_fileadapter.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common_c/detail/peak_common_defines.h>
 
#include <peak/backend/peak_backend.h>
#include <peak/common/peak_common_structs.hpp>
#include <peak/dll_interface/peak_dll_interface_util.hpp>
#include <peak/node_map/peak_node_map.hpp>
 
#include <cstdint>
#include <vector>
 
namespace peak
{
namespace core
{
namespace file
{

class FileAdapter
{
public:
    FileAdapter(const std::shared_ptr<NodeMap>& nodeMap, const std::string& fileName);
    ~FileAdapter();
 
    FileAdapter(const FileAdapter& other) = delete;
    FileAdapter& operator=(const FileAdapter& other) = delete;
    FileAdapter(FileAdapter&& other) = delete;
    FileAdapter& operator=(FileAdapter&& other) = delete;

    PEAK_COMMON_NO_DISCARD std::vector<uint8_t> Read(uint64_t size, uint64_t offset = 0) const;

    PEAK_COMMON_NO_DISCARD std::vector<uint8_t> ReadAll() const;

    PEAK_COMMON_NO_DISCARD uint64_t Read(uint8_t* buffer, uint64_t size, uint64_t offset = 0) const;

    void Write(const std::vector<uint8_t>& data, uint64_t offset = 0) const;

    void Write(const uint8_t* buffer, uint64_t bufferSize, uint64_t offset = 0) const;

    void Delete() const;

    PEAK_COMMON_NO_DISCARD uint64_t Size() const;

    PEAK_COMMON_NO_DISCARD uint64_t MaxSize() const;

    PEAK_COMMON_NO_DISCARD static std::vector<std::string> AvailableFileNames(
        const std::shared_ptr<NodeMap>& nodeMap);
 
private:
    PEAK_FILE_ADAPTER_HANDLE m_backendHandle{};
};
 
inline FileAdapter::FileAdapter(const std::shared_ptr<NodeMap>& nodeMap, const std::string& fileName)
{
    if (nodeMap == nullptr)
    {
        throw InvalidArgumentException("The given nodeMap is a nullptr!");
    }
 
    peak::core::ExecuteAndMapReturnCodes([&] {
        return PEAK_C_ABI_PREFIX PEAK_FileAdapter_Construct(
            nodeMap->Handle(), fileName.c_str(), &m_backendHandle);
    });
}
 
inline FileAdapter::~FileAdapter()
{
    (void)PEAK_C_ABI_PREFIX PEAK_FileAdapter_Destruct(m_backendHandle);
}
 
inline std::vector<uint8_t> FileAdapter::Read(uint64_t size, uint64_t offset) const
{
    std::vector<uint8_t> array(static_cast<size_t>(size));
    uint64_t readBytes{};
 
    peak::core::ExecuteAndMapReturnCodes([&] {
        return PEAK_C_ABI_PREFIX PEAK_FileAdapter_Read(m_backendHandle, size, offset, array.data(), &readBytes);
    });
 
    array.resize(static_cast<size_t>(readBytes));
 
    return array;
}
 
inline std::vector<uint8_t> FileAdapter::ReadAll() const
{
    return Read(MaxSize());
}
 
inline uint64_t FileAdapter::Read(uint8_t* buffer, uint64_t size, uint64_t offset) const
{
    uint64_t readBytes{};
 
    peak::core::ExecuteAndMapReturnCodes([&] {
        return PEAK_C_ABI_PREFIX PEAK_FileAdapter_Read(m_backendHandle, size, offset, buffer, &readBytes);
    });
 
    return readBytes;
}
 
inline void FileAdapter::Write(const std::vector<uint8_t>& data, uint64_t offset) const
{
    peak::core::ExecuteAndMapReturnCodes([&] {
        return PEAK_C_ABI_PREFIX PEAK_FileAdapter_Write(m_backendHandle, data.data(), data.size(), offset);
    });
}
 
inline void FileAdapter::Write(const uint8_t* buffer, uint64_t bufferSize, uint64_t offset) const
{
    peak::core::ExecuteAndMapReturnCodes(
        [&] { return PEAK_C_ABI_PREFIX PEAK_FileAdapter_Write(m_backendHandle, buffer, bufferSize, offset); });
}
 
inline void FileAdapter::Delete() const
{
    peak::core::ExecuteAndMapReturnCodes(
        [&] { return PEAK_C_ABI_PREFIX PEAK_FileAdapter_Delete(m_backendHandle); });
}
 
inline uint64_t FileAdapter::Size() const
{
    uint64_t size{};
    peak::core::ExecuteAndMapReturnCodes(
        [&] { return PEAK_C_ABI_PREFIX PEAK_FileAdapter_GetSize(m_backendHandle, &size); });
 
    return size;
}
 
inline uint64_t FileAdapter::MaxSize() const
{
    uint64_t size{};
    peak::core::ExecuteAndMapReturnCodes(
        [&] { return PEAK_C_ABI_PREFIX PEAK_FileAdapter_GetMaxSize(m_backendHandle, &size); });
 
    return size;
}
 
inline std::vector<std::string> FileAdapter::AvailableFileNames(const std::shared_ptr<NodeMap>& nodeMap)
{
    if (nodeMap == nullptr)
    {
        throw InvalidArgumentException("The given nodeMap is a nullptr!");
    }
 
    const auto fileSelectorNode = nodeMap->TryFindNode<nodes::EnumerationNode>("FileSelector");
    if (fileSelectorNode == nullptr)
    {
        throw NotAvailableException("EnumerationNode with the name 'FileSelector' not found.");
    }
    std::vector<std::string> availableFileNames{};
    const auto entries = fileSelectorNode->AvailableEntries();
    availableFileNames.reserve(entries.size());
 
    for (const auto& entry : entries)
    {
        availableFileNames.emplace_back(entry->SymbolicValue());
    }
    return availableFileNames;
}
 
} /* namespace file */
} /* namespace core */
} /* namespace peak */