network_manager.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_NETWORK_MANAGER_HPP_INCLUDED
#define _FGE_NETWORK_MANAGER_HPP_INCLUDED
 
#include "FastEngine/fge_extern.hpp"
#include "FastEngine/C_scene.hpp"
#include "FastEngine/network/C_client.hpp"
#include "FastEngine/network/C_packet.hpp"
#include "FastEngine/object/C_object.hpp"
#include <optional>
#include <variant>
 
namespace fge::net
{
 
FGE_API uint32_t GetSceneChecksum(fge::Scene& scene);
 
FGE_API bool WritePacketDataToFile(fge::net::Packet& pck, std::string const& file);
 
inline bool CheckSkey(fge::net::Packet& pck, fge::net::Skey skey);
inline fge::net::Skey GetSkey(fge::net::Packet& pck);
 
namespace rules
{
 
template<class TValue>
class ChainedArguments
{
public:
    constexpr ChainedArguments(fge::net::Packet const& pck, TValue* existingValue = nullptr);
    constexpr ChainedArguments(fge::net::Packet const& pck, Error&& err, TValue* existingValue = nullptr);
    constexpr ChainedArguments(ChainedArguments const& r) = default;
    constexpr ChainedArguments(ChainedArguments&& r) noexcept = default;
 
    constexpr ChainedArguments& operator=(ChainedArguments const& r) = default;
    constexpr ChainedArguments& operator=(ChainedArguments&& r) noexcept = default;
 
    [[nodiscard]] constexpr TValue* extract();
    template<class TPeek>
    [[nodiscard]] constexpr std::optional<TPeek> peek();
 
    [[nodiscard]] constexpr fge::net::Packet const& packet() const;
    [[nodiscard]] constexpr TValue const& value() const;
    [[nodiscard]] constexpr TValue& value();
 
    template<class TInvokable>
    [[nodiscard]] constexpr typename std::invoke_result_t<TInvokable, ChainedArguments<TValue>&>
    and_then(TInvokable&& f);
    template<class TInvokable, class TIndex>
    [[nodiscard]] constexpr ChainedArguments<TValue>&
    and_for_each(TIndex iStart, TIndex iEnd, TIndex iIncrement, TInvokable&& f);
    template<class TInvokable, class TIndex>
    [[nodiscard]] constexpr ChainedArguments<TValue>& and_for_each(TIndex iStart, TIndex iIncrement, TInvokable&& f);
    template<class TInvokable>
    [[nodiscard]] constexpr ChainedArguments<TValue>& and_for_each(TInvokable&& f);
    template<class TInvokable>
    constexpr std::optional<Error> on_error(TInvokable&& f);
    [[nodiscard]] constexpr std::optional<Error> end();
    [[nodiscard]] constexpr std::optional<Error> end(std::nullopt_t nullopt) const;
    [[nodiscard]] constexpr std::optional<Error> end(Error&& err) const;
 
    constexpr ChainedArguments<TValue>& apply(TValue& value);
    template<class TInvokable>
    constexpr ChainedArguments<TValue>& apply(TInvokable&& f);
 
    template<class TNewValue>
    constexpr ChainedArguments<TNewValue> newChain(TNewValue* existingValue = nullptr);
    template<class TNewValue>
    constexpr ChainedArguments<TNewValue> newChain(TNewValue* existingValue = nullptr) const;
 
    constexpr ChainedArguments<TValue>& setError(Error&& err);
    constexpr ChainedArguments<TValue>& invalidate(Error&& err);
 
private:
    using Value = std::variant<TValue, TValue*>;
 
    fge::net::Packet const* g_pck;
    Value g_value;
    Error g_error;
};
 
enum class ROutputs : bool
{
    R_NORMAL = false,
    R_INVERTED = true
};
 
template<class TValue, ROutputs TOutput = ROutputs::R_NORMAL>
constexpr ChainedArguments<TValue> RRange(TValue const& min, TValue const& max, ChainedArguments<TValue>&& args);
 
template<class TValue>
constexpr ChainedArguments<TValue> RValid(ChainedArguments<TValue>&& args);
 
template<class TValue, ROutputs TOutput = ROutputs::R_NORMAL>
constexpr ChainedArguments<TValue> RMustEqual(TValue const& a, ChainedArguments<TValue>&& args);
 
template<class TValue, ROutputs TOutput = ROutputs::R_NORMAL>
constexpr ChainedArguments<TValue> RStrictLess(TValue less, ChainedArguments<TValue>&& args);
 
template<class TValue, ROutputs TOutput = ROutputs::R_NORMAL>
constexpr ChainedArguments<TValue> RLess(TValue less, ChainedArguments<TValue>&& args);
 
template<class TValue, ROutputs TOutput = ROutputs::R_NORMAL>
constexpr ChainedArguments<TValue> RSizeRange(SizeType min, SizeType max, ChainedArguments<TValue>&& args);
 
template<class TValue, ROutputs TOutput = ROutputs::R_NORMAL>
constexpr ChainedArguments<TValue> RSizeMustEqual(fge::net::SizeType a, ChainedArguments<TValue>&& args);
 
template<class TValue, ROutputs TOutput = ROutputs::R_NORMAL>
constexpr ChainedArguments<TValue> RMustValidUtf8(ChainedArguments<TValue>&& args);
 
} // namespace rules
} // namespace fge::net
 
#include "network_manager.inl"
 
#endif // _FGE_NETWORK_MANAGER_HPP_INCLUDED