configmgr/source/xml/valueconverter.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: valueconverter.cxx,v $
  10  * $Revision: 1.23 $
  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 "valuetypeconverter.hxx"
  35 #include "typeconverter.hxx"
  36
  37 inline sal_Bool rtl_ascii_isWhitespace( sal_Unicode ch )
  38 {
  39     return ch <= 0x20 && ch;
  40 }
  41
  42 namespace configmgr
  43 {
  44 // -----------------------------------------------------------------------------
  45 static
  46 void throwConversionError(sal_Char const* pErrorMsg) SAL_THROW((script::CannotConvertException))
  47 {
  48     OSL_ENSURE(false, pErrorMsg);
  49
  50     script::CannotConvertException error;
  51     error.Message = rtl::OUString::createFromAscii(pErrorMsg);
  52     throw error;
  53 }
  54 // -----------------------------------------------------------------------------
  55 template <class Char>
  56 inline
  57 bool charInRange(Char ch, char from, char to) throw()
  58 {
  59     return Char(from) <= ch && ch <= Char(to);
  60 }
  61
  62 // -----------------------------------------------------------------------------
  63 static
  64 inline
  65 unsigned makeHexNibble(unsigned char ch) SAL_THROW((script::CannotConvertException))
  66 {
  67     unsigned nRet = 0;
  68
  69          if (charInRange(ch, '0', '9')) nRet = ch - unsigned('0');
  70
  71     else if (charInRange(ch, 'a', 'f')) nRet = ch - unsigned('a' - 10u);
  72
  73     else if (charInRange(ch, 'A', 'F')) nRet = ch - unsigned('A' - 10u);
  74
  75     else throwConversionError("Invalid Hex Character in binary value");
  76
  77     return nRet;
  78 }
  79
  80 // -----------------------------------------------------------------------------
  81 static
  82 inline
  83 unsigned readHexNibble(sal_Unicode ch) SAL_THROW((script::CannotConvertException))
  84 {
  85     if (!charInRange(ch, 0, 127)) throwConversionError("Non-Ascii Character in binary value");
  86
  87     return makeHexNibble(static_cast<unsigned char>(ch));
  88 }
  89
  90 // -----------------------------------------------------------------------------
  91 static
  92 inline
  93 unsigned int readHexByte(sal_Unicode const*& pStr) SAL_THROW((script::CannotConvertException))
  94 {
  95     register unsigned int nHigh = readHexNibble(*pStr++);
  96     register unsigned int nLow =  readHexNibble(*pStr++);
  97     return (nHigh << 4) | nLow;
  98 }
  99
 100 // -----------------------------------------------------------------------------
 101 static
 102 void parseHexBinary(rtl::OUString const& aHexString_, uno::Sequence<sal_Int8>& rBinarySeq_)
 103         SAL_THROW((script::CannotConvertException , com::sun::star::uno::RuntimeException))
 104 {
 105     // PRE: aBinaryString with HexCode
 106     // POST: rBinarySeq with the to Hex converted String
 107
 108     sal_uInt32 nCount = aHexString_.getLength();
 109     sal_Unicode const * pHex = aHexString_.getStr();
 110
 111     if (nCount % 2) throwConversionError("Hex string has odd number of characters");
 112     nCount /= 2;
 113
 114     rBinarySeq_.realloc(nCount);
 115     sal_Int8 * pBinary = rBinarySeq_.getArray();
 116
 117     while (nCount--)
 118     {
 119             *pBinary++ = static_cast<sal_Int8>(readHexByte(pHex));
 120     }
 121 }
 122
 123 // -----------------------------------------------------------------------------
 124 // -----------------------------------------------------------------------------
 125 uno::Sequence<sal_Int8> ValueConverter::parseBinary(rtl::OUString const& aBinaryString_) const
 126         SAL_THROW((script::CannotConvertException, com::sun::star::uno::RuntimeException))
 127 {
 128     uno::Sequence<sal_Int8> aResultSeq;
 129
 130     parseHexBinary(aBinaryString_,aResultSeq);
 131
 132     return aResultSeq;
 133 }
 134
 135 // -----------------------------------------------------------------------------
 136 static inline
 137 uno::Type getBinaryType()
 138 {
 139     uno::Sequence<sal_Int8> const * const for_binary = 0;
 140     return ::getCppuType(for_binary);
 141 }
 142
 143 // -----------------------------------------------------------------------------
 144 bool ValueConverter::isList() const
 145 {
 146     return  m_aType.getTypeClass() == uno::TypeClass_SEQUENCE &&
 147             m_aType != getBinaryType();
 148 }
 149
 150 // -----------------------------------------------------------------------------
 151 uno::Any ValueConverter::convertToAny(rtl::OUString const& aContent) const
 152         SAL_THROW((script::CannotConvertException, com::sun::star::uno::RuntimeException))
 153 {
 154     uno::Any aValue;
 155
 156     if (this->isNull())
 157     {
 158         OSL_ENSURE(aContent.trim().getLength() == 0, "ValueConverter: Non-empty Null Value - ignoring content");
 159         OSL_ASSERT(!aValue.hasValue());
 160     }
 161
 162     else if (this->isList())
 163     {
 164         std::vector< rtl::OUString > aContentList;
 165         splitListData(aContent, aContentList);
 166         convertListToAny(aContentList, aValue);
 167     }
 168
 169     else
 170     {
 171         convertScalarToAny(aContent, aValue);
 172     }
 173
 174     return aValue;
 175 }
 176
 177 // -----------------------------------------------------------------------------
 178 bool ValueConverter::convertScalarToAny(rtl::OUString const& aContent, uno::Any& rValue) const
 179         SAL_THROW((script::CannotConvertException , com::sun::star::uno::RuntimeException))
 180 {
 181     OSL_PRECOND(!this->isNull(),"ValueConverter::convertScalarToAny - check for NULL before calling");
 182     OSL_ENSURE(m_aType.getTypeClass() != uno::TypeClass_ANY,"'Any' values must be NULL");
 183
 184     // check for Binary
 185     if (m_aType == getBinaryType())
 186     {
 187         com::sun::star::uno::Sequence<sal_Int8> aBinarySeq = parseBinary(aContent);
 188         rValue <<= aBinarySeq;
 189     }
 190
 191     else
 192     {
 193         rValue = toAny(m_xTypeConverter, aContent, m_aType.getTypeClass());
 194     }
 195
 196     return !! rValue.hasValue();
 197 }
 198
 199 // -----------------------------------------------------------------------------
 200 template <class T>
 201 bool convertListToSequence(std::vector< rtl::OUString > const& aStringList, uno::Sequence< T >& rSequence, uno::TypeClass aElementTypeClass, ValueConverter const& rConverter)
 202         SAL_THROW((script::CannotConvertException , com::sun::star::uno::RuntimeException))
 203 {
 204     OSL_ASSERT(aElementTypeClass == ::getCppuType(static_cast<T const*>(0)).getTypeClass());
 205
 206     rSequence.realloc(aStringList.size());
 207
 208     sal_uInt32 nPos = 0;
 209
 210     for(std::vector< rtl::OUString >::const_iterator it = aStringList.begin();
 211         it != aStringList.end();
 212         ++it)
 213     {
 214         uno::Any aValueAny = toAny(rConverter.getTypeConverter(), *it, aElementTypeClass);
 215
 216         if (aValueAny >>= rSequence[nPos])
 217             ++nPos;
 218
 219         else if (!aValueAny.hasValue())
 220             OSL_ENSURE(false,"UNEXPECTED: Found NULL value in List - ignoring value !");
 221
 222         else
 223             OSL_ENSURE(false,"ERROR: Cannot extract converted value into List - skipping value !");
 224     }
 225
 226     bool bOK = (nPos == aStringList.size());
 227
 228     if (!bOK)
 229     {
 230         OSL_ASSERT(nPos < aStringList.size());
 231         rSequence.realloc(nPos);
 232     }
 233     return bOK;
 234 }
 235
 236 // -----------------------------------------------------------------------------
 237 // special conversion for string sequence
 238
 239 static
 240 inline
 241 void stringListToSequence(uno::Sequence< rtl::OUString > & rSequence, std::vector< rtl::OUString > const & aStringList)
 242 {
 243     rSequence .realloc( aStringList.size() );
 244
 245     std::copy( aStringList.begin(), aStringList.end(), rSequence.getArray() );
 246 }
 247 // -----------------------------------------------------------------------------
 248
 249 static
 250 inline
 251 std::vector< rtl::OUString > sequenceToStringList(uno::Sequence< rtl::OUString > const & aSequence)
 252 {
 253     rtl::OUString const * const pBegin = aSequence.getConstArray();
 254     rtl::OUString const * const pEnd = pBegin + aSequence.getLength();
 255
 256     return std::vector< rtl::OUString >(pBegin,pEnd);
 257 }
 258 // -----------------------------------------------------------------------------
 259
 260 uno::Sequence< rtl::OUString > ValueConverter::splitStringList(rtl::OUString const& aContent) const
 261 {
 262     std::vector< rtl::OUString > aList;
 263     splitListData(aContent, aList);
 264
 265     uno::Sequence< rtl::OUString > aResult;
 266     stringListToSequence(aResult,aList);
 267
 268     return aResult;
 269 }
 270 // -----------------------------------------------------------------------------
 271
 272 uno::Any ValueConverter::convertListToAny(uno::Sequence< rtl::OUString > const& aContentList) const
 273     SAL_THROW((script::CannotConvertException , com::sun::star::uno::RuntimeException))
 274 {
 275     uno::Any aResult;
 276     std::vector< rtl::OUString > const aStringList = sequenceToStringList(aContentList);
 277     convertListToAny(aStringList,aResult);
 278     return aResult;
 279 }
 280 // -----------------------------------------------------------------------------
 281 // special overload for binary sequence
 282
 283 // template<> // use an explicit specialization
 284 bool convertListToSequence(std::vector< rtl::OUString > const& aStringList, uno::Sequence< uno::Sequence<sal_Int8> >& rSequence, uno::TypeClass aElementTypeClass, ValueConverter const& rParser )
 285         SAL_THROW((script::CannotConvertException , com::sun::star::uno::RuntimeException))
 286 {
 287     { (void)aElementTypeClass; }
 288     OSL_ASSERT(aElementTypeClass == uno::TypeClass_SEQUENCE);
 289
 290     rSequence.realloc(aStringList.size());
 291
 292     sal_uInt32 nPos = 0;
 293
 294     for(std::vector< rtl::OUString >::const_iterator it = aStringList.begin();
 295         it != aStringList.end();
 296         ++it)
 297     {
 298         rSequence[nPos++] = rParser.parseBinary(*it);
 299     }
 300     return true;
 301 }
 302
 303 // -----------------------------------------------------------------------------
 304 // special overload for string sequence
 305
 306 // template<> // use an explicit specialization
 307 bool convertListToSequence(std::vector< rtl::OUString > const& aStringList, uno::Sequence< rtl::OUString >& rSequence, uno::TypeClass aElementTypeClass, ValueConverter const& /*rParser*/ )
 308         SAL_THROW((script::CannotConvertException , com::sun::star::uno::RuntimeException))
 309 {
 310     { (void)aElementTypeClass; }
 311     OSL_ASSERT(aElementTypeClass == uno::TypeClass_STRING);
 312
 313     stringListToSequence(rSequence, aStringList);
 314
 315     return true;
 316 }
 317
 318 // -----------------------------------------------------------------------------
 319
 320 #define MAYBE_EXTRACT_SEQUENCE( type ) \
 321     if (aElementType == ::getCppuType( (type const *)0))    \
 322     {                                                       \
 323         com::sun::star::uno::Sequence< type > aSequence;                         \
 324         convertListToSequence(aContentList,aSequence,aElementTypeClass, *this); \
 325         rValue <<= aSequence;                               \
 326     }
 327
 328 bool ValueConverter::convertListToAny(std::vector< rtl::OUString > const& aContentList, uno::Any& rValue) const
 329         SAL_THROW((script::CannotConvertException , com::sun::star::uno::RuntimeException))
 330 {
 331     OSL_PRECOND(!this->isNull(),"ValueConverter::convertListToAny - check for NULL before calling");
 332     OSL_ENSURE(m_aType.getTypeClass() == uno::TypeClass_SEQUENCE,"'Any' not allowed for lists");
 333
 334     uno::Type       aElementType        = getSequenceElementType(m_aType);
 335     uno::TypeClass  aElementTypeClass   = aElementType.getTypeClass();
 336
 337     OSL_ENSURE(aElementTypeClass != uno::TypeClass_ANY,"'Any' not allowed for list elements");
 338
 339     MAYBE_EXTRACT_SEQUENCE( rtl::OUString )
 340     else
 341     MAYBE_EXTRACT_SEQUENCE( sal_Bool )
 342     else
 343     MAYBE_EXTRACT_SEQUENCE( sal_Int16 )
 344     else
 345     MAYBE_EXTRACT_SEQUENCE( sal_Int32 )
 346     else
 347     MAYBE_EXTRACT_SEQUENCE( sal_Int64 )
 348     else
 349     MAYBE_EXTRACT_SEQUENCE( double )
 350     else
 351     MAYBE_EXTRACT_SEQUENCE( com::sun::star::uno::Sequence<sal_Int8> )
 352     else
 353     {
 354         OSL_ENSURE(false, "Unknown element type in list");
 355         throwConversionError("Invalid value-type found in list value");
 356     }
 357
 358     return !! rValue.hasValue();
 359 }
 360 #undef MAYBE_EXTRACT_SEQUENCE
 361
 362 // -----------------------------------------------------------------------------
 363 namespace
 364 {
 365     sal_Int32 const NO_MORE_TOKENS = -1;
 366     struct OTokenizeByWhitespace
 367     {
 368
 369         static inline bool isWhitespace(sal_Unicode ch)
 370         {
 371             // note: for definition of whitescape see also
 372             //   canUseWhitespace(rtl::OUString const&)
 373             // in xmlformater.cxx
 374             // -----------------------------------------------------------------------------
 375             return rtl_ascii_isWhitespace(ch) ? true : false;
 376         }
 377
 378         sal_Int32 findFirstTokenStart(rtl::OUString const& sText) const SAL_THROW(())
 379         {
 380             return findNextTokenStart(sText,0);
 381         }
 382
 383         sal_Int32 findNextTokenStart(rtl::OUString const& sText, sal_Int32 nPrevTokenEnd) const  SAL_THROW(())
 384         {
 385             sal_Int32 const nEnd = sText.getLength();
 386             sal_Int32 nPos = nPrevTokenEnd;
 387
 388             OSL_PRECOND( nPos == 0 || (0 < nPos && nPos < nEnd && isWhitespace(sText[nPos])) || nPos == nEnd,
 389                          "Invalid nPrevTokenEnd");
 390
 391             while (nPos < nEnd && isWhitespace(sText[nPos]))
 392             {
 393                 ++nPos;
 394             }
 395
 396             if (nPos < nEnd)
 397                 return nPos;
 398             else
 399                 return NO_MORE_TOKENS;
 400         }
 401
 402         sal_Int32 findTokenEnd(rtl::OUString const& sText, sal_Int32 nTokenStart) const SAL_THROW(())
 403         {
 404             sal_Int32 const nEnd = sText.getLength();
 405             sal_Int32 nPos = nTokenStart;
 406
 407             OSL_PRECOND( 0 <= nPos && nPos < nEnd && !isWhitespace(sText[nPos]),
 408                          "Invalid nTokenStart");
 409
 410             while (nPos < nEnd && !isWhitespace(sText[nPos]))
 411             {
 412                 ++nPos;
 413             }
 414
 415             return nPos;
 416         }
 417     };
 418 // -----------------------------------------------------------------------------
 419     struct OTokenizeBySeparator
 420     {
 421         rtl::OUString const sSeparator;
 422         OTokenizeBySeparator(rtl::OUString const& _sSeparator) SAL_THROW(())
 423             : sSeparator(_sSeparator)
 424         {
 425             OSL_PRECOND(sSeparator.trim().getLength() > 0, "Invalid empty separator string");
 426         }
 427
 428             sal_Int32 findFirstTokenStart(rtl::OUString const& /*sText*/) const SAL_THROW(())
 429         {
 430             return 0;
 431         }
 432         sal_Int32 findNextTokenStart(rtl::OUString const& sText, sal_Int32 nPrevTokenEnd) const SAL_THROW(())
 433         {
 434             sal_Int32 const nEnd = sText.getLength();
 435             sal_Int32 nPos = nPrevTokenEnd;
 436             OSL_PRECOND( nPos == nEnd || (0 <= nPos && nPos < nEnd && sText.indexOf(sSeparator, nPos) == nPos),
 437                          "Invalid nPrevTokenEnd");
 438
 439             if (nPos < nEnd)
 440                 return nPos + sSeparator.getLength();
 441             else
 442                 return NO_MORE_TOKENS;
 443         }
 444         sal_Int32 findTokenEnd(rtl::OUString const& sText, sal_Int32 nTokenStart) const SAL_THROW(())
 445         {
 446             sal_Int32 const nEnd = sText.getLength();
 447             OSL_PRECOND( 0 <= nTokenStart && nTokenStart <= nEnd ,
 448                          "Invalid nTokenStart");
 449
 450             sal_Int32 nPos = sText.indexOf(sSeparator,nTokenStart);
 451
 452             if (nPos >= 0)
 453                 return nPos;
 454             else
 455                 return nEnd;
 456         }
 457     };
 458 // -----------------------------------------------------------------------------
 459     template <class Tokenizer>
 460     void tokenizeListData(Tokenizer const& aTokenizer, rtl::OUString const& aContent, std::vector< rtl::OUString >& rContentList)
 461             SAL_THROW(())
 462     {
 463         sal_Int32 nTokenPos = aTokenizer.findFirstTokenStart(aContent);
 464
 465         while(nTokenPos != NO_MORE_TOKENS)
 466         {
 467             sal_Int32 nTokenEnd = aTokenizer.findTokenEnd(aContent, nTokenPos);
 468
 469             // this is what the tokenizer must provide
 470             OSL_ASSERT(0 <= nTokenPos && nTokenPos <= nTokenEnd && nTokenEnd <= aContent.getLength());
 471
 472             rContentList.push_back( aContent.copy(nTokenPos, nTokenEnd-nTokenPos) );
 473
 474             nTokenPos= aTokenizer.findNextTokenStart(aContent, nTokenEnd);
 475         }
 476     }
 477 // -----------------------------------------------------------------------------
 478 }
 479 // -----------------------------------------------------------------------------
 480 void ValueConverter::splitListData(rtl::OUString const& aContent, std::vector< rtl::OUString >& rContentList) const
 481     SAL_THROW(())
 482 {
 483     rtl::OUString sSeparator = m_sSeparator;
 484
 485     bool bSeparateByWhitespace = (sSeparator.trim().getLength() == 0);
 486
 487     if (bSeparateByWhitespace)
 488     {
 489         OSL_ENSURE( sSeparator.getLength()==0 || sSeparator.equalsAscii(" "),
 490                     "Unexpected whitespace-only separator");
 491
 492         tokenizeListData( OTokenizeByWhitespace(), aContent, rContentList );
 493     }
 494     else
 495     {
 496         OSL_ENSURE( sSeparator.trim()==sSeparator,
 497                     "Unexpected whitespace in separator");
 498
 499         tokenizeListData( OTokenizeBySeparator(sSeparator), aContent, rContentList );
 500     }
 501 }
 502 // -----------------------------------------------------------------------------
 503
 504 } // namespace