configmgr/source/xml/valueformatter.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: valueformatter.cxx,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_configmgr.hxx"
  33
  34 #include "valueformatter.hxx"
  35 #include "elementformatter.hxx"
  36 #include "xmlstrings.hxx"
  37 #include "typeconverter.hxx"
  38 #include "simpletypehelper.hxx"
  39 #include <rtl/ustrbuf.hxx>
  40 #include <com/sun/star/uno/Sequence.hxx>
  41
  42 #ifndef INCLUDED_ALGORITHM
  43 #include <algorithm>
  44 #define INCLUDED_ALGORITHM
  45 #endif
  46
  47 namespace configmgr
  48 {
  49     namespace uno = com::sun::star::uno;
  50
  51     namespace xml
  52     {
  53
  54 //==========================================================================
  55 //= Helper
  56 //==========================================================================
  57
  58 // -----------------------------------------------------------------------------
  59 namespace
  60 {
  61 // -----------------------------------------------------------------------------
  62
  63 static
  64 inline
  65 bool isWhitespaceCharacter( sal_Unicode ch )
  66 {
  67     return ch <= 0x20 && ch;
  68 }
  69 // -----------------------------------------------------------------------------
  70
  71 static
  72 inline
  73 bool isWhitespaceString(rtl::OUString const & aStr)
  74 {
  75     sal_Unicode const * const pBegin = aStr.getStr();
  76     sal_Unicode const * const pEnd   = pBegin + aStr.getLength();
  77
  78     // BACK: true, if any whitespace in string or string is empty
  79     if (pBegin == pEnd)
  80         return true;
  81
  82     sal_Unicode const * const pSpace = std::find_if(pBegin,pEnd,isWhitespaceCharacter);
  83
  84     return pSpace != pEnd;
  85 }
  86 // -----------------------------------------------------------------------------
  87
  88 static
  89 bool hasWhitespaceString( uno::Sequence< rtl::OUString > const & aSeq)
  90 {
  91     // BACK: true, if whitespace Separator is ok, (no whitespace in Strings, no empty strings)
  92     rtl::OUString const * const pBegin = aSeq.getConstArray();
  93     rtl::OUString const * const pEnd   = pBegin + aSeq.getLength();
  94
  95     rtl::OUString const * const pSpace = std::find_if(pBegin,pEnd,isWhitespaceString);
  96
  97     return pSpace != pEnd;
  98 }
  99 // -----------------------------------------------------------------------------
 100
 101 struct HasSubString
 102 {
 103     HasSubString(rtl::OUString const & _aSubStr)
 104     : m_aSubStr(_aSubStr)
 105     {}
 106
 107     bool operator()(rtl::OUString const & _aStr)
 108     { return _aStr.indexOf(m_aSubStr) >= 0; }
 109
 110     rtl::OUString const m_aSubStr;
 111 };
 112 // -----------------------------------------------------------------------------
 113
 114 static
 115 bool hasStringWithSubstring(const uno::Sequence< rtl::OUString > &aSeq, rtl::OUString const & _aSubStr)
 116 {
 117     rtl::OUString const * const pBegin = aSeq.getConstArray();
 118     rtl::OUString const * const pEnd   = pBegin + aSeq.getLength();
 119
 120     rtl::OUString const * const pSpace = std::find_if(pBegin,pEnd,HasSubString(_aSubStr));
 121
 122     return pSpace != pEnd;
 123 }
 124 // -----------------------------------------------------------------------------
 125
 126
 127 template <class Element_>
 128 struct IsEmptySequence
 129 {
 130     bool operator()(uno::Sequence<Element_> const & aSeq) const
 131     {
 132         return aSeq.getLength() == 0;
 133     }
 134 };
 135 // -----------------------------------------------------------------------------
 136
 137 template <class Element_>
 138 bool hasEmptySequence(uno::Sequence< uno::Sequence<Element_> > const & aSeqSeq)
 139 {
 140     // BACK: true, if whitespace Separator is ok, (no whitespace in Strings, no empty strings)
 141     uno::Sequence<Element_> const * const pBegin = aSeqSeq.getConstArray();
 142     uno::Sequence<Element_> const * const pEnd   = pBegin + aSeqSeq.getLength();
 143
 144     uno::Sequence<Element_> const * const pEmpty = std::find_if(pBegin, pEnd, IsEmptySequence<Element_>() );
 145
 146     return pEmpty != pEnd;
 147 }
 148 // -----------------------------------------------------------------------------
 149
 150 inline
 151 bool canUseSeparator(uno::Sequence< rtl::OUString > const & aSeq, rtl::OUString const & aSeparator)
 152 {
 153     return ! hasStringWithSubstring(aSeq,aSeparator);
 154 }
 155 // -----------------------------------------------------------------------------
 156
 157 inline
 158 bool canUseWhitespaceSeparator(uno::Sequence< rtl::OUString > const & aSeq)
 159 {
 160     return ! hasWhitespaceString(aSeq);
 161 }
 162 // -----------------------------------------------------------------------------
 163
 164 template <class Element_>
 165 inline
 166 bool canUseWhitespaceSeparator(const uno::Sequence< uno::Sequence<Element_> > &aSeq)
 167 {
 168     return ! hasEmptySequence(aSeq);
 169 }
 170 // -----------------------------------------------------------------------------
 171
 172 class Separator
 173 {
 174     rtl::OUString m_sValue;
 175 public:
 176     // -----------------------------------------------------------------------------
 177     Separator() : m_sValue() {}
 178     // -----------------------------------------------------------------------------
 179     bool isDefault() const { return m_sValue.getLength() == 0; }
 180     // -----------------------------------------------------------------------------
 181     rtl::OUString value() const { return isDefault() ? static_cast<rtl::OUString>(SEPARATOR_WHITESPACE) : m_sValue; }
 182     // -----------------------------------------------------------------------------
 183
 184     bool check(const uno::Sequence<rtl::OUString> &aSeq) const
 185     {
 186         return isDefault() ? canUseWhitespaceSeparator(aSeq) : canUseSeparator(aSeq, m_sValue);
 187     }
 188
 189     // -----------------------------------------------------------------------------
 190     bool trySeparator(rtl::OUString const& sSep, const uno::Sequence<rtl::OUString> & aSeq)
 191     {
 192         OSL_ENSURE( ! isWhitespaceString(sSep), "There should be no spaces in non-default separators");
 193         // BACK: true, if Separator is ok, not in Strings
 194         if (!canUseSeparator(aSeq, sSep))
 195             return false;
 196         this->setSeparator(sSep);
 197         return true;
 198     }
 199     // -----------------------------------------------------------------------------
 200     void setSeparator(rtl::OUString const& sSep)
 201     {
 202         m_sValue = sSep;
 203     }
 204     // -----------------------------------------------------------------------------
 205 };
 206 // -----------------------------------------------------------------------------
 207 #define ASCII( STRING_LIT_ ) ( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( STRING_LIT_ ) ) )
 208 // -----------------------------------------------------------------------------
 209 static
 210 Separator createSeparator(const uno::Any& aAny)
 211 {
 212     Separator aResult;
 213
 214     // create a Separator which isn't in any value
 215     if (aAny.getValueTypeClass() == uno::TypeClass_SEQUENCE)
 216     {
 217         uno::Type aElementType = configmgr::getSequenceElementType(aAny.getValueType());
 218         if (aElementType.getTypeClass() == uno::TypeClass_STRING)
 219         {
 220             // only in strings we need to search a separator
 221             uno::Sequence<rtl::OUString> aSeq;
 222
 223             OSL_VERIFY (aAny >>= aSeq);
 224
 225             bool bValidSeparator =
 226                     canUseWhitespaceSeparator(aSeq) ||
 227                     aResult.trySeparator(ASCII(","), aSeq) ||
 228                     aResult.trySeparator(ASCII(";"), aSeq) ||
 229                     aResult.trySeparator(ASCII(":"), aSeq) ||
 230                     aResult.trySeparator(ASCII("|"), aSeq) ||
 231                     aResult.trySeparator(ASCII("#"), aSeq) ||
 232                     aResult.trySeparator(ASCII("-#*=+#-"), aSeq);
 233
 234             if (!bValidSeparator)
 235             {
 236                 OSL_TRACE("ERROR: configuration formatter: Could not create Separator for string list");
 237                 OSL_ENSURE(false, "ERROR: Could not create Separator for string list");
 238             }
 239             else
 240             {
 241                 // maybe the whitespace test was invalid ?
 242                 OSL_ENSURE(aResult.check(aSeq), "Found Separator does not pass check ?!");
 243             }
 244         }
 245         else if (aElementType == SimpleTypeHelper::getBinaryType())
 246         {
 247             // only in strings we need to search a separator
 248             uno::Sequence< uno::Sequence<sal_Int8> > aSeq;
 249             OSL_VERIFY(aAny >>= aSeq);
 250
 251             if (!canUseWhitespaceSeparator(aSeq))
 252             {
 253                 aResult.setSeparator( ASCII(":") );
 254             }
 255         }
 256     }
 257
 258     // DefaultSeparator
 259     return aResult;
 260 }
 261 #undef ASCII
 262 // -----------------------------------------------------------------------------
 263 static
 264 inline
 265 sal_Unicode hexNibble(sal_uInt8 _nNibble)
 266 {
 267     OSL_ASSERT(_nNibble <= 0x0F);
 268
 269     const sal_uInt8 cDecOffset = sal_uInt8('0');
 270     const sal_uInt8 cHexOffset = sal_uInt8('a') - 10;
 271
 272     return _nNibble + (_nNibble<10 ? cDecOffset : cHexOffset);
 273 }
 274
 275 // -----------------------------------------------------------------------------
 276 static
 277 inline
 278 void appendHex(rtl::OUStringBuffer& rBuff, sal_uInt8 _nByte)
 279 {
 280     rBuff.append( hexNibble(_nByte >> 4) );
 281     rBuff.append( hexNibble(_nByte & 0x0f) );
 282 }
 283
 284 // -----------------------------------------------------------------------------
 285 static
 286 rtl::OUString binaryToHex(const uno::Sequence<sal_Int8>& _aBinarySeq)
 287 {
 288     sal_Int32 const nLength = _aBinarySeq.getLength();
 289
 290     rtl::OUStringBuffer sHex(2*nLength);
 291
 292     for (sal_Int32 nPos = 0;nPos < nLength; ++nPos)
 293     {
 294         appendHex( sHex, _aBinarySeq[nPos] );
 295     }
 296
 297     OSL_ASSERT(sHex.getLength() == 2*nLength);
 298     return sHex.makeStringAndClear();;
 299 }
 300 // -----------------------------------------------------------------------------
 301 rtl::OUString formatSimpleValue(uno::Any const & _aValue, uno::Reference< script::XTypeConverter > const & _xTCV)
 302 {
 303     rtl::OUString sResult;
 304
 305     if (_aValue.hasValue())
 306     {
 307         if (_aValue .getValueType() == SimpleTypeHelper::getBinaryType())
 308         {
 309             uno::Sequence<sal_Int8> aBinarySeq;
 310
 311             OSL_VERIFY(_aValue >>= aBinarySeq);
 312
 313             sResult = binaryToHex(aBinarySeq);
 314         }
 315         else
 316         {
 317             // cannot have nested any
 318             OSL_ASSERT(_aValue.getValueTypeClass() != uno::TypeClass_ANY);
 319
 320             sResult = toString(_xTCV, _aValue);
 321         }
 322     }
 323     return sResult;
 324 }
 325
 326 // -----------------------------------------------------------------------------
 327 template <class Element_>
 328 rtl::OUString formatSequence(uno::Sequence< Element_ > const& aSequence, rtl::OUString const& sSeparator, uno::Reference< script::XTypeConverter > const & _xTCV)
 329 {
 330     rtl::OUStringBuffer aResult;
 331
 332     if (sal_Int32 const nLength = aSequence.getLength())
 333     {
 334         Element_ const * pSeq = aSequence.getConstArray();
 335
 336         aResult = formatSimpleValue( uno::makeAny(pSeq[0]),_xTCV);
 337
 338         for(sal_Int32 i=1; i<nLength; ++i)
 339         {
 340             aResult.append( sSeparator );
 341             aResult.append( formatSimpleValue(uno::makeAny(pSeq[i]),_xTCV) );
 342         }
 343     }
 344
 345     return aResult.makeStringAndClear();
 346 }
 347 // -----------------------------------------------------------------------------
 348 // template <> // optimized overload for String
 349 rtl::OUString formatSequence(uno::Sequence< rtl::OUString > const& aSequence, rtl::OUString const& sSeparator, uno::Reference< script::XTypeConverter > const & )
 350 {
 351     rtl::OUStringBuffer aResult;
 352
 353     if (sal_Int32 const nLength = aSequence.getLength())
 354     {
 355         rtl::OUString const * pSeq = aSequence.getConstArray();
 356
 357         aResult = pSeq[0];
 358
 359         for(sal_Int32 i=1; i<nLength; ++i)
 360         {
 361             aResult.append( sSeparator ).append( pSeq[i] );
 362         }
 363     }
 364
 365     return aResult.makeStringAndClear();
 366 }
 367
 368 // -----------------------------------------------------------------------------
 369
 370 #define CASE_WRITE_SEQUENCE(TYPE_CLASS, DATA_TYPE)      \
 371     case TYPE_CLASS:                                                            \
 372     {                                                                                           \
 373         uno::Sequence< DATA_TYPE > aData;                               \
 374         OSL_ENSURE( ::getCppuType(static_cast< DATA_TYPE const*>(0)).getTypeClass() == (TYPE_CLASS),    \
 375                     "Usage Error for CASE_WRITE_SEQUENCE: Type extracted does not match type class");   \
 376         OSL_VERIFY( _aValue >>= aData );                                                                                \
 377         aResult = formatSequence(aData,sSeparator,xTCV);                                                \
 378     }   break                                                                                                                                   \
 379
 380 rtl::OUString formatSequenceValue(uno::Any const& _aValue, rtl::OUString const& sSeparator, uno::Reference< script::XTypeConverter > const & xTCV)
 381 {
 382     rtl::OUString aResult;
 383
 384     uno::Type aElementType = getSequenceElementType( _aValue.getValueType() );
 385
 386     switch(aElementType.getTypeClass())
 387     {
 388         CASE_WRITE_SEQUENCE( uno::TypeClass_BOOLEAN, sal_Bool );
 389
 390     CASE_WRITE_SEQUENCE( uno::TypeClass_SHORT, sal_Int16 );
 391
 392     CASE_WRITE_SEQUENCE( uno::TypeClass_LONG, sal_Int32 );
 393
 394     CASE_WRITE_SEQUENCE( uno::TypeClass_HYPER, sal_Int64 );
 395
 396     CASE_WRITE_SEQUENCE( uno::TypeClass_DOUBLE, double );
 397
 398     CASE_WRITE_SEQUENCE( uno::TypeClass_STRING, rtl::OUString );
 399
 400     CASE_WRITE_SEQUENCE( uno::TypeClass_SEQUENCE, uno::Sequence<sal_Int8> );
 401
 402     default:
 403         OSL_ENSURE(false, "Unexpected typeclass for sequence elements");
 404         break;
 405     }
 406
 407     return aResult;
 408 }
 409
 410 #undef CASE_WRITE_SEQUENCE
 411 // -----------------------------------------------------------------------------
 412 } // anonymous namspace
 413 // -----------------------------------------------------------------------------
 414 // -----------------------------------------------------------------------------
 415
 416 static inline bool isListVal(uno::Any const & _aValue)
 417 {
 418     bool bList = false;
 419     if (_aValue.hasValue())
 420     {
 421         getBasicType(_aValue.getValueType(),bList);
 422     }
 423     return bList;
 424 }
 425 // -----------------------------------------------------------------------------
 426 void ValueFormatter::makeSeparator()
 427 {
 428     if (isListVal(m_aValue))
 429     {
 430         Separator aSeparator = createSeparator(m_aValue);
 431
 432         m_sSeparator = aSeparator.value();
 433         m_bUseSeparator = !aSeparator.isDefault();
 434
 435         OSL_POSTCOND( this->isList() , "ValueFormatter: Could not mark as list");
 436     }
 437     else
 438     {
 439         m_sSeparator = rtl::OUString();
 440         m_bUseSeparator = false;
 441
 442         OSL_POSTCOND( !this->isList(), "ValueFormatter: Could not mark as non-list");
 443     }
 444 }
 445 // -----------------------------------------------------------------------------
 446
 447 rtl::OUString ValueFormatter::getContent(uno::Reference< script::XTypeConverter > const & _xTCV) const
 448 {
 449     rtl::OUString aResult;
 450     try
 451     {
 452         if (this->isList())
 453         {
 454             aResult = formatSequenceValue(m_aValue, m_sSeparator, _xTCV);
 455         }
 456         else
 457         {
 458             aResult = formatSimpleValue(m_aValue, _xTCV);
 459         }
 460     }
 461     catch (script::CannotConvertException& cce)
 462     {
 463         rtl::OUString const sMessage(RTL_CONSTASCII_USTRINGPARAM("Configuration: Could not convert value to XML representation: "));
 464         throw uno::RuntimeException(sMessage + cce.Message, cce.Context);
 465     }
 466
 467     return aResult;
 468 }
 469 // -----------------------------------------------------------------------------
 470
 471 bool ValueFormatter::addValueAttributes(ElementFormatter & _rFormatter) const
 472 {
 473     // do we have a NULL value
 474     if (!m_aValue.hasValue())
 475     {
 476         _rFormatter.addIsNull();
 477         return false;
 478     }
 479
 480     // create a sequence separator
 481     if (m_bUseSeparator)
 482     {
 483         OSL_ASSERT(this->isList());
 484         _rFormatter.addSeparator(m_sSeparator);
 485     }
 486
 487     return true;
 488 }
 489 // -----------------------------------------------------------------------------
 490
 491 // -----------------------------------------------------------------------------
 492 // -----------------------------------------------------------------------------
 493 } // namespace xml
 494
 495 // -----------------------------------------------------------------------------
 496 } // namespace configmgr
 497
 498