xmloff/source/core/nmspmap.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
  22 #include <tools/debug.hxx>
  23 #include <rtl/ustring.hxx>
  24 #include <rtl/ustrbuf.hxx>
  25
  26 #include <xmloff/xmltoken.hxx>
  27 #include <xmloff/nmspmap.hxx>
  28
  29 #include <xmloff/xmlnmspe.hxx>
  30
  31
  32 using namespace ::xmloff::token;
  33
  34 /* The basic idea of this class is that we have two two ways to search our
  35  * data...by prefix and by key. We use an unordered_map for fast prefix
  36  * searching and an STL map for fast key searching.
  37  *
  38  * The references to an 'Index' refer to an earlier implementation of the
  39  * name space map and remain to support code which uses these interfaces.
  40  *
  41  * In this implementation, key and index should always be the same number.
  42  *
  43  * All references to Indices are now deprecated and the corresponding
  44  * 'Key' methods should be used instead
  45  *
  46  * Martin 13/06/01
  47  */
  48
  49 SvXMLNamespaceMap::SvXMLNamespaceMap()
  50 : sXMLNS( GetXMLToken ( XML_XMLNS ) )
  51 {
  52 }
  53
  54 SvXMLNamespaceMap::SvXMLNamespaceMap( const SvXMLNamespaceMap& rMap )
  55 : sXMLNS( GetXMLToken ( XML_XMLNS ) )
  56 {
  57     aNameHash = rMap.aNameHash;
  58     aNameMap  = rMap.aNameMap;
  59 }
  60
  61 void SvXMLNamespaceMap::operator=( const SvXMLNamespaceMap& rMap )
  62 {
  63     aNameHash = rMap.aNameHash;
  64     aNameMap = rMap.aNameMap;
  65 }
  66
  67 SvXMLNamespaceMap::~SvXMLNamespaceMap()
  68 {
  69 }
  70
  71 bool SvXMLNamespaceMap::operator ==( const SvXMLNamespaceMap& rCmp ) const
  72 {
  73     return aNameHash == rCmp.aNameHash;
  74 }
  75
  76 sal_uInt16 SvXMLNamespaceMap::_Add( const OUString& rPrefix, const OUString &rName, sal_uInt16 nKey )
  77 {
  78     if( XML_NAMESPACE_UNKNOWN == nKey )
  79     {
  80         // create a new unique key with UNKNOWN flag set
  81         nKey = XML_NAMESPACE_UNKNOWN_FLAG;
  82         do
  83         {
  84             NameSpaceMap::const_iterator aIter = aNameMap.find ( nKey );
  85             if( aIter == aNameMap.end() )
  86                 break;
  87             nKey++;
  88         }
  89         while ( true );
  90     }
  91     ::rtl::Reference<NameSpaceEntry> pEntry(new NameSpaceEntry);
  92     pEntry->sName   = rName;
  93     pEntry->nKey    = nKey;
  94     pEntry->sPrefix = rPrefix;
  95     aNameHash[ rPrefix ] = pEntry;
  96     aNameMap [ nKey ]    = pEntry;
  97     return nKey;
  98 }
  99
 100 sal_uInt16 SvXMLNamespaceMap::Add( const OUString& rPrefix, const OUString& rName,
 101                                sal_uInt16 nKey )
 102 {
 103     if( XML_NAMESPACE_UNKNOWN == nKey )
 104         nKey = GetKeyByName( rName );
 105
 106     DBG_ASSERT( XML_NAMESPACE_NONE != nKey,
 107                 "SvXMLNamespaceMap::Add: invalid namespace key" );
 108
 109     if( XML_NAMESPACE_NONE == nKey )
 110         return USHRT_MAX;
 111
 112     if ( aNameHash.find ( rPrefix ) == aNameHash.end() )
 113         nKey = _Add( rPrefix, rName, nKey );
 114
 115     return nKey;
 116 }
 117
 118 sal_uInt16 SvXMLNamespaceMap::AddIfKnown( const OUString& rPrefix, const OUString& rName )
 119 {
 120     sal_uInt16 nKey = GetKeyByName( rName );
 121
 122     DBG_ASSERT( XML_NAMESPACE_NONE != nKey,
 123                 "SvXMLNamespaceMap::AddIfKnown: invalid namespace key" );
 124
 125     if( XML_NAMESPACE_NONE == nKey )
 126         return XML_NAMESPACE_UNKNOWN;
 127
 128     if( XML_NAMESPACE_UNKNOWN != nKey )
 129     {
 130         NameSpaceHash::const_iterator aIter = aNameHash.find( rPrefix );
 131         if( aIter == aNameHash.end() || (*aIter).second->sName != rName )
 132             nKey = _Add( rPrefix, rName, nKey );
 133     }
 134
 135     return nKey;
 136 }
 137
 138
 139 sal_uInt16 SvXMLNamespaceMap::GetKeyByPrefix( const OUString& rPrefix ) const
 140 {
 141     NameSpaceHash::const_iterator aIter = aNameHash.find(rPrefix);
 142     return (aIter != aNameHash.end()) ? (*aIter).second->nKey : USHRT_MAX;
 143 }
 144
 145 sal_uInt16 SvXMLNamespaceMap::GetKeyByName( const OUString& rName ) const
 146 {
 147     sal_uInt16 nKey = XML_NAMESPACE_UNKNOWN;
 148     NameSpaceHash::const_iterator aIter = aNameHash.begin(), aEnd = aNameHash.end();
 149     while (aIter != aEnd )
 150     {
 151         if ((*aIter).second->sName == rName)
 152         {
 153             nKey = (*aIter).second->nKey;
 154             break;
 155         }
 156         ++aIter;
 157     }
 158     return nKey;
 159 }
 160
 161 const OUString& SvXMLNamespaceMap::GetPrefixByKey( sal_uInt16 nKey ) const
 162 {
 163     NameSpaceMap::const_iterator aIter = aNameMap.find (nKey);
 164     return (aIter != aNameMap.end()) ? (*aIter).second->sPrefix : sEmpty;
 165 }
 166
 167 const OUString& SvXMLNamespaceMap::GetNameByKey( sal_uInt16 nKey ) const
 168 {
 169     NameSpaceMap::const_iterator aIter = aNameMap.find (nKey);
 170     return (aIter != aNameMap.end()) ? (*aIter).second->sName : sEmpty;
 171 }
 172
 173 OUString SvXMLNamespaceMap::GetAttrNameByKey( sal_uInt16 nKey ) const
 174 {
 175     OUStringBuffer sAttrName;
 176     NameSpaceMap::const_iterator aIter = aNameMap.find ( nKey );
 177     if (aIter != aNameMap.end())
 178     {
 179         sAttrName.append( sXMLNS  );
 180         const OUString & prefix( (*aIter).second->sPrefix );
 181         if (!prefix.isEmpty()) // not default namespace
 182         {
 183             sAttrName.append( ':' );
 184             sAttrName.append( prefix );
 185         }
 186     }
 187     return sAttrName.makeStringAndClear();
 188 }
 189
 190 OUString SvXMLNamespaceMap::GetQNameByKey( sal_uInt16 nKey,
 191                             const OUString& rLocalName,
 192                             bool bCache) const
 193 {
 194     // We always want to return at least the rLocalName...
 195
 196     switch ( nKey )
 197     {
 198         case XML_NAMESPACE_UNKNOWN:
 199             // ...if it's a completely unknown namespace, assert and return the local name
 200             DBG_ASSERT( false, "SvXMLNamespaceMap::GetQNameByKey: invalid namespace key" );
 201         case XML_NAMESPACE_NONE:
 202             // ...if there isn't one, return the local name
 203             return rLocalName;
 204         case XML_NAMESPACE_XMLNS:
 205         {
 206             // ...if it's in the xmlns namespace, make the prefix
 207             // don't bother caching this, it rarely happens
 208             OUStringBuffer sQName;
 209             sQName.append ( sXMLNS );
 210             if (!rLocalName.isEmpty()) // not default namespace
 211             {
 212                 sQName.append ( ':' );
 213                 sQName.append ( rLocalName );
 214             }
 215             return sQName.makeStringAndClear();
 216         }
 217         case XML_NAMESPACE_XML:
 218         {
 219             // this namespace is reserved, and needs not to be declared
 220             OUStringBuffer sQName;
 221             sQName.append ( GetXMLToken(XML_XML) );
 222             sQName.append ( ':' );
 223             sQName.append ( rLocalName );
 224             return sQName.makeStringAndClear();
 225         }
 226         default:
 227         {
 228             QNameCache::const_iterator aQCacheIter;
 229             if (bCache)
 230                 aQCacheIter = aQNameCache.find ( QNamePair ( nKey, rLocalName ) );
 231             else
 232                 aQCacheIter = aQNameCache.end();
 233             if ( aQCacheIter != aQNameCache.end() )
 234                 return (*aQCacheIter).second;
 235             else
 236             {
 237                 NameSpaceMap::const_iterator aIter = aNameMap.find ( nKey );
 238                 if ( aIter != aNameMap.end() )
 239                 {
 240                     OUStringBuffer sQName;
 241                     // ...if it's in our map, make the prefix
 242                     const OUString & prefix( (*aIter).second->sPrefix );
 243                     if (!prefix.isEmpty()) // not default namespace
 244                     {
 245                         sQName.append( prefix );
 246                         sQName.append( ':' );
 247                     }
 248                     sQName.append ( rLocalName );
 249                     if (bCache)
 250                     {
 251                         OUString sString(sQName.makeStringAndClear());
 252                         aQNameCache.insert(
 253                             QNameCache::value_type(
 254                                 QNamePair(nKey, rLocalName), sString));
 255                         return sString;
 256                     }
 257                     else
 258                         return sQName.makeStringAndClear();
 259                 }
 260                 else
 261                 {
 262                     // ... if it isn't, this is a Bad Thing, assert and return the local name
 263                     DBG_ASSERT( false, "SvXMLNamespaceMap::GetQNameByKey: invalid namespace key" );
 264                     return rLocalName;
 265                 }
 266             }
 267         }
 268     }
 269 }
 270
 271 sal_uInt16 SvXMLNamespaceMap::_GetKeyByAttrName(
 272                             const OUString& rAttrName,
 273                             OUString *pLocalName,
 274                             bool bCache) const
 275 {
 276     return _GetKeyByAttrName( rAttrName, 0, pLocalName, 0, bCache );
 277 }
 278
 279 sal_uInt16 SvXMLNamespaceMap::_GetKeyByAttrName( const OUString& rAttrName,
 280                                             OUString *pPrefix,
 281                                             OUString *pLocalName,
 282                                             OUString *pNamespace,
 283                                             bool bCache) const
 284 {
 285     sal_uInt16 nKey = XML_NAMESPACE_UNKNOWN;
 286
 287     NameSpaceHash::const_iterator it;
 288     if (bCache)
 289         it = aNameCache.find ( rAttrName );
 290     else
 291         it = aNameCache.end();
 292     if ( it != aNameCache.end() )
 293     {
 294         const NameSpaceEntry &rEntry = *((*it).second);
 295         if ( pPrefix )
 296             *pPrefix = rEntry.sPrefix;
 297         if ( pLocalName )
 298             *pLocalName = rEntry.sName;
 299         nKey = rEntry.nKey;
 300         if ( pNamespace )
 301         {
 302             NameSpaceMap::const_iterator aMapIter = aNameMap.find (nKey);
 303             *pNamespace = aMapIter != aNameMap.end() ? (*aMapIter).second->sName : sEmpty;
 304         }
 305     }
 306     else
 307     {
 308     rtl::Reference<NameSpaceEntry> xEntry(new NameSpaceEntry());
 309
 310         sal_Int32 nColonPos = rAttrName.indexOf( ':' );
 311         if( -1L == nColonPos )
 312         {
 313             // case: no ':' found -> default namespace
 314             (xEntry->sPrefix).clear();
 315             xEntry->sName = rAttrName;
 316         }
 317         else
 318         {
 319             // normal case: ':' found -> get prefix/suffix
 320             xEntry->sPrefix = rAttrName.copy( 0L, nColonPos );
 321             xEntry->sName = rAttrName.copy( nColonPos + 1L );
 322         }
 323
 324         if( pPrefix )
 325             *pPrefix = xEntry->sPrefix;
 326         if( pLocalName )
 327             *pLocalName = xEntry->sName;
 328
 329         NameSpaceHash::const_iterator aIter = aNameHash.find( xEntry->sPrefix );
 330         if ( aIter != aNameHash.end() )
 331         {
 332             // found: retrieve namespace key
 333             nKey = xEntry->nKey = (*aIter).second->nKey;
 334             if ( pNamespace )
 335                 *pNamespace = (*aIter).second->sName;
 336         }
 337         else if ( xEntry->sPrefix == sXMLNS )
 338             // not found, but xmlns prefix: return xmlns 'namespace'
 339             nKey = xEntry->nKey = XML_NAMESPACE_XMLNS;
 340         else if( nColonPos == -1L )
 341             // not found, and no namespace: 'namespace' none
 342             nKey = xEntry->nKey = XML_NAMESPACE_NONE;
 343
 344         if (bCache)
 345         {
 346             aNameCache.insert(NameSpaceHash::value_type(rAttrName, xEntry));
 347         }
 348     }
 349
 350     return nKey;
 351 }
 352
 353 sal_uInt16 SvXMLNamespaceMap::GetFirstKey() const
 354 {
 355     return aNameMap.empty() ? USHRT_MAX : (*aNameMap.begin()).second->nKey;
 356 }
 357
 358 sal_uInt16 SvXMLNamespaceMap::GetNextKey( sal_uInt16 nLastKey ) const
 359 {
 360     NameSpaceMap::const_iterator aIter = aNameMap.find ( nLastKey );
 361     return (++aIter == aNameMap.end()) ? USHRT_MAX : (*aIter).second->nKey;
 362 }
 363
 364
 365 // All methods after this are deprecated...
 366
 367 sal_uInt16 SvXMLNamespaceMap::GetIndexByKey( sal_uInt16 nKey )
 368 {
 369     return nKey;
 370 }
 371 sal_uInt16 SvXMLNamespaceMap::GetFirstIndex() const
 372 {
 373     return aNameMap.empty() ? USHRT_MAX : (*aNameMap.begin()).second->nKey;
 374 }
 375
 376 sal_uInt16 SvXMLNamespaceMap::GetNextIndex( sal_uInt16 nOldIdx ) const
 377 {
 378     NameSpaceMap::const_iterator aIter = aNameMap.find ( nOldIdx );
 379     return (++aIter == aNameMap.end()) ? USHRT_MAX : (*aIter).second->nKey;
 380 }
 381
 382 bool SvXMLNamespaceMap::AddAtIndex( sal_uInt16 /*nIdx*/, const OUString& rPrefix,
 383                                     const OUString& rName, sal_uInt16 nKey )
 384 {
 385     bool bRet = false;
 386
 387     if( XML_NAMESPACE_UNKNOWN == nKey )
 388         nKey = GetKeyByName( rName );
 389
 390     DBG_ASSERT( XML_NAMESPACE_NONE != nKey,
 391                 "SvXMLNamespaceMap::AddAtIndex: invalid namespace key" );
 392     if( XML_NAMESPACE_NONE != nKey && ! ( aNameHash.count ( rPrefix ) ) )
 393     {
 394         _Add( rPrefix, rName, nKey );
 395         bRet = true;
 396     }
 397     return bRet;
 398 }
 399
 400 OUString SvXMLNamespaceMap::GetAttrNameByIndex( sal_uInt16 nIdx ) const
 401 {
 402     return GetAttrNameByKey( nIdx );
 403 }
 404
 405 OUString SvXMLNamespaceMap::GetQNameByIndex( sal_uInt16 nIdx,
 406                                            const OUString& rLocalName ) const
 407 {
 408     return GetQNameByKey( nIdx, rLocalName );
 409 }
 410
 411 const OUString& SvXMLNamespaceMap::GetPrefixByIndex( sal_uInt16 nIdx ) const
 412 {
 413     NameSpaceMap::const_iterator aIter = aNameMap.find (nIdx);
 414     return (aIter != aNameMap.end()) ? (*aIter).second->sPrefix : sEmpty;
 415 }
 416
 417 const OUString& SvXMLNamespaceMap::GetNameByIndex( sal_uInt16 nIdx ) const
 418 {
 419     NameSpaceMap::const_iterator aIter = aNameMap.find (nIdx);
 420     return (aIter != aNameMap.end()) ? (*aIter).second->sName : sEmpty;
 421 }
 422
 423 sal_uInt16 SvXMLNamespaceMap::GetIndexByPrefix( const OUString& rPrefix ) const
 424 {
 425     NameSpaceHash::const_iterator aIter = aNameHash.find(rPrefix);
 426     return (aIter != aNameHash.end()) ? (*aIter).second->nKey : USHRT_MAX;
 427 }
 428 sal_uInt16 SvXMLNamespaceMap::GetKeyByAttrName(
 429                             const OUString& rAttrName,
 430                             OUString *pLocalName,
 431                             sal_uInt16 /*nIdxGuess*/) const
 432 {
 433     return _GetKeyByAttrName( rAttrName, 0, pLocalName, 0 );
 434 }
 435
 436 sal_uInt16 SvXMLNamespaceMap::GetKeyByAttrName( const OUString& rAttrName,
 437                                             OUString *pPrefix,
 438                                             OUString *pLocalName,
 439                                             OUString *pNamespace,
 440                                             sal_uInt16 /*nIdxGuess*/ ) const
 441 {
 442     return _GetKeyByAttrName ( rAttrName, pPrefix, pLocalName, pNamespace );
 443 }
 444
 445 bool SvXMLNamespaceMap::NormalizeURI( OUString& rName )
 446 {
 447     // try OASIS + W3 URI normalization
 448     bool bSuccess = NormalizeOasisURN( rName );
 449     if( ! bSuccess )
 450         bSuccess = NormalizeW3URI( rName );
 451     return bSuccess;
 452 }
 453
 454 bool SvXMLNamespaceMap::NormalizeW3URI( OUString& rName )
 455 {
 456     // check if URI matches:
 457     // http://www.w3.org/[0-9]*/[:letter:]*
 458     //                   (year)/(WG name)
 459     // For the following WG/standards names:
 460     // - xforms
 461
 462     bool bSuccess = false;
 463     const OUString sURIPrefix = GetXMLToken( XML_URI_W3_PREFIX );
 464     if( rName.startsWith( sURIPrefix ) )
 465     {
 466         const OUString sURISuffix = GetXMLToken( XML_URI_XFORMS_SUFFIX );
 467         sal_Int32 nCompareFrom = rName.getLength() - sURISuffix.getLength();
 468         if( rName.copy( nCompareFrom ).equals( sURISuffix ) )
 469         {
 470             // found W3 prefix, and xforms suffix
 471             rName = GetXMLToken( XML_N_XFORMS_1_0 );
 472             bSuccess = true;
 473         }
 474     }
 475     return bSuccess;
 476 }
 477
 478 bool SvXMLNamespaceMap::NormalizeOasisURN( OUString& rName )
 479 {
 480     // #i38644#
 481     // we exported the wrong namespace for smil, so we correct this here on load
 482     // for older documents
 483     if( IsXMLToken( rName, ::xmloff::token::XML_N_SVG ) )
 484     {
 485         rName = GetXMLToken( ::xmloff::token::XML_N_SVG_COMPAT );
 486         return true;
 487     }
 488     else if( IsXMLToken( rName, ::xmloff::token::XML_N_FO ) )
 489     {
 490         rName = GetXMLToken( ::xmloff::token::XML_N_FO_COMPAT );
 491         return true;
 492     }
 493     else if( IsXMLToken( rName, ::xmloff::token::XML_N_SMIL ) ||
 494                IsXMLToken( rName, ::xmloff::token::XML_N_SMIL_OLD )  )
 495     {
 496         rName = GetXMLToken( ::xmloff::token::XML_N_SMIL_COMPAT );
 497         return true;
 498     }
 499
 500
 501     // Check if URN matches
 502     // :urn:oasis:names:tc:[^:]*:xmlns:[^:]*:1.[^:]*
 503     //                     |---|       |---| |-----|
 504     //                     TC-Id      Sub-Id Version
 505
 506     sal_Int32 nNameLen = rName.getLength();
 507     // :urn:oasis:names:tc.*
 508     const OUString& rOasisURN = GetXMLToken( XML_URN_OASIS_NAMES_TC );
 509     if( !rName.startsWith( rOasisURN ) )
 510         return false;
 511
 512     // :urn:oasis:names:tc:.*
 513     sal_Int32 nPos = rOasisURN.getLength();
 514     if( nPos >= nNameLen || rName[nPos] != ':' )
 515         return false;
 516
 517     // :urn:oasis:names:tc:[^:]:.*
 518     sal_Int32 nTCIdStart = nPos+1;
 519     sal_Int32 nTCIdEnd = rName.indexOf( ':', nTCIdStart );
 520     if( -1 == nTCIdEnd )
 521         return false;
 522
 523     // :urn:oasis:names:tc:[^:]:xmlns.*
 524     nPos = nTCIdEnd + 1;
 525     OUString sTmp( rName.copy( nPos ) );
 526     const OUString& rXMLNS = GetXMLToken( XML_XMLNS );
 527     if( !sTmp.startsWith( rXMLNS ) )
 528         return false;
 529
 530     // :urn:oasis:names:tc:[^:]:xmlns:.*
 531     nPos += rXMLNS.getLength();
 532     if( nPos >= nNameLen || rName[nPos] != ':' )
 533         return false;
 534
 535     // :urn:oasis:names:tc:[^:]:xmlns:[^:]*:.*
 536     nPos = rName.indexOf( ':', nPos+1 );
 537     if( -1 == nPos )
 538         return false;
 539
 540     // :urn:oasis:names:tc:[^:]:xmlns:[^:]*:[^:][^:][^:][^:]*
 541     sal_Int32 nVersionStart = nPos+1;
 542     if( nVersionStart+2 >= nNameLen ||
 543         -1 != rName.indexOf( ':', nVersionStart ) )
 544         return false;
 545
 546     // :urn:oasis:names:tc:[^:]:xmlns:[^:]*:1\.[^:][^:]*
 547     if( rName[nVersionStart] != '1' || rName[nVersionStart+1] != '.' )
 548         return false;
 549
 550     // replace [tcid] with current TCID and version with current version.
 551
 552     rName = rName.copy( 0, nTCIdStart ) +
 553             GetXMLToken( XML_OPENDOCUMENT ) +
 554             rName.copy( nTCIdEnd, nVersionStart-nTCIdEnd ) +
 555             GetXMLToken( XML_1_0 );
 556
 557     return true;
 558 }
 559
 560 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */