xref: /trunk/main/cppu/source/helper/purpenv/helper_purpenv_Environment.cxx (revision 129fa3d1)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_cppu.hxx"

#include "cppu/helper/purpenv/Environment.hxx"

#include "osl/diagnose.h"
#include "uno/lbnames.h"

#include "typelib/typedescription.h"
#include "osl/interlck.h"

#ifdef debug
# define LOG_LIFECYCLE_cppu_helper_purpenv_Base
#endif

#ifdef LOG_LIFECYCLE_cppu_helper_purpenv_Base
#  include <iostream>
#  define LOG_LIFECYCLE_cppu_helper_purpenv_Base_emit(x) x

#else
#  define LOG_LIFECYCLE_cppu_helper_purpenv_Base_emit(x)

#endif


extern "C" {
typedef void SAL_CALL EnvFun_P   (uno_Environment *);
typedef void SAL_CALL EnvFun_PP_P(uno_Environment ** ppHardEnv, uno_Environment *);
typedef void SAL_CALL ExtEnv_registerProxyInterface (uno_ExtEnvironment                 *,
                                                     void                              ** ppProxy,
                                                     uno_freeProxyFunc                    freeProxy,
                                                     rtl_uString * pOId,
                                                     typelib_InterfaceTypeDescription   * pTypeDescr);
typedef void SAL_CALL ExtEnv_revokeInterface        (uno_ExtEnvironment                 *,
                                                     void                               * pInterface);
typedef void SAL_CALL ExtEnv_getObjectIdentifier    (uno_ExtEnvironment                 *,
                                                     rtl_uString                       **,
                                                     void                               *);
typedef void SAL_CALL ExtEnv_getRegisteredInterface (uno_ExtEnvironment                 *,
                                                     void                              **,
                                                     rtl_uString                        *,
                                                     typelib_InterfaceTypeDescription   *);
typedef void SAL_CALL ExtEnv_getRegisteredInterfaces(uno_ExtEnvironment                 *,
                                                     void                             *** pppInterfaces,
                                                     sal_Int32                          * pnLen,
                                                     uno_memAlloc                         memAlloc);
typedef void SAL_CALL ExtEnv_computeObjectIdentifier(uno_ExtEnvironment                 *,
                                                     rtl_uString                       ** ppOId,
                                                     void                               * pInterface);
typedef void SAL_CALL ExtEnv_acquireInterface       (uno_ExtEnvironment                 *,
                                                     void                               * pInterface);
typedef void SAL_CALL ExtEnv_releaseInterface       (uno_ExtEnvironment                 *,
                                                     void                               * pInterface);
}

class Base : public cppu::Enterable
{
public:
	explicit Base(uno_Environment * pEnv, cppu::Enterable * pEnterable);

	void acquireWeak(void);
	void releaseWeak(void);
	void harden     (uno_Environment ** ppHardEnv);
	void acquire    (void);
	void release    (void);

	void registerProxyInterface (void                                  ** ppProxy,
								 uno_freeProxyFunc                        freeProxy,
								 rtl::OUString                    const & oid,
								 typelib_InterfaceTypeDescription       * pTypeDescr);
	void revokeInterface        (void                                   * pInterface);
	void getObjectIdentifier    (void                                   * pInterface,
								 rtl::OUString                          * pOid);
	void getRegisteredInterface (void                                  **,
								 rtl::OUString                    const & oid,
								 typelib_InterfaceTypeDescription       *);
	void getRegisteredInterfaces(void                                 ***,
								 sal_Int32                              * pnLen,
								 uno_memAlloc                             memAlloc);
	void computeObjectIdentifier(void                                   * pInterface,
								 rtl::OUString                          * pOid);
	void acquireInterface       (void                                   * pInterface);
	void releaseInterface       (void                                   * pInterface);

	virtual void v_enter     (void);
	virtual void v_leave     (void);
	virtual void v_callInto_v(uno_EnvCallee * pCallee, va_list * pParam);
	virtual void v_callOut_v (uno_EnvCallee * pCallee, va_list * pParam);
	virtual int  v_isValid   (rtl::OUString * pReason);

protected:
    oslInterlockedCount    m_nRef;
	uno_Environment      * m_pEnv;
    cppu::Enterable      * m_pEnterable;

	EnvFun_P    * m_env_acquire;
	EnvFun_P    * m_env_release;
	EnvFun_PP_P * m_env_harden;
	EnvFun_P    * m_env_acquireWeak;
	EnvFun_P    * m_env_releaseWeak;

	ExtEnv_registerProxyInterface  * m_env_registerProxyInterface;
	ExtEnv_revokeInterface         * m_env_revokeInterface;
	ExtEnv_getObjectIdentifier     * m_env_getObjectIdentifier;
	ExtEnv_getRegisteredInterface  * m_env_getRegisteredInterface;
	ExtEnv_getRegisteredInterfaces * m_env_getRegisteredInterfaces;
	ExtEnv_computeObjectIdentifier * m_env_computeObjectIdentifier;
	ExtEnv_acquireInterface        * m_env_acquireInterface;
	ExtEnv_releaseInterface        * m_env_releaseInterface;

	virtual  ~Base();
};

extern "C" {
static void SAL_CALL s_acquire(uno_Environment * pEnv) //SAL_THROW_EXTERN_C()
{
	Base * pBase = static_cast<Base *>(pEnv->pReserved);
	pBase->acquire();
}

static void SAL_CALL s_release(uno_Environment * pEnv) SAL_THROW_EXTERN_C()
{
	Base * pBase = static_cast<Base *>(pEnv->pReserved);
	pBase->release();
}

static void SAL_CALL s_harden(uno_Environment ** ppHardEnv, uno_Environment * pEnv) SAL_THROW_EXTERN_C()
{
	Base * pBase = static_cast<Base *>(pEnv->pReserved);
	pBase->harden(ppHardEnv);
}

static void SAL_CALL s_acquireWeak(uno_Environment * pEnv) SAL_THROW_EXTERN_C()
{
	Base * pBase = static_cast<Base *>(pEnv->pReserved);
	pBase->acquireWeak();
}

static void SAL_CALL s_releaseWeak(uno_Environment * pEnv) SAL_THROW_EXTERN_C()
{
	Base * pBase = static_cast<Base *>(pEnv->pReserved);
	pBase->releaseWeak();
}


static void SAL_CALL s_registerProxyInterface(uno_ExtEnvironment                * pExtEnv,
                                                         void                             ** ppProxy,
                                                         uno_freeProxyFunc                   freeProxy,
                                                         rtl_uString                       * pOId,
                                                         typelib_InterfaceTypeDescription  * pTypeDescr)
{
	Base * pBase = static_cast<Base *>(pExtEnv->aBase.pReserved);
	pBase->registerProxyInterface(ppProxy, freeProxy, pOId, pTypeDescr);
}

static void SAL_CALL s_revokeInterface(uno_ExtEnvironment * pExtEnv, void * pInterface)
{
	Base * pBase = static_cast<Base *>(pExtEnv->aBase.pReserved);
	pBase->revokeInterface(pInterface);
}

static void SAL_CALL s_getObjectIdentifier(uno_ExtEnvironment *  pExtEnv,
                                                      rtl_uString        ** ppOId,
                                                      void               *  pInterface)
{
	Base * pBase = static_cast<Base *>(pExtEnv->aBase.pReserved);
	pBase->getObjectIdentifier(pInterface, reinterpret_cast<rtl::OUString *>(ppOId));
}

static void SAL_CALL s_getRegisteredInterface(uno_ExtEnvironment *  pExtEnv,
                                                         void               ** ppInterface,
                                                         rtl_uString        *  pOId,
                                                         typelib_InterfaceTypeDescription * pTypeDescr)
{
	Base * pBase = static_cast<Base *>(pExtEnv->aBase.pReserved);
	pBase->getRegisteredInterface(ppInterface, pOId, pTypeDescr);
}

static void SAL_CALL s_getRegisteredInterfaces(uno_ExtEnvironment   * pExtEnv,
                                                          void               *** pppInterface,
                                                          sal_Int32            * pnLen,
                                                          uno_memAlloc           memAlloc)
{
	Base * pBase = static_cast<Base *>(pExtEnv->aBase.pReserved);
	pBase->getRegisteredInterfaces(pppInterface, pnLen, memAlloc);
}

static void SAL_CALL s_computeObjectIdentifier(uno_ExtEnvironment *  pExtEnv,
                                                          rtl_uString        ** ppOId,
                                                          void               *  pInterface)
{
	Base * pBase = static_cast<Base *>(pExtEnv->aBase.pReserved);
	pBase->computeObjectIdentifier(pInterface, reinterpret_cast<rtl::OUString *>(ppOId));
}

static void SAL_CALL s_acquireInterface(uno_ExtEnvironment * pExtEnv, void * pInterface) {
	Base * pBase = static_cast<Base *>(pExtEnv->aBase.pReserved);
	pBase->acquireInterface(pInterface);
}

static void SAL_CALL s_releaseInterface(uno_ExtEnvironment * pExtEnv, void * pInterface) {
	Base * pBase = static_cast<Base *>(pExtEnv->aBase.pReserved);
	pBase->releaseInterface(pInterface);
}

}

Base::Base(uno_Environment * pEnv, cppu::Enterable * pEnterable)
	:m_nRef(1),
	 m_pEnv(pEnv),
     m_pEnterable     (pEnterable),
	 m_env_acquire    (pEnv->acquire),
	 m_env_release    (pEnv->release),
	 m_env_harden     (pEnv->harden),
	 m_env_acquireWeak(pEnv->acquireWeak),
	 m_env_releaseWeak(pEnv->releaseWeak),
	 m_env_registerProxyInterface (pEnv->pExtEnv->registerProxyInterface),
	 m_env_revokeInterface        (pEnv->pExtEnv->revokeInterface),
	 m_env_getObjectIdentifier    (pEnv->pExtEnv->getObjectIdentifier),
	 m_env_getRegisteredInterface (pEnv->pExtEnv->getRegisteredInterface),
	 m_env_getRegisteredInterfaces(pEnv->pExtEnv->getRegisteredInterfaces),
	 m_env_computeObjectIdentifier(pEnv->pExtEnv->computeObjectIdentifier),
	 m_env_acquireInterface       (pEnv->pExtEnv->acquireInterface),
	 m_env_releaseInterface       (pEnv->pExtEnv->releaseInterface)
{
	LOG_LIFECYCLE_cppu_helper_purpenv_Base_emit(fprintf(stderr, "LIFE: %s -> %p\n", "cppu::helper::purpenv::Base::Base(uno_Environment * pEnv)", this));
	OSL_ENSURE(
		rtl_ustr_ascii_compare_WithLength(pEnv->pTypeName->buffer, rtl_str_getLength(UNO_LB_UNO), UNO_LB_UNO)
			== 0,
			"### wrong environment type!");

	pEnv->acquire     = s_acquire;
	pEnv->release     = s_release;
	pEnv->harden      = s_harden;
	pEnv->acquireWeak = s_acquireWeak;
	pEnv->releaseWeak = s_releaseWeak;

	pEnv->pExtEnv->registerProxyInterface  = s_registerProxyInterface;
	pEnv->pExtEnv->revokeInterface         = s_revokeInterface;
	pEnv->pExtEnv->getObjectIdentifier     = s_getObjectIdentifier;
	pEnv->pExtEnv->getRegisteredInterface  = s_getRegisteredInterface;
	pEnv->pExtEnv->getRegisteredInterfaces = s_getRegisteredInterfaces;
	pEnv->pExtEnv->computeObjectIdentifier = s_computeObjectIdentifier;
	pEnv->pExtEnv->acquireInterface        = s_acquireInterface;
	pEnv->pExtEnv->releaseInterface        = s_releaseInterface;

	pEnv->pReserved = this;
}

Base::~Base()
{
	LOG_LIFECYCLE_cppu_helper_purpenv_Base_emit(fprintf(stderr, "LIFE: %s -> %p\n", "cppu::helper::purpenv::Base::~Base()", this));

	m_pEnv->acquire     = m_env_acquire;
	m_pEnv->release     = m_env_release;
	m_pEnv->harden      = m_env_harden;
	m_pEnv->acquireWeak = m_env_acquireWeak;
	m_pEnv->releaseWeak = m_env_releaseWeak;

	m_pEnv->pReserved = NULL;

    delete m_pEnterable;
	m_pEnv->release(m_pEnv);
}

void Base::acquire(void)
{
	m_env_acquire(m_pEnv);

    osl_incrementInterlockedCount(&m_nRef);
}

void Base::release(void)
{
    if (osl_decrementInterlockedCount(&m_nRef) == 0)
		delete this;

	else
		m_env_release(m_pEnv);
}

void Base::harden(uno_Environment ** ppHardEnv)
{
	m_env_harden(ppHardEnv, m_pEnv);
    osl_incrementInterlockedCount(&m_nRef);
}

void Base::acquireWeak(void)
{
	m_env_acquireWeak(m_pEnv);
}

void Base::releaseWeak(void)
{
	m_env_releaseWeak(m_pEnv);
}


extern "C" { static void s_registerProxyInterface_v(va_list * pParam)
{
	uno_ExtEnvironment                   * pExtEnv    = va_arg(*pParam, uno_ExtEnvironment *);
	void                                ** ppProxy    = va_arg(*pParam, void **);
	uno_freeProxyFunc                      freeProxy  = va_arg(*pParam, uno_freeProxyFunc);
	rtl_uString                          * pOId       = va_arg(*pParam, rtl_uString *);
	typelib_InterfaceTypeDescription     * pTypeDescr = va_arg(*pParam, typelib_InterfaceTypeDescription *);
	ExtEnv_registerProxyInterface  * pRegisterProxyInterface
		= va_arg(*pParam, ExtEnv_registerProxyInterface *);

	pRegisterProxyInterface(pExtEnv, ppProxy, freeProxy, pOId, pTypeDescr);
}}

void Base::registerProxyInterface(void                                  ** ppProxy,
								  uno_freeProxyFunc                        freeProxy,
								  rtl::OUString                    const & oid,
								  typelib_InterfaceTypeDescription       * pTypeDescr)
{
 	uno_Environment_invoke(m_pEnv,
						   s_registerProxyInterface_v,
						   m_pEnv->pExtEnv,
						   ppProxy,
						   freeProxy,
						   oid.pData,
						   pTypeDescr,
						   m_env_registerProxyInterface);
}


extern "C" { static void s_revokeInterface_v(va_list * pParam)
{
	uno_ExtEnvironment * pExtEnv    = va_arg(*pParam, uno_ExtEnvironment *);
	void               * pInterface = va_arg(*pParam, void *);
	ExtEnv_revokeInterface * pRevokeInterface = va_arg(*pParam, ExtEnv_revokeInterface *);

	pRevokeInterface(pExtEnv, pInterface);
}}

void Base::revokeInterface(void * pInterface)
{
 	uno_Environment_invoke(m_pEnv,
						   s_revokeInterface_v,
						   m_pEnv->pExtEnv,
						   pInterface,
						   m_env_revokeInterface);
}


extern "C" { static void s_getObjectIdentifier_v(va_list * pParam)
{
	uno_ExtEnvironment * pExtEnv    = va_arg(*pParam, uno_ExtEnvironment *);
	void               * pInterface = va_arg(*pParam, void *);
	rtl::OUString      * pOId       = va_arg(*pParam, rtl::OUString *);
	ExtEnv_getObjectIdentifier * pGetObjectIdentifier
		= va_arg(*pParam, ExtEnv_getObjectIdentifier *);

	pGetObjectIdentifier(pExtEnv, reinterpret_cast<rtl_uString **>(pOId), pInterface);
}}

void Base::getObjectIdentifier(void * pInterface, rtl::OUString * pOid)
{
 	uno_Environment_invoke(m_pEnv,
						   s_getObjectIdentifier_v,
						   m_pEnv->pExtEnv,
						   pInterface,
						   pOid,
						   m_env_getObjectIdentifier);
}


extern "C" { static void s_getRegisteredInterface_v(va_list * pParam)
{
	uno_ExtEnvironment                   * pExtEnv     = va_arg(*pParam, uno_ExtEnvironment *);
	void                                ** ppInterface = va_arg(*pParam, void **);
	rtl_uString                          * pOId        = va_arg(*pParam, rtl_uString *);
	typelib_InterfaceTypeDescription     * pTypeDescr  = va_arg(*pParam, typelib_InterfaceTypeDescription *);
	ExtEnv_getRegisteredInterface  * pGetRegisteredInterface
		= va_arg(*pParam, ExtEnv_getRegisteredInterface *);

	pGetRegisteredInterface(pExtEnv, ppInterface, pOId, pTypeDescr);
}}

void Base::getRegisteredInterface(void ** ppInterface,
								  rtl::OUString const & oid,
								  typelib_InterfaceTypeDescription * pTypeDescr)
{
 	uno_Environment_invoke(m_pEnv,
						   s_getRegisteredInterface_v,
						   m_pEnv->pExtEnv,
						   ppInterface,
						   oid.pData,
						   pTypeDescr,
						   m_env_getRegisteredInterface);
}


extern "C" { static void s_getRegisteredInterfaces_v(va_list * pParam)
{
	uno_ExtEnvironment   * pExtEnv      = va_arg(*pParam, uno_ExtEnvironment *);
	void               *** pppInterface = va_arg(*pParam, void ***);
	sal_Int32            * pnLen        = va_arg(*pParam, sal_Int32 *);
	uno_memAlloc           memAlloc     = va_arg(*pParam, uno_memAlloc);
	ExtEnv_getRegisteredInterfaces * pGetRegisteredInterfaces
		= va_arg(*pParam, ExtEnv_getRegisteredInterfaces *);

	pGetRegisteredInterfaces(pExtEnv, pppInterface, pnLen, memAlloc);
}}

void Base::getRegisteredInterfaces(void         *** pppInterface,
								   sal_Int32      * pnLen,
								   uno_memAlloc     memAlloc)
{
 	uno_Environment_invoke(m_pEnv,
						   s_getRegisteredInterfaces_v,
						   m_pEnv->pExtEnv,
						   pppInterface,
						   pnLen,
						   memAlloc,
						   m_env_getRegisteredInterfaces);
}


extern "C" { static void s_computeObjectIdentifier_v(va_list * pParam)
{
	uno_ExtEnvironment * pExtEnv    = va_arg(*pParam, uno_ExtEnvironment *);
	void               * pInterface = va_arg(*pParam, void *);
	rtl::OUString      * pOId       = va_arg(*pParam, rtl::OUString *);
	ExtEnv_computeObjectIdentifier * pComputeObjectIdentifier
		= va_arg(*pParam, ExtEnv_computeObjectIdentifier *);

	pComputeObjectIdentifier(pExtEnv, reinterpret_cast<rtl_uString **>(pOId), pInterface);
}}

void Base::computeObjectIdentifier(void * pInterface, rtl::OUString * pOid)
{
 	uno_Environment_invoke(m_pEnv,
						   s_computeObjectIdentifier_v,
						   m_pEnv->pExtEnv,
						   pInterface,
						   pOid,
						   m_env_computeObjectIdentifier);
}


extern "C" { static void s_acquireInterface_v(va_list * pParam)
{
	uno_ExtEnvironment * pExtEnv    = va_arg(*pParam, uno_ExtEnvironment *);
	void               * pInterface = va_arg(*pParam, void *);
	ExtEnv_acquireInterface * pAcquireInterface
		= va_arg(*pParam, ExtEnv_acquireInterface *);

	pAcquireInterface(pExtEnv, pInterface);
}}

void Base::acquireInterface(void * pInterface)
{
 	uno_Environment_invoke(m_pEnv, s_acquireInterface_v, m_pEnv->pExtEnv, pInterface, m_env_acquireInterface);
}


extern "C" { static void s_releaseInterface_v(va_list * pParam)
{
	uno_ExtEnvironment * pExtEnv    = va_arg(*pParam, uno_ExtEnvironment *);
	void               * pInterface = va_arg(*pParam, void *);
	ExtEnv_releaseInterface * pReleaseInterface
		= va_arg(*pParam, ExtEnv_releaseInterface *);

	pReleaseInterface(pExtEnv, pInterface);
}}

void Base::releaseInterface(void * pInterface)
{
 	uno_Environment_invoke(m_pEnv,
						   s_releaseInterface_v,
						   m_pEnv->pExtEnv,
						   pInterface,
						   m_env_releaseInterface);
}

void Base::v_enter(void)
{
    m_pEnterable->enter();
}

void Base::v_leave(void)
{
    m_pEnterable->leave();
}

void Base::v_callInto_v(uno_EnvCallee * pCallee, va_list * pParam)
{
    m_pEnterable->callInto_v(pCallee, pParam);
}

void Base::v_callOut_v(uno_EnvCallee * pCallee, va_list * pParam)
{
    m_pEnterable->callOut_v(pCallee, pParam);
}

int Base::v_isValid(rtl::OUString * pReason)
{
    return m_pEnterable->isValid(pReason);
}

namespace cppu { namespace helper { namespace purpenv {

void Environment_initWithEnterable(uno_Environment * pEnvironment, cppu::Enterable * pEnterable)
{
    new Base(pEnvironment, pEnterable);
}

}}}