container_integration.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
#ifndef KCENON_NETWORK_INTERNAL_INTEGRATION_CONTAINER_INTEGRATION_H_
#define KCENON_NETWORK_INTERNAL_INTEGRATION_CONTAINER_INTEGRATION_H_
 
#include <kcenon/network/detail/config/feature_flags.h>
 
#include <memory>
#include <vector>
#include <string>
#include <functional>
#include <any>
 
#include "kcenon/network/integration/thread_integration.h"
 
#if KCENON_WITH_CONTAINER_SYSTEM
#include "container.h"
#endif
 
namespace kcenon::network::integration {
 
class container_interface {
public:
    virtual ~container_interface() = default;
 
    virtual std::vector<uint8_t> serialize(const std::any& data) const = 0;
 
    virtual std::any deserialize(const std::vector<uint8_t>& bytes) const = 0;
 
    virtual std::string type_name() const = 0;
 
    virtual bool is_valid() const = 0;
};
 
#if KCENON_WITH_CONTAINER_SYSTEM
class container_system_adapter : public container_interface {
public:
    explicit container_system_adapter(
        std::shared_ptr<container_module::value_container> container
    );
 
    // container_interface implementation
    std::vector<uint8_t> serialize(const std::any& data) const override;
    std::any deserialize(const std::vector<uint8_t>& bytes) const override;
    std::string type_name() const override;
    bool is_valid() const override;
 
    std::shared_ptr<container_module::value_container> get_container() const;
 
private:
    std::shared_ptr<container_module::value_container> container_;
};
#endif
 
class basic_container : public container_interface {
public:
    basic_container();
    ~basic_container();
 
    // container_interface implementation
    std::vector<uint8_t> serialize(const std::any& data) const override;
    std::any deserialize(const std::vector<uint8_t>& bytes) const override;
    std::string type_name() const override;
    bool is_valid() const override;
 
    void set_serializer(
        std::function<std::vector<uint8_t>(const std::any&)> serializer
    );
 
    void set_deserializer(
        std::function<std::any(const std::vector<uint8_t>&)> deserializer
    );
 
private:
    class impl;
    std::unique_ptr<impl> pimpl_;
};
 
class container_manager {
public:
    static container_manager& instance();
 
    void register_container(
        const std::string& name,
        std::shared_ptr<container_interface> container
    );
 
    std::shared_ptr<container_interface> get_container(
        const std::string& name
    ) const;
 
    void set_default_container(
        std::shared_ptr<container_interface> container
    );
 
    std::shared_ptr<container_interface> get_default_container();
 
    std::vector<uint8_t> serialize(const std::any& data);
 
    std::any deserialize(const std::vector<uint8_t>& bytes);
 
    std::vector<std::string> list_containers() const;
 
private:
    container_manager();
    ~container_manager();
 
    class impl;
    std::unique_ptr<impl> pimpl_;
};
 
} // namespace kcenon::network::integration
 
// Backward compatibility namespace alias is defined in thread_integration.h
 
#endif // KCENON_NETWORK_INTERNAL_INTEGRATION_CONTAINER_INTEGRATION_H_