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
~StringRepresentation()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
StringRepresentation(uno::Reference<uno::XComponentContext> const & context)153 StringRepresentation::StringRepresentation(uno::Reference< uno::XComponentContext > const & context) :
154 m_xContext(context)
155 {}
156
157 // com.sun.star.uno.XServiceInfo:
getImplementationName()158 ::rtl::OUString SAL_CALL StringRepresentation::getImplementationName() throw (uno::RuntimeException)
159 {
160 return comp_StringRepresentation::_getImplementationName();
161 }
162
supportsService(::rtl::OUString const & serviceName)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
getSupportedServiceNames()168 uno::Sequence< ::rtl::OUString > SAL_CALL StringRepresentation::getSupportedServiceNames() throw (uno::RuntimeException)
169 {
170 return comp_StringRepresentation::_getSupportedServiceNames();
171 }
172
173 // inspection::XStringRepresentation:
convertToControlValue(const uno::Any & PropertyValue)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
convertToPropertyValue(const::rtl::OUString & ControlValue,const uno::Type & ControlValueType)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:
initialize(const uno::Sequence<uno::Any> & aArguments)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 //------------------------------------------------------------------------
convertSimpleToString(const uno::Any & _rValue)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 {
operator ()pcr::__anon00c67a3f0111::ConvertIntegerFromAndToString306 ::rtl::OUString operator()( sal_Int32 _rIntValue ) const
307 {
308 return ::rtl::OUString::valueOf( (sal_Int32)_rIntValue );
309 }
operator ()pcr::__anon00c67a3f0111::ConvertIntegerFromAndToString310 sal_Int32 operator()( const ::rtl::OUString& _rStringValue ) const
311 {
312 return _rStringValue.toInt32();
313 }
314 };
315
316 struct StringIdentity
317 {
operator ()pcr::__anon00c67a3f0111::StringIdentity318 ::rtl::OUString operator()( const ::rtl::OUString& _rValue ) const
319 {
320 return _rValue;
321 }
322 };
323
324 template < class ElementType, class Transformer >
composeSequenceElements(const Sequence<ElementType> & _rElements,const Transformer & _rTransformer)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 >
splitComposedStringToSequence(const::rtl::OUString & _rComposed,Sequence<ElementType> & _out_SplitUp,const Transformer & _rTransformer)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 //--------------------------------------------------------------------
convertGenericValueToString(const uno::Any & _rValue,::rtl::OUString & _rStringRep)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 //------------------------------------------------------------------------
convertStringToSimple(const::rtl::OUString & _rValue,const uno::TypeClass & _ePropertyType)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 //--------------------------------------------------------------------
convertStringToGenericValue(const::rtl::OUString & _rStringRep,uno::Any & _rValue,const uno::Type & _rTargetType)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
_getImplementationName()615 ::rtl::OUString SAL_CALL _getImplementationName() {
616 return ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
617 "StringRepresentation"));
618 }
619
_getSupportedServiceNames()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
_create(const uno::Reference<uno::XComponentContext> & context)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 //------------------------------------------------------------------------
createRegistryInfo_StringRepresentation()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