os::posix::circular_buffer< T > Class Template Reference

Circular buffer class template.<cmsis-plus/posix-driver/circular-buffer.h> More...

#include <circular-buffer.h>

Public Types
using	value_type = T
	Standard type definition.

Public Member Functions
Constructors & Destructor
	circular_buffer (const value_type *buf, std::size_t size, std::size_t high_water_mark, std::size_t low_water_mark=0)
	circular_buffer (const value_type *buf, std::size_t size)
	~circular_buffer ()
Public Member Functions
void	clear (void)
const value_type &	operator[] (std::size_t idx) const
std::size_t	push_back (value_type v)
std::size_t	push_back (const value_type *buf, std::size_t count)
std::size_t	advance_back (std::size_t count)
void	retreat_back (void)
std::size_t	pop_front (value_type *buf)
std::size_t	pop_front (value_type *buf, std::size_t size)
std::size_t	advance_front (std::size_t count)
std::size_t	front_contiguous_buffer (value_type **ppbuf)
std::size_t	back_contiguous_buffer (value_type **ppbuf)
bool	empty (void) const
bool	full (void) const
bool	above_high_water_mark (void) const
bool	below_high_water_mark (void) const
bool	above_low_water_mark (void) const
bool	below_low_water_mark (void) const
std::size_t	length (void) const
std::size_t	size (void) const
void	dump (void)

Detailed Description

template<typename T>
class os::posix::circular_buffer< T >

Definition at line 37 of file circular-buffer.h.

Member Typedef Documentation

value_type

template<typename T >

using os::posix::circular_buffer< T >::value_type = T

Definition at line 45 of file circular-buffer.h.

Constructor & Destructor Documentation

circular_buffer() [1/2]

template<typename T >

os::posix::circular_buffer< T >::circular_buffer	(	const value_type *	buf,
		std::size_t	size,
		std::size_t	high_water_mark,
		std::size_t	low_water_mark = 0
	)

Definition at line 209 of file circular-buffer.h.

        : buf_ (buf), //
          size_ (siz), //
          high_water_mark_ (high_water_mark <= size_ ? high_water_mark
                                                     : siz), //
          low_water_mark_ (low_water_mark)
    {
      assert (low_water_mark_ <= high_water_mark_);
 
      clear ();
    }

References os::posix::circular_buffer< T >::clear().

circular_buffer() [2/2]

template<typename T >

os::posix::circular_buffer< T >::circular_buffer	(	const value_type *	buf,
		std::size_t	size
	)

Definition at line 225 of file circular-buffer.h.

        : circular_buffer{ buf, siz, siz, 0 }
    {
      trace::printf ("%s(%p,%u) %p\n", __func__, buf, siz, this);
    }

References os::trace::printf().

~circular_buffer()

template<typename T >

os::posix::circular_buffer< T >::~circular_buffer

Definition at line 233 of file circular-buffer.h.

    {
      trace::printf ("%s() %p\n", __func__, this);
    }

References os::trace::printf().

Member Function Documentation

above_high_water_mark()

template<typename T >

bool os::posix::circular_buffer< T >::above_high_water_mark ( void  ) const

inline

Definition at line 275 of file circular-buffer.h.

    {
      // Allow for water mark to be size.
      return (len_ >= high_water_mark_);
    }

above_low_water_mark()

template<typename T >

bool os::posix::circular_buffer< T >::above_low_water_mark ( void  ) const

inline

Definition at line 298 of file circular-buffer.h.

    {
      return !below_low_water_mark ();
    }

advance_back()

template<typename T >

std::size_t os::posix::circular_buffer< T >::advance_back

(

std::size_t

count

)

Definition at line 381 of file circular-buffer.h.

    {
      std::size_t adjust = count;
      if (count > (size_ - len_))
        {
          adjust = size_ - len_;
        }
 
      if (adjust == 0)
        {
          return 0;
        }
 
      back_ += adjust;
      if (back_ >= (buf_ + size_))
        {
          // Wrap.
          back_ -= size_;
        }
      len_ += adjust;
 
      return adjust;
    }

advance_front()

template<typename T >

std::size_t os::posix::circular_buffer< T >::advance_front

(

std::size_t

count

)

Definition at line 481 of file circular-buffer.h.

    {
      if (count == 0)
        {
          return 0;
        }
 
      std::size_t adjust = count;
      if (adjust > len_)
        {
          adjust = len_;
        }
 
      front_ += adjust;
      if (front_ >= (buf_ + size_))
        {
          // Wrap.
          front_ -= size_;
        }
      len_ -= adjust;
 
      return adjust;
    }

back_contiguous_buffer()

template<typename T >

std::size_t os::posix::circular_buffer< T >::back_contiguous_buffer

(

value_type **

ppbuf

)

Definition at line 525 of file circular-buffer.h.

    {
      assert (ppbuf != nullptr);
 
      *ppbuf = back_;
 
      std::size_t sizeToEnd = size_ - static_cast<std::size_t> (back_ - buf_);
      std::size_t len = sizeToEnd;
      if (len > (size_ - len_))
        {
          len = size_ - len_;
        }
 
      return len;
    }

below_high_water_mark()

template<typename T >

bool os::posix::circular_buffer< T >::below_high_water_mark ( void  ) const

inline

Definition at line 291 of file circular-buffer.h.

    {
      return !above_high_water_mark ();
    }

below_low_water_mark()

template<typename T >

bool os::posix::circular_buffer< T >::below_low_water_mark ( void  ) const

inline

Definition at line 283 of file circular-buffer.h.

    {
      // Allow for water mark to be 0.
      return (len_ <= low_water_mark_);
    }

clear()

template<typename T >

void os::posix::circular_buffer< T >::clear

(

void

)

Definition at line 242 of file circular-buffer.h.

    {
      back_ = front_ = const_cast<value_type* volatile> (buf_);
      len_ = 0;
#if defined(DEBUG)
      std::memset (static_cast<void*> (const_cast<value_type*> (buf_)), '?',
                   size_ * sizeof (value_type));
#endif
    }

Referenced by os::posix::circular_buffer< T >::circular_buffer().

dump()

template<typename T >

void os::posix::circular_buffer< T >::dump

(

void

)

Definition at line 543 of file circular-buffer.h.

    {
      os::trace::printf ("%s @%p {buf=%p, size=%d, len=%d, hwm=%d, lwn=%d}\n",
                         __PRETTY_FUNCTION__, buf_, size_, len_,
                         high_water_mark_, low_water_mark_);
    }

References os::trace::printf().

empty()

template<typename T >

bool os::posix::circular_buffer< T >::empty ( void  ) const

inline

Definition at line 261 of file circular-buffer.h.

    {
      return (len_ == 0);
    }

front_contiguous_buffer()

template<typename T >

std::size_t os::posix::circular_buffer< T >::front_contiguous_buffer

(

value_type **

ppbuf

)

Definition at line 507 of file circular-buffer.h.

    {
      assert (ppbuf != nullptr);
 
      *ppbuf = front_;
 
      std::size_t sizeToEnd = size_ - static_cast<std::size_t> (front_ - buf_);
      std::size_t len = sizeToEnd;
      if (len > len_)
        {
          len = len_;
        }
 
      return len;
    }

full()

template<typename T >

bool os::posix::circular_buffer< T >::full ( void  ) const

inline

Definition at line 268 of file circular-buffer.h.

    {
      return (len_ >= size_);
    }

length()

template<typename T >

std::size_t os::posix::circular_buffer< T >::length ( void  ) const

inline

Definition at line 305 of file circular-buffer.h.

    {
      return len_;
    }

operator[]()

template<typename T >

const circular_buffer< T >::value_type & os::posix::circular_buffer< T >::operator[] ( std::size_t  idx ) const

inline

Definition at line 254 of file circular-buffer.h.

    {
      return buf_[idx];
    }

pop_front() [1/2]

template<typename T >

std::size_t os::posix::circular_buffer< T >::pop_front

(

value_type *

buf

)

Definition at line 423 of file circular-buffer.h.

    {
      assert (buf != nullptr);
 
      value_type c;
      if (len_ == 0)
        {
          return 0;
        }
      else
        {
          c = *front_++;
          if (static_cast<std::size_t> (front_ - buf_) >= size_)
            {
              front_ = const_cast<value_type* volatile> (buf_);
            }
          len_--;
          *buf = c;
          return 1;
        }
    }

pop_front() [2/2]

template<typename T >

std::size_t os::posix::circular_buffer< T >::pop_front	(	value_type *	buf,
		std::size_t	size
	)

Definition at line 447 of file circular-buffer.h.

    {
      assert (buf != nullptr);
 
      std::size_t len = siz;
      if (len > len_)
        {
          len = len_;
        }
 
      std::size_t sizeToEnd = size_ - static_cast<std::size_t> (front_ - buf_);
      if (len <= sizeToEnd)
        {
          std::memcpy (buf, front_, len);
          front_ += len;
          if (static_cast<std::size_t> (front_ - buf_) >= size_)
            {
              front_ = const_cast<value_type* volatile> (buf_);
            }
          len_ -= len;
        }
      else
        {
          std::memcpy (buf, front_, sizeToEnd);
          front_ = const_cast<value_type* volatile> (buf_);
          std::memcpy (buf + sizeToEnd, front_, len - sizeToEnd);
          front_ += (len - sizeToEnd);
          len_ -= len;
        }
      return len;
    }

push_back() [1/2]

template<typename T >

std::size_t os::posix::circular_buffer< T >::push_back	(	const value_type *	buf,
		std::size_t	count
	)

Definition at line 340 of file circular-buffer.h.

    {
      assert (buf != nullptr);
 
      std::size_t len = count;
      if (count > (size_ - len_))
        {
          len = size_ - len_;
        }
 
      if (len == 0)
        {
          return 0;
        }
 
      std::size_t sizeToEnd = static_cast<std::size_t> (
          size_ - static_cast<std::size_t> (back_ - buf_));
      if (len <= sizeToEnd)
        {
          std::memcpy (back_, buf, len);
          back_ += len;
          if (static_cast<std::size_t> (back_ - buf_) >= size_)
            {
              // Wrap.
              back_ = const_cast<value_type* volatile> (buf_);
            }
          len_ += len;
        }
      else
        {
          std::memcpy (back_, buf, sizeToEnd);
          back_ = const_cast<value_type* volatile> (buf_);
          std::memcpy (back_, buf + sizeToEnd, len - sizeToEnd);
          back_ += (len - sizeToEnd);
          len_ += len;
        }
      return len;
    }

push_back() [2/2]

template<typename T >

std::size_t os::posix::circular_buffer< T >::push_back

(

value_type

v

)

Definition at line 319 of file circular-buffer.h.

    {
      if (full ())
        {
          return 0;
        }
 
      // Add to back.
      *back_++ = v;
      if (static_cast<std::size_t> (back_ - buf_) >= size_)
        {
          // Wrap.
          back_ = const_cast<value_type* volatile> (buf_);
        }
      len_++;
      return 1;
    }

retreat_back()

template<typename T >

void os::posix::circular_buffer< T >::retreat_back

(

void

)

Definition at line 407 of file circular-buffer.h.

    {
      if (back_ == buf_)
        {
          back_ = static_cast<value_type*> (const_cast<value_type*> (buf_)
                                            + size_ - 1);
        }
      else
        {
          back_ -= 1;
        }
      len_--;
    }

size()

template<typename T >

std::size_t os::posix::circular_buffer< T >::size ( void  ) const

inline

Definition at line 312 of file circular-buffer.h.

    {
      return size_;
    }

---

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

• circular-buffer.h