1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_cppuhelper.hxx"
26 #include <osl/diagnose.h>
27 #include <osl/mutex.hxx>
28 #include <cppuhelper/weak.hxx>
29 #include <cppuhelper/component.hxx>
30 #include <cppuhelper/factory.hxx>
31 #ifndef _CPPUHELPER_IMPLBASE3_HXX
32 #include <cppuhelper/implbase3.hxx>
33 #endif
34 #include <cppuhelper/typeprovider.hxx>
35 #include <rtl/unload.h>
36
37 #include "cppuhelper/propshlp.hxx"
38
39 #include <com/sun/star/lang/XServiceInfo.hpp>
40 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
41 #include <com/sun/star/lang/XSingleComponentFactory.hpp>
42 #include <com/sun/star/lang/XInitialization.hpp>
43 #include <com/sun/star/loader/XImplementationLoader.hpp>
44 #include <com/sun/star/lang/XComponent.hpp>
45 #include <com/sun/star/lang/IllegalArgumentException.hpp>
46 #include <com/sun/star/uno/XUnloadingPreference.hpp>
47 #include "com/sun/star/beans/PropertyAttribute.hpp"
48
49 #include <memory>
50
51 #define OUSTR(x) ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(x) )
52
53
54 using namespace osl;
55 using namespace rtl;
56 using namespace com::sun::star;
57 using namespace com::sun::star::uno;
58 using namespace com::sun::star::lang;
59 using namespace com::sun::star::loader;
60 using namespace com::sun::star::registry;
61
62 namespace cppu
63 {
64
65 //-----------------------------------------------------------------------------
66 //-----------------------------------------------------------------------------
67 //-----------------------------------------------------------------------------
68 class OSingleFactoryHelper
69 : public XServiceInfo
70 , public XSingleServiceFactory
71 , public lang::XSingleComponentFactory
72 , public XUnloadingPreference
73 {
74 public:
OSingleFactoryHelper(const Reference<XMultiServiceFactory> & rServiceManager,const OUString & rImplementationName_,ComponentInstantiation pCreateFunction_,ComponentFactoryFunc fptr,const Sequence<OUString> * pServiceNames_)75 OSingleFactoryHelper(
76 const Reference<XMultiServiceFactory > & rServiceManager,
77 const OUString & rImplementationName_,
78 ComponentInstantiation pCreateFunction_,
79 ComponentFactoryFunc fptr,
80 const Sequence< OUString > * pServiceNames_ )
81 SAL_THROW( () )
82 : xSMgr( rServiceManager )
83 , pCreateFunction( pCreateFunction_ )
84 , m_fptr( fptr )
85 , aImplementationName( rImplementationName_ )
86 {
87 if( pServiceNames_ )
88 aServiceNames = *pServiceNames_;
89 }
90
91 // old function, only for backward compatibility
OSingleFactoryHelper(const Reference<XMultiServiceFactory> & rServiceManager,const OUString & rImplementationName_)92 OSingleFactoryHelper(
93 const Reference<XMultiServiceFactory > & rServiceManager,
94 const OUString & rImplementationName_ )
95 SAL_THROW( () )
96 : xSMgr( rServiceManager )
97 , pCreateFunction( NULL )
98 , m_fptr( 0 )
99 , aImplementationName( rImplementationName_ )
100 {}
101
102 virtual ~OSingleFactoryHelper();
103
104 // XInterface
105 Any SAL_CALL queryInterface( const Type & rType )
106 throw(::com::sun::star::uno::RuntimeException);
107
108 // XSingleServiceFactory
109 Reference<XInterface > SAL_CALL createInstance()
110 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
111 virtual Reference<XInterface > SAL_CALL createInstanceWithArguments(const Sequence<Any>& Arguments)
112 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
113 // XSingleComponentFactory
114 virtual Reference< XInterface > SAL_CALL createInstanceWithContext(
115 Reference< XComponentContext > const & xContext )
116 throw (Exception, RuntimeException);
117 virtual Reference< XInterface > SAL_CALL createInstanceWithArgumentsAndContext(
118 Sequence< Any > const & rArguments,
119 Reference< XComponentContext > const & xContext )
120 throw (Exception, RuntimeException);
121
122 // XServiceInfo
123 OUString SAL_CALL getImplementationName()
124 throw(::com::sun::star::uno::RuntimeException);
125 sal_Bool SAL_CALL supportsService(const OUString& ServiceName)
126 throw(::com::sun::star::uno::RuntimeException);
127 Sequence< OUString > SAL_CALL getSupportedServiceNames(void)
128 throw(::com::sun::star::uno::RuntimeException);
129
130 protected:
131 /**
132 * Create an instance specified by the factory. The one instance logic is implemented
133 * in the createInstance and createInstanceWithArguments methods.
134 * @return the newly created instance. Do not return a previous (one instance) instance.
135 */
136 virtual Reference<XInterface > createInstanceEveryTime(
137 Reference< XComponentContext > const & xContext )
138 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
139
140 Reference<XMultiServiceFactory > xSMgr;
141 ComponentInstantiation pCreateFunction;
142 ComponentFactoryFunc m_fptr;
143 Sequence< OUString > aServiceNames;
144 OUString aImplementationName;
145 };
~OSingleFactoryHelper()146 OSingleFactoryHelper::~OSingleFactoryHelper()
147 {
148 }
149
150
151 //-----------------------------------------------------------------------------
queryInterface(const Type & rType)152 Any OSingleFactoryHelper::queryInterface( const Type & rType )
153 throw(::com::sun::star::uno::RuntimeException)
154 {
155 return ::cppu::queryInterface(
156 rType,
157 static_cast< XSingleComponentFactory * >( this ),
158 static_cast< XSingleServiceFactory * >( this ),
159 static_cast< XServiceInfo * >( this ) ,
160 static_cast< XUnloadingPreference * >( this ));
161 }
162
163 // OSingleFactoryHelper
createInstanceEveryTime(Reference<XComponentContext> const & xContext)164 Reference<XInterface > OSingleFactoryHelper::createInstanceEveryTime(
165 Reference< XComponentContext > const & xContext )
166 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException)
167 {
168 if (m_fptr)
169 {
170 return (*m_fptr)( xContext );
171 }
172 else if( pCreateFunction )
173 {
174 if (xContext.is())
175 {
176 Reference< lang::XMultiServiceFactory > xContextMgr(
177 xContext->getServiceManager(), UNO_QUERY );
178 if (xContextMgr.is())
179 return (*pCreateFunction)( xContextMgr );
180 }
181 return (*pCreateFunction)( xSMgr );
182 }
183 else
184 {
185 return Reference< XInterface >();
186 }
187 }
188
189 // XSingleServiceFactory
createInstance()190 Reference<XInterface > OSingleFactoryHelper::createInstance()
191 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException)
192 {
193 return createInstanceWithContext( Reference< XComponentContext >() );
194 }
195
196 // XSingleServiceFactory
createInstanceWithArguments(const Sequence<Any> & Arguments)197 Reference<XInterface > OSingleFactoryHelper::createInstanceWithArguments(
198 const Sequence<Any>& Arguments )
199 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException)
200 {
201 return createInstanceWithArgumentsAndContext(
202 Arguments, Reference< XComponentContext >() );
203 }
204
205 // XSingleComponentFactory
206 //__________________________________________________________________________________________________
createInstanceWithContext(Reference<XComponentContext> const & xContext)207 Reference< XInterface > OSingleFactoryHelper::createInstanceWithContext(
208 Reference< XComponentContext > const & xContext )
209 throw (Exception, RuntimeException)
210 {
211 return createInstanceEveryTime( xContext );
212 }
213 //__________________________________________________________________________________________________
createInstanceWithArgumentsAndContext(Sequence<Any> const & rArguments,Reference<XComponentContext> const & xContext)214 Reference< XInterface > OSingleFactoryHelper::createInstanceWithArgumentsAndContext(
215 Sequence< Any > const & rArguments,
216 Reference< XComponentContext > const & xContext )
217 throw (Exception, RuntimeException)
218 {
219 Reference< XInterface > xRet( createInstanceWithContext( xContext ) );
220
221 Reference< lang::XInitialization > xInit( xRet, UNO_QUERY );
222 // always call initialize, even if there are no arguments.
223 // #i63511# / 2006-03-27 / frank.schoenheit@sun.com
224 if (xInit.is())
225 {
226 xInit->initialize( rArguments );
227 }
228 else
229 {
230 if ( rArguments.getLength() )
231 {
232 // dispose the here created UNO object before throwing out exception
233 // to avoid risk of memory leaks #i113722#
234 Reference<XComponent> xComp( xRet, UNO_QUERY );
235 if (xComp.is())
236 xComp->dispose();
237
238 throw lang::IllegalArgumentException(
239 OUString( RTL_CONSTASCII_USTRINGPARAM("cannot pass arguments to component => no XInitialization implemented!") ),
240 Reference< XInterface >(), 0 );
241 }
242 }
243
244 return xRet;
245 }
246
247 // XServiceInfo
getImplementationName()248 OUString OSingleFactoryHelper::getImplementationName()
249 throw(::com::sun::star::uno::RuntimeException)
250 {
251 return aImplementationName;
252 }
253
254 // XServiceInfo
supportsService(const OUString & ServiceName)255 sal_Bool OSingleFactoryHelper::supportsService(
256 const OUString& ServiceName )
257 throw(::com::sun::star::uno::RuntimeException)
258 {
259 Sequence< OUString > seqServices = getSupportedServiceNames();
260 const OUString * pServices = seqServices.getConstArray();
261 for( sal_Int32 i = 0; i < seqServices.getLength(); i++ )
262 if( pServices[i] == ServiceName )
263 return sal_True;
264
265 return sal_False;
266 }
267
268 // XServiceInfo
getSupportedServiceNames(void)269 Sequence< OUString > OSingleFactoryHelper::getSupportedServiceNames(void)
270 throw(::com::sun::star::uno::RuntimeException)
271 {
272 return aServiceNames;
273 }
274
275
276 //----------------------------------------------------------------------
277 //----------------------------------------------------------------------
278 //----------------------------------------------------------------------
279 struct OFactoryComponentHelper_Mutex
280 {
281 Mutex aMutex;
282 };
283
284 class OFactoryComponentHelper
285 : public OFactoryComponentHelper_Mutex
286 , public OComponentHelper
287 , public OSingleFactoryHelper
288 {
289 public:
OFactoryComponentHelper(const Reference<XMultiServiceFactory> & rServiceManager,const OUString & rImplementationName_,ComponentInstantiation pCreateFunction_,ComponentFactoryFunc fptr,const Sequence<OUString> * pServiceNames_,sal_Bool bOneInstance_=sal_False)290 OFactoryComponentHelper(
291 const Reference<XMultiServiceFactory > & rServiceManager,
292 const OUString & rImplementationName_,
293 ComponentInstantiation pCreateFunction_,
294 ComponentFactoryFunc fptr,
295 const Sequence< OUString > * pServiceNames_,
296 sal_Bool bOneInstance_ = sal_False )
297 SAL_THROW( () )
298 : OComponentHelper( aMutex )
299 , OSingleFactoryHelper( rServiceManager, rImplementationName_, pCreateFunction_, fptr, pServiceNames_ )
300 , bOneInstance( bOneInstance_ )
301 , pModuleCount(0)
302 {
303 }
304
305 // Used by the createXXXFactory functions. The argument pModCount is used to prevent the unloading of the module
306 // which contains pCreateFunction_
OFactoryComponentHelper(const Reference<XMultiServiceFactory> & rServiceManager,const OUString & rImplementationName_,ComponentInstantiation pCreateFunction_,ComponentFactoryFunc fptr,const Sequence<OUString> * pServiceNames_,rtl_ModuleCount * pModCount,sal_Bool bOneInstance_=sal_False)307 OFactoryComponentHelper(
308 const Reference<XMultiServiceFactory > & rServiceManager,
309 const OUString & rImplementationName_,
310 ComponentInstantiation pCreateFunction_,
311 ComponentFactoryFunc fptr,
312 const Sequence< OUString > * pServiceNames_,
313 rtl_ModuleCount * pModCount,
314 sal_Bool bOneInstance_ = sal_False )
315 SAL_THROW( () )
316 : OComponentHelper( aMutex )
317 , OSingleFactoryHelper( rServiceManager, rImplementationName_, pCreateFunction_, fptr, pServiceNames_ )
318 , bOneInstance( bOneInstance_ )
319 , pModuleCount(pModCount)
320 {
321 if(pModuleCount)
322 pModuleCount->acquire( pModuleCount);
323 }
324
325 // old function, only for backward compatibility
OFactoryComponentHelper(const Reference<XMultiServiceFactory> & rServiceManager,const OUString & rImplementationName_,sal_Bool bOneInstance_=sal_False)326 OFactoryComponentHelper(
327 const Reference<XMultiServiceFactory > & rServiceManager,
328 const OUString & rImplementationName_,
329 sal_Bool bOneInstance_ = sal_False )
330 SAL_THROW( () )
331 : OComponentHelper( aMutex )
332 , OSingleFactoryHelper( rServiceManager, rImplementationName_ )
333 , bOneInstance( bOneInstance_ )
334 , pModuleCount(0)
335 {
336 }
337
~OFactoryComponentHelper()338 ~OFactoryComponentHelper()
339 {
340 if(pModuleCount)
341 pModuleCount->release( pModuleCount);
342 }
343
344 // XInterface
345 Any SAL_CALL queryInterface( const Type & rType )
346 throw(::com::sun::star::uno::RuntimeException);
acquire()347 void SAL_CALL acquire() throw()
348 { OComponentHelper::acquire(); }
release()349 void SAL_CALL release() throw()
350 { OComponentHelper::release(); }
351
352 // XSingleServiceFactory
353 Reference<XInterface > SAL_CALL createInstance()
354 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
355 Reference<XInterface > SAL_CALL createInstanceWithArguments( const Sequence<Any>& Arguments )
356 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
357 // XSingleComponentFactory
358 virtual Reference< XInterface > SAL_CALL createInstanceWithContext(
359 Reference< XComponentContext > const & xContext )
360 throw (Exception, RuntimeException);
361 virtual Reference< XInterface > SAL_CALL createInstanceWithArgumentsAndContext(
362 Sequence< Any > const & rArguments,
363 Reference< XComponentContext > const & xContext )
364 throw (Exception, RuntimeException);
365
366 // XTypeProvider
367 virtual Sequence< Type > SAL_CALL getTypes() throw (::com::sun::star::uno::RuntimeException);
368 virtual Sequence< sal_Int8 > SAL_CALL getImplementationId() throw(::com::sun::star::uno::RuntimeException);
369
370 // XAggregation
371 Any SAL_CALL queryAggregation( const Type & rType )
372 throw(::com::sun::star::uno::RuntimeException);
373
374 // XUnloadingPreference
375 virtual sal_Bool SAL_CALL releaseOnNotification()
376 throw(::com::sun::star::uno::RuntimeException);
377
378 // OComponentHelper
379 void SAL_CALL dispose() throw(::com::sun::star::uno::RuntimeException);
380
381 private:
382 Reference<XInterface > xTheInstance;
383 sal_Bool bOneInstance;
384 rtl_ModuleCount * pModuleCount;
385 protected:
386 // needed for implementing XUnloadingPreference in inheriting classes
isOneInstance()387 sal_Bool isOneInstance() {return bOneInstance;}
isInstance()388 sal_Bool isInstance() {return xTheInstance.is();}
389 };
390
391
queryInterface(const Type & rType)392 Any SAL_CALL OFactoryComponentHelper::queryInterface( const Type & rType )
393 throw(::com::sun::star::uno::RuntimeException)
394 {
395 if( rType == ::getCppuType( (Reference<XUnloadingPreference>*)0))
396 {
397 return makeAny(
398 Reference< XUnloadingPreference >(
399 static_cast< XUnloadingPreference * >(this) ) );
400 }
401 return OComponentHelper::queryInterface( rType );
402 }
403
404 // XAggregation
queryAggregation(const Type & rType)405 Any OFactoryComponentHelper::queryAggregation( const Type & rType )
406 throw(::com::sun::star::uno::RuntimeException)
407 {
408 Any aRet( OComponentHelper::queryAggregation( rType ) );
409 return (aRet.hasValue() ? aRet : OSingleFactoryHelper::queryInterface( rType ));
410 }
411
412 // XTypeProvider
getTypes()413 Sequence< Type > OFactoryComponentHelper::getTypes()
414 throw (::com::sun::star::uno::RuntimeException)
415 {
416 Type ar[ 4 ];
417 ar[ 0 ] = ::getCppuType( (const Reference< XSingleServiceFactory > *)0 );
418 ar[ 1 ] = ::getCppuType( (const Reference< XServiceInfo > *)0 );
419 ar[ 2 ] = ::getCppuType( (const Reference< XUnloadingPreference > *)0 );
420
421 if (m_fptr)
422 ar[ 3 ] = ::getCppuType( (const Reference< XSingleComponentFactory > *)0 );
423
424 return Sequence< Type >( ar, m_fptr ? 4 : 3 );
425 }
426
getImplementationId()427 Sequence< sal_Int8 > OFactoryComponentHelper::getImplementationId()
428 throw (::com::sun::star::uno::RuntimeException)
429 {
430 static OImplementationId * pId = 0;
431 if (! pId)
432 {
433 MutexGuard aGuard( Mutex::getGlobalMutex() );
434 if (! pId)
435 {
436 static OImplementationId aId;
437 pId = &aId;
438 }
439 }
440 return pId->getImplementationId();
441 }
442
443 // XSingleServiceFactory
createInstance()444 Reference<XInterface > OFactoryComponentHelper::createInstance()
445 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException)
446 {
447 if( bOneInstance )
448 {
449 if( !xTheInstance.is() )
450 {
451 MutexGuard aGuard( aMutex );
452 if( !xTheInstance.is() )
453 xTheInstance = OSingleFactoryHelper::createInstance();
454 }
455 return xTheInstance;
456 }
457 return OSingleFactoryHelper::createInstance();
458 }
459
createInstanceWithArguments(const Sequence<Any> & Arguments)460 Reference<XInterface > OFactoryComponentHelper::createInstanceWithArguments(
461 const Sequence<Any>& Arguments )
462 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException)
463 {
464 if( bOneInstance )
465 {
466 if( !xTheInstance.is() )
467 {
468 MutexGuard aGuard( aMutex );
469 // OSL_ENSURE( !xTheInstance.is(), "### arguments will be ignored!" );
470 if( !xTheInstance.is() )
471 xTheInstance = OSingleFactoryHelper::createInstanceWithArguments( Arguments );
472 }
473 return xTheInstance;
474 }
475 return OSingleFactoryHelper::createInstanceWithArguments( Arguments );
476 }
477
478 // XSingleComponentFactory
479 //__________________________________________________________________________________________________
createInstanceWithContext(Reference<XComponentContext> const & xContext)480 Reference< XInterface > OFactoryComponentHelper::createInstanceWithContext(
481 Reference< XComponentContext > const & xContext )
482 throw (Exception, RuntimeException)
483 {
484 if( bOneInstance )
485 {
486 if( !xTheInstance.is() )
487 {
488 MutexGuard aGuard( aMutex );
489 // OSL_ENSURE( !xTheInstance.is(), "### context will be ignored!" );
490 if( !xTheInstance.is() )
491 xTheInstance = OSingleFactoryHelper::createInstanceWithContext( xContext );
492 }
493 return xTheInstance;
494 }
495 return OSingleFactoryHelper::createInstanceWithContext( xContext );
496 }
497 //__________________________________________________________________________________________________
createInstanceWithArgumentsAndContext(Sequence<Any> const & rArguments,Reference<XComponentContext> const & xContext)498 Reference< XInterface > OFactoryComponentHelper::createInstanceWithArgumentsAndContext(
499 Sequence< Any > const & rArguments,
500 Reference< XComponentContext > const & xContext )
501 throw (Exception, RuntimeException)
502 {
503 if( bOneInstance )
504 {
505 if( !xTheInstance.is() )
506 {
507 MutexGuard aGuard( aMutex );
508 // OSL_ENSURE( !xTheInstance.is(), "### context and arguments will be ignored!" );
509 if( !xTheInstance.is() )
510 xTheInstance = OSingleFactoryHelper::createInstanceWithArgumentsAndContext( rArguments, xContext );
511 }
512 return xTheInstance;
513 }
514 return OSingleFactoryHelper::createInstanceWithArgumentsAndContext( rArguments, xContext );
515 }
516
517
518 // OComponentHelper
dispose()519 void OFactoryComponentHelper::dispose()
520 throw(::com::sun::star::uno::RuntimeException)
521 {
522 OComponentHelper::dispose();
523
524 Reference<XInterface > x;
525 {
526 // do not delete in the guard section
527 MutexGuard aGuard( aMutex );
528 x = xTheInstance;
529 xTheInstance = Reference<XInterface >();
530 }
531 // if it is a component call dispose at the component
532 Reference<XComponent > xComp( x, UNO_QUERY );
533 if( xComp.is() )
534 xComp->dispose();
535 }
536
537 // XUnloadingPreference
538 // This class is used for single factories, component factories and
539 // one-instance factories. Depending on the usage this function has
540 // to return different values.
541 // one-instance factory: sal_False
542 // single factory: sal_True
543 // component factory: sal_True
releaseOnNotification()544 sal_Bool SAL_CALL OFactoryComponentHelper::releaseOnNotification() throw(::com::sun::star::uno::RuntimeException)
545 {
546 if( bOneInstance)
547 return sal_False;
548 return sal_True;
549 }
550
551
552 //-----------------------------------------------------------------------------
553 //-----------------------------------------------------------------------------
554 //-----------------------------------------------------------------------------
555 class ORegistryFactoryHelper : public OFactoryComponentHelper,
556 public OPropertySetHelper
557
558 {
559 public:
ORegistryFactoryHelper(const Reference<XMultiServiceFactory> & rServiceManager,const OUString & rImplementationName_,const Reference<XRegistryKey> & xImplementationKey_,sal_Bool bOneInstance_=sal_False)560 ORegistryFactoryHelper(
561 const Reference<XMultiServiceFactory > & rServiceManager,
562 const OUString & rImplementationName_,
563 const Reference<XRegistryKey > & xImplementationKey_,
564 sal_Bool bOneInstance_ = sal_False ) SAL_THROW( () )
565 : OFactoryComponentHelper(
566 rServiceManager, rImplementationName_, 0, 0, 0, bOneInstance_ ),
567 OPropertySetHelper( OComponentHelper::rBHelper ),
568 xImplementationKey( xImplementationKey_ )
569 {}
570
571 // XInterface
572 virtual Any SAL_CALL queryInterface( Type const & type )
573 throw (RuntimeException);
574 virtual void SAL_CALL acquire() throw ();
575 virtual void SAL_CALL release() throw ();
576 // XTypeProvider
577 virtual Sequence< Type > SAL_CALL getTypes()
578 throw (RuntimeException);
579 // XPropertySet
580 virtual Reference< beans::XPropertySetInfo > SAL_CALL getPropertySetInfo()
581 throw (RuntimeException);
582
583 // OPropertySetHelper
584 virtual IPropertyArrayHelper & SAL_CALL getInfoHelper();
585 virtual sal_Bool SAL_CALL convertFastPropertyValue(
586 Any & rConvertedValue, Any & rOldValue,
587 sal_Int32 nHandle, Any const & rValue )
588 throw (lang::IllegalArgumentException);
589 virtual void SAL_CALL setFastPropertyValue_NoBroadcast(
590 sal_Int32 nHandle, Any const & rValue )
591 throw (Exception);
592 using OPropertySetHelper::getFastPropertyValue;
593 virtual void SAL_CALL getFastPropertyValue(
594 Any & rValue, sal_Int32 nHandle ) const;
595
596 // OSingleFactoryHelper
597 Reference<XInterface > createInstanceEveryTime(
598 Reference< XComponentContext > const & xContext )
599 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
600
601 // XSingleServiceFactory
602 Reference<XInterface > SAL_CALL createInstanceWithArguments(const Sequence<Any>& Arguments)
603 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
604 // XSingleComponentFactory
605 Reference< XInterface > SAL_CALL createInstanceWithArgumentsAndContext(
606 Sequence< Any > const & rArguments,
607 Reference< XComponentContext > const & xContext )
608 throw (Exception, RuntimeException);
609
610 // XServiceInfo
611 Sequence< OUString > SAL_CALL getSupportedServiceNames(void)
612 throw(::com::sun::star::uno::RuntimeException);
613 // XUnloadingPreference
614 sal_Bool SAL_CALL releaseOnNotification()
615 throw( RuntimeException);
616
617
618 private:
619 Reference< XInterface > createModuleFactory()
620 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
621
622 /** The registry key of the implementation section */
623 Reference<XRegistryKey > xImplementationKey;
624 /** The factory created with the loader. */
625 Reference<XSingleComponentFactory > xModuleFactory;
626 Reference<XSingleServiceFactory > xModuleFactoryDepr;
627 Reference< beans::XPropertySetInfo > m_xInfo;
628 ::std::auto_ptr< IPropertyArrayHelper > m_property_array_helper;
629 protected:
630 using OPropertySetHelper::getTypes;
631 };
632
633 // XInterface
634 //______________________________________________________________________________
queryInterface(Type const & type)635 Any SAL_CALL ORegistryFactoryHelper::queryInterface(
636 Type const & type ) throw (RuntimeException)
637 {
638 Any ret( OFactoryComponentHelper::queryInterface( type ) );
639 if (ret.hasValue())
640 return ret;
641 else
642 return OPropertySetHelper::queryInterface( type );
643 }
644
645 //______________________________________________________________________________
acquire()646 void ORegistryFactoryHelper::acquire() throw ()
647 {
648 OFactoryComponentHelper::acquire();
649 }
650
651 //______________________________________________________________________________
release()652 void ORegistryFactoryHelper::release() throw ()
653 {
654 OFactoryComponentHelper::release();
655 }
656
657 // XTypeProvider
658 //______________________________________________________________________________
getTypes()659 Sequence< Type > ORegistryFactoryHelper::getTypes() throw (RuntimeException)
660 {
661 Sequence< Type > types( OFactoryComponentHelper::getTypes() );
662 sal_Int32 pos = types.getLength();
663 types.realloc( pos + 3 );
664 Type * p = types.getArray();
665 p[ pos++ ] = ::getCppuType(
666 reinterpret_cast< Reference< beans::XMultiPropertySet > const * >(0) );
667 p[ pos++ ] = ::getCppuType(
668 reinterpret_cast< Reference< beans::XFastPropertySet > const * >(0) );
669 p[ pos++ ] = ::getCppuType(
670 reinterpret_cast< Reference< beans::XPropertySet > const * >(0) );
671 return types;
672 }
673
674 // XPropertySet
675 //______________________________________________________________________________
676 Reference< beans::XPropertySetInfo >
getPropertySetInfo()677 ORegistryFactoryHelper::getPropertySetInfo() throw (RuntimeException)
678 {
679 ::osl::MutexGuard guard( aMutex );
680 if (! m_xInfo.is())
681 m_xInfo = createPropertySetInfo( getInfoHelper() );
682 return m_xInfo;
683 }
684
685 // OPropertySetHelper
686 //______________________________________________________________________________
getInfoHelper()687 IPropertyArrayHelper & ORegistryFactoryHelper::getInfoHelper()
688 {
689 ::osl::MutexGuard guard( aMutex );
690 if (m_property_array_helper.get() == 0)
691 {
692 beans::Property prop(
693 OUSTR("ImplementationKey") /* name */,
694 0 /* handle */,
695 ::getCppuType( &xImplementationKey ),
696 beans::PropertyAttribute::READONLY |
697 beans::PropertyAttribute::OPTIONAL );
698 m_property_array_helper.reset(
699 new ::cppu::OPropertyArrayHelper( &prop, 1 ) );
700 }
701 return *m_property_array_helper.get();
702 }
703
704 //______________________________________________________________________________
convertFastPropertyValue(Any &,Any &,sal_Int32,Any const &)705 sal_Bool ORegistryFactoryHelper::convertFastPropertyValue(
706 Any &, Any &, sal_Int32, Any const & )
707 throw (lang::IllegalArgumentException)
708 {
709 OSL_ENSURE( 0, "unexpected!" );
710 return false;
711 }
712
713 //______________________________________________________________________________
setFastPropertyValue_NoBroadcast(sal_Int32,Any const &)714 void ORegistryFactoryHelper::setFastPropertyValue_NoBroadcast(
715 sal_Int32, Any const & )
716 throw (Exception)
717 {
718 throw beans::PropertyVetoException(
719 OUSTR("unexpected: only readonly properties!"),
720 static_cast< OWeakObject * >(this) );
721 }
722
723 //______________________________________________________________________________
getFastPropertyValue(Any & rValue,sal_Int32 nHandle) const724 void ORegistryFactoryHelper::getFastPropertyValue(
725 Any & rValue, sal_Int32 nHandle ) const
726 {
727 if (nHandle == 0)
728 {
729 rValue <<= xImplementationKey;
730 }
731 else
732 {
733 rValue.clear();
734 throw beans::UnknownPropertyException(
735 OUSTR("unknown property!"), static_cast< OWeakObject * >(
736 const_cast< ORegistryFactoryHelper * >(this) ) );
737 }
738 }
739
createInstanceEveryTime(Reference<XComponentContext> const & xContext)740 Reference<XInterface > ORegistryFactoryHelper::createInstanceEveryTime(
741 Reference< XComponentContext > const & xContext )
742 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException)
743 {
744 if( !xModuleFactory.is() && !xModuleFactoryDepr.is() )
745 {
746 Reference< XInterface > x( createModuleFactory() );
747 if (x.is())
748 {
749 MutexGuard aGuard( aMutex );
750 if( !xModuleFactory.is() && !xModuleFactoryDepr.is() )
751 {
752 xModuleFactory.set( x, UNO_QUERY );
753 xModuleFactoryDepr.set( x, UNO_QUERY );
754 }
755 }
756 }
757 if( xModuleFactory.is() )
758 {
759 return xModuleFactory->createInstanceWithContext( xContext );
760 }
761 else if( xModuleFactoryDepr.is() )
762 {
763 return xModuleFactoryDepr->createInstance();
764 }
765
766 return Reference<XInterface >();
767 }
768
createInstanceWithArguments(const Sequence<Any> & Arguments)769 Reference<XInterface > SAL_CALL ORegistryFactoryHelper::createInstanceWithArguments(
770 const Sequence<Any>& Arguments )
771 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException)
772 {
773 if( !xModuleFactory.is() && !xModuleFactoryDepr.is() )
774 {
775 Reference< XInterface > x( createModuleFactory() );
776 if (x.is())
777 {
778 MutexGuard aGuard( aMutex );
779 if( !xModuleFactory.is() && !xModuleFactoryDepr.is() )
780 {
781 xModuleFactory.set( x, UNO_QUERY );
782 xModuleFactoryDepr.set( x, UNO_QUERY );
783 }
784 }
785 }
786 if( xModuleFactoryDepr.is() )
787 {
788 return xModuleFactoryDepr->createInstanceWithArguments( Arguments );
789 }
790 else if( xModuleFactory.is() )
791 {
792 #if OSL_DEBUG_LEVEL > 1
793 OSL_TRACE( "### no context ORegistryFactoryHelper::createInstanceWithArgumentsAndContext()!\n" );
794 #endif
795 return xModuleFactory->createInstanceWithArgumentsAndContext( Arguments, Reference< XComponentContext >() );
796 }
797
798 return Reference<XInterface >();
799 }
800
createInstanceWithArgumentsAndContext(Sequence<Any> const & rArguments,Reference<XComponentContext> const & xContext)801 Reference< XInterface > ORegistryFactoryHelper::createInstanceWithArgumentsAndContext(
802 Sequence< Any > const & rArguments,
803 Reference< XComponentContext > const & xContext )
804 throw (Exception, RuntimeException)
805 {
806 if( !xModuleFactory.is() && !xModuleFactoryDepr.is() )
807 {
808 Reference< XInterface > x( createModuleFactory() );
809 if (x.is())
810 {
811 MutexGuard aGuard( aMutex );
812 if( !xModuleFactory.is() && !xModuleFactoryDepr.is() )
813 {
814 xModuleFactory.set( x, UNO_QUERY );
815 xModuleFactoryDepr.set( x, UNO_QUERY );
816 }
817 }
818 }
819 if( xModuleFactory.is() )
820 {
821 return xModuleFactory->createInstanceWithArgumentsAndContext( rArguments, xContext );
822 }
823 else if( xModuleFactoryDepr.is() )
824 {
825 #if OSL_DEBUG_LEVEL > 1
826 if (xContext.is())
827 {
828 OSL_TRACE( "### ignoring context calling ORegistryFactoryHelper::createInstanceWithArgumentsAndContext()!\n" );
829 }
830 #endif
831 return xModuleFactoryDepr->createInstanceWithArguments( rArguments );
832 }
833
834 return Reference<XInterface >();
835 }
836
837
838 // OSingleFactoryHelper
createModuleFactory()839 Reference< XInterface > ORegistryFactoryHelper::createModuleFactory()
840 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException)
841 {
842 OUString aActivatorUrl;
843 OUString aActivatorName;
844 OUString aLocation;
845
846 Reference<XRegistryKey > xActivatorKey = xImplementationKey->openKey(
847 OUString( RTL_CONSTASCII_USTRINGPARAM("/UNO/ACTIVATOR") ) );
848 if( xActivatorKey.is() && xActivatorKey->getValueType() == RegistryValueType_ASCII )
849 {
850 aActivatorUrl = xActivatorKey->getAsciiValue();
851
852 OUString tmpActivator(aActivatorUrl.getStr());
853 sal_Int32 nIndex = 0;
854 aActivatorName = tmpActivator.getToken(0, ':', nIndex );
855
856 Reference<XRegistryKey > xLocationKey = xImplementationKey->openKey(
857 OUString( RTL_CONSTASCII_USTRINGPARAM("/UNO/LOCATION") ) );
858 if( xLocationKey.is() && xLocationKey->getValueType() == RegistryValueType_ASCII )
859 aLocation = xLocationKey->getAsciiValue();
860 }
861 else
862 {
863 // old style"url"
864 // the location of the program code of the implementation
865 Reference<XRegistryKey > xLocationKey = xImplementationKey->openKey(
866 OUString( RTL_CONSTASCII_USTRINGPARAM("/UNO/URL") ) );
867 // is the the key of the right type ?
868 if( xLocationKey.is() && xLocationKey->getValueType() == RegistryValueType_ASCII )
869 {
870 // one implementation found -> try to activate
871 aLocation = xLocationKey->getAsciiValue();
872
873 // search protocol delemitter
874 sal_Int32 nPos = aLocation.indexOf(
875 OUString( RTL_CONSTASCII_USTRINGPARAM("://") ) );
876 if( nPos != -1 )
877 {
878 aActivatorName = aLocation.copy( 0, nPos );
879 if( aActivatorName.compareToAscii( "java" ) == 0 )
880 aActivatorName = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.loader.Java") );
881 else if( aActivatorName.compareToAscii( "module" ) == 0 )
882 aActivatorName = OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.loader.SharedLibrary") );
883 aLocation = aLocation.copy( nPos + 3 );
884 }
885 }
886 }
887
888 Reference< XInterface > xFactory;
889 if( aActivatorName.getLength() != 0 )
890 {
891 Reference<XInterface > x = xSMgr->createInstance( aActivatorName );
892 Reference<XImplementationLoader > xLoader( x, UNO_QUERY );
893 Reference<XInterface > xMF;
894 if (xLoader.is())
895 {
896 xFactory = xLoader->activate( aImplementationName, aActivatorUrl, aLocation, xImplementationKey );
897 }
898 }
899 return xFactory;
900 }
901
902 // XServiceInfo
getSupportedServiceNames(void)903 Sequence< OUString > ORegistryFactoryHelper::getSupportedServiceNames(void)
904 throw(::com::sun::star::uno::RuntimeException)
905 {
906 MutexGuard aGuard( aMutex );
907 if( aServiceNames.getLength() == 0 )
908 {
909 // not yet loaded
910 try
911 {
912 Reference<XRegistryKey > xKey = xImplementationKey->openKey(
913 OUString( RTL_CONSTASCII_USTRINGPARAM("UNO/SERVICES") ) );
914
915 if (xKey.is())
916 {
917 // length of prefix. +1 for the '/' at the end
918 sal_Int32 nPrefixLen = xKey->getKeyName().getLength() + 1;
919
920 // Full qualified names like "IMPLEMENTATIONS/TEST/UNO/SERVICES/com.sun.star..."
921 Sequence<OUString> seqKeys = xKey->getKeyNames();
922 OUString* pKeys = seqKeys.getArray();
923 for( sal_Int32 i = 0; i < seqKeys.getLength(); i++ )
924 pKeys[i] = pKeys[i].copy(nPrefixLen);
925
926 aServiceNames = seqKeys;
927 }
928 }
929 catch (InvalidRegistryException &)
930 {
931 }
932 }
933 return aServiceNames;
934 }
935
releaseOnNotification()936 sal_Bool SAL_CALL ORegistryFactoryHelper::releaseOnNotification() throw(::com::sun::star::uno::RuntimeException)
937 {
938 sal_Bool retVal= sal_True;
939 if( isOneInstance() && isInstance())
940 {
941 retVal= sal_False;
942 }
943 else if( ! isOneInstance())
944 {
945 // try to delegate
946 if( xModuleFactory.is())
947 {
948 Reference<XUnloadingPreference> xunloading( xModuleFactory, UNO_QUERY);
949 if( xunloading.is())
950 retVal= xunloading->releaseOnNotification();
951 }
952 else if( xModuleFactoryDepr.is())
953 {
954 Reference<XUnloadingPreference> xunloading( xModuleFactoryDepr, UNO_QUERY);
955 if( xunloading.is())
956 retVal= xunloading->releaseOnNotification();
957 }
958 }
959 return retVal;
960 }
961
962 //-----------------------------------------------------------------------------
963 //-----------------------------------------------------------------------------
964 //-----------------------------------------------------------------------------
965
966 class OFactoryProxyHelper : public WeakImplHelper3< XServiceInfo, XSingleServiceFactory,
967 XUnloadingPreference >
968 {
969 Reference<XSingleServiceFactory > xFactory;
970
971 public:
972
OFactoryProxyHelper(const Reference<XMultiServiceFactory> &,const Reference<XSingleServiceFactory> & rFactory)973 OFactoryProxyHelper(
974 const Reference<XMultiServiceFactory > & /*rServiceManager*/,
975 const Reference<XSingleServiceFactory > & rFactory )
976 SAL_THROW( () )
977 : xFactory( rFactory )
978 {}
979
980 // XSingleServiceFactory
981 Reference<XInterface > SAL_CALL createInstance()
982 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
983 Reference<XInterface > SAL_CALL createInstanceWithArguments(const Sequence<Any>& Arguments)
984 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
985
986 // XServiceInfo
987 OUString SAL_CALL getImplementationName()
988 throw(::com::sun::star::uno::RuntimeException);
989 sal_Bool SAL_CALL supportsService(const OUString& ServiceName)
990 throw(::com::sun::star::uno::RuntimeException);
991 Sequence< OUString > SAL_CALL getSupportedServiceNames(void)
992 throw(::com::sun::star::uno::RuntimeException);
993 //XUnloadingPreference
994 sal_Bool SAL_CALL releaseOnNotification()
995 throw(::com::sun::star::uno::RuntimeException);
996
997 };
998
999 // XSingleServiceFactory
createInstance()1000 Reference<XInterface > OFactoryProxyHelper::createInstance()
1001 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException)
1002 {
1003 return xFactory->createInstance();
1004 }
1005
1006 // XSingleServiceFactory
createInstanceWithArguments(const Sequence<Any> & Arguments)1007 Reference<XInterface > OFactoryProxyHelper::createInstanceWithArguments
1008 (
1009 const Sequence<Any>& Arguments
1010 )
1011 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException)
1012 {
1013 return xFactory->createInstanceWithArguments( Arguments );
1014 }
1015
1016 // XServiceInfo
getImplementationName()1017 OUString OFactoryProxyHelper::getImplementationName()
1018 throw(::com::sun::star::uno::RuntimeException)
1019 {
1020 Reference<XServiceInfo > xInfo( xFactory, UNO_QUERY );
1021 if( xInfo.is() )
1022 return xInfo->getImplementationName();
1023 return OUString();
1024 }
1025
1026 // XServiceInfo
supportsService(const OUString & ServiceName)1027 sal_Bool OFactoryProxyHelper::supportsService(const OUString& ServiceName)
1028 throw(::com::sun::star::uno::RuntimeException)
1029 {
1030 Reference<XServiceInfo > xInfo( xFactory, UNO_QUERY );
1031 if( xInfo.is() )
1032 return xInfo->supportsService( ServiceName );
1033 return sal_False;
1034 }
1035
1036 // XServiceInfo
getSupportedServiceNames(void)1037 Sequence< OUString > OFactoryProxyHelper::getSupportedServiceNames(void)
1038 throw(::com::sun::star::uno::RuntimeException)
1039 {
1040 Reference<XServiceInfo > xInfo( xFactory, UNO_QUERY );
1041 if( xInfo.is() )
1042 return xInfo->getSupportedServiceNames();
1043 return Sequence< OUString >();
1044 }
1045
releaseOnNotification()1046 sal_Bool SAL_CALL OFactoryProxyHelper::releaseOnNotification() throw(::com::sun::star::uno::RuntimeException)
1047 {
1048
1049 Reference<XUnloadingPreference> pref( xFactory, UNO_QUERY);
1050 if( pref.is())
1051 return pref->releaseOnNotification();
1052 return sal_True;
1053 }
1054
1055
1056 //-----------------------------------------------------------------------------
1057 //-----------------------------------------------------------------------------
1058 //-----------------------------------------------------------------------------
1059 // global function
createSingleFactory(const Reference<XMultiServiceFactory> & rServiceManager,const OUString & rImplementationName,ComponentInstantiation pCreateFunction,const Sequence<OUString> & rServiceNames,rtl_ModuleCount * pModCount)1060 Reference<XSingleServiceFactory > SAL_CALL createSingleFactory(
1061 const Reference<XMultiServiceFactory > & rServiceManager,
1062 const OUString & rImplementationName,
1063 ComponentInstantiation pCreateFunction,
1064 const Sequence< OUString > & rServiceNames,
1065 rtl_ModuleCount *pModCount )
1066 SAL_THROW( () )
1067 {
1068 return new OFactoryComponentHelper(
1069 rServiceManager, rImplementationName, pCreateFunction, 0, &rServiceNames, pModCount, sal_False );
1070 }
1071
1072 // global function
createFactoryProxy(const Reference<XMultiServiceFactory> & rServiceManager,const Reference<XSingleServiceFactory> & rFactory)1073 Reference<XSingleServiceFactory > SAL_CALL createFactoryProxy(
1074 const Reference<XMultiServiceFactory > & rServiceManager,
1075 const Reference<XSingleServiceFactory > & rFactory )
1076 SAL_THROW( () )
1077 {
1078 return new OFactoryProxyHelper(
1079 rServiceManager, rFactory );
1080 }
1081
1082 // global function
createOneInstanceFactory(const Reference<XMultiServiceFactory> & rServiceManager,const OUString & rImplementationName,ComponentInstantiation pCreateFunction,const Sequence<OUString> & rServiceNames,rtl_ModuleCount * pModCount)1083 Reference<XSingleServiceFactory > SAL_CALL createOneInstanceFactory(
1084 const Reference<XMultiServiceFactory > & rServiceManager,
1085 const OUString & rImplementationName,
1086 ComponentInstantiation pCreateFunction,
1087 const Sequence< OUString > & rServiceNames,
1088 rtl_ModuleCount *pModCount )
1089 SAL_THROW( () )
1090 {
1091 return new OFactoryComponentHelper(
1092 rServiceManager, rImplementationName, pCreateFunction, 0, &rServiceNames, pModCount, sal_True );
1093 // return new OFactoryUnloadableComponentHelper(
1094 // rServiceManager, rImplementationName, pCreateFunction, 0, &rServiceNames, pModCount, sal_True );
1095 }
1096
1097 // global function
createSingleRegistryFactory(const Reference<XMultiServiceFactory> & rServiceManager,const OUString & rImplementationName,const Reference<XRegistryKey> & rImplementationKey)1098 Reference<XSingleServiceFactory > SAL_CALL createSingleRegistryFactory(
1099 const Reference<XMultiServiceFactory > & rServiceManager,
1100 const OUString & rImplementationName,
1101 const Reference<XRegistryKey > & rImplementationKey )
1102 SAL_THROW( () )
1103 {
1104 return new ORegistryFactoryHelper(
1105 rServiceManager, rImplementationName, rImplementationKey, sal_False );
1106 }
1107
1108 // global function
createOneInstanceRegistryFactory(const Reference<XMultiServiceFactory> & rServiceManager,const OUString & rImplementationName,const Reference<XRegistryKey> & rImplementationKey)1109 Reference<XSingleServiceFactory > SAL_CALL createOneInstanceRegistryFactory(
1110 const Reference<XMultiServiceFactory > & rServiceManager,
1111 const OUString & rImplementationName,
1112 const Reference<XRegistryKey > & rImplementationKey )
1113 SAL_THROW( () )
1114 {
1115 return new ORegistryFactoryHelper(
1116 rServiceManager, rImplementationName, rImplementationKey, sal_True );
1117 }
1118
1119 //##################################################################################################
createSingleComponentFactory(ComponentFactoryFunc fptr,OUString const & rImplementationName,Sequence<OUString> const & rServiceNames,rtl_ModuleCount * pModCount)1120 Reference< lang::XSingleComponentFactory > SAL_CALL createSingleComponentFactory(
1121 ComponentFactoryFunc fptr,
1122 OUString const & rImplementationName,
1123 Sequence< OUString > const & rServiceNames,
1124 rtl_ModuleCount * pModCount)
1125 SAL_THROW( () )
1126 {
1127 return new OFactoryComponentHelper(
1128 Reference< XMultiServiceFactory >(), rImplementationName, 0, fptr, &rServiceNames, pModCount, sal_False );
1129 }
1130
createOneInstanceComponentFactory(ComponentFactoryFunc fptr,OUString const & rImplementationName,Sequence<OUString> const & rServiceNames,rtl_ModuleCount * pModCount)1131 Reference< lang::XSingleComponentFactory > SAL_CALL createOneInstanceComponentFactory(
1132 ComponentFactoryFunc fptr,
1133 OUString const & rImplementationName,
1134 Sequence< OUString > const & rServiceNames,
1135 rtl_ModuleCount * pModCount)
1136 SAL_THROW( () )
1137 {
1138 return new OFactoryComponentHelper(
1139 Reference< XMultiServiceFactory >(), rImplementationName, 0, fptr, &rServiceNames, pModCount, sal_True );
1140 }
1141
1142 }
1143
1144
1145