peak_event.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/common/peak_common_structs.hpp>
#include <peak/dll_interface/peak_dll_interface_util.hpp>
 
#include <cstdint>
#include <vector>
 
 
namespace peak
{
namespace core
{

enum class EventType
{
    Error,
    FeatureInvalidate = 2,
    FeatureChange,
    RemoteDevice,
    Module,
 
    Custom = 1000
};
 
class NodeMap;

class Event
{
public:
    Event() = delete;
    ~Event();
    Event(const Event& other) = delete;
    Event& operator=(const Event& other) = delete;
    Event(Event&& other) = delete;
    Event& operator=(Event&& other) = delete;

    PEAK_COMMON_NO_DISCARD RawInformation Info(int32_t infoCommand) const;

    PEAK_COMMON_NO_DISCARD uint64_t ID() const;

    PEAK_COMMON_NO_DISCARD std::vector<uint8_t> Data() const;
 

    PEAK_COMMON_NO_DISCARD EventType Type() const;

    PEAK_COMMON_NO_DISCARD std::vector<uint8_t> RawData() const;
 
private:
    friend NodeMap;
    friend ClassCreator<Event>;
    explicit Event(PEAK_EVENT_HANDLE eventHandle);
    PEAK_EVENT_HANDLE m_backendHandle;
};
 
} /* namespace core */
} /* namespace peak */
 
/* Implementation */
namespace peak
{
namespace core
{
 
inline Event::Event(PEAK_EVENT_HANDLE eventHandle)
    : m_backendHandle(eventHandle)
{}
 
inline RawInformation Event::Info(int32_t infoCommand) const
{
    return QueryRawInformationFromCInterfaceFunction([&](int32_t* dataType, uint8_t* buffer, size_t* bufferSize) {
        return PEAK_C_ABI_PREFIX PEAK_Event_GetInfo(m_backendHandle, infoCommand, dataType, buffer, bufferSize);
    });
}
 
inline uint64_t Event::ID() const
{
    return QueryNumericFromCInterfaceFunction<uint64_t>(
        [&](uint64_t* id) { return PEAK_C_ABI_PREFIX PEAK_Event_GetID(m_backendHandle, id); });
}
 
inline std::vector<uint8_t> Event::Data() const
{
    return QueryNumericArrayFromCInterfaceFunction<uint8_t>([&](uint8_t* data, size_t* dataSize) {
        return PEAK_C_ABI_PREFIX PEAK_Event_GetData(m_backendHandle, data, dataSize);
    });
}
 
inline EventType Event::Type() const
{
    return static_cast<EventType>(QueryNumericFromCInterfaceFunction<PEAK_EVENT_TYPE>(
        [&](PEAK_EVENT_TYPE* type) { return PEAK_C_ABI_PREFIX PEAK_Event_GetType(m_backendHandle, type); }));
}
 
inline std::vector<uint8_t> Event::RawData() const
{
    return QueryNumericArrayFromCInterfaceFunction<uint8_t>([&](uint8_t* rawData, size_t* rawDataSize) {
        return PEAK_C_ABI_PREFIX PEAK_Event_GetRawData(m_backendHandle, rawData, rawDataSize);
    });
}
 
inline Event::~Event()
{
    (void)PEAK_C_ABI_PREFIX PEAK_Event_Destruct(m_backendHandle);
}
 
inline std::string ToString(EventType entry)
{
    std::string entryString;
 
    if (entry == EventType::Error)
    {
        entryString = "Error";
    }
    else if (entry == EventType::FeatureInvalidate)
    {
        entryString = "FeatureInvalidate";
    }
    else if (entry == EventType::FeatureChange)
    {
        entryString = "FeatureChange";
    }
    else if (entry == EventType::RemoteDevice)
    {
        entryString = "RemoteDevice";
    }
    else if (entry == EventType::Module)
    {
        entryString = "Module";
    }
    else if (entry >= EventType::Custom)
    {
        entryString = "Custom";
    }
 
    return entryString;
}
 
} /* namespace core */
} /* namespace peak */