#include "CircularBuffer.h"

Public Member Functions
	CircularBuffer (std::size_t size)

void	put (T item)

bool	empty () const

bool	full () const

std::size_t	capacity () const

std::size_t	size () const

std::vector< T >	content ()

T	peak_back ()

Private Attributes
std::mutex	mutex_

std::unique_ptr< T[]>	buf_

std::size_t	head_ = 0

std::size_t	tail_ = 0

const std::size_t	max_size_

bool	full_ = false

Detailed Description

template<typename T>
class CircularBuffer< T >

Constructor & Destructor Documentation

◆ CircularBuffer()

template<typename T >

CircularBuffer< T >::CircularBuffer ( std::size_t size )

inlineexplicit

                                            :
        buf_(std::unique_ptr<T[]>(new T[size])),
        max_size_(size)
    {
 
    }

Member Function Documentation

◆ capacity()

template<typename T >

std::size_t CircularBuffer< T >::capacity ( ) const

inline

    {
        return max_size_;
    }

References CircularBuffer< T >::max_size_.

◆ content()

template<typename T >

std::vector< T > CircularBuffer< T >::content ( )

inline

    {
        std::lock_guard<std::mutex> lock(mutex_);
 
        return std::vector<T>(buf_.get(), buf_.get() + size());
    }

References CircularBuffer< T >::buf_, CircularBuffer< T >::mutex_, and CircularBuffer< T >::size().

Referenced by WorldSession::ComputeNewClockDelta().

◆ empty()

template<typename T >

bool CircularBuffer< T >::empty ( ) const

inline

    {
        //if head and tail are equal, we are empty
        return (!full_ && (head_ == tail_));
    }

References CircularBuffer< T >::full_, CircularBuffer< T >::head_, and CircularBuffer< T >::tail_.

Referenced by CircularBuffer< T >::peak_back().

◆ full()

template<typename T >

bool CircularBuffer< T >::full ( ) const

inline

    {
        //If tail is ahead the head by 1, we are full
        return full_;
    }

References CircularBuffer< T >::full_.

◆ peak_back()

template<typename T >

T CircularBuffer< T >::peak_back ( )

inline

    {
        std::lock_guard<std::mutex> lock(mutex_);
 
        return empty() ? T() : buf_[tail_];
    }

References CircularBuffer< T >::buf_, CircularBuffer< T >::empty(), CircularBuffer< T >::mutex_, and CircularBuffer< T >::tail_.

Referenced by WorldSession::ComputeNewClockDelta().

◆ put()

template<typename T >

void CircularBuffer< T >::put ( T item )

inline

    {
        std::lock_guard<std::mutex> lock(mutex_);
 
        buf_[head_] = item;
 
        if (full_)
        {
            tail_ = (tail_ + 1) % max_size_;
        }
 
        head_ = (head_ + 1) % max_size_;
 
        full_ = head_ == tail_;
    }

References CircularBuffer< T >::buf_, CircularBuffer< T >::full_, CircularBuffer< T >::head_, CircularBuffer< T >::max_size_, CircularBuffer< T >::mutex_, and CircularBuffer< T >::tail_.

Referenced by WorldSession::HandleTimeSyncResp().

◆ size()

template<typename T >

std::size_t CircularBuffer< T >::size ( ) const

inline

    {
        std::size_t size = max_size_;
 
        if (!full_)
        {
            if (head_ >= tail_)
            {
                size = head_ - tail_;
            }
            else
            {
                size += head_ - tail_;
            }
        }
 
        return size;
    }