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 // MARKER(update_precomp.py): autogen include statement, do not remove 24 #include "precompiled_extensions.hxx" 25 26 #include "sal/config.h" 27 #include "cppuhelper/factory.hxx" 28 #include "cppuhelper/implementationentry.hxx" 29 #include "cppuhelper/implbase3.hxx" 30 #include "com/sun/star/lang/XServiceInfo.hpp" 31 #include "com/sun/star/inspection/XStringRepresentation.hpp" 32 #include "com/sun/star/lang/XInitialization.hpp" 33 #include "com/sun/star/script/XTypeConverter.hpp" 34 #include <com/sun/star/container/XHierarchicalNameAccess.hpp> 35 #include <com/sun/star/reflection/XConstantsTypeDescription.hpp> 36 #include <com/sun/star/beans/XIntrospection.hpp> 37 #include <com/sun/star/util/DateTime.hpp> 38 #include <com/sun/star/util/Date.hpp> 39 #include <com/sun/star/util/Time.hpp> 40 #include <comphelper/sequence.hxx> 41 #include <connectivity/dbconversion.hxx> 42 #ifndef _EXTENSIONS_PROPCTRLR_MODULEPRC_HXX_ 43 #include "modulepcr.hxx" 44 #endif 45 #ifndef _EXTENSIONS_FORMCTRLR_PROPRESID_HRC_ 46 #include "formresid.hrc" 47 #endif 48 #include <tools/debug.hxx> 49 #include <tools/string.hxx> 50 #include <tools/StringListResource.hxx> 51 #include <comphelper/types.hxx> 52 #ifndef _EXTENSIONS_PROPCTRLR_MODULEPCR_HXX_ 53 #include "modulepcr.hxx" 54 #endif 55 56 #include <functional> 57 #include <algorithm> 58 59 // component helper namespace 60 namespace comp_StringRepresentation { 61 62 using namespace ::com::sun::star; 63 64 // component and service helper functions: 65 ::rtl::OUString SAL_CALL _getImplementationName(); 66 uno::Sequence< ::rtl::OUString > SAL_CALL _getSupportedServiceNames(); 67 uno::Reference< uno::XInterface > SAL_CALL _create( uno::Reference< uno::XComponentContext > const & context ); 68 69 } // closing component helper namespace 70 71 72 namespace pcr{ 73 74 using namespace ::com::sun::star; 75 using namespace ::com::sun::star::uno; 76 77 class StringRepresentation: 78 public ::cppu::WeakImplHelper3< 79 lang::XServiceInfo, 80 inspection::XStringRepresentation, 81 lang::XInitialization> 82 { 83 public: 84 explicit StringRepresentation(uno::Reference< uno::XComponentContext > const & context); 85 86 // lang::XServiceInfo: 87 virtual ::rtl::OUString SAL_CALL getImplementationName() throw (uno::RuntimeException); 88 virtual ::sal_Bool SAL_CALL supportsService(const ::rtl::OUString & ServiceName) throw (uno::RuntimeException); 89 virtual uno::Sequence< ::rtl::OUString > SAL_CALL getSupportedServiceNames() throw (uno::RuntimeException); 90 91 // inspection::XStringRepresentation: 92 virtual ::rtl::OUString SAL_CALL convertToControlValue(const uno::Any & PropertyValue) throw (uno::RuntimeException, uno::Exception); 93 virtual uno::Any SAL_CALL convertToPropertyValue(const ::rtl::OUString & ControlValue, const uno::Type & ControlValueType) throw (uno::RuntimeException, uno::Exception); 94 95 // lang::XInitialization: 96 virtual void SAL_CALL initialize(const uno::Sequence< uno::Any > & aArguments) throw (uno::RuntimeException, uno::Exception); 97 98 private: 99 StringRepresentation(StringRepresentation &); // not defined 100 void operator =(StringRepresentation &); // not defined 101 102 virtual ~StringRepresentation() {} 103 104 /** converts a generic value into a string representation 105 106 If you want to convert values whose string representation does not depend 107 on a concrete property, use this version 108 109 @return <TRUE/> 110 if and only if the value could be converted 111 */ 112 bool convertGenericValueToString( 113 const uno::Any& _rValue, 114 ::rtl::OUString& _rStringRep 115 ); 116 117 /** converts string representation into generic value 118 119 If you want to convert values whose string representation does not depend 120 on a concrete property, use this version 121 122 @return <TRUE/> 123 if and only if the value could be converted 124 */ 125 bool convertStringToGenericValue( 126 const ::rtl::OUString& _rStringRep, 127 uno::Any& _rValue, 128 const uno::Type& _rTargetType 129 ); 130 131 /** uses the simple convert method from the type converter 132 * 133 * \param _rValue the value to be converted 134 * \return the converted string. 135 */ 136 ::rtl::OUString convertSimpleToString( const uno::Any& _rValue ); 137 138 /** converts a string into his constant value if it exists, otherwise the type converter is used. 139 * \param _rValue the value to be converted 140 * \param _ePropertyType teh type of the propery to be converted into 141 * \return the converted value 142 */ 143 uno::Any convertStringToSimple( const ::rtl::OUString& _rValue,const uno::TypeClass& _ePropertyType ); 144 145 uno::Reference< uno::XComponentContext > m_xContext; 146 uno::Reference< script::XTypeConverter > m_xTypeConverter; 147 uno::Reference< reflection::XConstantsTypeDescription > m_xTypeDescription; 148 uno::Sequence< ::rtl::OUString > m_aValues; 149 uno::Sequence< uno::Reference< reflection::XConstantTypeDescription> > m_aConstants; 150 151 }; 152 153 StringRepresentation::StringRepresentation(uno::Reference< uno::XComponentContext > const & context) : 154 m_xContext(context) 155 {} 156 157 // com.sun.star.uno.XServiceInfo: 158 ::rtl::OUString SAL_CALL StringRepresentation::getImplementationName() throw (uno::RuntimeException) 159 { 160 return comp_StringRepresentation::_getImplementationName(); 161 } 162 163 ::sal_Bool SAL_CALL StringRepresentation::supportsService(::rtl::OUString const & serviceName) throw (uno::RuntimeException) 164 { 165 return ::comphelper::existsValue(serviceName,comp_StringRepresentation::_getSupportedServiceNames()); 166 } 167 168 uno::Sequence< ::rtl::OUString > SAL_CALL StringRepresentation::getSupportedServiceNames() throw (uno::RuntimeException) 169 { 170 return comp_StringRepresentation::_getSupportedServiceNames(); 171 } 172 173 // inspection::XStringRepresentation: 174 ::rtl::OUString SAL_CALL StringRepresentation::convertToControlValue(const uno::Any & PropertyValue) throw (uno::RuntimeException, uno::Exception) 175 { 176 ::rtl::OUString sReturn; 177 if ( !convertGenericValueToString( PropertyValue, sReturn ) ) 178 { 179 sReturn = convertSimpleToString( PropertyValue ); 180 #ifdef DBG_UTIL 181 if ( !sReturn.getLength() && PropertyValue.hasValue() ) 182 { 183 ::rtl::OString sMessage( "StringRepresentation::convertPropertyValueToStringRepresentation: cannot convert values of type '" ); 184 sMessage += ::rtl::OString( PropertyValue.getValueType().getTypeName().getStr(), PropertyValue.getValueType().getTypeName().getLength(), RTL_TEXTENCODING_ASCII_US ); 185 sMessage += ::rtl::OString( "'!" ); 186 DBG_ERROR( sMessage.getStr() ); 187 } 188 #endif 189 } 190 191 return sReturn; 192 } 193 194 uno::Any SAL_CALL StringRepresentation::convertToPropertyValue(const ::rtl::OUString & ControlValue, const uno::Type & ControlValueType) throw (uno::RuntimeException, uno::Exception) 195 { 196 uno::Any aReturn; 197 198 uno::TypeClass ePropertyType = ControlValueType.getTypeClass(); 199 switch ( ePropertyType ) 200 { 201 case uno::TypeClass_FLOAT: 202 case uno::TypeClass_DOUBLE: 203 case uno::TypeClass_BYTE: 204 case uno::TypeClass_SHORT: 205 case uno::TypeClass_LONG: 206 case uno::TypeClass_HYPER: 207 case uno::TypeClass_UNSIGNED_SHORT: 208 case uno::TypeClass_UNSIGNED_LONG: 209 case uno::TypeClass_UNSIGNED_HYPER: 210 try 211 { 212 aReturn = convertStringToSimple(ControlValue, ePropertyType); 213 } 214 catch( const script::CannotConvertException& ) { } 215 catch( const lang::IllegalArgumentException& ) { } 216 break; 217 218 default: 219 #if OSL_DEBUG_LEVEL > 0 220 bool bCanConvert = 221 #endif 222 convertStringToGenericValue( ControlValue, aReturn, ControlValueType ); 223 224 #if OSL_DEBUG_LEVEL > 0 225 // could not convert ... 226 if ( !bCanConvert && ControlValue.getLength() ) 227 { 228 ::rtl::OString sMessage( "StringRepresentation::convertStringRepresentationToPropertyValue: cannot convert into values of type '" ); 229 sMessage += ::rtl::OString( ControlValueType.getTypeName().getStr(), ControlValueType.getTypeName().getLength(), RTL_TEXTENCODING_ASCII_US ); 230 sMessage += ::rtl::OString( "'!" ); 231 DBG_ERROR( sMessage.getStr() ); 232 } 233 #endif 234 } 235 236 return aReturn; 237 } 238 239 // lang::XInitialization: 240 void SAL_CALL StringRepresentation::initialize(const uno::Sequence< uno::Any > & aArguments) throw (uno::RuntimeException, uno::Exception) 241 { 242 sal_Int32 nLength = aArguments.getLength(); 243 if ( nLength ) 244 { 245 const uno::Any* pIter = aArguments.getConstArray(); 246 m_xTypeConverter.set(*pIter++,uno::UNO_QUERY); 247 if ( nLength == 3 ) 248 { 249 ::rtl::OUString sConstantName; 250 *pIter++ >>= sConstantName; 251 *pIter >>= m_aValues; 252 253 if ( m_xContext.is() ) 254 { 255 uno::Reference< container::XHierarchicalNameAccess > xTypeDescProv( 256 m_xContext->getValueByName( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/singletons/com.sun.star.reflection.theTypeDescriptionManager" ) ) ), 257 uno::UNO_QUERY_THROW ); 258 259 m_xTypeDescription.set( xTypeDescProv->getByHierarchicalName( sConstantName ), uno::UNO_QUERY_THROW ); 260 m_aConstants = m_xTypeDescription->getConstants(); 261 } 262 } 263 } 264 } 265 //------------------------------------------------------------------------ 266 ::rtl::OUString StringRepresentation::convertSimpleToString( const uno::Any& _rValue ) 267 { 268 ::rtl::OUString sReturn; 269 if ( m_xTypeConverter.is() && _rValue.hasValue() ) 270 { 271 try 272 { 273 if ( m_aConstants.getLength() ) 274 { 275 sal_Int16 nConstantValue = 0; 276 if ( _rValue >>= nConstantValue ) 277 { 278 const uno::Reference< reflection::XConstantTypeDescription>* pIter = m_aConstants.getConstArray(); 279 const uno::Reference< reflection::XConstantTypeDescription>* pEnd = pIter + m_aConstants.getLength(); 280 for(sal_Int32 i = 0;pIter != pEnd;++pIter,++i) 281 { 282 if ( (*pIter)->getConstantValue() == _rValue ) 283 { 284 OSL_ENSURE(i < m_aValues.getLength() ,"StringRepresentation::convertSimpleToString: Index is not in range of m_aValues"); 285 sReturn = m_aValues[i]; 286 break; 287 } 288 } 289 } 290 } 291 292 if ( !sReturn.getLength() ) 293 m_xTypeConverter->convertToSimpleType( _rValue, uno::TypeClass_STRING ) >>= sReturn; 294 } 295 catch( script::CannotConvertException& ) { } 296 catch( lang::IllegalArgumentException& ) { } 297 } 298 return sReturn; 299 } 300 301 //-------------------------------------------------------------------- 302 namespace 303 { 304 struct ConvertIntegerFromAndToString 305 { 306 ::rtl::OUString operator()( sal_Int32 _rIntValue ) const 307 { 308 return ::rtl::OUString::valueOf( (sal_Int32)_rIntValue ); 309 } 310 sal_Int32 operator()( const ::rtl::OUString& _rStringValue ) const 311 { 312 return _rStringValue.toInt32(); 313 } 314 }; 315 316 struct StringIdentity 317 { 318 ::rtl::OUString operator()( const ::rtl::OUString& _rValue ) const 319 { 320 return _rValue; 321 } 322 }; 323 324 template < class ElementType, class Transformer > 325 ::rtl::OUString composeSequenceElements( const Sequence< ElementType >& _rElements, const Transformer& _rTransformer ) 326 { 327 String sCompose; 328 329 // loop through the elements and concatenate the string representations of the integers 330 // (separated by a line break) 331 const ElementType* pElements = _rElements.getConstArray(); 332 const ElementType* pElementsEnd = pElements + _rElements.getLength(); 333 for ( ; pElements != pElementsEnd; ++pElements ) 334 { 335 sCompose += String( _rTransformer( *pElements ) ); 336 if ( pElements != pElementsEnd ) 337 sCompose += '\n'; 338 } 339 340 return sCompose; 341 } 342 343 template < class ElementType, class Transformer > 344 void splitComposedStringToSequence( const ::rtl::OUString& _rComposed, Sequence< ElementType >& _out_SplitUp, const Transformer& _rTransformer ) 345 { 346 _out_SplitUp.realloc( 0 ); 347 if ( !_rComposed.getLength() ) 348 return; 349 sal_Int32 tokenPos = 0; 350 do 351 { 352 _out_SplitUp.realloc( _out_SplitUp.getLength() + 1 ); 353 _out_SplitUp[ _out_SplitUp.getLength() - 1 ] = (ElementType)_rTransformer( _rComposed.getToken( 0, '\n', tokenPos ) ); 354 } 355 while ( tokenPos != -1 ); 356 } 357 } 358 359 //-------------------------------------------------------------------- 360 bool StringRepresentation::convertGenericValueToString( const uno::Any& _rValue, ::rtl::OUString& _rStringRep ) 361 { 362 bool bCanConvert = true; 363 364 switch ( _rValue.getValueTypeClass() ) 365 { 366 case uno::TypeClass_STRING: 367 _rValue >>= _rStringRep; 368 break; 369 370 case uno::TypeClass_BOOLEAN: 371 { 372 ::std::vector< ::rtl::OUString > aListEntries; 373 tools::StringListResource aRes(PcrRes(RID_RSC_ENUM_YESNO),aListEntries); 374 sal_Bool bValue = sal_False; 375 _rValue >>= bValue; 376 _rStringRep = bValue ? aListEntries[1] : aListEntries[0]; 377 } 378 break; 379 380 // some sequence types 381 case uno::TypeClass_SEQUENCE: 382 { 383 Sequence< ::rtl::OUString > aStringValues; 384 Sequence< sal_Int8 > aInt8Values; 385 Sequence< sal_uInt16 > aUInt16Values; 386 Sequence< sal_Int16 > aInt16Values; 387 Sequence< sal_uInt32 > aUInt32Values; 388 Sequence< sal_Int32 > aInt32Values; 389 390 // string sequences 391 if ( _rValue >>= aStringValues ) 392 { 393 _rStringRep = composeSequenceElements( aStringValues, StringIdentity() ); 394 } 395 // byte sequences 396 else if ( _rValue >>= aInt8Values ) 397 { 398 _rStringRep = composeSequenceElements( aInt8Values, ConvertIntegerFromAndToString() ); 399 } 400 // uInt16 sequences 401 else if ( _rValue >>= aUInt16Values ) 402 { 403 _rStringRep = composeSequenceElements( aUInt16Values, ConvertIntegerFromAndToString() ); 404 } 405 // Int16 sequences 406 else if ( _rValue >>= aInt16Values ) 407 { 408 _rStringRep = composeSequenceElements( aInt16Values, ConvertIntegerFromAndToString() ); 409 } 410 // uInt32 sequences 411 else if ( _rValue >>= aUInt32Values ) 412 { 413 _rStringRep = composeSequenceElements( aUInt32Values, ConvertIntegerFromAndToString() ); 414 } 415 // Int32 sequences 416 else if ( _rValue >>= aInt32Values ) 417 { 418 _rStringRep = composeSequenceElements( aInt32Values, ConvertIntegerFromAndToString() ); 419 } 420 else 421 bCanConvert = false; 422 } 423 break; 424 case uno::TypeClass_CONSTANT: 425 { 426 int i = 0; 427 ++i; 428 } 429 break; 430 431 // some structs 432 case uno::TypeClass_STRUCT: 433 OSL_ENSURE( false, "StringRepresentation::convertGenericValueToString(STRUCT): this is dead code - isn't it?" ); 434 if ( _rValue.getValueType().equals( ::getCppuType( static_cast< util::Date* >( NULL ) ) ) ) 435 { 436 // weird enough, the string representation of dates, as used 437 // by the control displaying dates, and thus as passed through the layers, 438 // is YYYYMMDD. 439 util::Date aUnoDate; 440 _rValue >>= aUnoDate; 441 _rStringRep = ::dbtools::DBTypeConversion::toDateString(aUnoDate); 442 } 443 else if ( _rValue.getValueType().equals( ::getCppuType( static_cast< util::Time* >( NULL ) ) ) ) 444 { 445 // similar for time (HHMMSSHH) 446 util::Time aUnoTime; 447 _rValue >>= aUnoTime; 448 _rStringRep = ::dbtools::DBTypeConversion::toTimeString(aUnoTime); 449 } 450 else if ( _rValue.getValueType().equals( ::getCppuType( static_cast< util::DateTime* >( NULL ) ) ) ) 451 { 452 util::DateTime aUnoDateTime; 453 _rValue >>= aUnoDateTime; 454 _rStringRep = ::dbtools::DBTypeConversion::toDateTimeString(aUnoDateTime); 455 } 456 else 457 bCanConvert = false; 458 break; 459 460 default: 461 bCanConvert = false; 462 break; 463 } 464 465 return bCanConvert; 466 } 467 //------------------------------------------------------------------------ 468 uno::Any StringRepresentation::convertStringToSimple( const ::rtl::OUString& _rValue,const uno::TypeClass& _ePropertyType ) 469 { 470 uno::Any aReturn; 471 if ( m_xTypeConverter.is() && _rValue.getLength() ) 472 { 473 try 474 { 475 if ( m_aConstants.getLength() && m_aValues.getLength() ) 476 { 477 const ::rtl::OUString* pIter = m_aValues.getConstArray(); 478 const ::rtl::OUString* pEnd = pIter + m_aValues.getLength(); 479 for(sal_Int32 i = 0;pIter != pEnd;++pIter,++i) 480 { 481 if ( *pIter == _rValue ) 482 { 483 OSL_ENSURE(i < m_aConstants.getLength() ,"StringRepresentation::convertSimpleToString: Index is not in range of m_aValues"); 484 aReturn <<= m_aConstants[i]->getConstantValue(); 485 break; 486 } 487 } 488 } 489 490 if ( !aReturn.hasValue() ) 491 aReturn = m_xTypeConverter->convertToSimpleType( makeAny( _rValue ), _ePropertyType ); 492 } 493 catch( script::CannotConvertException& ) { } 494 catch( lang::IllegalArgumentException& ) { } 495 } 496 return aReturn; 497 } 498 //-------------------------------------------------------------------- 499 bool StringRepresentation::convertStringToGenericValue( const ::rtl::OUString& _rStringRep, uno::Any& _rValue, const uno::Type& _rTargetType ) 500 { 501 bool bCanConvert = true; 502 503 switch ( _rTargetType.getTypeClass() ) 504 { 505 case uno::TypeClass_STRING: 506 _rValue <<= _rStringRep; 507 break; 508 509 case uno::TypeClass_BOOLEAN: 510 { 511 ::std::vector< ::rtl::OUString > aListEntries; 512 tools::StringListResource aRes(PcrRes(RID_RSC_ENUM_YESNO),aListEntries); 513 if ( aListEntries[0] == _rStringRep ) 514 _rValue <<= (sal_Bool)sal_False; 515 else 516 _rValue <<= (sal_Bool)sal_True; 517 } 518 break; 519 520 case uno::TypeClass_SEQUENCE: 521 { 522 uno::Type aElementType = ::comphelper::getSequenceElementType( _rTargetType ); 523 524 String aStr( _rStringRep ); 525 switch ( aElementType.getTypeClass() ) 526 { 527 case uno::TypeClass_STRING: 528 { 529 Sequence< ::rtl::OUString > aElements; 530 splitComposedStringToSequence( aStr, aElements, StringIdentity() ); 531 _rValue <<= aElements; 532 } 533 break; 534 case uno::TypeClass_SHORT: 535 { 536 Sequence< sal_Int16 > aElements; 537 splitComposedStringToSequence( aStr, aElements, ConvertIntegerFromAndToString() ); 538 _rValue <<= aElements; 539 } 540 break; 541 case uno::TypeClass_UNSIGNED_SHORT: 542 { 543 Sequence< sal_uInt16 > aElements; 544 splitComposedStringToSequence( aStr, aElements, ConvertIntegerFromAndToString() ); 545 _rValue <<= aElements; 546 } 547 break; 548 case uno::TypeClass_LONG: 549 { 550 Sequence< sal_Int32 > aElements; 551 splitComposedStringToSequence( aStr, aElements, ConvertIntegerFromAndToString() ); 552 _rValue <<= aElements; 553 } 554 break; 555 case uno::TypeClass_UNSIGNED_LONG: 556 { 557 Sequence< sal_uInt32 > aElements; 558 splitComposedStringToSequence( aStr, aElements, ConvertIntegerFromAndToString() ); 559 _rValue <<= aElements; 560 } 561 break; 562 case uno::TypeClass_BYTE: 563 { 564 Sequence< sal_Int8 > aElements; 565 splitComposedStringToSequence( aStr, aElements, ConvertIntegerFromAndToString() ); 566 _rValue <<= aElements; 567 } 568 break; 569 default: 570 bCanConvert = false; 571 break; 572 } 573 } 574 break; 575 576 case uno::TypeClass_STRUCT: 577 OSL_ENSURE( false, "StringRepresentation::convertStringToGenericValue(STRUCT): this is dead code - isn't it?" ); 578 if ( _rTargetType.equals( ::getCppuType( static_cast< util::Date* >( NULL ) ) ) ) 579 { 580 // weird enough, the string representation of dates, as used 581 // by the control displaying dates, and thus as passed through the layers, 582 // is YYYYMMDD. 583 584 _rValue <<= ::dbtools::DBTypeConversion::toDate(_rStringRep); 585 } 586 else if ( _rTargetType.equals( ::getCppuType( static_cast< util::Time* >( NULL ) ) ) ) 587 { 588 // similar for time (HHMMSSHH) 589 _rValue <<= ::dbtools::DBTypeConversion::toTime(_rStringRep); 590 } 591 else if ( _rTargetType.equals( ::getCppuType( static_cast< util::DateTime* >( NULL ) ) ) ) 592 { 593 _rValue <<= ::dbtools::DBTypeConversion::toDateTime(_rStringRep); 594 } 595 else 596 bCanConvert = false; 597 break; 598 599 default: 600 bCanConvert = false; 601 break; 602 } 603 604 return bCanConvert; 605 } 606 //------------------------------------------------------------------------ 607 //------------------------------------------------------------------------ 608 } // pcr 609 //------------------------------------------------------------------------ 610 611 612 // component helper namespace 613 namespace comp_StringRepresentation { 614 615 ::rtl::OUString SAL_CALL _getImplementationName() { 616 return ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( 617 "StringRepresentation")); 618 } 619 620 uno::Sequence< ::rtl::OUString > SAL_CALL _getSupportedServiceNames() 621 { 622 uno::Sequence< ::rtl::OUString > s(1); 623 s[0] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( 624 "com.sun.star.inspection.StringRepresentation")); 625 return s; 626 } 627 628 uno::Reference< uno::XInterface > SAL_CALL _create( 629 const uno::Reference< uno::XComponentContext > & context) 630 SAL_THROW((uno::Exception)) 631 { 632 return static_cast< ::cppu::OWeakObject * >(new pcr::StringRepresentation(context)); 633 } 634 635 } // closing component helper namespace 636 637 //------------------------------------------------------------------------ 638 extern "C" void SAL_CALL createRegistryInfo_StringRepresentation() 639 { 640 ::pcr::PcrModule::getInstance().registerImplementation( 641 comp_StringRepresentation::_getImplementationName(), 642 comp_StringRepresentation::_getSupportedServiceNames(), 643 comp_StringRepresentation::_create 644 ); 645 } 646 647