juce::SingleThreadedAbstractFifo Class Reference

Encapsulates the logic for a single-threaded FIFO. More...

#include <juce_SingleThreadedAbstractFifo.h>

Collaboration diagram for juce::SingleThreadedAbstractFifo:

Public Member Functions
	SingleThreadedAbstractFifo ()=default
	Creates a SingleThreadedAbstractFifo with no size. More...
	SingleThreadedAbstractFifo (int sizeIn)
	Creates a SingleThreadedAbstractFifo that can manage a buffer of the specified size. More...
int	getNumReadable () const
	Returns the number of pending elements present in the buffer. More...
int	getRemainingSpace () const
	Returns the number of unused elements present in the buffer. More...
int	getSize () const
	Returns the size of the managed buffer. More...
std::array< Range< int >, 2 >	read (int num)
	Returns two blocks in the buffer from which new items may be read. More...
std::array< Range< int >, 2 >	write (int num)
	Returns two blocks in the buffer where new items may be written. More...

Private Attributes
int	numReadable = 0
int	readPos = 0
int	size = 0

Detailed Description

Encapsulates the logic for a single-threaded FIFO.

This might be useful for building buffers which can be written and read in blocks of different sizes. For example, in an audio effect we might wish to run some processing on fixed-size blocks of audio input, but the host may provide input blocks of varying sizes. In this situation, we might want to store the previous input in a buffer, and extract a fixed-size block whenever there are enough samples available. The SingleThreadedAbstractFifo implements logic suitable for this use-case.

This class is quite similar to AbstractFifo, in that it only keeps track of the current read/write locations. The user is responsible for providing the actual buffer that will be read/written.

The intended usage of this class is as follows:

• Create some backing storage in a vector, AudioBuffer etc.
• Construct a SingleThreadedAbstractFifo to manage the buffer, passing the number of items in the buffer.
• Each time new input is ready, call write(), passing the number of items you wish to write into the buffer. This function returns a pair of ranges describing which indices in the backing storage should be written.
• Call getNumReadable() to find out how many items are ready to read from the buffer.
• If there are enough items ready to read, call read(), passing the number of items you require. This function returns a pair of ranges describing which indices in the backing storage may be read.

Unlike AbstractFifo, the SingleThreadedAbstractFifo is intended for use from a single thread. It is not safe to call any non-const member function of SingleThreadedAbstractFifo concurrently with any other member function.

See also

AbstractFifo

@tags{Core}

Constructor & Destructor Documentation

SingleThreadedAbstractFifo() [1/2]

juce::SingleThreadedAbstractFifo::SingleThreadedAbstractFifo ( )

default

Creates a SingleThreadedAbstractFifo with no size.

SingleThreadedAbstractFifo() [2/2]

juce::SingleThreadedAbstractFifo::SingleThreadedAbstractFifo ( int  sizeIn )

inlineexplicit

Creates a SingleThreadedAbstractFifo that can manage a buffer of the specified size.

References juce::isPowerOfTwo(), and jassert.

Member Function Documentation

getNumReadable()

int juce::SingleThreadedAbstractFifo::getNumReadable ( ) const

inline

Returns the number of pending elements present in the buffer.

References numReadable.

getRemainingSpace()

int juce::SingleThreadedAbstractFifo::getRemainingSpace ( ) const

inline

Returns the number of unused elements present in the buffer.

References numReadable, and size.

Referenced by write().

getSize()

int juce::SingleThreadedAbstractFifo::getSize ( ) const

inline

Returns the size of the managed buffer.

References size.

read()

std::array<Range<int>, 2> juce::SingleThreadedAbstractFifo::read ( int  num )

inline

Returns two blocks in the buffer from which new items may be read.

Note that if the buffer doesn't have the requested number of items available, the sum of the lengths of the returned ranges may be less than num!

References juce::jmin(), juce::gl::num, numReadable, readPos, and size.

write()

std::array<Range<int>, 2> juce::SingleThreadedAbstractFifo::write ( int  num )

inline

Returns two blocks in the buffer where new items may be written.

Note that if the buffer is running low on free space, the sum of the lengths of the returned ranges may be less than num!

References getRemainingSpace(), juce::jmin(), juce::gl::num, numReadable, readPos, and size.

Member Data Documentation

numReadable

int juce::SingleThreadedAbstractFifo::numReadable = 0

private

Referenced by getNumReadable(), getRemainingSpace(), read(), and write().

readPos

int juce::SingleThreadedAbstractFifo::readPos = 0

private

Referenced by read(), and write().

size

int juce::SingleThreadedAbstractFifo::size = 0

private

Referenced by getRemainingSpace(), getSize(), read(), and write().

---

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

• juce_SingleThreadedAbstractFifo.h