FifoBuffer Class Reference

#include <FifoBuffer.h>

Collaboration diagram for FifoBuffer:

Classes
struct	Page

Public Member Functions
	FifoBuffer (int pageSize)
int64_t	Write (const void *data, int64_t size)
int64_t	Read (void *data, int64_t size)
int64_t	GetAvailable () const

Private Attributes
std::deque< Page >	mAllocatedPages
std::queue< Page * >	mActivePages
std::deque< Page * >	mFreePages
int64_t	mAvaliable {}
const int	mPageSize {}

Detailed Description

Definition at line 17 of file FifoBuffer.h.

Constructor & Destructor Documentation

FifoBuffer()

FifoBuffer::FifoBuffer ( int  pageSize )

explicit

Definition at line 26 of file FifoBuffer.cpp.

    : mPageSize { pageSize }
{
}

Member Function Documentation

GetAvailable()

int64_t FifoBuffer::GetAvailable

(

)

const

Definition at line 103 of file FifoBuffer.cpp.

{
   return mAvaliable;
}

References mAvaliable.

Read()

int64_t FifoBuffer::Read	(	void *	data,
		int64_t	size
	)

Definition at line 68 of file FifoBuffer.cpp.

{
   size = std::min(size, mAvaliable);
 
   int8_t* dataPtr = static_cast<int8_t*>(data);
 
   int bytesRead = 0;
 
   while (size > 0)
   {
      auto& page = mActivePages.front();
      auto toRead =
         std::min(size, static_cast<int64_t>(mPageSize - page->ReadPosition));
 
      std::copy(
         page->Data.begin() + page->ReadPosition,
         page->Data.begin() + page->ReadPosition + toRead, dataPtr);
      page->ReadPosition += toRead;
      mAvaliable -= toRead;
 
      dataPtr += toRead;
      size -= toRead;
      bytesRead += toRead;
 
      if (page->ReadPosition == mPageSize)
      {
         page->Reset();
         mFreePages.push_back(page);
         mActivePages.pop();
      }
   }
 
   return bytesRead;
}

References staffpad::vo::copy(), mActivePages, mAvaliable, mFreePages, min(), mPageSize, and size.

Here is the call graph for this function:

Write()

int64_t FifoBuffer::Write	(	const void *	data,
		int64_t	size
	)

Definition at line 31 of file FifoBuffer.cpp.

{
   const int8_t* data = static_cast<const int8_t*>(dataPtr);
 
   auto bytesLeft = size;
 
   while (bytesLeft > 0)
   {
      if (
         mActivePages.empty() ||
         mActivePages.back()->WritePosition == mPageSize)
      {
         if (mFreePages.empty())
         {
            mAllocatedPages.emplace_back(mPageSize);
            mFreePages.push_back(&mAllocatedPages.back());
         }
 
         mActivePages.push(mFreePages.back());
         mFreePages.pop_back();
      }
 
      auto& page   = mActivePages.back();
      auto toWrite = std::min(
         bytesLeft, static_cast<int64_t>(mPageSize - page->WritePosition));
 
      std::copy(data, data + toWrite, page->Data.begin() + page->WritePosition);
      page->WritePosition += toWrite;
      mAvaliable += toWrite;
 
      data += toWrite;
      bytesLeft -= toWrite;
   }
 
   return size;
}

References staffpad::vo::copy(), mActivePages, mAllocatedPages, mAvaliable, mFreePages, min(), mPageSize, and size.

Here is the call graph for this function:

Member Data Documentation

mActivePages

std::queue<Page*> FifoBuffer::mActivePages

private

Definition at line 41 of file FifoBuffer.h.

Referenced by Read(), and Write().

mAllocatedPages

std::deque<Page> FifoBuffer::mAllocatedPages

private

Definition at line 39 of file FifoBuffer.h.

Referenced by Write().

mAvaliable

int64_t FifoBuffer::mAvaliable {}

private

Definition at line 44 of file FifoBuffer.h.

Referenced by GetAvailable(), Read(), and Write().

mFreePages

std::deque<Page*> FifoBuffer::mFreePages

private

Definition at line 42 of file FifoBuffer.h.

Referenced by Read(), and Write().

mPageSize

const int FifoBuffer::mPageSize {}

private

Definition at line 45 of file FifoBuffer.h.

Referenced by Read(), and Write().

---

The documentation for this class was generated from the following files:

• FifoBuffer.h
• FifoBuffer.cpp