Interface.h

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

#ifndef CMR_INTERFACE_INCLUDED
#define CMR_INTERFACE_INCLUDED

#include "Commore.h"
#include "AutoRef.h"
#include "AString.h"

namespace commore
{
    class Interface;
    typedef AutoRef<Interface> PInterface;
    typedef Interface* PPInterface;

    class Service;
    typedef AutoRef<Service> PService;
    typedef Service* PPService;

    struct Internals_;

    class  CMREXD Interface : public RefObject
    {
        friend class  Service;

    public:
        Interface(const AChar* name);
        virtual ~Interface();

    public:
        virtual bool  is_proxy() const
        {
            return false;
        }
        virtual long call(const Tuple& in_args, Tuple& out_args);
        virtual long call(const Tuple& in_args, Tuple& out_args, const Tuple* param);

        const AString& get_name() const;
        virtual  PService  get_service() const;
        CriticalSection* get_cs() const;

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

    protected:
        Internals_* internals_;

    protected:
        bool set_service(const PService& service);

    private:
        PInterface  find(const AChar* name);

    protected:
        Interface(const Interface&) {}
    };

    class CMREXD ProxyInterface : public Interface
    {
    public:
        ProxyInterface(const AChar* name);
        ~ProxyInterface();
        bool  is_proxy() const
        {
            return true;
        }
        virtual long call(const Tuple& inArgs, Tuple& outArgs);
        virtual long call(const Tuple& inArgs, Tuple& outArgs, const Tuple* param);
    };
    typedef AutoRef<ProxyInterface> PProxyInterface;


    class CMREXD InterfaceFactory
    {
    public:
        InterfaceFactory(const AChar* name);
        virtual ~InterfaceFactory();

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

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

    private:
        AString  class_name_;

    };

    template <class I> class DummyInterfaceFactory : public InterfaceFactory
    {
    public:
        DummyInterfaceFactory()
            : InterfaceFactory(I::get_factory_class_name())
        {
        }
        PInterface create(const AChar* name, PService& service)
        {
            PInterface inter = new I();
            return inter;
        }
    };
};


#endif