C_ipAddress.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_C_IPADDRESS_HPP_INCLUDED_
#define _FGE_C_IPADDRESS_HPP_INCLUDED_
 
#include "FastEngine/fge_extern.hpp"
#include "FastEngine/extra/extra_function.hpp"
#include <array>
#include <cstdint>
#include <optional>
#include <string>
#include <variant>
#include <vector>
 
#ifndef _WIN32
    #undef None
#endif
 
#define FGE_ANYPORT 0
 
namespace fge::net
{
class IpAddress;
class Packet;
} // namespace fge::net
 
template<>
struct std::hash<fge::net::IpAddress>;
 
namespace fge::net
{
 
using Port = uint16_t;

class FGE_API IpAddress
{
public:
    using Ipv4Data = uint32_t;
    using Ipv6Data = std::array<uint16_t, 8>;
    using Data = std::variant<Ipv4Data, Ipv6Data>;
 
    enum class Types : uint8_t
    {
        None,
        Ipv4,
        Ipv6
    };
 
    enum class CheckHostname
    {
        No,
        Yes
    };

    IpAddress() noexcept;
    IpAddress(std::string const& address, CheckHostname check = CheckHostname::Yes);
    IpAddress(char const* address, CheckHostname check = CheckHostname::Yes);
    IpAddress(uint8_t byte3, uint8_t byte2, uint8_t byte1, uint8_t byte0) noexcept;
    IpAddress(std::initializer_list<uint16_t> words) noexcept;
    IpAddress(Ipv6Data const& data) noexcept;
    IpAddress(Ipv4Data address) noexcept;
    ~IpAddress() = default;

    bool set(std::string const& address, CheckHostname check = CheckHostname::Yes);
    bool set(char const* address, CheckHostname check = CheckHostname::Yes);
    bool set(uint8_t byte3, uint8_t byte2, uint8_t byte1, uint8_t byte0);
    bool set(std::initializer_list<uint16_t> words);
    bool set(Ipv6Data const& data);
    bool set(uint8_t const bytes[16]);
    bool set(Ipv4Data address);
    bool setNetworkByteOrdered(Ipv4Data address);
    bool setNetworkByteOrdered(Ipv6Data const& data);
    bool setNetworkByteOrdered(uint8_t const bytes[16]);
 
    [[nodiscard]] bool operator==(IpAddress const& r) const;

    [[nodiscard]] std::optional<std::string> toString() const;

    [[nodiscard]] std::optional<Data> getNetworkByteOrder() const;
    [[nodiscard]] std::optional<Data> getHostByteOrder() const;
 
    [[nodiscard]] Types getType() const;

    [[nodiscard]] std::optional<IpAddress> mapToIpv6() const;
    [[nodiscard]] std::optional<IpAddress> mapToIpv4() const;
    [[nodiscard]] bool isIpv4MappedIpv6() const;

    [[nodiscard]] static std::optional<std::string> getHostName();
    [[nodiscard]] static std::vector<IpAddress> getLocalAddresses(Types type = Types::None);
 
    static IpAddress const None; 
 
    static IpAddress const Ipv4Any; 
    static IpAddress const Ipv6Any; 
    static IpAddress Any(Types addressType);
 
    static IpAddress const Ipv4Loopback; 
    static IpAddress const Ipv6Loopback; 
    static IpAddress Loopback(Types addressType);
 
    static IpAddress const Ipv4Broadcast; 
 
private:
    std::variant<std::monostate, Ipv4Data, Ipv6Data> g_address; 
 
    friend struct std::hash<IpAddress>;
};
 
FGE_API Packet const& operator>>(Packet const& pck, IpAddress& data);
FGE_API Packet& operator<<(Packet& pck, IpAddress const& data);
 
} // namespace fge::net
 
template<>
struct std::hash<fge::net::IpAddress>
{
    inline std::size_t operator()(fge::net::IpAddress const& r) const noexcept
    {
        if (std::holds_alternative<std::monostate>(r.g_address))
        {
            return std::hash<std::monostate>{}(std::monostate{});
        }
        if (std::holds_alternative<fge::net::IpAddress::Ipv4Data>(r.g_address))
        {
            return std::hash<fge::net::IpAddress::Ipv4Data>{}(std::get<fge::net::IpAddress::Ipv4Data>(r.g_address));
        }
        auto const& array = std::get<fge::net::IpAddress::Ipv6Data>(r.g_address);
        return fge::Hash(array.data(), array.size() * 2);
    }
};
 
#endif // _FGE_C_IPADDRESS_HPP_INCLUDED_