IPAddressPico.h

// Copyright 2022 Pico Technology Co., Ltd.All rights reserved.
// This plugin incorporates portions of the Unreal® Engine. Unreal® is a trademark or registered trademark of Epic Games, Inc.In the United States of America and elsewhere.
// Unreal® Engine, Copyright 1998 – 2022, Epic Games, Inc.All rights reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "IPAddress.h"
#include "Algo/Reverse.h"
#include "Engine/EngineBaseTypes.h"
#include "OnlineSubsystemPico.h"
#include "OnlineSubsystemPicoTypes.h"
#include "OnlineSubsystemPicoPackage.h"
 
class FInternetAddrPico : public FInternetAddr
{
PACKAGE_SCOPE:
 
#if ENGINE_MAJOR_VERSION > 4
    FUniqueNetIdPicoRef PicoId;
#elif ENGINE_MINOR_VERSION > 26
    FUniqueNetIdPicoRef PicoId;
#elif ENGINE_MINOR_VERSION > 24
    FUniqueNetIdPico PicoId;
#endif
 
    FInternetAddrPico(const FInternetAddrPico& Src) :
        PicoId(Src.PicoId)
    {
    }
 
 
public:
#if ENGINE_MAJOR_VERSION > 4
    FInternetAddrPico() :
        PicoId(FUniqueNetIdPico::EmptyId())
    {
    }
 
    explicit FInternetAddrPico(const FUniqueNetIdPico& InPicoId) :
        PicoId(InPicoId.AsShared())
    {
    }
 
    explicit FInternetAddrPico(ppfID InPicoId) :
        PicoId(FUniqueNetIdPico::Create(InPicoId))
    {
    }
    explicit FInternetAddrPico(const FString& UserId) :
        PicoId(FUniqueNetIdPico::Create(UserId))
    {
    }
 
    static FInternetAddrPico FromUrl(const FURL& ConnectURL)
    {
        FString Host = ConnectURL.Host;
        // Parse the URL: unreal://<pico_id>.pico or unreal://<pico_id>
        int32 DotIndex;
        FString PicoStringID = (Host.FindChar('.', DotIndex)) ? Host.Left(DotIndex) : Host;
        uint64 PicoUintId = strtoull(TCHAR_TO_ANSI(*PicoStringID), nullptr, 10);
        const FUniqueNetIdPicoRef PicoNetId = FUniqueNetIdPico::Create(PicoUintId);
        return FInternetAddrPico(*PicoNetId);
    }
#elif ENGINE_MINOR_VERSION > 26
    FInternetAddrPico() :
        PicoId(FUniqueNetIdPico::EmptyId())
    {
    }
 
    explicit FInternetAddrPico(const FUniqueNetIdPico& InPicoId) :
        PicoId(InPicoId.AsShared())
    {
    }
 
    explicit FInternetAddrPico(ppfID InPicoId) :
        PicoId(FUniqueNetIdPico::Create(InPicoId))
    {
    }
    explicit FInternetAddrPico(const FString& UserId) :
        PicoId(FUniqueNetIdPico::Create(UserId))
    {
    }
 
    static FInternetAddrPico FromUrl(const FURL& ConnectURL)
    {
        FString Host = ConnectURL.Host;
        // Parse the URL: unreal://<pico_id>.pico or unreal://<pico_id>
        int32 DotIndex;
        FString PicoStringID = (Host.FindChar('.', DotIndex)) ? Host.Left(DotIndex) : Host;
        uint64 PicoUintId = strtoull(TCHAR_TO_ANSI(*PicoStringID), nullptr, 10);
        const FUniqueNetIdPicoRef PicoNetId = FUniqueNetIdPico::Create(PicoUintId);
        return FInternetAddrPico(*PicoNetId);
    }
 
#elif ENGINE_MINOR_VERSION > 24
    FInternetAddrPico() :
        PicoId(0ull)
    {
    }
 
    explicit FInternetAddrPico(const FUniqueNetIdPico& InPicoId) :
        PicoId(InPicoId)
    {
    }
 
    explicit FInternetAddrPico(ppfID InPicoId) :
        PicoId(FUniqueNetIdPico(InPicoId))
    {
    }
    explicit FInternetAddrPico(const FString& UserId) :
        PicoId(FUniqueNetIdPico(UserId))
    {
    }
 
    explicit FInternetAddrPico(const FURL& ConnectURL)
    {
        auto Host = ConnectURL.Host;
 
        // Parse the URL: unreal://<oculus_id>.oculus or unreal://<oculus_id>
        int32 DotIndex;
        auto PicoStringID = (Host.FindChar('.', DotIndex)) ? Host.Left(DotIndex) : Host;
        PicoId = strtoull(TCHAR_TO_ANSI(*PicoStringID), nullptr, 10);
    }
#endif
 
 
#if ENGINE_MAJOR_VERSION > 4
    ppfID GetID() const
    {
        return PicoId->GetID();
    }
    FString GetStrID() const
    {
        return PicoId->GetStringID();
    }
#elif ENGINE_MINOR_VERSION > 26
    ppfID GetID() const
    {
        return PicoId->GetID();
}
    FString GetStrID() const
    {
        return PicoId->GetStringID();
    }
#elif ENGINE_MINOR_VERSION > 24
    ppfID GetID() const
    {
        return PicoId.GetID();
    }
    FString GetStrID() const
    {
        return PicoId.GetStringID();
    }
#endif
 
    virtual TArray<uint8> GetRawIp() const override
    {
#if ENGINE_MAJOR_VERSION > 4
        TArray<uint8> RawAddressArray;
        const uint8* PicoIdWalk = PicoId->GetBytes();
        while (RawAddressArray.Num() < PicoId->GetSize())
        {
            RawAddressArray.Add(*PicoIdWalk);
            ++PicoIdWalk;
        }
#elif ENGINE_MINOR_VERSION > 26
        TArray<uint8> RawAddressArray;
        const uint8* PicoIdWalk = PicoId->GetBytes();
        while (RawAddressArray.Num() < PicoId->GetSize())
        {
            RawAddressArray.Add(*PicoIdWalk);
            ++PicoIdWalk;
        }
 
#elif ENGINE_MINOR_VERSION > 24
        TArray<uint8> RawAddressArray;
        const uint8* PicoIdWalk = PicoId.GetBytes();
        while (RawAddressArray.Num() < PicoId.GetSize())
        {
            RawAddressArray.Add(*PicoIdWalk);
            ++PicoIdWalk;
        }
#endif
 
 
        // We want to make sure that these arrays are in big endian format.
#if PLATFORM_LITTLE_ENDIAN
        Algo::Reverse(RawAddressArray);
#endif
 
        return RawAddressArray;
    }
 
    virtual void SetRawIp(const TArray<uint8>& RawAddr) override
    {
        ppfID NewId = 0;
 
        // Make a quick copy of the array
        TArray<uint8> WorkingArray = RawAddr;
 
        // If we're little endian, we need to reverse so that the shifts turn out correct
#if PLATFORM_LITTLE_ENDIAN
        Algo::Reverse(WorkingArray);
#endif
 
        for (int32 i = 0; i < WorkingArray.Num(); ++i)
        {
            NewId |= (ppfID)WorkingArray[i] << (i * 8);
        }
 
#if ENGINE_MAJOR_VERSION > 4
        PicoId = FUniqueNetIdPico::Create(NewId);
#elif ENGINE_MINOR_VERSION > 26
        PicoId = FUniqueNetIdPico::Create(NewId);
#elif ENGINE_MINOR_VERSION > 24
        PicoId = FUniqueNetIdPico(NewId);
#endif
 
 
    }
 
    void SetIp(uint32 InAddr) override
    {
    }
 
    void SetIp(const TCHAR* InAddr, bool& bIsValid) override
    {
    }
 
    void GetIp(uint32& OutAddr) const override
    {
    }
 
    void SetPort(int32 InPort) override
    {
    }
 
    void GetPort(int32& OutPort) const override
    {
    }
 
    int32 GetPort() const override
    {
        return 0;
    }
 
    void SetAnyAddress() override
    {
    }
 
    void SetBroadcastAddress() override
    {
    }
 
    void SetLoopbackAddress() override
    {
    }
 
    FString ToString(bool bAppendPort) const override
    {
#if ENGINE_MAJOR_VERSION > 4
        return PicoId->ToString();
#elif ENGINE_MINOR_VERSION > 26
        return PicoId->ToString();
#elif ENGINE_MINOR_VERSION > 24
        return PicoId.ToString();
#endif
 
    }
 
    virtual bool operator==(const FInternetAddr& Other) const override
    {
        FInternetAddrPico& PicoOther = (FInternetAddrPico&)Other;
        return PicoId == PicoOther.PicoId;
    }
 
    bool operator!=(const FInternetAddrPico& Other) const
    {
        return !(FInternetAddrPico::operator==(Other));
    }
 
    virtual uint32 GetTypeHash() const override
    {
        return ::GetTypeHash((uint64)GetID());
    }
 
    virtual FName GetProtocolType() const override
    {
        return FNetworkProtocolTypes::Pico;
    }
 
    virtual bool IsValid() const override
    {
#if ENGINE_MAJOR_VERSION > 4
        return PicoId->IsValid();
#elif ENGINE_MINOR_VERSION > 26
        return PicoId->IsValid();
#elif ENGINE_MINOR_VERSION > 24
        return PicoId.IsValid();
#endif
 
    }
 
    virtual TSharedRef<FInternetAddr> Clone() const override
    {
        TSharedRef<FInternetAddrPico> NewAddress = MakeShareable(new FInternetAddrPico);
        NewAddress->PicoId = PicoId;
        return NewAddress;
    }
};