Service.h

//
// Copyright (c) 2006-2014 Raphael David / CANTOR
//

#ifndef CMR_SERVICE_INCLUDED
#define CMR_SERVICE_INCLUDED

#include "Commore.h"
#include "Interface.h"
#include "Listener.h"

//
// TODO : session
//

namespace commore
{
    class Tuple;
    class Service;
    typedef AutoRef<Service> PService;
    class Interface;
    class ServiceFactory;
    typedef ServiceFactory* PServiceFactory;
    class InterfaceFactory;
    typedef InterfaceFactory* PInterfaceFactory;


    class CMREXD PServiceManager
    {
    public:
        struct Impl;
    private:
        Impl* impl_;
        PServiceManager(Impl* impl);
    public:
        PServiceManager();
        ~PServiceManager();
        PServiceManager(const PServiceManager& p);
        PServiceManager& operator = (const PServiceManager& p);
        Impl* get_impl() const { return impl_; }
        Impl* get() const { return impl_; }
        long publish(const PService& service);
        long unpublish(const PService& service);
        bool add_listener(const AChar* spec);
        bool add_listener(const PListener& listener);
        bool remove_listener(const AChar* spec);
        bool remove_listener(const PListener& listener);
        
        ListAString& get_addresses(ListAString& addresses) const;

        
        PService getMyService(const char* className, const char* name);

        static long get_managers_of(const PService& service, List<PServiceManager>& managers);
        
        static PService getService(const char* className, const char* name);
        
        PServiceManager* operator ->() { return this; }
        const PServiceManager* operator ->() const { return this; }
    };

    class CMREXD Service : public Interface
    {
        friend class PServiceManager;
        friend class Interface;

    public:
        class CMREXD CallMethod
        {
        public:
            CallMethod(const AChar* interface_name, const AChar* method_name);
            virtual ~CallMethod();

        public:
            virtual bool is_oneway() { return false; }
            virtual long call(PInterface inter, const Tuple& in_arg, Tuple& out_arg) = 0;

        public:
            static  CallMethod* get(const AChar* interface_name, const AChar* method_name);

        private:
            struct Impl;
            Impl* impl_;

        };


    public:
        ListAString& get_addresses(ListAString& addresses) const;

        AString get_address() const;

        PService get_service() { return this; }
        const AString& get_name() const;
        void set_name(const AChar* name);
        const AString& get_class_name() const;
        virtual long connect(const AChar* user_name, const AChar* password);

        AString get_session_id() const;
        void set_session_id(const AChar* session_id);
        
        Tuple* get_session_context_ptr(bool createIfNeeded = false);
        virtual bool get_session_context(Tuple& t);
        virtual void set_session_context(const Tuple& sessionContext);

        virtual bool get_self_session_context(Tuple& t) const;
        virtual void set_self_session_context();

        long publish(PServiceManager& manager);
        
        long unpublish(PServiceManager& manager);
        
        long unpublish();

        long get_managers(List<PServiceManager>& managers) const;

        virtual long call(const Tuple& inArgs, Tuple& outArgs);
        virtual long call(const AChar* interface_name, const Tuple& inArgs, Tuple& outArgs);
        virtual long call(const AChar* interface_name, const Tuple& inArgs, Tuple& outArgs, const Tuple* param);
        long call(Tuple& sessionContext, const AChar* interface_name, const Tuple& inArgs, Tuple& outArgs);

        long get_interface(const AChar* name, PInterface& inter);

        bool add_interface(const PInterface& inter);
        
    public:
        static AutoRefBase  create(const AChar*);
        static AutoRefBase create(const AChar*, ServiceFactory& factory);
        static AutoRefBase bind(const AChar* spec);

    protected:
        Service(const AChar* class_name);
        Service(const AChar* class_name, const AChar* name, const AChar* address);
        Service(const AChar* class_name, const Tuple& init);
        ~Service();
    private:
        Service(const Service& s) : Interface(s) {}
        PInterface find_interface(const AChar* name);
    };

    class CMREXD ProxyService : public Service
    {
    public:
        ProxyService(const AChar* class_name, const AChar* name, const AChar* args);
        ~ProxyService();
        bool is_proxy() const { return true; }

        virtual long call(const Tuple& inArgs, Tuple& outArgs);
        virtual long call(const AChar* interface_name, const Tuple& inArgs, Tuple& outArgs);
        virtual long call(const AChar* interface_name, const Tuple& inArgs, Tuple& outArgs, const Tuple* param);

        AString get_address() const;
        
        bool check_connection();
    };
    typedef AutoRef<ProxyService> PProxyService;


    class CMREXD ServiceFactory
    {
    public:
        ServiceFactory(const AChar* class_name, bool  noregister = false);
        ~ServiceFactory();

    public:
        const AString& get_class_name() const { return class_name_; }
        virtual PService create(const AChar* class_name, const AChar* name, const AChar* args) = 0;

    public:
        static int get(const AChar* class_name, List<ServiceFactory*>& factoryList);

    private:
        AString  class_name_;
        bool  noregister_;

    };

    template <class T> class DefaultServiceFactory : public ServiceFactory
    {
    public:
        DefaultServiceFactory(bool  noregister = false)
            : ServiceFactory(T::get_factory_class_name(), noregister)
        {
        }
        PService create(const AChar* class_name, const AChar* name, const AChar* args)
        {
            PService service = new T();
            service->set_name(name);
            return service;
        }
    };
};

#endif