G01_0350/venv_win32/Lib/site-packages/win32com/include/PythonCOMServer.h

#ifndef __PYTHONCOMSERVER_H__
#define __PYTHONCOMSERVER_H__

// PythonCOMServer.h :Server side COM support

#include <Python.h>

#define DLLAcquireGlobalLock PyWin_AcquireGlobalLock
#define DLLReleaseGlobalLock PyWin_ReleaseGlobalLock

void PYCOM_EXPORT PyCom_DLLAddRef(void);
void PYCOM_EXPORT PyCom_DLLReleaseRef(void);

// Use this macro at the start of all gateway methods.
#define PY_GATEWAY_METHOD CEnterLeavePython _celp

class PyGatewayBase;
// Gateway constructors.
// Each gateway must be able to be created from a "gateway constructor".  This
// is simply a function that takes a Python instance as as argument, and returns
// a gateway object of the correct type.  The MAKE_PYGATEWAY_CTOR is a helper that
// will embed such a constructor in the class - however, this is not necessary -
// _any_ function of the correct signature can be used.

typedef HRESULT (*pfnPyGatewayConstructor)(PyObject *PythonInstance, PyGatewayBase *, void **ppResult, REFIID iid);
HRESULT PyCom_MakeRegisteredGatewayObject(REFIID iid, PyObject *instance, PyGatewayBase *base, void **ppv);

// A version of the above which support classes being derived from
// other than IUnknown
#define PYGATEWAY_MAKE_SUPPORT2(classname, IInterface, theIID, gatewaybaseclass)                                 \
   public:                                                                                                       \
    static HRESULT classname::PyGatewayConstruct(PyObject *pPyInstance, PyGatewayBase *unkBase, void **ppResult, \
                                                 REFIID iid)                                                     \
    {                                                                                                            \
        if (ppResult == NULL)                                                                                    \
            return E_INVALIDARG;                                                                                 \
        classname *newob = new classname(pPyInstance);                                                           \
        newob->m_pBaseObject = unkBase;                                                                          \
        if (unkBase)                                                                                             \
            unkBase->AddRef();                                                                                   \
        *ppResult = newob->ThisAsIID(iid);                                                                       \
        return *ppResult ? S_OK : E_OUTOFMEMORY;                                                                 \
    }                                                                                                            \
                                                                                                                 \
   protected:                                                                                                    \
    virtual IID GetIID(void) { return theIID; }                                                                  \
    virtual void *ThisAsIID(IID iid)                                                                             \
    {                                                                                                            \
        if (this == NULL)                                                                                        \
            return NULL;                                                                                         \
        if (iid == theIID)                                                                                       \
            return (IInterface *)this;                                                                           \
        else                                                                                                     \
            return gatewaybaseclass::ThisAsIID(iid);                                                             \
    }                                                                                                            \
    STDMETHOD_(ULONG, AddRef)(void) { return gatewaybaseclass::AddRef(); }                                       \
    STDMETHOD_(ULONG, Release)(void) { return gatewaybaseclass::Release(); }                                     \
    STDMETHOD(QueryInterface)(REFIID iid, void **obj) { return gatewaybaseclass::QueryInterface(iid, obj); };

// This is the "old" version to use, or use it if you derive
// directly from PyGatewayBase
#define PYGATEWAY_MAKE_SUPPORT(classname, IInterface, theIID) \
    PYGATEWAY_MAKE_SUPPORT2(classname, IInterface, theIID, PyGatewayBase)

#define GET_PYGATEWAY_CTOR(classname) classname::PyGatewayConstruct

#ifdef _MSC_VER
// Disable an OK warning...
#pragma warning(disable : 4275)
// warning C4275: non dll-interface struct 'IDispatch' used as base for dll-interface class 'PyGatewayBase'
#endif  // _MSC_VER

// Helper interface for fetching a Python object from a gateway

extern const GUID IID_IInternalUnwrapPythonObject;

interface IInternalUnwrapPythonObject : public IUnknown
{
   public:
    STDMETHOD(Unwrap)(PyObject * *ppPyObject) = 0;
};

/////////////////////////////////////////////////////////////////////////////
// PyGatewayBase
//
// Base class for all gateways.
//
class PYCOM_EXPORT PyGatewayBase :
#ifndef NO_PYCOM_IDISPATCHEX
    public IDispatchEx,  // IDispatch comes along for the ride!
#else
    public IDispatch,  // No IDispatchEx - must explicitely use IDispatch
#endif
    public ISupportErrorInfo,
    public IInternalUnwrapPythonObject {
   protected:
    PyGatewayBase(PyObject *instance);
    virtual ~PyGatewayBase();

    // Invoke the Python method (via the policy object)
    STDMETHOD(InvokeViaPolicy)(const char *szMethodName, PyObject **ppResult = NULL, const char *szFormat = NULL, ...);

   public:
    // IUnknown
    STDMETHOD_(ULONG, AddRef)(void);
    STDMETHOD_(ULONG, Release)(void);
    STDMETHOD(QueryInterface)(REFIID iid, void **obj);

    // IDispatch
    STDMETHOD(GetTypeInfoCount)(UINT FAR *pctInfo);
    STDMETHOD(GetTypeInfo)(UINT itinfo, LCID lcid, ITypeInfo FAR *FAR *pptInfo);
    STDMETHOD(GetIDsOfNames)(REFIID refiid, OLECHAR FAR *FAR *rgszNames, UINT cNames, LCID lcid, DISPID FAR *rgdispid);
    STDMETHOD(Invoke)
    (DISPID dispid, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS FAR *params, VARIANT FAR *pVarResult,
     EXCEPINFO FAR *pexcepinfo, UINT FAR *puArgErr);

    // IDispatchEx
#ifndef NO_PYCOM_IDISPATCHEX
    STDMETHOD(GetDispID)(BSTR bstrName, DWORD grfdex, DISPID *pid);
    STDMETHOD(InvokeEx)
    (DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp, VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller);
    STDMETHOD(DeleteMemberByName)(BSTR bstr, DWORD grfdex);
    STDMETHOD(DeleteMemberByDispID)(DISPID id);
    STDMETHOD(GetMemberProperties)(DISPID id, DWORD grfdexFetch, DWORD *pgrfdex);
    STDMETHOD(GetMemberName)(DISPID id, BSTR *pbstrName);
    STDMETHOD(GetNextDispID)(DWORD grfdex, DISPID id, DISPID *pid);
    STDMETHOD(GetNameSpaceParent)(IUnknown **ppunk);
#endif  // NO_PYCOM_IDISPATCHEX
    // ISupportErrorInfo
    STDMETHOD(InterfaceSupportsErrorInfo)(REFIID riid);

    // IInternalUnwrapPythonObject
    STDMETHOD(Unwrap)(PyObject **ppPyObject);

    // Basically just PYGATEWAY_MAKE_SUPPORT(PyGatewayBase, IDispatch, IID_IDispatch);
    // but with special handling as its the base class.
    static HRESULT PyGatewayBase::PyGatewayConstruct(PyObject *pPyInstance, PyGatewayBase *gatewayBase, void **ppResult,
                                                     REFIID iid)
    {
        if (ppResult == NULL)
            return E_INVALIDARG;
        PyGatewayBase *obNew = new PyGatewayBase(pPyInstance);
        obNew->m_pBaseObject = gatewayBase;
        if (gatewayBase)
            gatewayBase->AddRef();
        *ppResult = (IDispatch *)obNew;
        return *ppResult ? S_OK : E_OUTOFMEMORY;
    }
    // Currently this is used only for ISupportErrorInfo,
    // so hopefully this will never be called in this base class.
    // (however, this is not a rule, so we wont assert or anything!)
    virtual IID GetIID(void) { return IID_IUnknown; }
    virtual void *ThisAsIID(IID iid);
    // End of PYGATEWAY_MAKE_SUPPORT
    PyObject *m_pPyObject;
    PyGatewayBase *m_pBaseObject;

   private:
    LONG m_cRef;
};

#ifdef _MSC_VER
#pragma warning(default : 4275)
#endif  // _MSC_VER

// B/W compat hack for gateways.
#define PyCom_HandlePythonFailureToCOM() \
    PyCom_SetAndLogCOMErrorFromPyExceptionEx(this->m_pPyObject, "<unknown>", GetIID())

// F/W compat hack for gateways!  Must be careful about updating
// PyGatewayBase vtable, so a slightly older pythoncomXX.dll will work
// with slightly later extensions.  So use a #define.
#define MAKE_PYCOM_GATEWAY_FAILURE_CODE(method_name) \
    PyCom_SetAndLogCOMErrorFromPyExceptionEx(this->m_pPyObject, method_name, GetIID())

#endif /* __PYTHONCOMSERVER_H__ */