/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <sal/config.h>
#include <cppuhelper/factory.hxx>
#include <cppuhelper/implementationentry.hxx>
#include <cppuhelper/implbase.hxx>
#include <cppuhelper/supportsservice.hxx>
#include <com/sun/star/lang/XServiceInfo.hpp>
#include <com/sun/star/inspection/XStringRepresentation.hpp>
#include <com/sun/star/lang/XInitialization.hpp>
#include <com/sun/star/script/CannotConvertException.hpp>
#include <com/sun/star/script/XTypeConverter.hpp>
#include <com/sun/star/container/XHierarchicalNameAccess.hpp>
#include <com/sun/star/reflection/XConstantsTypeDescription.hpp>
#include <com/sun/star/beans/XIntrospection.hpp>
#include <com/sun/star/util/DateTime.hpp>
#include <com/sun/star/util/Date.hpp>
#include <com/sun/star/util/Time.hpp>
#include <com/sun/star/uno/XComponentContext.hpp>
#include <connectivity/dbconversion.hxx>
#include <osl/diagnose.h>
#include <rtl/ustrbuf.hxx>
#include <sal/log.hxx>
#include <strings.hrc>
#include <yesno.hrc>
#include "pcrservices.hxx"
#include <comphelper/types.hxx>
#include "modulepcr.hxx"
#include <functional>
#include <algorithm>
// component helper namespace
namespace comp_StringRepresentation {
using namespace ::com::sun::star;
// component and service helper functions:
OUString _getImplementationName();
uno::Sequence< OUString > _getSupportedServiceNames();
uno::Reference< uno::XInterface > _create( uno::Reference< uno::XComponentContext > const & context );
} // closing component helper namespace
namespace pcr{
using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
class StringRepresentation:
public ::cppu::WeakImplHelper<
lang::XServiceInfo,
inspection::XStringRepresentation,
lang::XInitialization>
{
public:
explicit StringRepresentation(uno::Reference< uno::XComponentContext > const & context);
StringRepresentation (const StringRepresentation&) = delete;
StringRepresentation& operator=(const StringRepresentation&) = delete;
// lang::XServiceInfo:
virtual OUString SAL_CALL getImplementationName() override;
virtual sal_Bool SAL_CALL supportsService(const OUString & ServiceName) override;
virtual uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
// inspection::XStringRepresentation:
virtual OUString SAL_CALL convertToControlValue(const uno::Any & PropertyValue) override;
virtual uno::Any SAL_CALL convertToPropertyValue(const OUString & ControlValue, const uno::Type & ControlValueType) override;
// lang::XInitialization:
virtual void SAL_CALL initialize(const uno::Sequence< uno::Any > & aArguments) override;
private:
virtual ~StringRepresentation() override {}
/** converts a generic value into a string representation
If you want to convert values whose string representation does not depend
on a concrete property, use this version
@return <TRUE/>
if and only if the value could be converted
*/
static bool convertGenericValueToString(
const uno::Any& _rValue,
OUString& _rStringRep
);
/** converts string representation into generic value
If you want to convert values whose string representation does not depend
on a concrete property, use this version
@return <TRUE/>
if and only if the value could be converted
*/
static bool convertStringToGenericValue(
const OUString& _rStringRep,
uno::Any& _rValue,
const uno::Type& _rTargetType
);
/** uses the simple convert method from the type converter
*
* \param _rValue the value to be converted
* \return the converted string.
*/
OUString convertSimpleToString( const uno::Any& _rValue );
/** converts a string into his constant value if it exists, otherwise the type converter is used.
* \param _rValue the value to be converted
* \param _ePropertyType the type of the property to be converted into
* \return the converted value
*/
uno::Any convertStringToSimple( const OUString& _rValue,const uno::TypeClass& _ePropertyType );
uno::Reference< uno::XComponentContext > m_xContext;
uno::Reference< script::XTypeConverter > m_xTypeConverter;
uno::Reference< reflection::XConstantsTypeDescription > m_xTypeDescription;
uno::Sequence< OUString > m_aValues;
uno::Sequence< uno::Reference< reflection::XConstantTypeDescription> > m_aConstants;
};
StringRepresentation::StringRepresentation(uno::Reference< uno::XComponentContext > const & context) :
m_xContext(context)
{}
// com.sun.star.uno.XServiceInfo:
OUString SAL_CALL StringRepresentation::getImplementationName()
{
return comp_StringRepresentation::_getImplementationName();
}
sal_Bool SAL_CALL StringRepresentation::supportsService(OUString const & serviceName)
{
return cppu::supportsService(this, serviceName);
}
uno::Sequence< OUString > SAL_CALL StringRepresentation::getSupportedServiceNames()
{
return comp_StringRepresentation::_getSupportedServiceNames();
}
// inspection::XStringRepresentation:
OUString SAL_CALL StringRepresentation::convertToControlValue(const uno::Any & PropertyValue)
{
OUString sReturn;
if ( !convertGenericValueToString( PropertyValue, sReturn ) )
{
sReturn = convertSimpleToString( PropertyValue );
#ifdef DBG_UTIL
if ( sReturn.isEmpty() && PropertyValue.hasValue() )
{
SAL_WARN( "extensions.propctrlr", "StringRepresentation::convertPropertyValueToStringRepresentation: cannot convert values of type '"
<< PropertyValue.getValueType().getTypeName()
<< "'!" );
}
#endif
}
return sReturn;
}
uno::Any SAL_CALL StringRepresentation::convertToPropertyValue(const OUString & ControlValue, const uno::Type & ControlValueType)
{
uno::Any aReturn;
uno::TypeClass ePropertyType = ControlValueType.getTypeClass();
switch ( ePropertyType )
{
case uno::TypeClass_FLOAT:
case uno::TypeClass_DOUBLE:
case uno::TypeClass_BYTE:
case uno::TypeClass_SHORT:
case uno::TypeClass_LONG:
case uno::TypeClass_HYPER:
case uno::TypeClass_UNSIGNED_SHORT:
case uno::TypeClass_UNSIGNED_LONG:
case uno::TypeClass_UNSIGNED_HYPER:
try
{
aReturn = convertStringToSimple(ControlValue, ePropertyType);
}
catch( const script::CannotConvertException& ) { }
catch( const lang::IllegalArgumentException& ) { }
break;
default:
#if OSL_DEBUG_LEVEL > 0
bool bCanConvert =
#endif
convertStringToGenericValue( ControlValue, aReturn, ControlValueType );
#if OSL_DEBUG_LEVEL > 0
// could not convert ...
if ( !bCanConvert && !ControlValue.isEmpty() )
{
SAL_WARN( "extensions.propctrlr", "StringRepresentation::convertStringRepresentationToPropertyValue: cannot convert into values of type '"
<< ControlValueType.getTypeName() << "'!" );
}
#endif
}
return aReturn;
}
namespace {
// This comparison functor assumes an underlying set of constants with pairwise
// unequal values that are all of UNO SHORT or LONG type:
struct CompareConstants {
bool operator ()(
css::uno::Reference< css::reflection::XConstantTypeDescription > const &
c1,
css::uno::Reference< css::reflection::XConstantTypeDescription > const &
c2) const
{
return c1->getConstantValue().get<sal_Int32>()
< c2->getConstantValue().get<sal_Int32>();
}
};
}
// lang::XInitialization:
void SAL_CALL StringRepresentation::initialize(const uno::Sequence< uno::Any > & aArguments)
{
sal_Int32 nLength = aArguments.getLength();
if ( nLength )
{
const uno::Any* pIter = aArguments.getConstArray();
m_xTypeConverter.set(*pIter++,uno::UNO_QUERY);
if ( nLength == 3 )
{
OUString sConstantName;
*pIter++ >>= sConstantName;
*pIter >>= m_aValues;
if ( m_xContext.is() )
{
uno::Reference< container::XHierarchicalNameAccess > xTypeDescProv(
m_xContext->getValueByName("/singletons/com.sun.star.reflection.theTypeDescriptionManager"),
uno::UNO_QUERY_THROW );
m_xTypeDescription.set( xTypeDescProv->getByHierarchicalName( sConstantName ), uno::UNO_QUERY_THROW );
uno::Sequence<
uno::Reference< reflection::XConstantTypeDescription > >
cs(m_xTypeDescription->getConstants());
std::sort(cs.begin(), cs.end(), CompareConstants());
m_aConstants = cs;
}
}
}
}
OUString StringRepresentation::convertSimpleToString( const uno::Any& _rValue )
{
OUString sReturn;
if ( m_xTypeConverter.is() && _rValue.hasValue() )
{
try
{
if ( m_aConstants.getLength() )
{
sal_Int16 nConstantValue = 0;
if ( _rValue >>= nConstantValue )
{
const uno::Reference< reflection::XConstantTypeDescription>* pIter = m_aConstants.getConstArray();
const uno::Reference< reflection::XConstantTypeDescription>* pEnd = pIter + m_aConstants.getLength();
for(sal_Int32 i = 0;pIter != pEnd;++pIter,++i)
{
if ( (*pIter)->getConstantValue() == _rValue )
{
OSL_ENSURE(i < m_aValues.getLength() ,"StringRepresentation::convertSimpleToString: Index is not in range of m_aValues");
sReturn = m_aValues[i];
break;
}
}
}
}
if ( sReturn.isEmpty() )
m_xTypeConverter->convertToSimpleType( _rValue, uno::TypeClass_STRING ) >>= sReturn;
}
catch( const script::CannotConvertException& ) { }
catch( const lang::IllegalArgumentException& ) { }
}
return sReturn;
}
namespace
{
struct ConvertIntegerFromAndToString
{
OUString operator()( sal_Int32 _rIntValue ) const
{
return OUString::number( _rIntValue );
}
sal_Int32 operator()( const OUString& _rStringValue ) const
{
return _rStringValue.toInt32();
}
};
struct StringIdentity
{
OUString operator()( const OUString& _rValue ) const
{
return _rValue;
}
};
template < class ElementType, class Transformer >
OUString composeSequenceElements( const Sequence< ElementType >& _rElements, const Transformer& _rTransformer )
{
OUStringBuffer sCompose;
// loop through the elements and concatenate the string representations of the integers
// (separated by a line break)
const ElementType* pElements = _rElements.getConstArray();
const ElementType* pElementsEnd = pElements + _rElements.getLength();
for ( ; pElements != pElementsEnd; ++pElements )
{
sCompose.append( OUString( _rTransformer( *pElements ) ) );
if ( pElements != pElementsEnd )
sCompose.append("\n");
}
return sCompose.makeStringAndClear();
}
template < class ElementType, class Transformer >
void splitComposedStringToSequence( const OUString& _rComposed, Sequence< ElementType >& _out_SplitUp, const Transformer& _rTransformer )
{
_out_SplitUp.realloc( 0 );
if ( _rComposed.isEmpty() )
return;
sal_Int32 tokenPos = 0;
do
{
_out_SplitUp.realloc( _out_SplitUp.getLength() + 1 );
_out_SplitUp[ _out_SplitUp.getLength() - 1 ] = static_cast<ElementType>(_rTransformer( _rComposed.getToken( 0, '\n', tokenPos ) ));
}
while ( tokenPos != -1 );
}
}
bool StringRepresentation::convertGenericValueToString( const uno::Any& _rValue, OUString& _rStringRep )
{
bool bCanConvert = true;
switch ( _rValue.getValueTypeClass() )
{
case uno::TypeClass_STRING:
_rValue >>= _rStringRep;
break;
case uno::TypeClass_BOOLEAN:
{
bool bValue = false;
_rValue >>= bValue;
_rStringRep = bValue ? PcrRes(RID_RSC_ENUM_YESNO[1])
: PcrRes(RID_RSC_ENUM_YESNO[0]);
}
break;
// some sequence types
case uno::TypeClass_SEQUENCE:
{
Sequence< OUString > aStringValues;
Sequence< sal_Int8 > aInt8Values;
Sequence< sal_uInt16 > aUInt16Values;
Sequence< sal_Int16 > aInt16Values;
Sequence< sal_uInt32 > aUInt32Values;
Sequence< sal_Int32 > aInt32Values;
// string sequences
if ( _rValue >>= aStringValues )
{
_rStringRep = composeSequenceElements( aStringValues, StringIdentity() );
}
// byte sequences
else if ( _rValue >>= aInt8Values )
{
_rStringRep = composeSequenceElements( aInt8Values, ConvertIntegerFromAndToString() );
}
// uInt16 sequences
else if ( _rValue >>= aUInt16Values )
{
_rStringRep = composeSequenceElements( aUInt16Values, ConvertIntegerFromAndToString() );
}
// Int16 sequences
else if ( _rValue >>= aInt16Values )
{
_rStringRep = composeSequenceElements( aInt16Values, ConvertIntegerFromAndToString() );
}
// uInt32 sequences
else if ( _rValue >>= aUInt32Values )
{
_rStringRep = composeSequenceElements( aUInt32Values, ConvertIntegerFromAndToString() );
}
// Int32 sequences
else if ( _rValue >>= aInt32Values )
{
_rStringRep = composeSequenceElements( aInt32Values, ConvertIntegerFromAndToString() );
}
else
bCanConvert = false;
}
break;
case uno::TypeClass_CONSTANT:
{
int i = 0;
++i;
}
break;
// some structs
case uno::TypeClass_STRUCT:
OSL_FAIL( "StringRepresentation::convertGenericValueToString(STRUCT): this is dead code - isn't it?" );
if ( _rValue.getValueType().equals( cppu::UnoType< util::Date >::get() ))
{
// weird enough, the string representation of dates, as used
// by the control displaying dates, and thus as passed through the layers,
// is YYYYMMDD.
util::Date aUnoDate;
_rValue >>= aUnoDate;
_rStringRep = ::dbtools::DBTypeConversion::toDateString(aUnoDate);
}
else if ( _rValue.getValueType().equals( cppu::UnoType< util::Time >::get() ))
{
// similar for time (HHMMSSHH)
util::Time aUnoTime;
_rValue >>= aUnoTime;
_rStringRep = ::dbtools::DBTypeConversion::toTimeString(aUnoTime);
}
else if ( _rValue.getValueType().equals( cppu::UnoType< util::DateTime >::get() ))
{
util::DateTime aUnoDateTime;
_rValue >>= aUnoDateTime;
_rStringRep = ::dbtools::DBTypeConversion::toDateTimeString(aUnoDateTime);
}
else
bCanConvert = false;
break;
default:
bCanConvert = false;
break;
}
return bCanConvert;
}
uno::Any StringRepresentation::convertStringToSimple( const OUString& _rValue,const uno::TypeClass& _ePropertyType )
{
uno::Any aReturn;
if ( m_xTypeConverter.is() && !_rValue.isEmpty() )
{
try
{
if ( m_aConstants.getLength() && m_aValues.getLength() )
{
const OUString* pIter = m_aValues.getConstArray();
const OUString* pEnd = pIter + m_aValues.getLength();
for(sal_Int32 i = 0;pIter != pEnd;++pIter,++i)
{
if ( *pIter == _rValue )
{
OSL_ENSURE(i < m_aConstants.getLength() ,"StringRepresentation::convertSimpleToString: Index is not in range of m_aValues");
aReturn = m_aConstants[i]->getConstantValue();
break;
}
}
}
if ( !aReturn.hasValue() )
aReturn = m_xTypeConverter->convertToSimpleType( makeAny( _rValue ), _ePropertyType );
}
catch( const script::CannotConvertException& ) { }
catch( const lang::IllegalArgumentException& ) { }
}
return aReturn;
}
bool StringRepresentation::convertStringToGenericValue( const OUString& _rStringRep, uno::Any& _rValue, const uno::Type& _rTargetType )
{
bool bCanConvert = true;
switch ( _rTargetType.getTypeClass() )
{
case uno::TypeClass_STRING:
_rValue <<= _rStringRep;
break;
case uno::TypeClass_BOOLEAN:
{
_rValue <<= PcrRes(RID_RSC_ENUM_YESNO[0]) != _rStringRep;
}
break;
case uno::TypeClass_SEQUENCE:
{
uno::Type aElementType = ::comphelper::getSequenceElementType( _rTargetType );
switch ( aElementType.getTypeClass() )
{
case uno::TypeClass_STRING:
{
Sequence< OUString > aElements;
splitComposedStringToSequence( _rStringRep, aElements, StringIdentity() );
_rValue <<= aElements;
}
break;
case uno::TypeClass_SHORT:
{
Sequence< sal_Int16 > aElements;
splitComposedStringToSequence( _rStringRep, aElements, ConvertIntegerFromAndToString() );
_rValue <<= aElements;
}
break;
case uno::TypeClass_UNSIGNED_SHORT:
{
Sequence< sal_uInt16 > aElements;
splitComposedStringToSequence( _rStringRep, aElements, ConvertIntegerFromAndToString() );
_rValue <<= aElements;
}
break;
case uno::TypeClass_LONG:
{
Sequence< sal_Int32 > aElements;
splitComposedStringToSequence( _rStringRep, aElements, ConvertIntegerFromAndToString() );
_rValue <<= aElements;
}
break;
case uno::TypeClass_UNSIGNED_LONG:
{
Sequence< sal_uInt32 > aElements;
splitComposedStringToSequence( _rStringRep, aElements, ConvertIntegerFromAndToString() );
_rValue <<= aElements;
}
break;
case uno::TypeClass_BYTE:
{
Sequence< sal_Int8 > aElements;
splitComposedStringToSequence( _rStringRep, aElements, ConvertIntegerFromAndToString() );
_rValue <<= aElements;
}
break;
default:
bCanConvert = false;
break;
}
}
break;
case uno::TypeClass_STRUCT:
OSL_FAIL( "StringRepresentation::convertStringToGenericValue(STRUCT): this is dead code - isn't it?" );
if ( _rTargetType.equals( cppu::UnoType< util::Date >::get() ))
{
// weird enough, the string representation of dates, as used
// by the control displaying dates, and thus as passed through the layers,
// is YYYYMMDD.
_rValue <<= ::dbtools::DBTypeConversion::toDate(_rStringRep);
}
else if ( _rTargetType.equals( cppu::UnoType< util::Time >::get() ))
{
// similar for time (HHMMSSHH)
_rValue <<= ::dbtools::DBTypeConversion::toTime(_rStringRep);
}
else if ( _rTargetType.equals( cppu::UnoType< util::DateTime >::get() ))
{
_rValue <<= ::dbtools::DBTypeConversion::toDateTime(_rStringRep);
}
else
bCanConvert = false;
break;
default:
bCanConvert = false;
break;
}
return bCanConvert;
}
} // pcr
// component helper namespace
namespace comp_StringRepresentation {
OUString _getImplementationName() {
return OUString(
"StringRepresentation");
}
uno::Sequence< OUString > _getSupportedServiceNames()
{
uno::Sequence< OUString > s { "com.sun.star.inspection.StringRepresentation" };
return s;
}
uno::Reference< uno::XInterface > _create(
const uno::Reference< uno::XComponentContext > & context)
{
return static_cast< ::cppu::OWeakObject * >(new pcr::StringRepresentation(context));
}
} // closing component helper namespace
extern "C" void createRegistryInfo_StringRepresentation()
{
::pcr::PcrModule::getInstance().registerImplementation(
comp_StringRepresentation::_getImplementationName(),
comp_StringRepresentation::_getSupportedServiceNames(),
comp_StringRepresentation::_create
);
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V547 Expression 'pElements != pElementsEnd' is always true.