network_manager.hpp

/*
 * Copyright 2025 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_packet.hpp"
#include <optional>
#include <variant>
 
namespace fge::net
{


FGE_API uint32_t GetSceneChecksum(fge::Scene& scene);

FGE_API bool WritePacketDataToFile(Packet& pck, std::string const& file);

 
namespace rules
{

template<class TValue>
class ChainedArguments
{
public:
    constexpr ChainedArguments(Packet const& pck, TValue* existingValue = nullptr);
    constexpr ChainedArguments(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 operator Packet const&() const;
    [[nodiscard]] constexpr 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> final();
    [[nodiscard]] constexpr std::optional<Error> skip() const;
    [[nodiscard]] constexpr std::optional<Error> stop(char const* error, char const* function) const;

    constexpr ChainedArguments<TValue>& apply(TValue& value);
    template<class TInvokable>
    constexpr ChainedArguments<TValue>& apply(TInvokable&& f);

    constexpr ChainedArguments<TValue>& setError(Error&& err);
    constexpr ChainedArguments<TValue>& invalidate(Error&& err);
    constexpr ChainedArguments<TValue>& invalidate(char const* error, char const* function);
 
private:
    using Value = std::variant<TValue, TValue*>;
 
    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, ROutputs TOutput = ROutputs::R_NORMAL>
constexpr ChainedArguments<TValue>
RRange(TValue const& min, TValue const& max, Packet const& pck, TValue* existingValue = nullptr)
{
    return RRange<TValue, TOutput>(min, max, ChainedArguments<TValue>{pck, existingValue});
}

template<class TValue>
constexpr ChainedArguments<TValue> RValid(ChainedArguments<TValue>&& args);
template<class TValue>
constexpr ChainedArguments<TValue> RValid(Packet const& pck, TValue* existingValue = nullptr)
{
    return RValid<TValue>(ChainedArguments<TValue>{pck, existingValue});
}

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> RMustEqual(TValue const& a, Packet const& pck, TValue* existingValue = nullptr)
{
    return RMustEqual<TValue, TOutput>(a, ChainedArguments<TValue>{pck, existingValue});
}

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> RStrictLess(TValue less, Packet const& pck, TValue* existingValue = nullptr)
{
    return RStrictLess<TValue, TOutput>(less, ChainedArguments<TValue>{pck, existingValue});
}

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> RLess(TValue less, Packet const& pck, TValue* existingValue = nullptr)
{
    return RLess<TValue, TOutput>(less, ChainedArguments<TValue>{pck, existingValue});
}

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>
RSizeRange(SizeType min, SizeType max, Packet const& pck, TValue* existingValue = nullptr)
{
    return RSizeRange<TValue, TOutput>(min, max, ChainedArguments<TValue>{pck, existingValue});
}
template<class TString>
constexpr ChainedArguments<TString>
RStringRange(SizeType min, SizeType max, Packet const& pck, TString* existingValue = nullptr)
{
    return RValid(RSizeRange<TString, ROutputs::R_NORMAL>(min, max, ChainedArguments<TString>{pck, existingValue}));
}

template<class TValue, ROutputs TOutput = ROutputs::R_NORMAL>
constexpr ChainedArguments<TValue> RSizeMustEqual(SizeType a, ChainedArguments<TValue>&& args);
template<class TValue, ROutputs TOutput = ROutputs::R_NORMAL>
constexpr ChainedArguments<TValue> RSizeMustEqual(SizeType a, Packet const& pck, TValue* existingValue = nullptr)
{
    return RSizeMustEqual<TValue, TOutput>(a, ChainedArguments<TValue>{pck, existingValue});
}
template<class TString>
constexpr ChainedArguments<TString> RStringMustEqual(SizeType a, Packet const& pck, TString* existingValue = nullptr)
{
    return RValid(RSizeMustEqual<TString, ROutputs::R_NORMAL>(a, ChainedArguments<TString>{pck, existingValue}));
}

template<class TValue, ROutputs TOutput = ROutputs::R_NORMAL>
constexpr ChainedArguments<TValue> RMustValidUtf8(ChainedArguments<TValue>&& args);
template<class TValue, ROutputs TOutput = ROutputs::R_NORMAL>
constexpr ChainedArguments<TValue> RMustValidUtf8(Packet const& pck, TValue* existingValue = nullptr)
{
    return RMustValidUtf8<TValue, TOutput>(ChainedArguments<TValue>{pck, existingValue});
}

 
} // namespace rules
} // namespace fge::net
 
#include "network_manager.inl"
 
#endif // _FGE_NETWORK_MANAGER_HPP_INCLUDED