C_baseManager.hpp

/*
 * Copyright 2024 Guillaume Guillet
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef _FGE_C_BASEMANAGER_HPP_INCLUDED
#define _FGE_C_BASEMANAGER_HPP_INCLUDED
 
#include "FastEngine/C_accessLock.hpp"
#include "FastEngine/fge_except.hpp"
#include "FastEngine/network/C_packet.hpp"
#include "FastEngine/string_hash.hpp"
#include "json.hpp"
#include <cstddef>
#include <filesystem>
#include <memory>
#include <mutex>
#include <string>
#include <string_view>
#include <type_traits>
#include <unordered_map>
#include <variant>
 
#define FGE_MANAGER_BAD std::string_view()
 
namespace fge::manager
{
 
template<class TData>
struct BaseDataBlock
{
    virtual ~BaseDataBlock() = default;
    using DataPointer = std::shared_ptr<TData>;
 
    inline virtual void unload() {}
 
    DataPointer _ptr;
    bool _valid{false};
    std::filesystem::path _path;
};
 
template<class TData, class TDataBlock = BaseDataBlock<TData>>
class BaseManager
{
public:
    using DataType = TData;
    using DataBlockType = TDataBlock;
    using DataBlockPointer = std::shared_ptr<TDataBlock>;
    using Map = std::unordered_map<std::string, DataBlockPointer, StringHash, std::equal_to<>>;
 
    BaseManager() = default;
    BaseManager(BaseManager const& r) = delete;
    BaseManager(BaseManager&& r) noexcept = delete;
    virtual ~BaseManager() = default;
 
    BaseManager& operator=(BaseManager const& r) = delete;
    BaseManager& operator=(BaseManager&& r) noexcept = delete;
 
    virtual bool initialize() = 0;
    [[nodiscard]] virtual bool isInitialized() = 0;
    virtual void uninitialize() = 0;
 
    [[nodiscard]] std::size_t size() const;
 
    [[nodiscard]] AccessLock<std::mutex> acquireLock() const;
    [[nodiscard]] typename Map::const_iterator begin(AccessLock<std::mutex> const& lock) const;
    [[nodiscard]] typename Map::const_iterator end(AccessLock<std::mutex> const& lock) const;
 
    [[nodiscard]] DataBlockPointer const& getBadElement() const;
 
    [[nodiscard]] DataBlockPointer getElement(std::string_view name) const;
    [[nodiscard]] bool contains(std::string_view name) const;
    bool unload(std::string_view name);
    void unloadAll();
 
    bool push(std::string_view name, DataBlockPointer block);
 
private:
    Map g_data;
    mutable std::mutex g_mutex;
 
protected:
    DataBlockPointer _g_badElement;
};
 
enum class DataAccessorOptions
{
    BLOCKPOINTER_ONLY,
    ALLOW_VARIANT_OF_DATAPOINTER_AND_BLOCKPOINTER
};
 
template<class TManager, TManager* TGlobalManager>
struct GlobalDataAccessorManagerInfo
{
    using Manager = TManager;
    [[nodiscard]] inline constexpr TManager& operator()() const { return *TGlobalManager; }
};
 
template<class TDataAccessorManagerInfo, DataAccessorOptions TOption>
class BaseDataAccessor
{
public:
    using SharedDataType = typename TDataAccessorManagerInfo::Manager::DataBlockPointer;
    using SharedType = typename TDataAccessorManagerInfo::Manager::DataBlockType::DataPointer;
 
    BaseDataAccessor();
    BaseDataAccessor(std::string_view name);
    BaseDataAccessor(char const name[]);
    BaseDataAccessor(std::string name);
    BaseDataAccessor(SharedDataType data);
    BaseDataAccessor(SharedType data)
        requires(TOption == DataAccessorOptions::ALLOW_VARIANT_OF_DATAPOINTER_AND_BLOCKPOINTER);
    virtual ~BaseDataAccessor() = default;
 
    virtual void clear();
 
    void reload();
 
    [[nodiscard]] bool valid() const;
 
    [[nodiscard]] SharedDataType const& getSharedBlock() const;
    [[nodiscard]] SharedType const& getSharedData() const
        requires(TOption == DataAccessorOptions::ALLOW_VARIANT_OF_DATAPOINTER_AND_BLOCKPOINTER);
    [[nodiscard]] std::string const& getName() const;
 
    auto& operator=(std::string_view name);
    auto& operator=(char const name[]);
    auto& operator=(std::string name);
    auto& operator=(SharedDataType data);
    auto& operator=(SharedType data)
        requires(TOption == DataAccessorOptions::ALLOW_VARIANT_OF_DATAPOINTER_AND_BLOCKPOINTER);
 
    [[nodiscard]] typename TDataAccessorManagerInfo::Manager::DataType* retrieve();
    [[nodiscard]] typename TDataAccessorManagerInfo::Manager::DataType const* retrieve() const;
 
private:
    using VariantType = std::variant<SharedDataType, SharedType>;
    using Type = std::conditional_t<TOption == DataAccessorOptions::BLOCKPOINTER_ONLY, SharedDataType, VariantType>;
 
    Type g_data;
    std::string g_name;
};
 
template<class TDataAccessorManagerInfo, DataAccessorOptions TOption>
static net::Packet const& operator>>(net::Packet const& pck, BaseDataAccessor<TDataAccessorManagerInfo, TOption>& data);
template<class TDataAccessorManagerInfo, DataAccessorOptions TOption>
static net::Packet& operator<<(net::Packet& pck, BaseDataAccessor<TDataAccessorManagerInfo, TOption> const& data);
 
template<class TDataAccessorManagerInfo, DataAccessorOptions TOption>
static void to_json(nlohmann::json& j, BaseDataAccessor<TDataAccessorManagerInfo, TOption> const& p);
template<class TDataAccessorManagerInfo, DataAccessorOptions TOption>
static void from_json(nlohmann::json const& j, BaseDataAccessor<TDataAccessorManagerInfo, TOption>& p);
 
} // namespace fge::manager
 
#include "C_baseManager.inl"
 
#endif // _FGE_C_BASEMANAGER_HPP_INCLUDED