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

interface.h

Go to the documentation of this file.

/*
 * Copyright © 2000, 2001 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_INTERFACE_H
#define COMET_INTERFACE_H

#include <comet/config.h>

#include <ocidl.h>
#include <string>
#include <stdexcept>

#include <comet/typelist.h>
#include <comet/static_assert.h>
#include <comet/uuid_fwd.h>

#pragma warning(push, 4)
// NB: coclass_implementation _must_ have no data members.
// The comet framework uses the test
// sizeof coclass_implementation<T> == sizeof coclass_implementation<nil>
// in order to determine whether the user has specialized based on T or not.
// The logic here is that any real implementation will have a size that is at least
// sizeof IUnknown, because any real coclass_implementation must at least derive
// off IUnknown and have a "vtable" pointer.
template<typename T> class coclass_implementation {};

#pragma warning(pop)

namespace comet {

        template<typename ITF, UUID *ItfID, typename BASE = ::IUnknown> struct uuid_comtype
        {
                static const uuid_t& uuid() { return uuid_t::create_const_reference(*ItfID); }
                typedef BASE base;
        };
        

        template<typename T> struct comtype {
                static const IID& uuid() throw() { return comtype<COMET_STRICT_TYPENAME T::interface_is>::uuid(); }
                typedef typename comtype<COMET_STRICT_TYPENAME T::interface_is>::base base;
        };

        template<> struct comtype<nil> {
//              static const IID& uuid() throw() { throw std::logic_error("interface.h:35"); return IID_NULL; }
                typedef nil base;
        };

        template<> struct comtype< ::IUnknown >
        {
                static const IID& uuid() { return IID_IUnknown; }
                typedef nil base;
        };

        template<> struct comtype<IConnectionPoint>
        {
                static const IID& uuid() { return IID_IConnectionPoint; }
                typedef ::IUnknown base;
        };

        template<> struct comtype<IConnectionPointContainer>
        {
                static const IID& uuid() { return IID_IConnectionPointContainer; }
                typedef ::IUnknown base;
        };

        template<> struct comtype<IEnumConnections>
        {
                static const IID& uuid() { return IID_IEnumConnections; }
                typedef ::IUnknown base;
        };

        template<> struct comtype<IDispatch>
        {
                static const IID& uuid() { return IID_IDispatch; }
                typedef ::IUnknown base;
        };

        template<> struct comtype<IEnumVARIANT>
        {
                static const IID& uuid() { return IID_IEnumVARIANT; }
                typedef ::IUnknown base;
        };

        template<> struct comtype<ISupportErrorInfo>
        {
                static const IID& uuid() { return IID_ISupportErrorInfo; }
                typedef ::IUnknown base;
        };

        template<> struct comtype<IErrorInfo>
        {
                static const IID& uuid() { return IID_IErrorInfo; }
                typedef ::IUnknown base;
        };

        template<> struct comtype<IProvideClassInfo>
        {
                static const IID& uuid() throw() { return IID_IProvideClassInfo; }
                typedef ::IUnknown base;
        };

        template<> struct comtype<IPersist>
        {
                static const IID& uuid() throw() { return IID_IPersist; }
                typedef ::IUnknown base;
        };

        template<> struct comtype<IPersistFile>
        {
                static const IID& uuid() throw() { return IID_IPersistFile; }
                typedef ::IPersist base;
        };

        template<> struct comtype<IPersistStream>
        {
                static const IID& uuid() throw() { return IID_IPersistStream; }
                typedef ::IPersist base;
        };

        template<> struct comtype<IPersistStreamInit>
        {
                static const IID& uuid() throw() { return IID_IPersistStreamInit; }
                typedef ::IPersist base;
        };

        template<> struct comtype<IMessageFilter>
        {
                static const IID& uuid() throw() { return IID_IMessageFilter; }
                typedef ::IUnknown base;
        };

        template<> struct comtype<IProvideClassInfo2>
        {
                static const IID& uuid() throw() { return IID_IProvideClassInfo2; }
                typedef ::IUnknown base;
        };
        
        template<> struct comtype<IMarshal>
        {
                static const IID& uuid() throw() { return IID_IMarshal; }
                typedef ::IUnknown base;
        };
        
        template<> struct comtype<IFontDisp>
        {
                static const IID& uuid() throw() { return IID_IFontDisp; }
                typedef ::IDispatch base;
        };
        
        template<> struct comtype<IPictureDisp>
        {
                static const IID& uuid() throw() { return IID_IPictureDisp; }
                typedef ::IDispatch base;
        };
        template<> struct comtype<IGlobalInterfaceTable>
        {
                static const IID& uuid() throw() { return IID_IGlobalInterfaceTable; }
                typedef ::IUnknown base;
        };

        template<> struct comtype<IClassFactory>
        {
                static const IID& uuid() throw() { return IID_IClassFactory; }
                typedef ::IUnknown base;
        };


        

        template<typename Itf> inline const uuid_t& uuidof(Itf * = 0) throw()
        { return uuid_t::create_const_reference(comtype<Itf>::uuid()); }

        namespace impl {
                
                template<typename Itf> struct interface_lookup
                {
                        static bool supports(const uuid_t& iid)
                        {
                                if (iid == uuidof<Itf>())
                                        return true;
                                else
                                        return interface_lookup< typename comtype<Itf>::base >::supports();
                        }
                        
                        template<typename T> static Itf* cast(T* t)
                        {
                                return static_cast<Itf*>(t);
                        }
                };
                
                template<> struct interface_lookup<nil>
                {
                        static bool supports(const uuid_t&)
                        {
                                return false;
                        }
                        
                };

/*              template<> struct interface_lookup<make_list<> >
                {
                        static bool supports(const uuid_t&)
                        {
                                return false;
                        }
                        
                };*/
        }
        
} // namespace

#endif

Copyright 2002 Sofus Mortensen. All rights reserved.