Frame.h

Go to the documentation of this file.

 
#ifndef __ROGUE_INTERFACES_STREAM_FRAME_H__
#define __ROGUE_INTERFACES_STREAM_FRAME_H__
#include "rogue/Directives.h"
 
#include <stdint.h>
 
#include <memory>
#include <mutex>
#include <thread>
#include <vector>
 
#include "rogue/EnableSharedFromThis.h"
 
#ifndef NO_PYTHON
    #include <boost/python.hpp>
#endif
 
namespace rogue {
namespace interfaces {
namespace stream {
 
class Buffer;
class FrameIterator;
class FrameLock;
 
class Frame : public rogue::EnableSharedFromThis<rogue::interfaces::stream::Frame> {
    friend class Buffer;
    friend class FrameLock;
 
    // Interface specific flags
    uint16_t flags_;
 
    // Error state
    uint8_t error_;
 
    // Channel
    uint8_t chan_;
 
    // List of buffers which hold real data
    std::vector<std::shared_ptr<rogue::interfaces::stream::Buffer> > buffers_;
 
    // Total size of buffers
    uint32_t size_;
 
    // Total payload size
    uint32_t payload_;
 
    // Update buffer size counts
    void updateSizes();
 
    // Size values dirty flags
    bool sizeDirty_;
 
  protected:
    // Set size values dirty
    void setSizeDirty();
 
    // Frame lock
    std::mutex lock_;
 
  public:
    typedef std::vector<std::shared_ptr<rogue::interfaces::stream::Buffer> >::iterator BufferIterator;
 
    static void setup_python();
 
    static std::shared_ptr<rogue::interfaces::stream::Frame> create();
 
    Frame();
 
    ~Frame();
 
    std::shared_ptr<rogue::interfaces::stream::FrameLock> lock();
 
    std::vector<std::shared_ptr<rogue::interfaces::stream::Buffer> >::iterator appendFrame(
        std::shared_ptr<rogue::interfaces::stream::Frame> frame);
 
    std::vector<std::shared_ptr<rogue::interfaces::stream::Buffer> >::iterator appendBuffer(
        std::shared_ptr<rogue::interfaces::stream::Buffer> buff);
 
    std::vector<std::shared_ptr<rogue::interfaces::stream::Buffer> >::iterator beginBuffer();
 
    std::vector<std::shared_ptr<rogue::interfaces::stream::Buffer> >::iterator endBuffer();
 
    uint32_t bufferCount();
 
    void clear();
 
    bool isEmpty();
 
    uint32_t getSize();
 
    uint32_t getAvailable();
 
    uint32_t getPayload();
 
    void setPayload(uint32_t size);
 
    void minPayload(uint32_t size);
 
    void adjustPayload(int32_t value);
 
    void setPayloadFull();
 
    void setPayloadEmpty();
 
    uint16_t getFlags();
 
    void setFlags(uint16_t flags);
 
    uint8_t getFirstUser();
 
    void setFirstUser(uint8_t fuser);
 
    uint8_t getLastUser();
 
    void setLastUser(uint8_t fuser);
 
    uint8_t getChannel();
 
    void setChannel(uint8_t channel);
 
    uint8_t getError();
 
    void setError(uint8_t error);
 
    rogue::interfaces::stream::FrameIterator begin();
 
    rogue::interfaces::stream::FrameIterator end();
 
    rogue::interfaces::stream::FrameIterator beginRead();
 
    rogue::interfaces::stream::FrameIterator endRead();
 
    rogue::interfaces::stream::FrameIterator beginWrite();
 
    rogue::interfaces::stream::FrameIterator endWrite();
 
#ifndef NO_PYTHON
 
    void readPy(boost::python::object p, uint32_t offset);
 
    boost::python::object getBytearrayPy(uint32_t offset, uint32_t count);
 
    boost::python::object getMemoryviewPy();
 
    void writePy(boost::python::object p, uint32_t offset);
 
    boost::python::object getNumpy(uint32_t offset, uint32_t count);
 
    void putNumpy(boost::python::object np, uint32_t offset);
#endif
 
    void debug();
};
 
typedef std::shared_ptr<rogue::interfaces::stream::Frame> FramePtr;
}  // namespace stream
}  // namespace interfaces
}  // namespace rogue
 
#endif