RingBuffer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "CoreMinimal.h"
#include "Misc/SecureHash.h"
 
template< typename DataType >
class TRingBuffer
{
public:
    TRingBuffer(uint32 BufferDataSize);
 
    ~TRingBuffer();
 
    void Empty();
 
    void Enqueue(const DataType& Val);
 
    void Enqueue(const DataType* ValBuf, const uint32& BufLen);
 
    bool Dequeue(DataType& ValOut);
 
    uint32 Dequeue(DataType* ValBuf, const uint32& BufLen);
 
    bool Peek(DataType& ValOut) const;
 
    uint32 Peek(DataType* ValBuf, const uint32& BufLen) const;
 
    int32 SerialCompare(const DataType* SerialBuffer, uint32 CompareLen) const;
 
    void GetShaHash(FSHAHash& OutHash) const;
 
    void Serialize(DataType* SerialBuffer) const;
 
    FORCEINLINE const DataType& operator[](const int32& Index) const;
    FORCEINLINE DataType& operator[](const int32& Index);
 
    FORCEINLINE const DataType& Top() const;
    FORCEINLINE DataType& Top();
 
    FORCEINLINE const DataType& Bottom() const;
    FORCEINLINE DataType& Bottom();
 
    FORCEINLINE uint32 TopIndex() const;
 
    FORCEINLINE uint32 BottomIndex() const;
 
    FORCEINLINE uint32 NextIndex() const;
 
    FORCEINLINE uint32 RingDataSize() const;
 
    FORCEINLINE uint32 RingDataUsage() const;
 
    FORCEINLINE uint64 TotalDataPushed() const;
 
 
private:
    TRingBuffer() = delete;
 
    // Buffer size
    const uint32 BufferDataSize;
 
    // The data memory
    DataType* Data;
 
    // Value keeping track of free space
    uint32 NumDataAvailable;
 
    // Value keeping track of the next data index
    uint32 DataIndex;
 
    // Value to keep track of total amount of data Enqueued
    uint64 TotalNumDataPushed;
};
 
/* TRingBuffer implementation
*****************************************************************************/
template< typename DataType >
TRingBuffer< DataType >::TRingBuffer(uint32 InBufferDataSize)
    : BufferDataSize(InBufferDataSize)
{
    Data = new DataType[BufferDataSize];
    Empty();
}
 
template< typename DataType >
TRingBuffer< DataType >::~TRingBuffer()
{
    delete[] Data;
}
 
template< typename DataType >
void TRingBuffer< DataType >::Empty()
{
    FMemory::Memzero(Data, sizeof(DataType)* BufferDataSize);
    NumDataAvailable = 0;
    DataIndex = 0;
    TotalNumDataPushed = 0;
}
 
template< typename DataType >
void TRingBuffer< DataType >::Enqueue(const DataType& Val)
{
    Data[DataIndex++] = Val;
    DataIndex %= BufferDataSize;
    ++TotalNumDataPushed;
    NumDataAvailable = FMath::Clamp< uint32 >(NumDataAvailable + 1, 0, BufferDataSize);
}
 
template< typename DataType >
void TRingBuffer< DataType >::Enqueue(const DataType* ValBuf, const uint32& BufLen)
{
    check(BufLen <= BufferDataSize);
    const uint32 FirstPartLen = BufferDataSize - DataIndex;
    FMemory::Memcpy(Data + DataIndex, ValBuf, sizeof(DataType)* FMath::Min(FirstPartLen, BufLen));
    if (FirstPartLen < BufLen)
    {
        FMemory::Memcpy(Data, ValBuf + FirstPartLen, sizeof(DataType)* (BufLen - FirstPartLen));
    }
    DataIndex += BufLen;
    DataIndex %= BufferDataSize;
    TotalNumDataPushed += BufLen;
    NumDataAvailable = FMath::Clamp<uint32>(NumDataAvailable + BufLen, 0, BufferDataSize);
}
 
template< typename DataType >
bool TRingBuffer< DataType >::Dequeue(DataType& ValOut)
{
    if (Peek(ValOut))
    {
        NumDataAvailable = FMath::Clamp< uint32 >(NumDataAvailable - 1, 0, BufferDataSize);
        return true;
    }
    else
    {
        return false;
    }
}
 
template< typename DataType >
uint32 TRingBuffer< DataType >::Dequeue(DataType* ValBuf, const uint32& BufLen)
{
    const uint32 DataProvided = Peek(ValBuf, BufLen);
    NumDataAvailable -= DataProvided;
    return DataProvided;
}
 
template< typename DataType >
bool TRingBuffer< DataType >::Peek(DataType& ValOut) const
{
    if (NumDataAvailable > 0)
    {
        ValOut = Bottom();
        return true;
    }
    else
    {
        return false;
    }
}
 
template< typename DataType >
uint32 TRingBuffer< DataType >::Peek(DataType* ValBuf, const uint32& BufLen) const
{
    const uint32 DataProvided = FMath::Min(BufLen, NumDataAvailable);
    const uint32 BottomIdx = BottomIndex();
    const uint32 BottomPartLen = BufferDataSize - BottomIdx;
    FMemory::Memcpy(ValBuf, Data + BottomIdx, sizeof(DataType)* FMath::Min(BottomPartLen, DataProvided));
    if (BottomPartLen < DataProvided)
    {
        FMemory::Memcpy(ValBuf + BottomPartLen, Data, sizeof(DataType)* (DataProvided - BottomPartLen));
    }
    return DataProvided;
}
 
template< typename DataType >
int32 TRingBuffer< DataType >::SerialCompare(const DataType* SerialBuffer, uint32 CompareLen) const
{
    check(CompareLen <= BufferDataSize);
    const uint32 FirstPartLen = BufferDataSize - DataIndex;
    int32 FirstCmp = FMemory::Memcmp(Data + BottomIndex(), SerialBuffer, sizeof(DataType)* FMath::Min(FirstPartLen, CompareLen));
    if (FirstCmp != 0 || FirstPartLen >= CompareLen)
    {
        return FirstCmp;
    }
    return FMemory::Memcmp(Data, &SerialBuffer[FirstPartLen], sizeof(DataType)* (CompareLen - FirstPartLen));
}
 
template< typename DataType >
void TRingBuffer< DataType >::GetShaHash(FSHAHash& OutHash) const
{
    const uint32 FirstPartLen = FMath::Min(BufferDataSize - DataIndex, NumDataAvailable);
    FSHA1 Sha;
    Sha.Update(Data + BottomIndex(), sizeof(DataType) * FirstPartLen);
    if (FirstPartLen < NumDataAvailable)
    {
        Sha.Update(Data, sizeof(DataType) * (NumDataAvailable - FirstPartLen));
    }
    Sha.Final();
    Sha.GetHash(OutHash.Hash);
}
 
template< typename DataType >
void TRingBuffer< DataType >::Serialize(DataType* SerialBuffer) const
{
    const uint32 BottomIdx = BottomIndex();
    const uint32 BottomPartLen = BufferDataSize - BottomIdx;
    FMemory::Memcpy(SerialBuffer, Data + BottomIdx, sizeof(DataType)* BottomPartLen);
    FMemory::Memcpy(SerialBuffer + BottomPartLen, Data, sizeof(DataType)* (BufferDataSize - BottomPartLen));
}
 
template< typename DataType >
FORCEINLINE const DataType& TRingBuffer< DataType >::operator[](const int32& Index) const
{
    return Data[(BottomIndex() + Index) % BufferDataSize];
}
 
template< typename DataType >
FORCEINLINE DataType& TRingBuffer< DataType >::operator[](const int32& Index)
{
    return Data[(BottomIndex() + Index) % BufferDataSize];
}
 
template< typename DataType >
FORCEINLINE const DataType& TRingBuffer< DataType >::Top() const
{
    return Data[TopIndex()];
}
 
template< typename DataType >
FORCEINLINE DataType& TRingBuffer< DataType >::Top()
{
    return Data[TopIndex()];
}
 
template< typename DataType >
FORCEINLINE const DataType& TRingBuffer< DataType >::Bottom() const
{
    return Data[BottomIndex()];
}
 
template< typename DataType >
FORCEINLINE DataType& TRingBuffer< DataType >::Bottom()
{
    return Data[BottomIndex()];
}
 
template< typename DataType >
FORCEINLINE uint32 TRingBuffer< DataType >::TopIndex() const
{
    return (DataIndex + BufferDataSize - 1) % BufferDataSize;
}
 
template< typename DataType >
FORCEINLINE uint32 TRingBuffer< DataType >::BottomIndex() const
{
    return (DataIndex + BufferDataSize - NumDataAvailable) % BufferDataSize;
}
 
template< typename DataType >
FORCEINLINE uint32 TRingBuffer< DataType >::NextIndex() const
{
    return DataIndex;
}
 
template< typename DataType >
FORCEINLINE uint32 TRingBuffer< DataType >::RingDataSize() const
{
    return BufferDataSize;
}
 
template< typename DataType >
FORCEINLINE uint32 TRingBuffer< DataType >::RingDataUsage() const
{
    return NumDataAvailable;
}
 
template< typename DataType >
FORCEINLINE uint64 TRingBuffer< DataType >::TotalDataPushed() const
{
    return TotalNumDataPushed;
}