peak_module.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common_c/detail/peak_common_defines.h>
 
#include <peak/backend/peak_backend.h>
#include <peak/generic/peak_init_once.hpp>
 
#include <cstddef>
#include <memory>
#include <vector>
 
 
namespace peak
{
namespace core
{
 
class NodeMap;
class Port;

class Module : public InitOnce
{
public:
    Module() = default;
    virtual ~Module() = default;
    Module(const Module& other) = delete;
    Module& operator=(const Module& other) = delete;
    Module(Module&& other) = delete;
    Module& operator=(Module&& other) = delete;

    PEAK_COMMON_NO_DISCARD std::vector<std::shared_ptr<NodeMap>> NodeMaps() const;

    PEAK_COMMON_NO_DISCARD std::shared_ptr<class Port> Port() const;
 
protected:
    virtual PEAK_MODULE_HANDLE ModuleHandle() const = 0;

    void Initialize() const override;
 
private:
    mutable std::vector<std::shared_ptr<NodeMap>> m_nodeMaps;
    mutable std::shared_ptr<class Port> m_port;
};
 
} /* namespace core */
} /* namespace peak */
 
#include <peak/node_map/peak_node_map.hpp>
#include <peak/port/peak_port.hpp>
 
 
/* Implementation */
namespace peak
{
namespace core
{
 
inline std::vector<std::shared_ptr<NodeMap>> Module::NodeMaps() const
{
    InitializeIfNecessary();
    return m_nodeMaps;
}
 
inline std::shared_ptr<class Port> Module::Port() const
{
    InitializeIfNecessary();
    return m_port;
}

inline void Module::Initialize() const
{
    auto moduleHandle = ModuleHandle();
 
    auto numNodeMaps = QueryNumericFromCInterfaceFunction<size_t>([&](size_t* _numNodeMaps) {
        return PEAK_C_ABI_PREFIX PEAK_Module_GetNumNodeMaps(moduleHandle, _numNodeMaps);
    });
 
    std::vector<std::shared_ptr<NodeMap>> nodeMaps;
    for (size_t x = 0; x < numNodeMaps; ++x)
    {
        auto nodeMapHandle = QueryNumericFromCInterfaceFunction<PEAK_NODE_MAP_HANDLE>(
            [&](PEAK_NODE_MAP_HANDLE* _nodeMapHandle) {
                return PEAK_C_ABI_PREFIX PEAK_Module_GetNodeMap(moduleHandle, x, _nodeMapHandle);
            });
 
        nodeMaps.emplace_back(std::make_shared<ClassCreator<NodeMap>>(nodeMapHandle));
    }
 
    m_nodeMaps = nodeMaps;
 
    auto portHandle = QueryNumericFromCInterfaceFunction<PEAK_PORT_HANDLE>([&](PEAK_PORT_HANDLE* _portHandle) {
        return PEAK_C_ABI_PREFIX PEAK_Module_GetPort(moduleHandle, _portHandle);
    });
 
    m_port = std::make_shared<ClassCreator<peak::core::Port>>(portHandle);
}
 
} /* namespace core */
} /* namespace peak */