home / products / comet / documentation

l a m b d a s o f t

c o m e t

features

documentation

faq

introduction

todo

troubleshooting

forum

download

cp.h

Go to the documentation of this file.

/*
 * Copyright © 2000 Sofus Mortensen
 *
 * This material is provided "as is", with absolutely no warranty 
 * expressed or implied. Any use is at your own risk. Permission to 
 * use or copy this software for any purpose is hereby granted without 
 * fee, provided the above notices are retained on all copies. 
 * Permission to modify the code and to distribute modified code is 
 * granted, provided the above notices are retained, and a notice that 
 * the code was modified is included with the above copyright notice. 
 *
 * This header is part of comet.
 * http://www.lambdasoft.dk/comet
 */

#ifndef COMET_CP_H
#define COMET_CP_H

#include <comet/config.h>

#include <map>

#include <comet/server.h>
#include <comet/enum.h>

#pragma warning( push )
#pragma warning( disable : 4355 )

namespace comet {

        template<typename Itf> class connection_point;

        template<typename Itf> class ATL_NO_VTABLE simple_cpc : public IConnectionPointContainer
        {
        public:
                typedef IConnectionPointContainer interface_is;

        protected:

                STDMETHOD(EnumConnectionPoints)(IEnumConnectionPoints**) 
                { 
                        return E_NOTIMPL; 
                }

                STDMETHOD(FindConnectionPoint)(REFIID riid, IConnectionPoint** ppCP)
                {
                        if (!ppCP) return E_POINTER;
                        if (riid == uuidof<Itf>()) {
                                *ppCP = &connection_point;
                                (*ppCP)->AddRef();
                                return S_OK;
                        }
                        return CONNECT_E_NOCONNECTION;
                }

        protected:
                simple_cpc() : connection_point(this) {}

                connection_point<Itf> connection_point;
        };


        template<typename Itf> class connection_point_for 
        {
        public:
                connection_point_for(::IUnknown *self) : connection_point(self) {}
                connection_point<Itf> connection_point;
        };

        
        namespace impl {

                template<typename ITF_LIST> struct connection_point_finder
                {
                        template<typename T> COMET_FORCEINLINE static ::IConnectionPoint* find_connection_point(T* This, const IID& iid)
                        {
                                typedef find_compatibility< COMET_STRICT_TYPENAME ITF_LIST::head > compatible;
                                if (iid == uuidof<COMET_STRICT_TYPENAME ITF_LIST::head>())
                                        return &((static_cast<connection_point_for< COMET_STRICT_TYPENAME ITF_LIST::head > *>(This))->connection_point)  ;
                                else return connection_point_finder<COMET_STRICT_TYPENAME ITF_LIST::tail>::find_connection_point(This, iid); 
                        }
                };
                template<> struct connection_point_finder<nil>
                {
                        template<typename T> COMET_FORCEINLINE static ::IConnectionPoint* find_connection_point(T*, const IID&)
                        {
                                return 0;
                        }
                };

        }

        namespace impl {
                

                        template<typename ITF_LIST>     struct ATL_NO_VTABLE inherit_all_ex_unknown;

#ifdef COMET_GOOD_RECURSIVE_STRUCT
                        // Remove level of indirection. PC-lint cannot handle it, and MSVC7
                        // should be ale to.
                        template<typename ITF_LIST>     struct ATL_NO_VTABLE inherit_all_ex_unknown 
                                : public ITF_LIST::head, public inherit_all_ex_unknown<typename ITF_LIST::tail >
                        {
                                inherit_all_ex_unknown( ::IUnknown *initParam)
                                        : ITF_LIST::head(initParam), inherit_all_ex_unknown< COMET_STRICT_TYPENAME ITF_LIST::tail >(initParam)
                                {}
                        };
                        template<> struct inherit_all_ex_unknown<nil> { inherit_all_ex_unknown(::IUnknown *) {} };

#else // COMET_GOOD_RECURSIVE_STRUCT
                        template<typename HEAD, typename ITF_TAIL>      struct ATL_NO_VTABLE inherit_all_ex_aux_unknown 
                                : public HEAD, public inherit_all_ex_unknown<ITF_TAIL>
                        {
                                inherit_all_ex_aux_unknown( ::IUnknown *initParam)
                                        : HEAD(initParam), inherit_all_ex_unknown<ITF_TAIL>(initParam)
                                {}
                        };

// COMET_CONFIG_H is always defined! This is just a trick to get Doxygen to ignore the following declaration that
// otherwise seems to be cause an exception in Doxygen 1.2.8
#ifdef COMET_CONFIG_H
                        template<typename ITF_LIST>     struct ATL_NO_VTABLE inherit_all_ex_unknown 
                                : public inherit_all_ex_aux_unknown<typename ITF_LIST::head,typename ITF_LIST::tail >
                        {
                                inherit_all_ex_unknown( ::IUnknown *initParam)
                                        :inherit_all_ex_aux_unknown< COMET_STRICT_TYPENAME ITF_LIST::head, COMET_STRICT_TYPENAME ITF_LIST::tail >(initParam)
                                {
                                }
                        };
                        template<> struct inherit_all_ex_unknown<nil> { inherit_all_ex_unknown(::IUnknown *) {} };
#endif // COMET_CONFIG_H
#endif // COMET_GOOD_RECURSIVE_STRUCT


                
        }


        COMET_WRAP_EACH_DECLARE( connection_point_for);


        template< typename ITF_LST> struct ATL_NO_VTABLE implement_cpc : public IConnectionPointContainer
                , public impl::inherit_all_ex_unknown< COMET_WRAP_EACH(connection_point_for, ITF_LST) >
        {
                typedef IConnectionPointContainer interface_is;
        public:
                implement_cpc()
                        : impl::inherit_all_ex_unknown< COMET_WRAP_EACH(connection_point_for, ITF_LST) >((::IUnknown *)this)
                {}

        protected:
                friend struct impl::connection_point_finder<ITF_LST>;

                STDMETHOD(EnumConnectionPoints)(IEnumConnectionPoints**) 
                { 
                        return E_NOTIMPL; 
                }

                STDMETHOD(FindConnectionPoint)(REFIID riid, IConnectionPoint** ppCP)
                {
                        if (!ppCP) return E_POINTER;

                        const IID& iid = riid;

                        *ppCP = impl::connection_point_finder<ITF_LST>::find_connection_point(this, iid);

                        if ( *ppCP !=NULL)
                        {
                                (*ppCP)->AddRef();
                                return S_OK;
                        }
                        return CONNECT_E_NOCONNECTION;
                }
        };


    template<typename Itf> class ATL_NO_VTABLE connection_point_impl : public embedded_object< IUnknown, IConnectionPoint >
        {
        public:
                bool is_connected() const
                {       return !connections_.empty(); }
        protected:
        connection_point_impl(::IUnknown* pUnk) : next_cookie_(1), embedded_object< IUnknown, IConnectionPoint >(pUnk) {}


                STDMETHOD(GetConnectionInterface)(IID* pIID)
                {
                        *pIID = uuidof<Itf>();
                        return S_OK;
                }

                STDMETHOD(GetConnectionPointContainer)(IConnectionPointContainer** ppCPC) { 
                        com_ptr<IConnectionPointContainer> p;
                        p = try_cast(com_ptr< ::IUnknown >(get_parent()));
                        *ppCPC = com_ptr<IConnectionPointContainer>::detach( p );
                        return S_OK;
                }

                STDMETHOD(Advise)(::IUnknown* pUnkSink, DWORD* pdwCookie)
                {
                        try {
                                connections_[next_cookie_] = try_cast( com_ptr< ::IUnknown >(pUnkSink) );
                        }
                        catch (...) {
                                return CONNECT_E_CANNOTCONNECT;
                        }
                        *pdwCookie = next_cookie_++;
                        return S_OK;
                }
                STDMETHOD(Unadvise)(DWORD dwCookie)
                {
                        CONNECTIONS::iterator it = connections_.find(dwCookie);
                        if (it == connections_.end()) return CONNECT_E_NOCONNECTION;
                        connections_.erase(it);
                        return S_OK;
                }

                STDMETHOD(EnumConnections)(IEnumConnections** ppEnum) 
                { 
                        try {
                                *ppEnum = com_ptr<IEnumConnections>::detach( stl_enumeration<IEnumConnections>::create(connections_, get_unknown()) );
                        } catch (...) {
                                return E_FAIL;
                        }
                        return S_OK; 
                }

                typedef std::map<DWORD, com_ptr<Itf> > CONNECTIONS;
                CONNECTIONS connections_;
        private:
                UINT next_cookie_;
        };
        
        template<typename Itf> class ATL_NO_VTABLE sink_impl : public static_object<Itf>
        {
        public:
                void advise(const com_ptr<::IUnknown>& t)
                {
                        if (ptr_) throw std::runtime_error("Cannot double advise.");
                        com_ptr<IConnectionPointContainer> cpc( try_cast(t) );
                        IConnectionPoint* cp;
                        cpc->FindConnectionPoint( uuidof<Itf>(), &cp) | raise_exception; 
                        
                        HRESULT hr = cp->Advise(static_cast< ::IUnknown* >(static_cast<Itf*>(this)), &cookie_);
                        
                        cp->Release();
                        
                        hr | raise_exception;

                        ptr_ = t;
                }
                
                void unadvise()
                {
                        if (ptr_) {
                                com_ptr<IConnectionPointContainer> cpc( try_cast(ptr_) );
                                IConnectionPoint* cp;
                                cpc->FindConnectionPoint( uuidof<Itf>(), &cp) | raise_exception; 
                                
                                HRESULT hr = cp->Unadvise(cookie_);
                                cookie_ = 0;
                                ptr_ = 0;
                                
                                cp->Release();
                                
                                hr | raise_exception;
                        }
                }

                com_ptr<::IUnknown> object()
                {
                        return ptr_;
                }

                bool is_advised()
                {
                        return !ptr_.is_null();
                }

        protected:
                sink_impl() : cookie_(0) {}
                ~sink_impl() { unadvise(); }
        private:
                DWORD cookie_;
                com_ptr<::IUnknown> ptr_;
        };
                
}

#pragma warning( pop )

#endif

Copyright 2002 Sofus Mortensen. All rights reserved.