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 "IdentityMapping.hxx"
22 :
23 : #include <boost/unordered_map.hpp>
24 : #include <set>
25 : #include <algorithm>
26 :
27 : #include "rtl/unload.h"
28 : #include "rtl/ustring.hxx"
29 : #include "rtl/ustrbuf.hxx"
30 : #include "osl/module.h"
31 : #include "osl/diagnose.h"
32 : #include "osl/mutex.hxx"
33 : #include "osl/interlck.h"
34 :
35 : #include "uno/dispatcher.h"
36 : #include "uno/mapping.h"
37 : #include "uno/lbnames.h"
38 : #include "uno/environment.hxx"
39 :
40 : #include "typelib/typedescription.h"
41 :
42 : #include "cppu/EnvDcp.hxx"
43 : #include "cascade_mapping.hxx"
44 : #include "IdentityMapping.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 6474 : inline Mapping & SAL_CALL operator = ( const Mapping & rMapping ) SAL_THROW(())
68 6474 : { return operator = ( rMapping._pMapping ); }
69 60054 : inline uno_Mapping * SAL_CALL get() const SAL_THROW(())
70 60054 : { return _pMapping; }
71 113038 : inline sal_Bool SAL_CALL is() const SAL_THROW(())
72 113038 : { return (_pMapping != 0); }
73 : };
74 : //__________________________________________________________________________________________________
75 26492 : inline Mapping::Mapping( uno_Mapping * pMapping ) SAL_THROW(())
76 26492 : : _pMapping( pMapping )
77 : {
78 26492 : if (_pMapping)
79 0 : (*_pMapping->acquire)( _pMapping );
80 26492 : }
81 : //__________________________________________________________________________________________________
82 6474 : inline Mapping::Mapping( const Mapping & rMapping ) SAL_THROW(())
83 6474 : : _pMapping( rMapping._pMapping )
84 : {
85 6474 : if (_pMapping)
86 6474 : (*_pMapping->acquire)( _pMapping );
87 6474 : }
88 : //__________________________________________________________________________________________________
89 32966 : inline Mapping::~Mapping() SAL_THROW(())
90 : {
91 32966 : if (_pMapping)
92 32966 : (*_pMapping->release)( _pMapping );
93 32966 : }
94 : //__________________________________________________________________________________________________
95 20018 : inline Mapping & Mapping::operator = ( uno_Mapping * pMapping ) SAL_THROW(())
96 : {
97 20018 : if (pMapping)
98 20018 : (*pMapping->acquire)( pMapping );
99 20018 : if (_pMapping)
100 0 : (*_pMapping->release)( _pMapping );
101 20018 : _pMapping = pMapping;
102 20018 : return *this;
103 : }
104 :
105 : //==================================================================================================
106 13170 : struct MappingEntry
107 : {
108 : sal_Int32 nRef;
109 : uno_Mapping * pMapping;
110 : uno_freeMappingFunc freeMapping;
111 : OUString aMappingName;
112 :
113 13176 : 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 13176 : , aMappingName( rMappingName_ )
121 13176 : {}
122 : };
123 : //--------------------------------------------------------------------------------------------------
124 : struct FctOUStringHash : public std::unary_function< const OUString &, size_t >
125 : {
126 33873 : size_t operator()( const OUString & rKey ) const SAL_THROW(())
127 33873 : { return (size_t)rKey.hashCode(); }
128 : };
129 : //--------------------------------------------------------------------------------------------------
130 : struct FctPtrHash : public std::unary_function< uno_Mapping *, size_t >
131 : {
132 40201 : size_t operator()( uno_Mapping * pKey ) const SAL_THROW(())
133 40201 : { 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 114 : 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 52838 : static MappingsData & getMappingsData() SAL_THROW(())
159 : {
160 : static MappingsData * s_p = 0;
161 52838 : if (! s_p)
162 : {
163 114 : MutexGuard aGuard( Mutex::getGlobalMutex() );
164 114 : if (! s_p)
165 : {
166 : //TODO This memory is leaked; see #i63473# for when this should be
167 : // changed again:
168 114 : s_p = new MappingsData;
169 114 : }
170 : }
171 52838 : 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 successfull!
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 33194 : static inline OUString getMappingName(
284 : const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
285 : SAL_THROW(())
286 : {
287 33194 : OUStringBuffer aKey( 64 );
288 33194 : aKey.append( rAddPurpose );
289 33194 : aKey.append( (sal_Unicode)';' );
290 33194 : aKey.append( rFrom.getTypeName() );
291 33194 : aKey.append( (sal_Unicode)'[' );
292 33194 : aKey.append( reinterpret_cast< sal_IntPtr >(rFrom.get()), 16 );
293 33194 : aKey.appendAscii( RTL_CONSTASCII_STRINGPARAM("];") );
294 33194 : aKey.append( rTo.getTypeName() );
295 33194 : aKey.append( (sal_Unicode)'[' );
296 33194 : aKey.append( reinterpret_cast< sal_IntPtr >(rTo.get()), 16 );
297 33194 : aKey.append( (sal_Unicode)']' );
298 33194 : return aKey.makeStringAndClear();
299 : }
300 : //==================================================================================================
301 6474 : static inline OUString getBridgeName(
302 : const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
303 : SAL_THROW(())
304 : {
305 6474 : OUStringBuffer aBridgeName( 16 );
306 6474 : if (!rAddPurpose.isEmpty())
307 : {
308 0 : aBridgeName.append( rAddPurpose );
309 0 : aBridgeName.append( (sal_Unicode)'_' );
310 : }
311 6474 : aBridgeName.append( EnvDcp::getTypeName(rFrom.getTypeName()) );
312 6474 : aBridgeName.append( (sal_Unicode)'_' );
313 6474 : aBridgeName.append( EnvDcp::getTypeName(rTo.getTypeName()) );
314 6474 : return aBridgeName.makeStringAndClear();
315 : }
316 : //==================================================================================================
317 0 : static inline void setNegativeBridge( const OUString & rBridgeName )
318 : SAL_THROW(())
319 : {
320 0 : MappingsData & rData = getMappingsData();
321 0 : MutexGuard aGuard( rData.aNegativeLibsMutex );
322 0 : rData.aNegativeLibs.insert( rBridgeName );
323 0 : }
324 :
325 : #ifdef DISABLE_DYNLOADING
326 :
327 : static uno_ext_getMappingFunc selectMapFunc( const OUString & rBridgeName )
328 : SAL_THROW(())
329 : {
330 : if (rBridgeName.equalsAscii( CPPU_CURRENT_LANGUAGE_BINDING_NAME "_uno" ))
331 : return CPPU_ENV_uno_ext_getMapping;
332 : #ifdef SOLAR_JAVA
333 : if (rBridgeName.equalsAscii( "java" "_uno" ))
334 : return java_uno_ext_getMapping;
335 : #endif
336 :
337 : #if 0
338 : // I don't think the affine or log bridges will be needed on any
339 : // DISABLE_DYNLOADING platform (iOS at least, possibly Android), but if
340 : // somebody wants to experiment, need to find out then whether these are
341 : // needed.
342 : if (rBridgeName.equalsAscii( "affine_uno_uno" ))
343 : return affine_uno_uno_ext_getMapping;
344 : if (rBridgeName.equalsAscii( "log_uno_uno" ))
345 : return log_uno_uno_ext_getMapping;
346 : #endif
347 : return 0;
348 : }
349 :
350 : #else
351 :
352 6474 : static inline oslModule loadModule( const OUString & rBridgeName )
353 : SAL_THROW(())
354 : {
355 : sal_Bool bNeg;
356 : {
357 6474 : MappingsData & rData = getMappingsData();
358 6474 : MutexGuard aGuard( rData.aNegativeLibsMutex );
359 6474 : const t_OUStringSet::const_iterator iFind( rData.aNegativeLibs.find( rBridgeName ) );
360 6474 : bNeg = (iFind != rData.aNegativeLibs.end());
361 : }
362 :
363 6474 : if (! bNeg)
364 : {
365 6474 : oslModule hModule = cppu::detail::loadModule( rBridgeName );
366 :
367 6474 : if (hModule)
368 6474 : return hModule;
369 :
370 0 : setNegativeBridge( rBridgeName ); // no load again
371 : }
372 0 : return 0;
373 : }
374 :
375 : #endif
376 :
377 : //==================================================================================================
378 6474 : static Mapping loadExternalMapping(
379 : const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
380 : SAL_THROW(())
381 : {
382 : OSL_ASSERT( rFrom.is() && rTo.is() );
383 6474 : if (rFrom.is() && rTo.is())
384 : {
385 : #ifdef DISABLE_DYNLOADING
386 : OUString aName;
387 : uno_ext_getMappingFunc fpGetMapFunc = 0;
388 :
389 : if (EnvDcp::getTypeName(rFrom.getTypeName()).equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_LB_UNO) ))
390 : {
391 : aName = getBridgeName( rTo, rFrom, rAddPurpose );
392 : fpGetMapFunc = selectMapFunc( aName );
393 : }
394 : if (! fpGetMapFunc)
395 : {
396 : aName = getBridgeName( rFrom, rTo, rAddPurpose );
397 : fpGetMapFunc = selectMapFunc( aName );
398 : }
399 : if (! fpGetMapFunc)
400 : {
401 : aName = getBridgeName( rTo, rFrom, rAddPurpose );
402 : fpGetMapFunc = selectMapFunc( aName );
403 : }
404 :
405 : if (! fpGetMapFunc)
406 : {
407 : #if OSL_DEBUG_LEVEL > 1
408 : OSL_TRACE( "Could not find mapfunc for %s", OUStringToOString( aName, RTL_TEXTENCODING_ASCII_US ).getStr());
409 : #endif
410 : return Mapping();
411 : }
412 :
413 : if (fpGetMapFunc)
414 : {
415 : Mapping aExt;
416 : (*fpGetMapFunc)( (uno_Mapping **)&aExt, rFrom.get(), rTo.get() );
417 : OSL_ASSERT( aExt.is() );
418 : if (aExt.is())
419 : return aExt;
420 : }
421 : #else
422 : // find proper lib
423 6474 : oslModule hModule = 0;
424 6474 : OUString aName;
425 :
426 6474 : if ( EnvDcp::getTypeName(rFrom.getTypeName()) == UNO_LB_UNO )
427 6074 : hModule = loadModule( aName = getBridgeName( rTo, rFrom, rAddPurpose ) );
428 6474 : if (! hModule)
429 400 : hModule = loadModule( aName = getBridgeName( rFrom, rTo, rAddPurpose ) );
430 6474 : if (! hModule)
431 0 : hModule = loadModule( aName = getBridgeName( rTo, rFrom, rAddPurpose ) );
432 :
433 6474 : if (hModule)
434 : {
435 6474 : OUString aSymbolName( RTL_CONSTASCII_USTRINGPARAM(UNO_EXT_GETMAPPING) );
436 : uno_ext_getMappingFunc fpGetMapFunc =
437 : (uno_ext_getMappingFunc)::osl_getFunctionSymbol(
438 6474 : hModule, aSymbolName.pData );
439 :
440 6474 : if (fpGetMapFunc)
441 : {
442 6474 : Mapping aExt;
443 6474 : (*fpGetMapFunc)( (uno_Mapping **)&aExt, rFrom.get(), rTo.get() );
444 : OSL_ASSERT( aExt.is() );
445 6474 : if (aExt.is())
446 : {
447 6474 : ::rtl_registerModuleForUnloading( hModule );
448 6474 : return aExt;
449 6474 : }
450 : }
451 0 : ::osl_unloadModule( hModule );
452 0 : setNegativeBridge( aName );
453 6474 : }
454 : #endif
455 : }
456 0 : return Mapping();
457 : }
458 :
459 : //==================================================================================================
460 0 : static Mapping getDirectMapping(
461 : const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose = OUString() )
462 : SAL_THROW(())
463 : {
464 : OSL_ASSERT( rFrom.is() && rTo.is() );
465 0 : if (rFrom.is() && rTo.is())
466 : {
467 0 : MappingsData & rData = getMappingsData();
468 0 : ClearableMutexGuard aGuard( rData.aMappingsMutex );
469 :
470 : // try to find registered mapping
471 : const t_OUString2Entry::const_iterator iFind( rData.aName2Entry.find(
472 0 : getMappingName( rFrom, rTo, rAddPurpose ) ) );
473 :
474 0 : if (iFind == rData.aName2Entry.end())
475 : {
476 0 : aGuard.clear();
477 0 : return loadExternalMapping( rFrom, rTo, rAddPurpose );
478 : }
479 : else
480 : {
481 0 : return Mapping( (*iFind).second->pMapping );
482 0 : }
483 : }
484 0 : return Mapping();
485 : }
486 :
487 : //--------------------------------------------------------------------------------------------------
488 0 : static inline Mapping createMediateMapping(
489 : const Environment & rFrom, const Environment & rTo,
490 : const Mapping & rFrom2Uno, const Mapping & rUno2To,
491 : const OUString & rAddPurpose )
492 : SAL_THROW(())
493 : {
494 : uno_Mapping * pRet = new uno_Mediate_Mapping(
495 0 : rFrom, rTo, rFrom2Uno, rUno2To, rAddPurpose ); // ref count initially 1
496 : uno_registerMapping(
497 0 : &pRet, mediate_free, rFrom.get(), rTo.get(), rAddPurpose.pData );
498 0 : Mapping aRet( pRet );
499 0 : (*pRet->release)( pRet );
500 0 : return aRet;
501 : }
502 : //==================================================================================================
503 0 : static Mapping getMediateMapping(
504 : const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
505 : SAL_THROW(())
506 : {
507 0 : Environment aUno;
508 0 : Mapping aUno2To;
509 :
510 : // backwards: from dest to source of mapping chain
511 :
512 : // connect to uno
513 0 : OUString aUnoEnvTypeName( RTL_CONSTASCII_USTRINGPARAM(UNO_LB_UNO) );
514 0 : if (rTo.getTypeName() == aUnoEnvTypeName) // to is uno
515 : {
516 0 : aUno = rTo;
517 : // no Uno2To mapping necessary
518 : }
519 : else
520 : {
521 : // get registered uno env
522 0 : ::uno_getEnvironment( (uno_Environment **)&aUno, aUnoEnvTypeName.pData, 0 );
523 :
524 0 : aUno2To = getDirectMapping( aUno, rTo );
525 : // : uno <-> to
526 0 : if (! aUno2To.is())
527 0 : return Mapping();
528 : }
529 :
530 : // connect to uno
531 0 : if (!rAddPurpose.isEmpty()) // insert purpose mapping between new ano_uno <-> uno
532 : {
533 : // create anonymous uno env
534 0 : Environment aAnUno;
535 0 : ::uno_createEnvironment( (uno_Environment **)&aAnUno, aUnoEnvTypeName.pData, 0 );
536 :
537 0 : Mapping aAnUno2Uno( getDirectMapping( aAnUno, aUno, rAddPurpose ) );
538 0 : if (! aAnUno2Uno.is())
539 0 : return Mapping();
540 :
541 0 : if (aUno2To.is()) // to is not uno
542 : {
543 : // create another purposed mediate mapping
544 0 : aUno2To = createMediateMapping( aAnUno, rTo, aAnUno2Uno, aUno2To, rAddPurpose );
545 : // : ano_uno <-> uno <-> to
546 : }
547 : else
548 : {
549 0 : aUno2To = aAnUno2Uno;
550 : // : ano_uno <-> to (i.e., uno)
551 : }
552 0 : aUno = aAnUno;
553 : }
554 :
555 0 : Mapping aFrom2Uno( getDirectMapping( rFrom, aUno ) );
556 0 : if (aFrom2Uno.is() && aUno2To.is())
557 : {
558 0 : return createMediateMapping( rFrom, rTo, aFrom2Uno, aUno2To, rAddPurpose );
559 : // : from <-> some uno ...
560 : }
561 :
562 0 : return Mapping();
563 : }
564 : }
565 :
566 : using namespace ::cppu;
567 :
568 : extern "C"
569 : {
570 : //##################################################################################################
571 20018 : void SAL_CALL uno_getMapping(
572 : uno_Mapping ** ppMapping, uno_Environment * pFrom, uno_Environment * pTo,
573 : rtl_uString * pAddPurpose )
574 : SAL_THROW_EXTERN_C()
575 : {
576 : OSL_ENSURE( ppMapping && pFrom && pTo, "### null ptr!" );
577 20018 : if (*ppMapping)
578 : {
579 0 : (*(*ppMapping)->release)( *ppMapping );
580 0 : *ppMapping = 0;
581 : }
582 :
583 20018 : Mapping aRet;
584 20018 : Environment aFrom( pFrom ), aTo( pTo );
585 :
586 20018 : OUString aAddPurpose;
587 20018 : if (pAddPurpose)
588 19930 : aAddPurpose = pAddPurpose;
589 :
590 20018 : MappingsData & rData = getMappingsData();
591 :
592 : // try registered mapping
593 : {
594 20018 : MutexGuard aGuard( rData.aMappingsMutex );
595 : const t_OUString2Entry::const_iterator iFind( rData.aName2Entry.find(
596 20018 : getMappingName( aFrom, aTo, aAddPurpose ) ) );
597 20018 : if (iFind != rData.aName2Entry.end())
598 6842 : aRet = (*iFind).second->pMapping;
599 : }
600 :
601 : // See if an identity mapping does fit.
602 20018 : if (!aRet.is() && pFrom == pTo && aAddPurpose.isEmpty())
603 6702 : aRet = createIdentityMapping(pFrom);
604 :
605 20018 : if (!aRet.is())
606 : {
607 6474 : getCascadeMapping(ppMapping, pFrom, pTo, pAddPurpose);
608 :
609 6474 : if (*ppMapping)
610 : return;
611 : }
612 :
613 20018 : if (! aRet.is()) // try callback chain
614 : {
615 6474 : MutexGuard aGuard( rData.aCallbacksMutex );
616 19422 : for ( t_CallbackSet::const_iterator iPos( rData.aCallbacks.begin() );
617 12948 : iPos != rData.aCallbacks.end(); ++iPos )
618 : {
619 0 : (**iPos)( ppMapping, pFrom, pTo, aAddPurpose.pData );
620 0 : if (*ppMapping)
621 : return;
622 6474 : }
623 : }
624 :
625 20018 : if (! aRet.is())
626 : {
627 6474 : aRet = loadExternalMapping( aFrom, aTo, aAddPurpose ); // direct try
628 6474 : if (! aRet.is())
629 0 : aRet = getMediateMapping( aFrom, aTo, aAddPurpose ); // try via uno
630 : }
631 :
632 20018 : if (aRet.is())
633 : {
634 20018 : (*aRet.get()->acquire)( aRet.get() );
635 20018 : *ppMapping = aRet.get();
636 20018 : }
637 : }
638 : //##################################################################################################
639 56 : void SAL_CALL uno_getMappingByName(
640 : uno_Mapping ** ppMapping, rtl_uString * pFrom, rtl_uString * pTo,
641 : rtl_uString * pAddPurpose )
642 : SAL_THROW_EXTERN_C()
643 : {
644 : OSL_ENSURE( ppMapping && pFrom && pTo, "### null ptr!" );
645 56 : if (*ppMapping)
646 : {
647 0 : (*(*ppMapping)->release)( *ppMapping );
648 0 : *ppMapping = 0;
649 : }
650 :
651 56 : uno_Environment * pEFrom = 0;
652 56 : uno_getEnvironment( &pEFrom, pFrom, 0 );
653 : OSL_ENSURE( pEFrom, "### cannot get source environment!" );
654 56 : if (pEFrom)
655 : {
656 56 : uno_Environment * pETo = 0;
657 56 : uno_getEnvironment( &pETo, pTo, 0 );
658 : OSL_ENSURE( pETo, "### cannot get target environment!" );
659 56 : if (pETo)
660 : {
661 56 : ::uno_getMapping( ppMapping, pEFrom, pETo, pAddPurpose );
662 56 : (*pETo->release)( pETo );
663 : }
664 56 : (*pEFrom->release)( pEFrom );
665 : }
666 56 : }
667 :
668 : //##################################################################################################
669 13176 : CPPU_DLLPUBLIC void SAL_CALL uno_registerMapping(
670 : uno_Mapping ** ppMapping, uno_freeMappingFunc freeMapping,
671 : uno_Environment * pFrom, uno_Environment * pTo, rtl_uString * pAddPurpose )
672 : SAL_THROW_EXTERN_C()
673 : {
674 13176 : MappingsData & rData = getMappingsData();
675 13176 : ClearableMutexGuard aGuard( rData.aMappingsMutex );
676 :
677 13176 : const t_Mapping2Entry::const_iterator iFind( rData.aMapping2Entry.find( *ppMapping ) );
678 13176 : if (iFind == rData.aMapping2Entry.end())
679 : {
680 : OUString aMappingName(
681 13176 : getMappingName( pFrom, pTo, pAddPurpose ? OUString(pAddPurpose) : OUString() ) );
682 : #if OSL_DEBUG_LEVEL > 2
683 : OString cstr( OUStringToOString( aMappingName, RTL_TEXTENCODING_ASCII_US ) );
684 : OSL_TRACE( "> inserting new mapping: %s", cstr.getStr() );
685 : #endif
686 : // count initially 1
687 13176 : MappingEntry * pEntry = new MappingEntry( *ppMapping, freeMapping, aMappingName );
688 13176 : rData.aName2Entry[ aMappingName ] = pEntry;
689 13176 : rData.aMapping2Entry[ *ppMapping ] = pEntry;
690 : }
691 : else
692 : {
693 0 : MappingEntry * pEntry = (*iFind).second;
694 0 : ++pEntry->nRef;
695 :
696 0 : if (pEntry->pMapping != *ppMapping) // exchange mapping to be registered
697 : {
698 0 : (*pEntry->pMapping->acquire)( pEntry->pMapping );
699 0 : --pEntry->nRef; // correct count; kill mapping to be registered
700 0 : aGuard.clear();
701 0 : (*freeMapping)( *ppMapping );
702 0 : *ppMapping = pEntry->pMapping;
703 : }
704 13176 : }
705 13176 : }
706 : //##################################################################################################
707 13170 : CPPU_DLLPUBLIC void SAL_CALL uno_revokeMapping(
708 : uno_Mapping * pMapping )
709 : SAL_THROW_EXTERN_C()
710 : {
711 13170 : MappingsData & rData = getMappingsData();
712 13170 : ClearableMutexGuard aGuard( rData.aMappingsMutex );
713 :
714 13170 : const t_Mapping2Entry::const_iterator iFind( rData.aMapping2Entry.find( pMapping ) );
715 : OSL_ASSERT( iFind != rData.aMapping2Entry.end() );
716 13170 : MappingEntry * pEntry = (*iFind).second;
717 13170 : if (! --pEntry->nRef)
718 : {
719 13170 : rData.aMapping2Entry.erase( pEntry->pMapping );
720 13170 : rData.aName2Entry.erase( pEntry->aMappingName );
721 13170 : aGuard.clear();
722 : #if OSL_DEBUG_LEVEL > 2
723 : OString cstr( OUStringToOString( pEntry->aMappingName, RTL_TEXTENCODING_ASCII_US ) );
724 : OSL_TRACE( "> revoking mapping %s", cstr.getStr() );
725 : #endif
726 13170 : (*pEntry->freeMapping)( pEntry->pMapping );
727 13170 : delete pEntry;
728 13170 : }
729 13170 : }
730 :
731 : //##################################################################################################
732 0 : CPPU_DLLPUBLIC void SAL_CALL uno_registerMappingCallback(
733 : uno_getMappingFunc pCallback )
734 : SAL_THROW_EXTERN_C()
735 : {
736 : OSL_ENSURE( pCallback, "### null ptr!" );
737 0 : MappingsData & rData = getMappingsData();
738 0 : MutexGuard aGuard( rData.aCallbacksMutex );
739 0 : rData.aCallbacks.insert( pCallback );
740 0 : }
741 : //##################################################################################################
742 0 : CPPU_DLLPUBLIC void SAL_CALL uno_revokeMappingCallback(
743 : uno_getMappingFunc pCallback )
744 : SAL_THROW_EXTERN_C()
745 : {
746 : OSL_ENSURE( pCallback, "### null ptr!" );
747 0 : MappingsData & rData = getMappingsData();
748 0 : MutexGuard aGuard( rData.aCallbacksMutex );
749 0 : rData.aCallbacks.erase( pCallback );
750 0 : }
751 : } // extern "C"
752 :
753 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
