Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include "cppu/helper/purpenv/Environment.hxx"
22 :
23 : #include "osl/diagnose.h"
24 : #include "uno/lbnames.h"
25 : #include <cppu/Enterable.hxx>
26 :
27 : #include "typelib/typedescription.h"
28 : #include "osl/interlck.h"
29 :
30 : #ifdef debug
31 : # define LOG_LIFECYCLE_cppu_helper_purpenv_Base
32 : #endif
33 :
34 : #ifdef LOG_LIFECYCLE_cppu_helper_purpenv_Base
35 : # include <iostream>
36 : # define LOG_LIFECYCLE_cppu_helper_purpenv_Base_emit(x) x
37 :
38 : #else
39 : # define LOG_LIFECYCLE_cppu_helper_purpenv_Base_emit(x)
40 :
41 : #endif
42 :
43 :
44 : extern "C" {
45 : typedef void SAL_CALL EnvFun_P (uno_Environment *);
46 : typedef void SAL_CALL EnvFun_PP_P(uno_Environment ** ppHardEnv, uno_Environment *);
47 : typedef void SAL_CALL ExtEnv_registerProxyInterface (uno_ExtEnvironment *,
48 : void ** ppProxy,
49 : uno_freeProxyFunc freeProxy,
50 : rtl_uString * pOId,
51 : typelib_InterfaceTypeDescription * pTypeDescr);
52 : typedef void SAL_CALL ExtEnv_revokeInterface (uno_ExtEnvironment *,
53 : void * pInterface);
54 : typedef void SAL_CALL ExtEnv_getObjectIdentifier (uno_ExtEnvironment *,
55 : rtl_uString **,
56 : void *);
57 : typedef void SAL_CALL ExtEnv_getRegisteredInterface (uno_ExtEnvironment *,
58 : void **,
59 : rtl_uString *,
60 : typelib_InterfaceTypeDescription *);
61 : typedef void SAL_CALL ExtEnv_getRegisteredInterfaces(uno_ExtEnvironment *,
62 : void *** pppInterfaces,
63 : sal_Int32 * pnLen,
64 : uno_memAlloc memAlloc);
65 : typedef void SAL_CALL ExtEnv_computeObjectIdentifier(uno_ExtEnvironment *,
66 : rtl_uString ** ppOId,
67 : void * pInterface);
68 : typedef void SAL_CALL ExtEnv_acquireInterface (uno_ExtEnvironment *,
69 : void * pInterface);
70 : typedef void SAL_CALL ExtEnv_releaseInterface (uno_ExtEnvironment *,
71 : void * pInterface);
72 : }
73 :
74 : class Base : public cppu::Enterable
75 : {
76 : public:
77 : explicit Base(uno_Environment * pEnv, cppu::Enterable * pEnterable);
78 :
79 : void acquireWeak();
80 : void releaseWeak();
81 : void harden (uno_Environment ** ppHardEnv);
82 : void acquire();
83 : void release();
84 :
85 : void registerProxyInterface (void ** ppProxy,
86 : uno_freeProxyFunc freeProxy,
87 : rtl::OUString const & oid,
88 : typelib_InterfaceTypeDescription * pTypeDescr);
89 : void revokeInterface (void * pInterface);
90 : void getObjectIdentifier (void * pInterface,
91 : rtl::OUString * pOid);
92 : void getRegisteredInterface (void **,
93 : rtl::OUString const & oid,
94 : typelib_InterfaceTypeDescription *);
95 : void getRegisteredInterfaces(void ***,
96 : sal_Int32 * pnLen,
97 : uno_memAlloc memAlloc);
98 : void computeObjectIdentifier(void * pInterface,
99 : rtl::OUString * pOid);
100 : void acquireInterface (void * pInterface);
101 : void releaseInterface (void * pInterface);
102 :
103 : virtual void v_enter() SAL_OVERRIDE;
104 : virtual void v_leave() SAL_OVERRIDE;
105 : virtual void v_callInto_v(uno_EnvCallee * pCallee, va_list * pParam) SAL_OVERRIDE;
106 : virtual void v_callOut_v (uno_EnvCallee * pCallee, va_list * pParam) SAL_OVERRIDE;
107 : virtual bool v_isValid (rtl::OUString * pReason) SAL_OVERRIDE;
108 :
109 : protected:
110 : oslInterlockedCount m_nRef;
111 : uno_Environment * m_pEnv;
112 : cppu::Enterable * m_pEnterable;
113 :
114 : EnvFun_P * m_env_acquire;
115 : EnvFun_P * m_env_release;
116 : EnvFun_PP_P * m_env_harden;
117 : EnvFun_P * m_env_acquireWeak;
118 : EnvFun_P * m_env_releaseWeak;
119 :
120 : ExtEnv_registerProxyInterface * m_env_registerProxyInterface;
121 : ExtEnv_revokeInterface * m_env_revokeInterface;
122 : ExtEnv_getObjectIdentifier * m_env_getObjectIdentifier;
123 : ExtEnv_getRegisteredInterface * m_env_getRegisteredInterface;
124 : ExtEnv_getRegisteredInterfaces * m_env_getRegisteredInterfaces;
125 : ExtEnv_computeObjectIdentifier * m_env_computeObjectIdentifier;
126 : ExtEnv_acquireInterface * m_env_acquireInterface;
127 : ExtEnv_releaseInterface * m_env_releaseInterface;
128 :
129 : virtual ~Base();
130 : };
131 :
132 : extern "C" {
133 192936 : static void SAL_CALL s_acquire(uno_Environment * pEnv) //SAL_THROW_EXTERN_C()
134 : {
135 192936 : Base * pBase = static_cast<Base *>(pEnv->pReserved);
136 192936 : pBase->acquire();
137 192936 : }
138 :
139 907430 : static void SAL_CALL s_release(uno_Environment * pEnv) SAL_THROW_EXTERN_C()
140 : {
141 907430 : Base * pBase = static_cast<Base *>(pEnv->pReserved);
142 907430 : pBase->release();
143 907430 : }
144 :
145 714525 : static void SAL_CALL s_harden(uno_Environment ** ppHardEnv, uno_Environment * pEnv) SAL_THROW_EXTERN_C()
146 : {
147 714525 : Base * pBase = static_cast<Base *>(pEnv->pReserved);
148 714525 : pBase->harden(ppHardEnv);
149 714525 : }
150 :
151 5 : static void SAL_CALL s_acquireWeak(uno_Environment * pEnv) SAL_THROW_EXTERN_C()
152 : {
153 5 : Base * pBase = static_cast<Base *>(pEnv->pReserved);
154 5 : pBase->acquireWeak();
155 5 : }
156 :
157 0 : static void SAL_CALL s_releaseWeak(uno_Environment * pEnv) SAL_THROW_EXTERN_C()
158 : {
159 0 : Base * pBase = static_cast<Base *>(pEnv->pReserved);
160 0 : pBase->releaseWeak();
161 0 : }
162 :
163 :
164 96425 : static void SAL_CALL s_registerProxyInterface(uno_ExtEnvironment * pExtEnv,
165 : void ** ppProxy,
166 : uno_freeProxyFunc freeProxy,
167 : rtl_uString * pOId,
168 : typelib_InterfaceTypeDescription * pTypeDescr)
169 : {
170 96425 : Base * pBase = static_cast<Base *>(pExtEnv->aBase.pReserved);
171 96425 : pBase->registerProxyInterface(ppProxy, freeProxy, pOId, pTypeDescr);
172 96425 : }
173 :
174 192806 : static void SAL_CALL s_revokeInterface(uno_ExtEnvironment * pExtEnv, void * pInterface)
175 : {
176 192806 : Base * pBase = static_cast<Base *>(pExtEnv->aBase.pReserved);
177 192806 : pBase->revokeInterface(pInterface);
178 192806 : }
179 :
180 98561 : static void SAL_CALL s_getObjectIdentifier(uno_ExtEnvironment * pExtEnv,
181 : rtl_uString ** ppOId,
182 : void * pInterface)
183 : {
184 98561 : Base * pBase = static_cast<Base *>(pExtEnv->aBase.pReserved);
185 98561 : pBase->getObjectIdentifier(pInterface, reinterpret_cast<rtl::OUString *>(ppOId));
186 98561 : }
187 :
188 181129 : static void SAL_CALL s_getRegisteredInterface(uno_ExtEnvironment * pExtEnv,
189 : void ** ppInterface,
190 : rtl_uString * pOId,
191 : typelib_InterfaceTypeDescription * pTypeDescr)
192 : {
193 181129 : Base * pBase = static_cast<Base *>(pExtEnv->aBase.pReserved);
194 181129 : pBase->getRegisteredInterface(ppInterface, pOId, pTypeDescr);
195 181129 : }
196 :
197 0 : static void SAL_CALL s_getRegisteredInterfaces(uno_ExtEnvironment * pExtEnv,
198 : void *** pppInterface,
199 : sal_Int32 * pnLen,
200 : uno_memAlloc memAlloc)
201 : {
202 0 : Base * pBase = static_cast<Base *>(pExtEnv->aBase.pReserved);
203 0 : pBase->getRegisteredInterfaces(pppInterface, pnLen, memAlloc);
204 0 : }
205 :
206 0 : static void SAL_CALL s_computeObjectIdentifier(uno_ExtEnvironment * pExtEnv,
207 : rtl_uString ** ppOId,
208 : void * pInterface)
209 : {
210 0 : Base * pBase = static_cast<Base *>(pExtEnv->aBase.pReserved);
211 0 : pBase->computeObjectIdentifier(pInterface, reinterpret_cast<rtl::OUString *>(ppOId));
212 0 : }
213 :
214 2136 : static void SAL_CALL s_acquireInterface(uno_ExtEnvironment * pExtEnv, void * pInterface) {
215 2136 : Base * pBase = static_cast<Base *>(pExtEnv->aBase.pReserved);
216 2136 : pBase->acquireInterface(pInterface);
217 2136 : }
218 :
219 12 : static void SAL_CALL s_releaseInterface(uno_ExtEnvironment * pExtEnv, void * pInterface) {
220 12 : Base * pBase = static_cast<Base *>(pExtEnv->aBase.pReserved);
221 12 : pBase->releaseInterface(pInterface);
222 12 : }
223 :
224 : }
225 :
226 5 : Base::Base(uno_Environment * pEnv, cppu::Enterable * pEnterable)
227 : :m_nRef(1),
228 : m_pEnv(pEnv),
229 : m_pEnterable (pEnterable),
230 : m_env_acquire (pEnv->acquire),
231 : m_env_release (pEnv->release),
232 : m_env_harden (pEnv->harden),
233 : m_env_acquireWeak(pEnv->acquireWeak),
234 : m_env_releaseWeak(pEnv->releaseWeak),
235 : m_env_registerProxyInterface (pEnv->pExtEnv->registerProxyInterface),
236 : m_env_revokeInterface (pEnv->pExtEnv->revokeInterface),
237 : m_env_getObjectIdentifier (pEnv->pExtEnv->getObjectIdentifier),
238 : m_env_getRegisteredInterface (pEnv->pExtEnv->getRegisteredInterface),
239 : m_env_getRegisteredInterfaces(pEnv->pExtEnv->getRegisteredInterfaces),
240 : m_env_computeObjectIdentifier(pEnv->pExtEnv->computeObjectIdentifier),
241 : m_env_acquireInterface (pEnv->pExtEnv->acquireInterface),
242 5 : m_env_releaseInterface (pEnv->pExtEnv->releaseInterface)
243 : {
244 : LOG_LIFECYCLE_cppu_helper_purpenv_Base_emit(fprintf(stderr, "LIFE: %s -> %p\n", "cppu::helper::purpenv::Base::Base(uno_Environment * pEnv)", this));
245 : OSL_ENSURE(
246 : rtl_ustr_ascii_compare_WithLength(pEnv->pTypeName->buffer, rtl_str_getLength(UNO_LB_UNO), UNO_LB_UNO)
247 : == 0,
248 : "### wrong environment type!");
249 :
250 5 : pEnv->acquire = s_acquire;
251 5 : pEnv->release = s_release;
252 5 : pEnv->harden = s_harden;
253 5 : pEnv->acquireWeak = s_acquireWeak;
254 5 : pEnv->releaseWeak = s_releaseWeak;
255 :
256 5 : pEnv->pExtEnv->registerProxyInterface = s_registerProxyInterface;
257 5 : pEnv->pExtEnv->revokeInterface = s_revokeInterface;
258 5 : pEnv->pExtEnv->getObjectIdentifier = s_getObjectIdentifier;
259 5 : pEnv->pExtEnv->getRegisteredInterface = s_getRegisteredInterface;
260 5 : pEnv->pExtEnv->getRegisteredInterfaces = s_getRegisteredInterfaces;
261 5 : pEnv->pExtEnv->computeObjectIdentifier = s_computeObjectIdentifier;
262 5 : pEnv->pExtEnv->acquireInterface = s_acquireInterface;
263 5 : pEnv->pExtEnv->releaseInterface = s_releaseInterface;
264 :
265 5 : pEnv->pReserved = this;
266 5 : }
267 :
268 3 : Base::~Base()
269 : {
270 : LOG_LIFECYCLE_cppu_helper_purpenv_Base_emit(fprintf(stderr, "LIFE: %s -> %p\n", "cppu::helper::purpenv::Base::~Base()", this));
271 :
272 1 : m_pEnv->acquire = m_env_acquire;
273 1 : m_pEnv->release = m_env_release;
274 1 : m_pEnv->harden = m_env_harden;
275 1 : m_pEnv->acquireWeak = m_env_acquireWeak;
276 1 : m_pEnv->releaseWeak = m_env_releaseWeak;
277 :
278 1 : m_pEnv->pReserved = NULL;
279 :
280 1 : delete m_pEnterable;
281 1 : m_pEnv->release(m_pEnv);
282 2 : }
283 :
284 192936 : void Base::acquire()
285 : {
286 192936 : m_env_acquire(m_pEnv);
287 :
288 192936 : osl_atomic_increment(&m_nRef);
289 192936 : }
290 :
291 907430 : void Base::release()
292 : {
293 907430 : if (osl_atomic_decrement(&m_nRef) == 0)
294 1 : delete this;
295 :
296 : else
297 907429 : m_env_release(m_pEnv);
298 907430 : }
299 :
300 714525 : void Base::harden(uno_Environment ** ppHardEnv)
301 : {
302 714525 : m_env_harden(ppHardEnv, m_pEnv);
303 714525 : osl_atomic_increment(&m_nRef);
304 714525 : }
305 :
306 5 : void Base::acquireWeak()
307 : {
308 5 : m_env_acquireWeak(m_pEnv);
309 5 : }
310 :
311 0 : void Base::releaseWeak()
312 : {
313 0 : m_env_releaseWeak(m_pEnv);
314 0 : }
315 :
316 :
317 96425 : extern "C" { static void s_registerProxyInterface_v(va_list * pParam)
318 : {
319 96425 : uno_ExtEnvironment * pExtEnv = va_arg(*pParam, uno_ExtEnvironment *);
320 96425 : void ** ppProxy = va_arg(*pParam, void **);
321 96425 : uno_freeProxyFunc freeProxy = va_arg(*pParam, uno_freeProxyFunc);
322 96425 : rtl_uString * pOId = va_arg(*pParam, rtl_uString *);
323 96425 : typelib_InterfaceTypeDescription * pTypeDescr = va_arg(*pParam, typelib_InterfaceTypeDescription *);
324 : ExtEnv_registerProxyInterface * pRegisterProxyInterface
325 96425 : = va_arg(*pParam, ExtEnv_registerProxyInterface *);
326 :
327 96425 : pRegisterProxyInterface(pExtEnv, ppProxy, freeProxy, pOId, pTypeDescr);
328 96425 : }}
329 :
330 96425 : void Base::registerProxyInterface(void ** ppProxy,
331 : uno_freeProxyFunc freeProxy,
332 : rtl::OUString const & oid,
333 : typelib_InterfaceTypeDescription * pTypeDescr)
334 : {
335 : uno_Environment_invoke(m_pEnv,
336 : s_registerProxyInterface_v,
337 : m_pEnv->pExtEnv,
338 : ppProxy,
339 : freeProxy,
340 : oid.pData,
341 : pTypeDescr,
342 96425 : m_env_registerProxyInterface);
343 96425 : }
344 :
345 :
346 192806 : extern "C" { static void s_revokeInterface_v(va_list * pParam)
347 : {
348 192806 : uno_ExtEnvironment * pExtEnv = va_arg(*pParam, uno_ExtEnvironment *);
349 192806 : void * pInterface = va_arg(*pParam, void *);
350 192806 : ExtEnv_revokeInterface * pRevokeInterface = va_arg(*pParam, ExtEnv_revokeInterface *);
351 :
352 192806 : pRevokeInterface(pExtEnv, pInterface);
353 192806 : }}
354 :
355 192806 : void Base::revokeInterface(void * pInterface)
356 : {
357 : uno_Environment_invoke(m_pEnv,
358 : s_revokeInterface_v,
359 : m_pEnv->pExtEnv,
360 : pInterface,
361 192806 : m_env_revokeInterface);
362 192806 : }
363 :
364 :
365 98561 : extern "C" { static void s_getObjectIdentifier_v(va_list * pParam)
366 : {
367 98561 : uno_ExtEnvironment * pExtEnv = va_arg(*pParam, uno_ExtEnvironment *);
368 98561 : void * pInterface = va_arg(*pParam, void *);
369 98561 : rtl::OUString * pOId = va_arg(*pParam, rtl::OUString *);
370 : ExtEnv_getObjectIdentifier * pGetObjectIdentifier
371 98561 : = va_arg(*pParam, ExtEnv_getObjectIdentifier *);
372 :
373 98561 : pGetObjectIdentifier(pExtEnv, reinterpret_cast<rtl_uString **>(pOId), pInterface);
374 98561 : }}
375 :
376 98561 : void Base::getObjectIdentifier(void * pInterface, rtl::OUString * pOid)
377 : {
378 : uno_Environment_invoke(m_pEnv,
379 : s_getObjectIdentifier_v,
380 : m_pEnv->pExtEnv,
381 : pInterface,
382 : pOid,
383 98561 : m_env_getObjectIdentifier);
384 98561 : }
385 :
386 :
387 181129 : extern "C" { static void s_getRegisteredInterface_v(va_list * pParam)
388 : {
389 181129 : uno_ExtEnvironment * pExtEnv = va_arg(*pParam, uno_ExtEnvironment *);
390 181129 : void ** ppInterface = va_arg(*pParam, void **);
391 181129 : rtl_uString * pOId = va_arg(*pParam, rtl_uString *);
392 181129 : typelib_InterfaceTypeDescription * pTypeDescr = va_arg(*pParam, typelib_InterfaceTypeDescription *);
393 : ExtEnv_getRegisteredInterface * pGetRegisteredInterface
394 181129 : = va_arg(*pParam, ExtEnv_getRegisteredInterface *);
395 :
396 181129 : pGetRegisteredInterface(pExtEnv, ppInterface, pOId, pTypeDescr);
397 181129 : }}
398 :
399 181129 : void Base::getRegisteredInterface(void ** ppInterface,
400 : rtl::OUString const & oid,
401 : typelib_InterfaceTypeDescription * pTypeDescr)
402 : {
403 : uno_Environment_invoke(m_pEnv,
404 : s_getRegisteredInterface_v,
405 : m_pEnv->pExtEnv,
406 : ppInterface,
407 : oid.pData,
408 : pTypeDescr,
409 181129 : m_env_getRegisteredInterface);
410 181129 : }
411 :
412 :
413 0 : extern "C" { static void s_getRegisteredInterfaces_v(va_list * pParam)
414 : {
415 0 : uno_ExtEnvironment * pExtEnv = va_arg(*pParam, uno_ExtEnvironment *);
416 0 : void *** pppInterface = va_arg(*pParam, void ***);
417 0 : sal_Int32 * pnLen = va_arg(*pParam, sal_Int32 *);
418 0 : uno_memAlloc memAlloc = va_arg(*pParam, uno_memAlloc);
419 : ExtEnv_getRegisteredInterfaces * pGetRegisteredInterfaces
420 0 : = va_arg(*pParam, ExtEnv_getRegisteredInterfaces *);
421 :
422 0 : pGetRegisteredInterfaces(pExtEnv, pppInterface, pnLen, memAlloc);
423 0 : }}
424 :
425 0 : void Base::getRegisteredInterfaces(void *** pppInterface,
426 : sal_Int32 * pnLen,
427 : uno_memAlloc memAlloc)
428 : {
429 : uno_Environment_invoke(m_pEnv,
430 : s_getRegisteredInterfaces_v,
431 : m_pEnv->pExtEnv,
432 : pppInterface,
433 : pnLen,
434 : memAlloc,
435 0 : m_env_getRegisteredInterfaces);
436 0 : }
437 :
438 :
439 0 : extern "C" { static void s_computeObjectIdentifier_v(va_list * pParam)
440 : {
441 0 : uno_ExtEnvironment * pExtEnv = va_arg(*pParam, uno_ExtEnvironment *);
442 0 : void * pInterface = va_arg(*pParam, void *);
443 0 : rtl::OUString * pOId = va_arg(*pParam, rtl::OUString *);
444 : ExtEnv_computeObjectIdentifier * pComputeObjectIdentifier
445 0 : = va_arg(*pParam, ExtEnv_computeObjectIdentifier *);
446 :
447 0 : pComputeObjectIdentifier(pExtEnv, reinterpret_cast<rtl_uString **>(pOId), pInterface);
448 0 : }}
449 :
450 0 : void Base::computeObjectIdentifier(void * pInterface, rtl::OUString * pOid)
451 : {
452 : uno_Environment_invoke(m_pEnv,
453 : s_computeObjectIdentifier_v,
454 : m_pEnv->pExtEnv,
455 : pInterface,
456 : pOid,
457 0 : m_env_computeObjectIdentifier);
458 0 : }
459 :
460 :
461 2136 : extern "C" { static void s_acquireInterface_v(va_list * pParam)
462 : {
463 2136 : uno_ExtEnvironment * pExtEnv = va_arg(*pParam, uno_ExtEnvironment *);
464 2136 : void * pInterface = va_arg(*pParam, void *);
465 : ExtEnv_acquireInterface * pAcquireInterface
466 2136 : = va_arg(*pParam, ExtEnv_acquireInterface *);
467 :
468 2136 : pAcquireInterface(pExtEnv, pInterface);
469 2136 : }}
470 :
471 2136 : void Base::acquireInterface(void * pInterface)
472 : {
473 2136 : uno_Environment_invoke(m_pEnv, s_acquireInterface_v, m_pEnv->pExtEnv, pInterface, m_env_acquireInterface);
474 2136 : }
475 :
476 :
477 12 : extern "C" { static void s_releaseInterface_v(va_list * pParam)
478 : {
479 12 : uno_ExtEnvironment * pExtEnv = va_arg(*pParam, uno_ExtEnvironment *);
480 12 : void * pInterface = va_arg(*pParam, void *);
481 : ExtEnv_releaseInterface * pReleaseInterface
482 12 : = va_arg(*pParam, ExtEnv_releaseInterface *);
483 :
484 12 : pReleaseInterface(pExtEnv, pInterface);
485 12 : }}
486 :
487 12 : void Base::releaseInterface(void * pInterface)
488 : {
489 : uno_Environment_invoke(m_pEnv,
490 : s_releaseInterface_v,
491 : m_pEnv->pExtEnv,
492 : pInterface,
493 12 : m_env_releaseInterface);
494 12 : }
495 :
496 0 : void Base::v_enter()
497 : {
498 0 : m_pEnterable->enter();
499 0 : }
500 :
501 0 : void Base::v_leave()
502 : {
503 0 : m_pEnterable->leave();
504 0 : }
505 :
506 714518 : void Base::v_callInto_v(uno_EnvCallee * pCallee, va_list * pParam)
507 : {
508 714518 : m_pEnterable->callInto_v(pCallee, pParam);
509 714518 : }
510 :
511 44515 : void Base::v_callOut_v(uno_EnvCallee * pCallee, va_list * pParam)
512 : {
513 44515 : m_pEnterable->callOut_v(pCallee, pParam);
514 44515 : }
515 :
516 0 : bool Base::v_isValid(rtl::OUString * pReason)
517 : {
518 0 : return m_pEnterable->isValid(pReason);
519 : }
520 :
521 : namespace cppu { namespace helper { namespace purpenv {
522 :
523 5 : void Environment_initWithEnterable(uno_Environment * pEnvironment, cppu::Enterable * pEnterable)
524 : {
525 5 : new Base(pEnvironment, pEnterable);
526 5 : }
527 :
528 : }}}
529 :
530 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
