OutputPort.hpp

Go to the documentation of this file.

#pragma once
#include <Pothos/Config.hpp>
#include <Pothos/Object/Object.hpp>
#include <Pothos/Framework/DType.hpp>
#include <Pothos/Framework/Label.hpp>
#include <Pothos/Framework/BufferChunk.hpp>
#include <string>

namespace Pothos {

class OutputPortImpl;
class WorkerActor;
class InputPort;

class POTHOS_API OutputPort
{
public:

    ~OutputPort(void);

    int index(void) const;

    const std::string &name(void) const;

    const DType &dtype(void) const;

    const std::string &domain(void) const;

    const BufferChunk &buffer(void) const;

    size_t elements(void) const;

    unsigned long long totalElements(void) const;

    unsigned long long totalMessages(void) const;

    void produce(const size_t numElements);

    void popBuffer(const size_t numBytes);

    void postLabel(const Label &label);

    template <typename ValueType>
    void postMessage(ValueType &&message);

    void postBuffer(const BufferChunk &buffer);

    bool isSignal(void) const;

    void setReadBeforeWrite(InputPort *port);

private:
    OutputPortImpl *_impl;
    int _index;
    std::string _name;
    DType _dtype;
    std::string _domain;
    BufferChunk _buffer;
    size_t _elements;
    unsigned long long _totalElements;
    unsigned long long _totalMessages;
    size_t _pendingElements;
    OutputPort(OutputPortImpl *);
    OutputPort(const OutputPort &){} // non construction-copyable
    OutputPort &operator=(const OutputPort &){return *this;} // non copyable
    friend class WorkerActor;
    void _postMessage(const Object &message);
};

} //namespace Pothos

inline int Pothos::OutputPort::index(void) const
{
    return _index;
}

inline const std::string &Pothos::OutputPort::name(void) const
{
    return _name;
}

inline const Pothos::DType &Pothos::OutputPort::dtype(void) const
{
    return _dtype;
}

inline const std::string &Pothos::OutputPort::domain(void) const
{
    return _domain;
}

inline const Pothos::BufferChunk &Pothos::OutputPort::buffer(void) const
{
    return _buffer;
}

inline size_t Pothos::OutputPort::elements(void) const
{
    return _elements;
}

inline unsigned long long Pothos::OutputPort::totalElements(void) const
{
    return _totalElements;
}

inline unsigned long long Pothos::OutputPort::totalMessages(void) const
{
    return _totalMessages;
}

inline void Pothos::OutputPort::produce(const size_t numElements)
{
    _pendingElements += numElements;
}

template <typename ValueType>
void Pothos::OutputPort::postMessage(ValueType &&message)
{
    Pothos::OutputPort::_postMessage(Pothos::Object(std::forward<ValueType>(message)));
}