BufferBase.h

[詳解]

// -*- C++ -*-
#ifndef RTC_BUFFERBASE_H
#define RTC_BUFFERBASE_H

#include <stddef.h>
#include <coil/Properties.h>
#include <rtm/BufferStatus.h>

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

    virtual ~BufferBase(void)
    {
    };
    
    virtual void init(const coil::Properties& prop) = 0;

    virtual size_t length(void) const = 0;

    virtual ReturnCode length(size_t n) = 0;

    virtual ReturnCode reset() = 0;


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

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

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

    virtual ReturnCode write(const DataType& value,
                             long int sec = -1, long int nsec = -1) = 0;

    virtual size_t writable() const = 0;

    virtual bool full(void) const = 0;

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

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

    virtual ReturnCode get(DataType& value) = 0;

    virtual DataType&  get() = 0;

    virtual ReturnCode read(DataType& value,
                            long int sec = -1, long int nsec = -1) = 0;
    
    virtual size_t readable() const = 0;

    virtual bool empty(void) const = 0;

  };
  
  template <class DataType>
  class NullBuffer
    : public BufferBase<DataType>
  {
  public:
    NullBuffer(long int size = 1)
      : m_length(1)
    {
    }
    
    virtual ~NullBuffer(void)
    {
    }
    
    virtual long int length(void) 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(void) const
    {
      return false;
    }
    
    virtual bool isEmpty(void) const
    {
      return false;
    }
    
  protected:
    virtual void put(const DataType& data)
    {
      m_data = data;
    }
    
    virtual const DataType& get(void)
    {
      return m_data;
    }
    
    virtual DataType& getRef(void)
    {
      return m_data;
    }
    
  private:
    DataType m_data;
    long int m_length;
  };
}; // namespace RTC
#endif // BufferBase_h