IService.h

Go to the documentation of this file.

#ifndef ZSERIO_ISERVICE_H_INC
#define ZSERIO_ISERVICE_H_INC
 
#include "zserio/IReflectable.h"
#include "zserio/Span.h"
#include "zserio/StringView.h"
#include "zserio/Types.h"
#include "zserio/Vector.h"
 
namespace zserio
{
 
template <typename ALLOC = std::allocator<uint8_t>>
class IBasicServiceData
{
public:
    virtual ~IBasicServiceData() = default;
 
    virtual IBasicReflectableConstPtr<ALLOC> getReflectable() const = 0;
 
    virtual Span<const uint8_t> getData() const = 0;
};
 
template <typename ALLOC = std::allocator<uint8_t>>
using IBasicServiceDataPtr = std::shared_ptr<IBasicServiceData<ALLOC>>;
 
template <typename ALLOC = std::allocator<uint8_t>>
class BasicReflectableServiceData : public IBasicServiceData<ALLOC>
{
public:
    explicit BasicReflectableServiceData(
            const IBasicReflectableConstPtr<ALLOC>& reflectable, const ALLOC& allocator = ALLOC()) :
            m_reflectable(reflectable),
            m_data(allocator)
    {}
 
    IBasicReflectableConstPtr<ALLOC> getReflectable() const override
    {
        return m_reflectable;
    }
 
    Span<const uint8_t> getData() const override
    {
        if (m_reflectable && m_data.getBitSize() == 0)
        {
            // lazy initialization
            m_data = BasicBitBuffer<ALLOC>(m_reflectable->bitSizeOf(), m_data.get_allocator());
            BitStreamWriter writer(m_data);
            m_reflectable->write(writer);
        }
        return m_data.getData();
    }
 
private:
    IBasicReflectableConstPtr<ALLOC> m_reflectable;
    mutable BasicBitBuffer<ALLOC> m_data;
};
 
template <typename ALLOC = std::allocator<uint8_t>>
class BasicObjectServiceData : public IBasicServiceData<ALLOC>
{
public:
    template <typename ZSERIO_OBJECT>
    explicit BasicObjectServiceData(ZSERIO_OBJECT& object, const ALLOC& allocator = ALLOC()) :
            m_data(object.bitSizeOf(), allocator)
    {
        BitStreamWriter writer(m_data);
        object.write(writer);
    }
 
    IBasicReflectableConstPtr<ALLOC> getReflectable() const override
    {
        return nullptr;
    }
 
    Span<const uint8_t> getData() const override
    {
        return m_data.getData();
    }
 
private:
    BasicBitBuffer<ALLOC> m_data;
};
 
template <typename ALLOC = std::allocator<uint8_t>>
class BasicRawServiceDataHolder : public IBasicServiceData<ALLOC>
{
public:
    explicit BasicRawServiceDataHolder(const vector<uint8_t, ALLOC>& rawData) :
            m_data(rawData)
    {}
 
    explicit BasicRawServiceDataHolder(vector<uint8_t, ALLOC>&& rawData) :
            m_data(std::move(rawData))
    {}
 
    IBasicReflectableConstPtr<ALLOC> getReflectable() const override
    {
        return nullptr;
    }
 
    Span<const uint8_t> getData() const override
    {
        return m_data;
    }
 
private:
    vector<uint8_t, ALLOC> m_data;
};
 
template <typename ALLOC = std::allocator<uint8_t>>
class BasicRawServiceDataView : public IBasicServiceData<ALLOC>
{
public:
    explicit BasicRawServiceDataView(zserio::Span<const uint8_t> rawData) :
            m_data(rawData)
    {}
 
    IBasicReflectableConstPtr<ALLOC> getReflectable() const override
    {
        return nullptr;
    }
 
    Span<const uint8_t> getData() const override
    {
        return m_data;
    }
 
private:
    Span<const uint8_t> m_data;
};
 
template <typename ALLOC = std::allocator<uint8_t>>
class IBasicService
{
public:
    virtual ~IBasicService() = default;
 
    virtual IBasicServiceDataPtr<ALLOC> callMethod(
            StringView methodName, Span<const uint8_t> requestData, void* context) = 0;
};
 
template <typename ALLOC = std::allocator<uint8_t>>
class IBasicServiceClient
{
public:
    virtual ~IBasicServiceClient() = default;
 
    virtual vector<uint8_t, ALLOC> callMethod(
            StringView methodName, const IBasicServiceData<ALLOC>& requestData, void* context) = 0;
};
 
using IServiceData = IBasicServiceData<>;
using IServiceDataPtr = IBasicServiceDataPtr<>;
using IService = IBasicService<>;
using IServiceClient = IBasicServiceClient<>;
using ReflectableServiceData = BasicReflectableServiceData<>;
using ObjectServiceData = BasicObjectServiceData<>;
using RawServiceDataHolder = BasicRawServiceDataHolder<>;
using RawServiceDataView = BasicRawServiceDataView<>;
} // namespace zserio
 
#endif // ifndef ZSERIO_ISERVICE_H_INC