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