Block.hpp

Go to the documentation of this file.

#pragma once
#include <Pothos/Config.hpp>
#include <Pothos/Framework/Connectable.hpp>
#include <Pothos/Framework/WorkInfo.hpp>
#include <Pothos/Framework/InputPort.hpp>
#include <Pothos/Framework/OutputPort.hpp>
#include <Pothos/Framework/ThreadPool.hpp>
#include <memory>
#include <string>
#include <vector>
#include <map>

namespace Pothos {

    class BufferManager;

class POTHOS_API Block : public Connectable
{
public:

    explicit Block(void);

    virtual ~Block(void);

    void setThreadPool(const ThreadPool &threadPool);

    const ThreadPool &getThreadPool(void) const;

protected:

    virtual void work(void);

    virtual void activate(void);

    virtual void deactivate(void);

    virtual void propagateLabels(const InputPort *input);

    virtual Object opaqueCallHandler(const std::string &name, const Object *inputArgs, const size_t numArgs);

    virtual std::shared_ptr<BufferManager> getInputBufferManager(const std::string &name, const std::string &domain);

    virtual std::shared_ptr<BufferManager> getOutputBufferManager(const std::string &name, const std::string &domain);

public:

    std::vector<PortInfo> inputPortInfo(void);

    std::vector<PortInfo> outputPortInfo(void);

    InputPort *input(const std::string &name) const;

    InputPort *input(const size_t index) const;

    OutputPort *output(const std::string &name) const;

    OutputPort *output(const size_t index) const;

    const std::vector<InputPort*> &inputs(void) const;

    const std::vector<OutputPort*> &outputs(void) const;

    const std::map<std::string, InputPort*> &allInputs(void) const;

    const std::map<std::string, OutputPort*> &allOutputs(void) const;

    const WorkInfo &workInfo(void) const;

    bool isActive(void) const;

    InputPort *setupInput(const std::string &name, const DType &dtype = "", const std::string &domain = "");

    InputPort *setupInput(const size_t index, const DType &dtype = "", const std::string &domain = "");

    OutputPort *setupOutput(const std::string &name, const DType &dtype = "", const std::string &domain = "");

    OutputPort *setupOutput(const size_t index, const DType &dtype = "", const std::string &domain = "");

    void registerCallable(const std::string &name, const Callable &call);

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

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

    void registerProbe(
        const std::string &name,
        const std::string &signalName="",
        const std::string &slotName="");

    void yield(void);

    template <typename... ArgsType>
    void emitSignal(const std::string &name, ArgsType&&... args);

    Object opaqueCallMethod(const std::string &name, const Object *inputArgs, const size_t numArgs) const;

private:
    WorkInfo _workInfo;
    std::vector<std::string> _inputPortNames;
    std::vector<std::string> _outputPortNames;
    std::vector<InputPort*> _indexedInputs;
    std::vector<OutputPort*> _indexedOutputs;
    std::map<std::string, InputPort*> _namedInputs;
    std::map<std::string, OutputPort*> _namedOutputs;
    std::multimap<std::string, Callable> _calls;
    std::map<std::string, std::pair<std::string, std::string>> _probes;
    ThreadPool _threadPool;
    Block(const Block &){} // non construction-copyable
    Block &operator=(const Block &){return *this;} // non copyable
public:
    std::shared_ptr<WorkerActor> _actor;
    friend class WorkerActor;
};

} //namespace Pothos