SequenceNumber.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "HAL/UnrealMemory.h"
#include "Misc/AssertionMacros.h"
#include "Templates/IsSigned.h"
 
template <SIZE_T NumBits, typename SequenceType>
class TSequenceNumber
{
    static_assert(TIsSigned<SequenceType>::Value == false, "The base type for sequence numbers must be unsigned");
 
public:
    using SequenceT = SequenceType;
    using DifferenceT = int32;
 
    // Constants
    enum { SeqNumberBits = NumBits };
    enum { SeqNumberCount = SequenceT(1) << NumBits };
    enum { SeqNumberHalf = SequenceT(1) << (NumBits - 1) };
    enum { SeqNumberMax = SeqNumberCount - 1u };
    enum { SeqNumberMask = SeqNumberMax };
 
    TSequenceNumber() : Value(0u) {}
 
    TSequenceNumber(SequenceT ValueIn) : Value(ValueIn & SeqNumberMask) {}
    
    SequenceT Get() const { return Value; }
 
    static DifferenceT Diff(TSequenceNumber A, TSequenceNumber B);
    
    bool operator>(const TSequenceNumber& Other) const { return (Value != Other.Value) && (((Value - Other.Value) & SeqNumberMask) < SeqNumberHalf); }
 
    bool operator>=(const TSequenceNumber& Other) const { return ((Value - Other.Value) & SeqNumberMask) < SeqNumberHalf; }
 
    TSequenceNumber& operator++() { Increment(1u); return *this; }
    
    TSequenceNumber operator++(int) { TSequenceNumber Tmp(*this); Increment(1u); return Tmp; }
 
private:
    void Increment(SequenceT InValue) { *this = TSequenceNumber(Value + InValue); }
    SequenceT Value;
 
    friend bool operator<(const TSequenceNumber& Lhs, const TSequenceNumber& Rhs)
    {
        return !(Lhs >= Rhs);
    }
 
    friend bool operator<=(const TSequenceNumber& Lhs, const TSequenceNumber& Rhs)
    {
        return !(Lhs > Rhs);
    }
 
    friend bool operator==(const TSequenceNumber& Lhs, const TSequenceNumber& Rhs)
    { 
        return Lhs.Get() == Rhs.Get(); 
    }
 
    friend bool operator!=(const TSequenceNumber& Lhs, const TSequenceNumber& Rhs)
    {
        return Lhs.Get() != Rhs.Get();
    }
 
    friend const TSequenceNumber operator+(const TSequenceNumber& Lhs, const TSequenceNumber& Rhs)
    {
        return TSequenceNumber(Lhs.Get() + Rhs.Get());
    }
 
    friend const TSequenceNumber operator-(const TSequenceNumber& Lhs, const TSequenceNumber& Rhs)
    {
        return TSequenceNumber(Lhs.Get() - Rhs.Get());
    }
 
    friend const TSequenceNumber operator+(const TSequenceNumber& Lhs, SequenceType Rhs)
    {
        return TSequenceNumber(Lhs.Get() + Rhs);
    }
 
    friend const TSequenceNumber operator-(const TSequenceNumber& Lhs, SequenceType Rhs)
    {
        return TSequenceNumber(Lhs.Get() - Rhs);
    }
};
 
template <SIZE_T NumBits, typename SequenceType>
typename TSequenceNumber<NumBits, SequenceType>::DifferenceT TSequenceNumber<NumBits, SequenceType>::Diff(TSequenceNumber A, TSequenceNumber B) 
{ 
    constexpr SIZE_T ShiftValue = sizeof(DifferenceT)*8 - NumBits;
 
    const SequenceT ValueA = A.Value;
    const SequenceT ValueB = B.Value;
 
    return (DifferenceT)((ValueA - ValueB) << ShiftValue) >> ShiftValue;
};