IService.h

Go to the documentation of this file.

#ifndef ZSERIO_ISERVICE_H_INC
#define ZSERIO_ISERVICE_H_INC
 
#include <string_view>
 
#include "zserio/IIntrospectableView.h"
#include "zserio/SerializeUtil.h"
#include "zserio/Span.h"
#include "zserio/Types.h"
#include "zserio/Vector.h"
#include "zserio/View.h"
 
namespace zserio
{
 
template <typename ALLOC = std::allocator<uint8_t>>
class IBasicServiceData
{
public:
    virtual ~IBasicServiceData() = default;
 
    virtual IBasicIntrospectableViewConstPtr<ALLOC> getIntrospectable() 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 ZSERIO_OBJECT, typename ALLOC = std::allocator<uint8_t>>
class BasicIntrospectableServiceData : public IBasicServiceData<ALLOC>
{
public:
    explicit BasicIntrospectableServiceData(const ZSERIO_OBJECT& object, const ALLOC& allocator = ALLOC()) :
            m_object(object),
            m_introspectable(introspectable(View(m_object), allocator)),
            m_data(allocator)
    {}
 
    explicit BasicIntrospectableServiceData(ZSERIO_OBJECT&& object, const ALLOC& allocator = ALLOC()) :
            m_object(std::move(object)),
            m_introspectable(introspectable(View(m_object), allocator)),
            m_data(allocator)
    {}
 
    IBasicIntrospectableViewConstPtr<ALLOC> getIntrospectable() const override
    {
        return m_introspectable;
    }
 
    Span<const uint8_t> getData() const override
    {
        if (m_introspectable && m_data.getBitSize() == 0)
        {
            // lazy initialization
            m_data = m_introspectable->serialize(m_data.get_allocator());
        }
        return m_data.getData();
    }
 
private:
    ZSERIO_OBJECT m_object;
    IBasicIntrospectableViewConstPtr<ALLOC> m_introspectable;
    mutable BasicBitBuffer<ALLOC> m_data;
};
 
template <typename ALLOC = std::allocator<uint8_t>>
class BasicObjectServiceData : public IBasicServiceData<ALLOC>
{
public:
    template <typename ZSERIO_OBJECT>
    explicit BasicObjectServiceData(const ZSERIO_OBJECT& object, const ALLOC& allocator = ALLOC()) :
            m_data(zserio::serialize(object, allocator))
    {}
 
    IBasicIntrospectableViewConstPtr<ALLOC> getIntrospectable() 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))
    {}
 
    IBasicIntrospectableViewConstPtr<ALLOC> getIntrospectable() 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)
    {}
 
    IBasicIntrospectableViewConstPtr<ALLOC> getIntrospectable() 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(
            std::string_view 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(
            std::string_view methodName, const IBasicServiceData<ALLOC>& requestData, void* context) = 0;
};
 
using IServiceData = IBasicServiceData<>;
using IServiceDataPtr = IBasicServiceDataPtr<>;
using IService = IBasicService<>;
using IServiceClient = IBasicServiceClient<>;
template <typename ZSERIO_OBJECT>
using IntrospectableServiceData = BasicIntrospectableServiceData<ZSERIO_OBJECT>;
using ObjectServiceData = BasicObjectServiceData<>;
using RawServiceDataHolder = BasicRawServiceDataHolder<>;
using RawServiceDataView = BasicRawServiceDataView<>;
} // namespace zserio
 
#endif // ifndef ZSERIO_ISERVICE_H_INC