base_stub.hpp

//
// Created by gabriele on 04/11/18.
//

#ifndef LIBFORB_BASE_STUB_HPP
#define LIBFORB_BASE_STUB_HPP

#include <vector>
#include <string>
#include <memory>
#include <mutex>

#include <forb/stream/shared_memory.hpp>
#include <forb/stream/socket.hpp>
#include <forb/stream/stream.hpp>

namespace forb {
    // Forward declaration of registry class
    class remote_registry;

    /* ************************************************** ALIASES *************************************************** */

    // Forward declaration
    class base_stub;

    using remote_ptr = std::shared_ptr<base_stub>;

    using remote_var = std::unique_ptr<base_stub>;

    /* *************************************************** CLASS **************************************************** */

    class base_stub {
        friend class remote_registry;

        /* ************************************* ALIASES AND STATIC ATTRIBUTES ************************************** */
    public:
        using buffer_size_t = forb::streams::shared_memory::size_t;

    private:
        using ssocket = forb::streams::socket;
        using shared_memory = forb::streams::shared_memory;
        using stream = forb::streams::stream;

        constexpr static buffer_size_t default_buffer_size = 1024;

        /* *********************************************** ATTRIBUTES *********************************************** */
    protected:
        std::mutex _mutex;

        stream *rpcstream = nullptr;

        stream *datastream = nullptr;

    private:
        ssocket _socket;

        shared_memory _shmem;

        bool _force_socket = false;

        buffer_size_t _buffer_size = default_buffer_size;

        /* ********************************************** CONSTRUCTORS ********************************************** */
    protected:
        explicit base_stub() = default;

        /**************************************************************************************************************/
    public:
        virtual ~base_stub() noexcept = default;

        base_stub(const base_stub &other) = delete;

        base_stub &operator=(const base_stub &other) = delete;

        base_stub(base_stub &&other) = delete;

        base_stub &operator=(base_stub &&other) = delete;

        /**************************************************************************************************************/
    public:
        shared_memory::size_t buffer_size() const {
            return _buffer_size;
        };


    protected:
        void init_call(call_id_t code);

        // TODO: check wait return
        void wait_return();

    private:
        void force_socket() {
            _force_socket = true;
        };

        void set_buffer_size(buffer_size_t buffer_size) {
            _buffer_size = buffer_size;
        };

        void set_skeleton(std::string address, int port);

        /* ******************************************** FACTORY METHODS ********************************************* */
    protected:
        virtual bool _match(const std::string &type) const = 0;

        virtual remote_var _create_empty() const = 0;

        static std::vector<base_stub *> &_protos();

    private:
        static remote_var _create(const std::string &type);
    };

    /* ************************************************* TEMPLATES ************************************************** */

    template<typename T>
    bool is_nil(const std::shared_ptr<T> &ptr) {
        static_assert(std::is_base_of<base_stub, T>::value,
                      "The given type is not derived from forb::base_stub!");
        return ptr == nullptr;
    }

    template<typename T>
    bool is_nil(const std::unique_ptr<T> &ptr) {
        static_assert(std::is_base_of<base_stub, T>::value,
                      "The given type is not derived from forb::base_stub!");
        return ptr == nullptr;
    }


} // namespace forb


#endif //LIBFORB_BASE_STUB_HPP