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 : #include <config_features.h>
21 :
22 : #include "IdentityMapping.hxx"
23 :
24 : #include <boost/unordered_map.hpp>
25 : #include <set>
26 : #include <algorithm>
27 : #include <cassert>
28 :
29 : #include "rtl/ustring.hxx"
30 : #include "rtl/ustrbuf.hxx"
31 : #include "osl/module.h"
32 : #include "osl/diagnose.h"
33 : #include "osl/mutex.hxx"
34 : #include "osl/interlck.h"
35 :
36 : #include "uno/dispatcher.h"
37 : #include "uno/mapping.h"
38 : #include "uno/lbnames.h"
39 : #include "uno/environment.hxx"
40 :
41 : #include "typelib/typedescription.h"
42 :
43 : #include "cppu/EnvDcp.hxx"
44 : #include "cascade_mapping.hxx"
45 : #include "loadmodule.hxx"
46 :
47 : using namespace std;
48 : using namespace osl;
49 : using namespace com::sun::star::uno;
50 : using ::rtl::OUString;
51 : using ::rtl::OUStringBuffer;
52 : using ::rtl::OUStringToOString;
53 : using ::rtl::OUStringHash;
54 : using ::rtl::OString;
55 :
56 : namespace cppu
57 : {
58 :
59 : class Mapping
60 : {
61 : uno_Mapping * _pMapping;
62 :
63 : public:
64 : inline explicit Mapping( uno_Mapping * pMapping = 0 );
65 : inline Mapping( const Mapping & rMapping );
66 : inline ~Mapping();
67 : inline Mapping & SAL_CALL operator = ( uno_Mapping * pMapping );
68 16839 : inline Mapping & SAL_CALL operator = ( const Mapping & rMapping )
69 16839 : { return operator = ( rMapping._pMapping ); }
70 158676 : inline uno_Mapping * SAL_CALL get() const
71 158676 : { return _pMapping; }
72 298162 : inline bool SAL_CALL is() const
73 298162 : { return (_pMapping != 0); }
74 : };
75 :
76 69763 : inline Mapping::Mapping( uno_Mapping * pMapping )
77 69763 : : _pMapping( pMapping )
78 : {
79 69763 : if (_pMapping)
80 10 : (*_pMapping->acquire)( _pMapping );
81 69763 : }
82 :
83 16841 : inline Mapping::Mapping( const Mapping & rMapping )
84 16841 : : _pMapping( rMapping._pMapping )
85 : {
86 16841 : if (_pMapping)
87 16841 : (*_pMapping->acquire)( _pMapping );
88 16841 : }
89 :
90 86604 : inline Mapping::~Mapping()
91 : {
92 86604 : if (_pMapping)
93 86574 : (*_pMapping->release)( _pMapping );
94 86604 : }
95 :
96 52900 : inline Mapping & Mapping::operator = ( uno_Mapping * pMapping )
97 : {
98 52900 : if (pMapping)
99 52894 : (*pMapping->acquire)( pMapping );
100 52900 : if (_pMapping)
101 0 : (*_pMapping->release)( _pMapping );
102 52900 : _pMapping = pMapping;
103 52900 : return *this;
104 : }
105 :
106 :
107 20565 : struct MappingEntry
108 : {
109 : sal_Int32 nRef;
110 : uno_Mapping * pMapping;
111 : uno_freeMappingFunc freeMapping;
112 : OUString aMappingName;
113 :
114 20717 : MappingEntry(
115 : uno_Mapping * pMapping_, uno_freeMappingFunc freeMapping_,
116 : const OUString & rMappingName_ )
117 : : nRef( 1 )
118 : , pMapping( pMapping_ )
119 : , freeMapping( freeMapping_ )
120 20717 : , aMappingName( rMappingName_ )
121 20717 : {}
122 : };
123 :
124 : struct FctPtrHash : public std::unary_function< uno_Mapping *, size_t >
125 : {
126 82564 : size_t operator()( uno_Mapping * pKey ) const
127 82564 : { return reinterpret_cast<size_t>(pKey); }
128 : };
129 :
130 : typedef boost::unordered_map<
131 : OUString, MappingEntry *, OUStringHash > t_OUString2Entry;
132 : typedef boost::unordered_map<
133 : uno_Mapping *, MappingEntry *, FctPtrHash, equal_to< uno_Mapping * > > t_Mapping2Entry;
134 :
135 : typedef set< uno_getMappingFunc > t_CallbackSet;
136 : typedef set< OUString > t_OUStringSet;
137 :
138 :
139 642 : struct MappingsData
140 : {
141 : Mutex aMappingsMutex;
142 : t_OUString2Entry aName2Entry;
143 : t_Mapping2Entry aMapping2Entry;
144 :
145 : Mutex aCallbacksMutex;
146 : t_CallbackSet aCallbacks;
147 :
148 : Mutex aNegativeLibsMutex;
149 : t_OUStringSet aNegativeLibs;
150 : };
151 :
152 111059 : static MappingsData & getMappingsData()
153 : {
154 : static MappingsData * s_p = 0;
155 111059 : if (! s_p)
156 : {
157 642 : MutexGuard aGuard( Mutex::getGlobalMutex() );
158 642 : if (! s_p)
159 : {
160 : //TODO This memory is leaked; see #i63473# for when this should be
161 : // changed again:
162 642 : s_p = new MappingsData;
163 642 : }
164 : }
165 111059 : return *s_p;
166 : }
167 :
168 : /**
169 : * This class mediates two different mapping via uno, e.g. form any language to uno,
170 : * then from uno to any other language.
171 : */
172 6 : struct uno_Mediate_Mapping : public uno_Mapping
173 : {
174 : sal_Int32 nRef;
175 :
176 : Environment aFrom;
177 : Environment aTo;
178 :
179 : Mapping aFrom2Uno;
180 : Mapping aUno2To;
181 :
182 : OUString aAddPurpose;
183 :
184 : uno_Mediate_Mapping(
185 : const Environment & rFrom_, const Environment & rTo_,
186 : const Mapping & rFrom2Uno_, const Mapping & rUno2To_,
187 : const OUString & rAddPurpose );
188 : };
189 : extern "C"
190 : {
191 :
192 6 : static void SAL_CALL mediate_free( uno_Mapping * pMapping )
193 : {
194 6 : delete static_cast< uno_Mediate_Mapping * >( pMapping );
195 6 : }
196 :
197 18 : static void SAL_CALL mediate_acquire( uno_Mapping * pMapping )
198 : {
199 18 : if (1 == osl_atomic_increment(
200 : & static_cast< uno_Mediate_Mapping * >( pMapping )->nRef ))
201 : {
202 : uno_registerMapping(
203 : &pMapping, mediate_free,
204 : static_cast< uno_Mediate_Mapping * >( pMapping )->aFrom.get(),
205 : static_cast< uno_Mediate_Mapping * >( pMapping )->aTo.get(),
206 0 : static_cast< uno_Mediate_Mapping * >( pMapping )->aAddPurpose.pData );
207 : }
208 18 : }
209 :
210 24 : static void SAL_CALL mediate_release( uno_Mapping * pMapping )
211 : {
212 24 : if (! osl_atomic_decrement(
213 : & static_cast< uno_Mediate_Mapping * >( pMapping )->nRef ))
214 : {
215 6 : uno_revokeMapping( pMapping );
216 : }
217 24 : }
218 :
219 6 : static void SAL_CALL mediate_mapInterface(
220 : uno_Mapping * pMapping,
221 : void ** ppOut, void * pInterface,
222 : typelib_InterfaceTypeDescription * pInterfaceTypeDescr )
223 : {
224 : OSL_ENSURE( pMapping && ppOut, "### null ptr!" );
225 6 : if (pMapping && ppOut)
226 : {
227 6 : uno_Mediate_Mapping * that = static_cast< uno_Mediate_Mapping * >( pMapping );
228 6 : uno_Mapping * pFrom2Uno = that->aFrom2Uno.get();
229 :
230 6 : uno_Interface * pUnoI = 0;
231 6 : (*pFrom2Uno->mapInterface)( pFrom2Uno, (void **) &pUnoI, pInterface, pInterfaceTypeDescr );
232 6 : if (0 == pUnoI)
233 : {
234 0 : void * pOut = *ppOut;
235 0 : if (0 != pOut)
236 : {
237 0 : uno_ExtEnvironment * pTo = that->aTo.get()->pExtEnv;
238 : OSL_ENSURE( 0 != pTo, "### cannot release out interface: leaking!" );
239 0 : if (0 != pTo)
240 0 : (*pTo->releaseInterface)( pTo, pOut );
241 0 : *ppOut = 0; // set to 0 anyway, because mapping was not successful!
242 : }
243 : }
244 : else
245 : {
246 6 : uno_Mapping * pUno2To = that->aUno2To.get();
247 6 : (*pUno2To->mapInterface)( pUno2To, ppOut, pUnoI, pInterfaceTypeDescr );
248 6 : (*pUnoI->release)( pUnoI );
249 : }
250 : }
251 6 : }
252 : }
253 :
254 6 : uno_Mediate_Mapping::uno_Mediate_Mapping(
255 : const Environment & rFrom_, const Environment & rTo_,
256 : const Mapping & rFrom2Uno_, const Mapping & rUno2To_,
257 : const OUString & rAddPurpose_ )
258 : : nRef( 1 )
259 : , aFrom( rFrom_ )
260 : , aTo( rTo_ )
261 : , aFrom2Uno( rFrom2Uno_ )
262 : , aUno2To( rUno2To_ )
263 6 : , aAddPurpose( rAddPurpose_ )
264 : {
265 6 : uno_Mapping::acquire = mediate_acquire;
266 6 : uno_Mapping::release = mediate_release;
267 6 : uno_Mapping::mapInterface = mediate_mapInterface;
268 6 : }
269 :
270 :
271 73641 : static inline OUString getMappingName(
272 : const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
273 : {
274 73641 : OUStringBuffer aKey( 64 );
275 73641 : aKey.append( rAddPurpose );
276 73641 : aKey.append( ';' );
277 73641 : aKey.append( rFrom.getTypeName() );
278 73641 : aKey.append( '[' );
279 73641 : aKey.append( reinterpret_cast< sal_IntPtr >(rFrom.get()), 16 );
280 73641 : aKey.append( "];" );
281 73641 : aKey.append( rTo.getTypeName() );
282 73641 : aKey.append( '[' );
283 73641 : aKey.append( reinterpret_cast< sal_IntPtr >(rTo.get()), 16 );
284 73641 : aKey.append( ']' );
285 73641 : return aKey.makeStringAndClear();
286 : }
287 :
288 16841 : static inline OUString getBridgeName(
289 : const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
290 : {
291 16841 : OUStringBuffer aBridgeName( 16 );
292 16841 : if (!rAddPurpose.isEmpty())
293 : {
294 8 : aBridgeName.append( rAddPurpose );
295 8 : aBridgeName.append( '_' );
296 : }
297 16841 : aBridgeName.append( EnvDcp::getTypeName(rFrom.getTypeName()) );
298 16841 : aBridgeName.append( '_' );
299 16841 : aBridgeName.append( EnvDcp::getTypeName(rTo.getTypeName()) );
300 16841 : return aBridgeName.makeStringAndClear();
301 : }
302 :
303 : #ifndef DISABLE_DYNLOADING
304 :
305 12 : static inline void setNegativeBridge( const OUString & rBridgeName )
306 : {
307 12 : MappingsData & rData = getMappingsData();
308 12 : MutexGuard aGuard( rData.aNegativeLibsMutex );
309 12 : rData.aNegativeLibs.insert( rBridgeName );
310 12 : }
311 :
312 : #endif
313 :
314 : #ifdef DISABLE_DYNLOADING
315 :
316 : static uno_ext_getMappingFunc selectMapFunc( const OUString & rBridgeName )
317 : {
318 : if (rBridgeName.equalsAscii( CPPU_CURRENT_LANGUAGE_BINDING_NAME "_uno" ))
319 : return CPPU_ENV_uno_ext_getMapping;
320 : #if HAVE_FEATURE_JAVA
321 : if (rBridgeName.equalsAscii( "java" "_uno" ))
322 : return java_uno_ext_getMapping;
323 : #endif
324 :
325 : #if 0
326 : // I don't think the affine or log bridges will be needed on any
327 : // DISABLE_DYNLOADING platform (iOS at least, possibly Android), but if
328 : // somebody wants to experiment, need to find out then whether these are
329 : // needed.
330 : if (rBridgeName.equalsAscii( "affine_uno_uno" ))
331 : return affine_uno_uno_ext_getMapping;
332 : if (rBridgeName.equalsAscii( "log_uno_uno" ))
333 : return log_uno_uno_ext_getMapping;
334 : #endif
335 : return 0;
336 : }
337 :
338 : #else
339 :
340 16841 : static inline oslModule loadModule( const OUString & rBridgeName )
341 : {
342 : bool bNeg;
343 : {
344 16841 : MappingsData & rData = getMappingsData();
345 16841 : MutexGuard aGuard( rData.aNegativeLibsMutex );
346 16841 : const t_OUStringSet::const_iterator iFind( rData.aNegativeLibs.find( rBridgeName ) );
347 16841 : bNeg = (iFind != rData.aNegativeLibs.end());
348 : }
349 :
350 16841 : if (! bNeg)
351 : {
352 16841 : oslModule hModule = cppu::detail::loadModule( rBridgeName );
353 :
354 16841 : if (hModule)
355 16829 : return hModule;
356 :
357 12 : setNegativeBridge( rBridgeName ); // no load again
358 : }
359 12 : return 0;
360 : }
361 :
362 : #endif
363 :
364 :
365 16835 : static Mapping loadExternalMapping(
366 : const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
367 : {
368 : OSL_ASSERT( rFrom.is() && rTo.is() );
369 16835 : if (rFrom.is() && rTo.is())
370 : {
371 : #ifdef DISABLE_DYNLOADING
372 : OUString aName;
373 : uno_ext_getMappingFunc fpGetMapFunc = 0;
374 :
375 : if (EnvDcp::getTypeName(rFrom.getTypeName()) == UNO_LB_UNO)
376 : {
377 : aName = getBridgeName( rTo, rFrom, rAddPurpose );
378 : fpGetMapFunc = selectMapFunc( aName );
379 : }
380 : if (! fpGetMapFunc)
381 : {
382 : aName = getBridgeName( rFrom, rTo, rAddPurpose );
383 : fpGetMapFunc = selectMapFunc( aName );
384 : }
385 : if (! fpGetMapFunc)
386 : {
387 : aName = getBridgeName( rTo, rFrom, rAddPurpose );
388 : fpGetMapFunc = selectMapFunc( aName );
389 : }
390 :
391 : if (! fpGetMapFunc)
392 : {
393 : #if OSL_DEBUG_LEVEL > 1
394 : OSL_TRACE( "Could not find mapfunc for %s", OUStringToOString( aName, RTL_TEXTENCODING_ASCII_US ).getStr());
395 : #endif
396 : return Mapping();
397 : }
398 :
399 : if (fpGetMapFunc)
400 : {
401 : Mapping aExt;
402 : (*fpGetMapFunc)( (uno_Mapping **)&aExt, rFrom.get(), rTo.get() );
403 : OSL_ASSERT( aExt.is() );
404 : if (aExt.is())
405 : return aExt;
406 : }
407 : #else
408 : // find proper lib
409 16835 : oslModule hModule = 0;
410 16835 : OUString aName;
411 :
412 16835 : if ( EnvDcp::getTypeName(rFrom.getTypeName()) == UNO_LB_UNO )
413 15361 : hModule = loadModule( aName = getBridgeName( rTo, rFrom, rAddPurpose ) );
414 16835 : if (! hModule)
415 1474 : hModule = loadModule( aName = getBridgeName( rFrom, rTo, rAddPurpose ) );
416 16835 : if (! hModule)
417 6 : hModule = loadModule( aName = getBridgeName( rTo, rFrom, rAddPurpose ) );
418 :
419 16835 : if (hModule)
420 : {
421 16829 : OUString aSymbolName( UNO_EXT_GETMAPPING );
422 : uno_ext_getMappingFunc fpGetMapFunc =
423 : (uno_ext_getMappingFunc)::osl_getFunctionSymbol(
424 16829 : hModule, aSymbolName.pData );
425 :
426 16829 : if (fpGetMapFunc)
427 : {
428 16829 : Mapping aExt;
429 16829 : (*fpGetMapFunc)( (uno_Mapping **)&aExt, rFrom.get(), rTo.get() );
430 : OSL_ASSERT( aExt.is() );
431 16829 : if (aExt.is())
432 : {
433 16829 : return aExt;
434 0 : }
435 : }
436 0 : ::osl_unloadModule( hModule );
437 0 : setNegativeBridge( aName );
438 6 : }
439 : #endif
440 : }
441 6 : return Mapping();
442 : }
443 :
444 :
445 12 : static Mapping getDirectMapping(
446 : const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose = OUString() )
447 :
448 : {
449 : OSL_ASSERT( rFrom.is() && rTo.is() );
450 12 : if (rFrom.is() && rTo.is())
451 : {
452 12 : MappingsData & rData = getMappingsData();
453 12 : ClearableMutexGuard aGuard( rData.aMappingsMutex );
454 :
455 : // try to find registered mapping
456 : const t_OUString2Entry::const_iterator iFind( rData.aName2Entry.find(
457 12 : getMappingName( rFrom, rTo, rAddPurpose ) ) );
458 :
459 12 : if (iFind == rData.aName2Entry.end())
460 : {
461 8 : aGuard.clear();
462 8 : return loadExternalMapping( rFrom, rTo, rAddPurpose );
463 : }
464 : else
465 : {
466 4 : return Mapping( (*iFind).second->pMapping );
467 12 : }
468 : }
469 0 : return Mapping();
470 : }
471 :
472 :
473 6 : static inline Mapping createMediateMapping(
474 : const Environment & rFrom, const Environment & rTo,
475 : const Mapping & rFrom2Uno, const Mapping & rUno2To,
476 : const OUString & rAddPurpose )
477 : {
478 : uno_Mapping * pRet = new uno_Mediate_Mapping(
479 6 : rFrom, rTo, rFrom2Uno, rUno2To, rAddPurpose ); // ref count initially 1
480 : uno_registerMapping(
481 6 : &pRet, mediate_free, rFrom.get(), rTo.get(), rAddPurpose.pData );
482 6 : Mapping aRet( pRet );
483 6 : (*pRet->release)( pRet );
484 6 : return aRet;
485 : }
486 :
487 6 : static Mapping getMediateMapping(
488 : const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
489 : {
490 6 : Environment aUno;
491 12 : Mapping aUno2To;
492 :
493 : // backwards: from dest to source of mapping chain
494 :
495 : // connect to uno
496 12 : OUString aUnoEnvTypeName( UNO_LB_UNO );
497 6 : if (rTo.getTypeName() == aUnoEnvTypeName) // to is uno
498 : {
499 0 : aUno = rTo;
500 : // no Uno2To mapping necessary
501 : }
502 : else
503 : {
504 : // get registered uno env
505 6 : ::uno_getEnvironment( (uno_Environment **)&aUno, aUnoEnvTypeName.pData, 0 );
506 :
507 6 : aUno2To = getDirectMapping( aUno, rTo );
508 : // : uno <-> to
509 6 : if (! aUno2To.is())
510 0 : return Mapping();
511 : }
512 :
513 : // connect to uno
514 6 : if (!rAddPurpose.isEmpty()) // insert purpose mapping between new ano_uno <-> uno
515 : {
516 : // create anonymous uno env
517 0 : Environment aAnUno;
518 0 : ::uno_createEnvironment( (uno_Environment **)&aAnUno, aUnoEnvTypeName.pData, 0 );
519 :
520 0 : Mapping aAnUno2Uno( getDirectMapping( aAnUno, aUno, rAddPurpose ) );
521 0 : if (! aAnUno2Uno.is())
522 0 : return Mapping();
523 :
524 0 : if (aUno2To.is()) // to is not uno
525 : {
526 : // create another purposed mediate mapping
527 0 : aUno2To = createMediateMapping( aAnUno, rTo, aAnUno2Uno, aUno2To, rAddPurpose );
528 : // : ano_uno <-> uno <-> to
529 : }
530 : else
531 : {
532 0 : aUno2To = aAnUno2Uno;
533 : // : ano_uno <-> to (i.e., uno)
534 : }
535 0 : aUno = aAnUno;
536 : }
537 :
538 12 : Mapping aFrom2Uno( getDirectMapping( rFrom, aUno ) );
539 6 : if (aFrom2Uno.is() && aUno2To.is())
540 : {
541 6 : return createMediateMapping( rFrom, rTo, aFrom2Uno, aUno2To, rAddPurpose );
542 : // : from <-> some uno ...
543 : }
544 :
545 6 : return Mapping();
546 : }
547 : }
548 :
549 : using namespace ::cppu;
550 :
551 : extern "C"
552 : {
553 :
554 52912 : void SAL_CALL uno_getMapping(
555 : uno_Mapping ** ppMapping, uno_Environment * pFrom, uno_Environment * pTo,
556 : rtl_uString * pAddPurpose )
557 : SAL_THROW_EXTERN_C()
558 : {
559 : assert(ppMapping != 0);
560 : assert(pFrom != 0);
561 : assert(pTo != 0);
562 52912 : if (*ppMapping)
563 : {
564 0 : (*(*ppMapping)->release)( *ppMapping );
565 0 : *ppMapping = 0;
566 : }
567 :
568 52912 : Mapping aRet;
569 105800 : Environment aFrom( pFrom ), aTo( pTo );
570 :
571 105800 : OUString aAddPurpose;
572 52912 : if (pAddPurpose)
573 51944 : aAddPurpose = pAddPurpose;
574 :
575 52912 : MappingsData & rData = getMappingsData();
576 :
577 : // try registered mapping
578 : {
579 52912 : MutexGuard aGuard( rData.aMappingsMutex );
580 : const t_OUString2Entry::const_iterator iFind( rData.aName2Entry.find(
581 52912 : getMappingName( aFrom, aTo, aAddPurpose ) ) );
582 52912 : if (iFind != rData.aName2Entry.end())
583 32195 : aRet = (*iFind).second->pMapping;
584 : }
585 :
586 : // See if an identity mapping does fit.
587 52912 : if (!aRet.is() && pFrom == pTo && aAddPurpose.isEmpty())
588 3866 : aRet = createIdentityMapping(pFrom);
589 :
590 52912 : if (!aRet.is())
591 : {
592 16851 : getCascadeMapping(ppMapping, pFrom, pTo, pAddPurpose);
593 :
594 16851 : if (*ppMapping)
595 24 : return;
596 : }
597 :
598 52888 : if (! aRet.is()) // try callback chain
599 : {
600 16827 : MutexGuard aGuard( rData.aCallbacksMutex );
601 50481 : for ( t_CallbackSet::const_iterator iPos( rData.aCallbacks.begin() );
602 33654 : iPos != rData.aCallbacks.end(); ++iPos )
603 : {
604 0 : (**iPos)( ppMapping, pFrom, pTo, aAddPurpose.pData );
605 0 : if (*ppMapping)
606 0 : return;
607 16827 : }
608 : }
609 :
610 52888 : if (! aRet.is())
611 : {
612 16827 : aRet = loadExternalMapping( aFrom, aTo, aAddPurpose ); // direct try
613 16827 : if (! aRet.is())
614 6 : aRet = getMediateMapping( aFrom, aTo, aAddPurpose ); // try via uno
615 : }
616 :
617 52888 : if (aRet.is())
618 : {
619 52888 : (*aRet.get()->acquire)( aRet.get() );
620 52888 : *ppMapping = aRet.get();
621 52888 : }
622 : }
623 :
624 348 : void SAL_CALL uno_getMappingByName(
625 : uno_Mapping ** ppMapping, rtl_uString * pFrom, rtl_uString * pTo,
626 : rtl_uString * pAddPurpose )
627 : SAL_THROW_EXTERN_C()
628 : {
629 : assert(ppMapping && pFrom && pTo && "### null ptr!");
630 348 : if (*ppMapping)
631 : {
632 0 : (*(*ppMapping)->release)( *ppMapping );
633 0 : *ppMapping = 0;
634 : }
635 :
636 348 : uno_Environment * pEFrom = 0;
637 348 : uno_getEnvironment( &pEFrom, pFrom, 0 );
638 : OSL_ENSURE( pEFrom, "### cannot get source environment!" );
639 348 : if (pEFrom)
640 : {
641 348 : uno_Environment * pETo = 0;
642 348 : uno_getEnvironment( &pETo, pTo, 0 );
643 : OSL_ENSURE( pETo, "### cannot get target environment!" );
644 348 : if (pETo)
645 : {
646 348 : ::uno_getMapping( ppMapping, pEFrom, pETo, pAddPurpose );
647 348 : (*pETo->release)( pETo );
648 : }
649 348 : (*pEFrom->release)( pEFrom );
650 : }
651 348 : }
652 :
653 :
654 20717 : CPPU_DLLPUBLIC void SAL_CALL uno_registerMapping(
655 : uno_Mapping ** ppMapping, uno_freeMappingFunc freeMapping,
656 : uno_Environment * pFrom, uno_Environment * pTo, rtl_uString * pAddPurpose )
657 : SAL_THROW_EXTERN_C()
658 : {
659 20717 : MappingsData & rData = getMappingsData();
660 20717 : ClearableMutexGuard aGuard( rData.aMappingsMutex );
661 :
662 20717 : const t_Mapping2Entry::const_iterator iFind( rData.aMapping2Entry.find( *ppMapping ) );
663 20717 : if (iFind == rData.aMapping2Entry.end())
664 : {
665 : OUString aMappingName(
666 20717 : getMappingName( pFrom, pTo, pAddPurpose ? OUString(pAddPurpose) : OUString() ) );
667 : #if OSL_DEBUG_LEVEL > 2
668 : OString cstr( OUStringToOString( aMappingName, RTL_TEXTENCODING_ASCII_US ) );
669 : OSL_TRACE( "> inserting new mapping: %s", cstr.getStr() );
670 : #endif
671 : // count initially 1
672 20717 : MappingEntry * pEntry = new MappingEntry( *ppMapping, freeMapping, aMappingName );
673 20717 : rData.aName2Entry[ aMappingName ] = pEntry;
674 20717 : rData.aMapping2Entry[ *ppMapping ] = pEntry;
675 : }
676 : else
677 : {
678 0 : MappingEntry * pEntry = (*iFind).second;
679 0 : ++pEntry->nRef;
680 :
681 0 : if (pEntry->pMapping != *ppMapping) // exchange mapping to be registered
682 : {
683 0 : (*pEntry->pMapping->acquire)( pEntry->pMapping );
684 0 : --pEntry->nRef; // correct count; kill mapping to be registered
685 0 : aGuard.clear();
686 0 : (*freeMapping)( *ppMapping );
687 0 : *ppMapping = pEntry->pMapping;
688 : }
689 20717 : }
690 20717 : }
691 :
692 20565 : CPPU_DLLPUBLIC void SAL_CALL uno_revokeMapping(
693 : uno_Mapping * pMapping )
694 : SAL_THROW_EXTERN_C()
695 : {
696 20565 : MappingsData & rData = getMappingsData();
697 20565 : ClearableMutexGuard aGuard( rData.aMappingsMutex );
698 :
699 20565 : const t_Mapping2Entry::const_iterator iFind( rData.aMapping2Entry.find( pMapping ) );
700 : OSL_ASSERT( iFind != rData.aMapping2Entry.end() );
701 20565 : MappingEntry * pEntry = (*iFind).second;
702 20565 : if (! --pEntry->nRef)
703 : {
704 20565 : rData.aMapping2Entry.erase( pEntry->pMapping );
705 20565 : rData.aName2Entry.erase( pEntry->aMappingName );
706 20565 : aGuard.clear();
707 : #if OSL_DEBUG_LEVEL > 2
708 : OString cstr( OUStringToOString( pEntry->aMappingName, RTL_TEXTENCODING_ASCII_US ) );
709 : OSL_TRACE( "> revoking mapping %s", cstr.getStr() );
710 : #endif
711 20565 : (*pEntry->freeMapping)( pEntry->pMapping );
712 20565 : delete pEntry;
713 20565 : }
714 20565 : }
715 :
716 :
717 0 : CPPU_DLLPUBLIC void SAL_CALL uno_registerMappingCallback(
718 : uno_getMappingFunc pCallback )
719 : SAL_THROW_EXTERN_C()
720 : {
721 : OSL_ENSURE( pCallback, "### null ptr!" );
722 0 : MappingsData & rData = getMappingsData();
723 0 : MutexGuard aGuard( rData.aCallbacksMutex );
724 0 : rData.aCallbacks.insert( pCallback );
725 0 : }
726 :
727 0 : CPPU_DLLPUBLIC void SAL_CALL uno_revokeMappingCallback(
728 : uno_getMappingFunc pCallback )
729 : SAL_THROW_EXTERN_C()
730 : {
731 : OSL_ENSURE( pCallback, "### null ptr!" );
732 0 : MappingsData & rData = getMappingsData();
733 0 : MutexGuard aGuard( rData.aCallbacksMutex );
734 0 : rData.aCallbacks.erase( pCallback );
735 0 : }
736 : } // extern "C"
737 :
738 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
