BufferManager.hpp

Go to the documentation of this file.

#pragma once
#include <Pothos/Config.hpp>
#include <Pothos/Framework/ManagedBuffer.hpp>
#include <Pothos/Framework/BufferChunk.hpp>
#include <memory> //shared_ptr
#include <string>
#include <functional>

namespace Pothos {

struct POTHOS_API BufferManagerArgs
{
    BufferManagerArgs(void);

    size_t numBuffers;

    size_t bufferSize;

    long nodeAffinity;
};

class POTHOS_API BufferManager
{
public:

    typedef std::shared_ptr<BufferManager> Sptr;

    virtual ~BufferManager(void);

    static Sptr make(const std::string &name);

    static Sptr make(const std::string &name, const BufferManagerArgs &args);

    virtual void init(const BufferManagerArgs &args);

    virtual bool empty(void) const = 0;

    const BufferChunk &front(void) const;

    virtual void pop(const size_t numBytes) = 0;

    virtual void push(const ManagedBuffer &buff) = 0;

    void pushExternal(const ManagedBuffer &buff);

    void setCallback(const std::function<void(const ManagedBuffer &)> &callback);

    bool isInitialized(void) const;

protected:
    BufferManager(void);

    void setFrontBuffer(const BufferChunk &buff);

private:
    bool _initialized;
    BufferChunk _frontBuffer;
    std::function<void(const ManagedBuffer &)> _callback;
};

} //namespace Pothos

inline const Pothos::BufferChunk &Pothos::BufferManager::front(void) const
{
    return _frontBuffer;
}

inline void Pothos::BufferManager::setFrontBuffer(const BufferChunk &buff)
{
    _frontBuffer = buff;
}

inline void Pothos::BufferManager::pushExternal(const ManagedBuffer &buff)
{
    if (_callback) _callback(buff);
    else this->push(buff);
}

inline bool Pothos::BufferManager::isInitialized(void) const
{
    return _initialized;
}