extensions/source/propctrlr/stringrepresentation.cxx

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