BufferBase.h

[詳解]

// -*- C++ -*-
 
#ifndef RTC_BUFFERBASE_H
#define RTC_BUFFERBASE_H
 
#include <cstddef>
#include <coil/Properties.h>
#include <rtm/BufferStatus.h>
#include <chrono>

namespace RTC
{
  template <class DataType>
  class BufferBase
  {
  public:

    virtual ~BufferBase() = default;

    virtual void init(const coil::Properties& prop) = 0;

    virtual size_t length() const = 0;

    virtual BufferStatus length(size_t n) = 0;

    virtual BufferStatus reset() = 0;
 
 
    //----------------------------------------------------------------------
    virtual DataType* wptr(long int n = 0) = 0;

    virtual BufferStatus advanceWptr(long int n = 1, bool unlock_enable = true) = 0;

    virtual BufferStatus put(const DataType& value) = 0;

    virtual BufferStatus write(const DataType& value,
                               std::chrono::nanoseconds timeout
                               = std::chrono::nanoseconds(-1)) = 0;

    virtual size_t writable() const = 0;

    virtual bool full() const = 0;
 
    //----------------------------------------------------------------------
    virtual DataType* rptr(long int n = 0) = 0;

    virtual BufferStatus advanceRptr(long int n = 1, bool unlock_enable = true) = 0;

    virtual BufferStatus get(DataType& value) = 0;

    virtual DataType&  get() = 0;

    virtual BufferStatus read(DataType& value,
                              std::chrono::nanoseconds nsec
                              = std::chrono::nanoseconds(-1)) = 0;

    virtual size_t readable() const = 0;

    virtual bool empty() const = 0;
 
  };

  template <class DataType>
  class NullBuffer
    : public BufferBase<DataType>
  {
  public:
    explicit NullBuffer(long int size = 1)
      : m_length(size)
    {
    }

    virtual ~NullBuffer() = default;

    virtual long int length() const
    {
      return 1;
    }

    virtual bool write(const DataType& value)
    {
      m_data = value;
      return true;
    }

    virtual bool read(DataType& value)
    {
      value = m_data;
      return true;
    }

    virtual bool isFull() const
    {
      return false;
    }

    virtual bool isEmpty() const
    {
      return false;
    }
 
  protected:
    virtual void put(const DataType& data)
    {
      m_data = data;
    }

    virtual const DataType& get()
    {
      return m_data;
    }

    virtual DataType& getRef()
    {
      return m_data;
    }
 
  private:
    DataType m_data;
    long int m_length;
  };
} // namespace RTC
#endif  // BufferBase_h