scripting/source/stringresource/stringresource.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 <memory>
  21 #include "stringresource.hxx"
  22 #include <com/sun/star/io/TempFile.hpp>
  23 #include <com/sun/star/io/TextInputStream.hpp>
  24 #include <com/sun/star/io/TextOutputStream.hpp>
  25 #include <com/sun/star/io/XStream.hpp>
  26 #include <com/sun/star/io/XSeekable.hpp>
  27 #include <com/sun/star/embed/ElementModes.hpp>
  28 #include <com/sun/star/lang/NoSupportException.hpp>
  29 #include <com/sun/star/resource/MissingResourceException.hpp>
  30 #include <cppuhelper/supportsservice.hxx>
  31 #include <com/sun/star/beans/XPropertySet.hpp>
  32 #include <com/sun/star/container/ElementExistException.hpp>
  33 #include <com/sun/star/ucb/SimpleFileAccess.hpp>
  34
  35 #include <osl/diagnose.h>
  36 #include <o3tl/string_view.hxx>
  37 #include <rtl/ref.hxx>
  38 #include <rtl/tencinfo.h>
  39 #include <rtl/ustrbuf.hxx>
  40 #include <tools/urlobj.hxx>
  41 #include <unotools/tempfile.hxx>
  42 #include <i18nlangtag/languagetag.hxx>
  43 #include <sal/log.hxx>
  44
  45 using namespace ::com::sun::star;
  46 using namespace ::com::sun::star::lang;
  47 using namespace ::com::sun::star::uno;
  48 using namespace ::com::sun::star::ucb;
  49 using namespace ::com::sun::star::util;
  50 using namespace ::com::sun::star::embed;
  51 using namespace ::com::sun::star::container;
  52
  53
  54 namespace stringresource
  55 {
  56
  57 // StringResourceImpl
  58
  59 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
  60 scripting_StringResourcePersistenceImpl_implementation(
  61     css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const&)
  62 {
  63     return cppu::acquire(new StringResourcePersistenceImpl(context));
  64 }
  65
  66
  67 StringResourceImpl::StringResourceImpl( const Reference< XComponentContext >& rxContext )
  68     : m_xContext( rxContext )
  69     , m_pCurrentLocaleItem( nullptr )
  70     , m_pDefaultLocaleItem( nullptr )
  71     , m_bDefaultModified( false )
  72     , m_bModified( false )
  73     , m_bReadOnly( false )
  74     , m_nNextUniqueNumericId( UNIQUE_NUMBER_NEEDS_INITIALISATION )
  75 {
  76 }
  77
  78
  79 StringResourceImpl::~StringResourceImpl()
  80 {
  81 }
  82
  83
  84 // XServiceInfo
  85
  86 OUString StringResourceImpl::getImplementationName(  )
  87 {
  88     return "com.sun.star.comp.scripting.StringResource";
  89 }
  90
  91 sal_Bool StringResourceImpl::supportsService( const OUString& rServiceName )
  92 {
  93     return cppu::supportsService(this, rServiceName);
  94 }
  95
  96 Sequence< OUString > StringResourceImpl::getSupportedServiceNames(  )
  97 {
  98     return { "com.sun.star.resource.StringResource" };
  99 }
 100
 101
 102 // XModifyBroadcaster
 103
 104 void StringResourceImpl::addModifyListener( const Reference< XModifyListener >& aListener )
 105 {
 106     if( !aListener.is() )
 107         throw RuntimeException();
 108
 109     std::unique_lock aGuard( m_aMutex );
 110     m_aListenerContainer.addInterface( aGuard, aListener );
 111 }
 112
 113 void StringResourceImpl::removeModifyListener( const Reference< XModifyListener >& aListener )
 114 {
 115     if( !aListener.is() )
 116         throw RuntimeException();
 117
 118     std::unique_lock aGuard( m_aMutex );
 119     m_aListenerContainer.removeInterface( aGuard, aListener );
 120 }
 121
 122
 123 // XStringResourceResolver
 124
 125 OUString StringResourceImpl::implResolveString
 126     ( const OUString& ResourceID, LocaleItem* pLocaleItem )
 127 {
 128     OUString aRetStr;
 129     bool bSuccess = false;
 130     if( pLocaleItem != nullptr && loadLocale( pLocaleItem ) )
 131     {
 132         IdToStringMap::iterator it = pLocaleItem->m_aIdToStringMap.find( ResourceID );
 133         if( it != pLocaleItem->m_aIdToStringMap.end() )
 134         {
 135             aRetStr = (*it).second;
 136             bSuccess = true;
 137         }
 138     }
 139     if( !bSuccess )
 140     {
 141         throw css::resource::MissingResourceException( "StringResourceImpl: No entry for ResourceID: " + ResourceID );
 142     }
 143     return aRetStr;
 144 }
 145
 146 OUString StringResourceImpl::resolveString( const OUString& ResourceID )
 147 {
 148     std::unique_lock aGuard( m_aMutex );
 149     return implResolveString( ResourceID, m_pCurrentLocaleItem );
 150 }
 151
 152 OUString StringResourceImpl::resolveStringForLocale( const OUString& ResourceID, const Locale& locale )
 153 {
 154     std::unique_lock aGuard( m_aMutex );
 155     LocaleItem* pLocaleItem = getItemForLocale( locale, false );
 156     return implResolveString( ResourceID, pLocaleItem );
 157 }
 158
 159 bool StringResourceImpl::implHasEntryForId( const OUString& ResourceID, LocaleItem* pLocaleItem )
 160 {
 161     bool bSuccess = false;
 162     if( pLocaleItem != nullptr && loadLocale( pLocaleItem ) )
 163     {
 164         IdToStringMap::iterator it = pLocaleItem->m_aIdToStringMap.find( ResourceID );
 165         if( it != pLocaleItem->m_aIdToStringMap.end() )
 166             bSuccess = true;
 167     }
 168     return bSuccess;
 169 }
 170
 171 sal_Bool StringResourceImpl::hasEntryForId( const OUString& ResourceID )
 172 {
 173     std::unique_lock aGuard( m_aMutex );
 174     return implHasEntryForId( ResourceID, m_pCurrentLocaleItem );
 175 }
 176
 177 sal_Bool StringResourceImpl::hasEntryForIdAndLocale( const OUString& ResourceID,
 178     const Locale& locale )
 179 {
 180     std::unique_lock aGuard( m_aMutex );
 181     LocaleItem* pLocaleItem = getItemForLocale( locale, false );
 182     return implHasEntryForId( ResourceID, pLocaleItem );
 183 }
 184
 185 Sequence< OUString > StringResourceImpl::implGetResourceIDs( LocaleItem* pLocaleItem )
 186 {
 187     Sequence< OUString > aIDSeq( 0 );
 188     if( pLocaleItem && loadLocale( pLocaleItem ) )
 189     {
 190         const IdToStringMap& rHashMap = pLocaleItem->m_aIdToStringMap;
 191         sal_Int32 nResourceIDCount = rHashMap.size();
 192         aIDSeq.realloc( nResourceIDCount );
 193         OUString* pStrings = aIDSeq.getArray();
 194
 195         int iTarget = 0;
 196         for( const auto& rEntry : rHashMap )
 197         {
 198             pStrings[iTarget] = rEntry.first;
 199             iTarget++;
 200         }
 201     }
 202     return aIDSeq;
 203 }
 204
 205 Sequence< OUString > StringResourceImpl::getResourceIDsForLocale
 206     ( const Locale& locale )
 207 {
 208     std::unique_lock aGuard( m_aMutex );
 209     LocaleItem* pLocaleItem = getItemForLocale( locale, false );
 210     return implGetResourceIDs( pLocaleItem );
 211 }
 212
 213 Sequence< OUString > StringResourceImpl::getResourceIDs(  )
 214 {
 215     std::unique_lock aGuard( m_aMutex );
 216     return implGetResourceIDs( m_pCurrentLocaleItem );
 217 }
 218
 219 Locale StringResourceImpl::getCurrentLocale()
 220 {
 221     std::unique_lock aGuard( m_aMutex );
 222
 223     Locale aRetLocale;
 224     if( m_pCurrentLocaleItem != nullptr )
 225         aRetLocale = m_pCurrentLocaleItem->m_locale;
 226     return aRetLocale;
 227 }
 228
 229 Locale StringResourceImpl::getDefaultLocale(  )
 230 {
 231     std::unique_lock aGuard( m_aMutex );
 232
 233     Locale aRetLocale;
 234     if( m_pDefaultLocaleItem != nullptr )
 235         aRetLocale = m_pDefaultLocaleItem->m_locale;
 236     return aRetLocale;
 237 }
 238
 239 Sequence< Locale > StringResourceImpl::getLocales(  )
 240 {
 241     std::unique_lock aGuard( m_aMutex );
 242
 243     sal_Int32 nSize = m_aLocaleItemVector.size();
 244     Sequence< Locale > aLocalSeq( nSize );
 245     Locale* pLocales = aLocalSeq.getArray();
 246     int iTarget = 0;
 247     for( const auto& pLocaleItem : m_aLocaleItemVector )
 248     {
 249         pLocales[iTarget] = pLocaleItem->m_locale;
 250         iTarget++;
 251     }
 252     return aLocalSeq;
 253 }
 254
 255
 256 // XStringResourceManager
 257
 258 void StringResourceImpl::implCheckReadOnly( const char* pExceptionMsg )
 259 {
 260     if( m_bReadOnly )
 261     {
 262         OUString errorMsg = OUString::createFromAscii( pExceptionMsg );
 263         throw NoSupportException( errorMsg );
 264     }
 265 }
 266
 267 sal_Bool StringResourceImpl::isReadOnly()
 268 {
 269     return m_bReadOnly;
 270 }
 271
 272 void StringResourceImpl::implSetCurrentLocale( std::unique_lock<std::mutex>& rGuard, const Locale& locale,
 273     bool FindClosestMatch, bool bUseDefaultIfNoMatch )
 274 {
 275     LocaleItem* pLocaleItem = nullptr;
 276     if( FindClosestMatch )
 277         pLocaleItem = getClosestMatchItemForLocale( locale );
 278     else
 279         pLocaleItem = getItemForLocale( locale, true );
 280
 281     if( pLocaleItem == nullptr && bUseDefaultIfNoMatch )
 282         pLocaleItem = m_pDefaultLocaleItem;
 283
 284     if( pLocaleItem != nullptr )
 285     {
 286         (void)loadLocale( pLocaleItem );
 287         m_pCurrentLocaleItem = pLocaleItem;
 288
 289         // Only notify without modifying
 290         implNotifyListeners(rGuard);
 291     }
 292 }
 293
 294 void StringResourceImpl::setCurrentLocale( const Locale& locale, sal_Bool FindClosestMatch )
 295 {
 296     std::unique_lock aGuard( m_aMutex );
 297     implSetCurrentLocale( aGuard, locale, FindClosestMatch, false/*bUseDefaultIfNoMatch*/ );
 298 }
 299
 300 void StringResourceImpl::setDefaultLocale( const Locale& locale )
 301 {
 302     std::unique_lock aGuard( m_aMutex );
 303     implCheckReadOnly( "StringResourceImpl::setDefaultLocale(): Read only" );
 304
 305     LocaleItem* pLocaleItem = getItemForLocale( locale, true );
 306     if( pLocaleItem && pLocaleItem != m_pDefaultLocaleItem )
 307     {
 308         if( m_pDefaultLocaleItem )
 309         {
 310             m_aChangedDefaultLocaleVector.push_back(
 311                 std::make_unique<LocaleItem>( m_pDefaultLocaleItem->m_locale ) );
 312         }
 313
 314         m_pDefaultLocaleItem = pLocaleItem;
 315         m_bDefaultModified = true;
 316         implModified(aGuard);
 317     }
 318 }
 319
 320 void StringResourceImpl::implSetString( std::unique_lock<std::mutex>& rGuard, const OUString& ResourceID,
 321     const OUString& Str, LocaleItem* pLocaleItem )
 322 {
 323     if( !(pLocaleItem != nullptr && loadLocale( pLocaleItem )) )
 324         return;
 325
 326     IdToStringMap& rHashMap = pLocaleItem->m_aIdToStringMap;
 327
 328     IdToStringMap::iterator it = rHashMap.find( ResourceID );
 329     bool bNew = ( it == rHashMap.end() );
 330     if( bNew )
 331     {
 332         IdToIndexMap& rIndexMap = pLocaleItem->m_aIdToIndexMap;
 333         rIndexMap[ ResourceID ] = pLocaleItem->m_nNextIndex++;
 334         implScanIdForNumber( ResourceID );
 335     }
 336     rHashMap[ ResourceID ] = Str;
 337     pLocaleItem->m_bModified = true;
 338     implModified(rGuard);
 339 }
 340
 341 void StringResourceImpl::setString( const OUString& ResourceID, const OUString& Str )
 342 {
 343     std::unique_lock aGuard( m_aMutex );
 344     implCheckReadOnly( "StringResourceImpl::setString(): Read only" );
 345     implSetString( aGuard, ResourceID, Str, m_pCurrentLocaleItem );
 346 }
 347
 348 void StringResourceImpl::setStringForLocale
 349     ( const OUString& ResourceID, const OUString& Str, const Locale& locale )
 350 {
 351     std::unique_lock aGuard( m_aMutex );
 352     implCheckReadOnly( "StringResourceImpl::setStringForLocale(): Read only" );
 353     LocaleItem* pLocaleItem = getItemForLocale( locale, false );
 354     implSetString( aGuard, ResourceID, Str, pLocaleItem );
 355 }
 356
 357 void StringResourceImpl::implRemoveId( std::unique_lock<std::mutex>& rGuard, const OUString& ResourceID, LocaleItem* pLocaleItem )
 358 {
 359     if( pLocaleItem != nullptr && loadLocale( pLocaleItem ) )
 360     {
 361         IdToStringMap& rHashMap = pLocaleItem->m_aIdToStringMap;
 362         IdToStringMap::iterator it = rHashMap.find( ResourceID );
 363         if( it == rHashMap.end() )
 364         {
 365             throw css::resource::MissingResourceException( "StringResourceImpl: No entries for ResourceID: " + ResourceID );
 366         }
 367         rHashMap.erase( it );
 368         pLocaleItem->m_bModified = true;
 369         implModified(rGuard);
 370     }
 371 }
 372
 373 void StringResourceImpl::removeId( const OUString& ResourceID )
 374 {
 375     std::unique_lock aGuard( m_aMutex );
 376     implCheckReadOnly( "StringResourceImpl::removeId(): Read only" );
 377     implRemoveId( aGuard, ResourceID, m_pCurrentLocaleItem );
 378 }
 379
 380 void StringResourceImpl::removeIdForLocale( const OUString& ResourceID, const Locale& locale )
 381 {
 382     std::unique_lock aGuard( m_aMutex );
 383     implCheckReadOnly( "StringResourceImpl::removeIdForLocale(): Read only" );
 384     LocaleItem* pLocaleItem = getItemForLocale( locale, false );
 385     implRemoveId( aGuard, ResourceID, pLocaleItem );
 386 }
 387
 388 void StringResourceImpl::newLocale( const Locale& locale )
 389 {
 390     std::unique_lock aGuard( m_aMutex );
 391     implCheckReadOnly( "StringResourceImpl::newLocale(): Read only" );
 392
 393     if( getItemForLocale( locale, false ) != nullptr )
 394     {
 395         throw ElementExistException( "StringResourceImpl: locale already exists" );
 396     }
 397
 398     // TODO?: Check if locale is valid? How?
 399     //if (!bValid)
 400     //{
 401     //    OUString errorMsg("StringResourceImpl: Invalid locale");
 402     //    throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 0 );
 403     //}
 404
 405     LocaleItem* pLocaleItem = new LocaleItem( locale );
 406     m_aLocaleItemVector.emplace_back( pLocaleItem );
 407     pLocaleItem->m_bModified = true;
 408
 409     // Copy strings from default locale
 410     LocaleItem* pCopyFromItem = m_pDefaultLocaleItem;
 411     if( pCopyFromItem == nullptr )
 412         pCopyFromItem = m_pCurrentLocaleItem;
 413     if( pCopyFromItem != nullptr && loadLocale( pCopyFromItem ) )
 414     {
 415         const IdToStringMap& rSourceMap = pCopyFromItem->m_aIdToStringMap;
 416         IdToStringMap& rTargetMap = pLocaleItem->m_aIdToStringMap;
 417         for( const auto& rEntry : rSourceMap )
 418         {
 419             OUString aId  = rEntry.first;
 420             OUString aStr = rEntry.second;
 421             rTargetMap[ aId ] = aStr;
 422         }
 423
 424         const IdToIndexMap& rSourceIndexMap = pCopyFromItem->m_aIdToIndexMap;
 425         IdToIndexMap& rTargetIndexMap = pLocaleItem->m_aIdToIndexMap;
 426         for( const auto& rIndex : rSourceIndexMap )
 427         {
 428             OUString aId = rIndex.first;
 429             sal_Int32 nIndex = rIndex.second;
 430             rTargetIndexMap[ aId ] = nIndex;
 431         }
 432         pLocaleItem->m_nNextIndex = pCopyFromItem->m_nNextIndex;
 433     }
 434
 435     if( m_pCurrentLocaleItem == nullptr )
 436         m_pCurrentLocaleItem = pLocaleItem;
 437
 438     if( m_pDefaultLocaleItem == nullptr )
 439     {
 440         m_pDefaultLocaleItem = pLocaleItem;
 441         m_bDefaultModified = true;
 442     }
 443
 444     implModified(aGuard);
 445 }
 446
 447 void StringResourceImpl::removeLocale( const Locale& locale )
 448 {
 449     std::unique_lock aGuard( m_aMutex );
 450     implCheckReadOnly( "StringResourceImpl::removeLocale(): Read only" );
 451
 452     LocaleItem* pRemoveItem = getItemForLocale( locale, true );
 453     if( !pRemoveItem )
 454         return;
 455
 456     // Last locale?
 457     sal_Int32 nLocaleCount = m_aLocaleItemVector.size();
 458     if( nLocaleCount > 1 )
 459     {
 460         if( m_pCurrentLocaleItem == pRemoveItem ||
 461             m_pDefaultLocaleItem  == pRemoveItem )
 462         {
 463             LocaleItem* pFallbackItem = nullptr;
 464             for( const auto& pLocaleItem : m_aLocaleItemVector )
 465             {
 466                 if( pLocaleItem.get() != pRemoveItem )
 467                 {
 468                     pFallbackItem = pLocaleItem.get();
 469                     break;
 470                 }
 471             }
 472             if( m_pCurrentLocaleItem == pRemoveItem )
 473             {
 474                 setCurrentLocale( pFallbackItem->m_locale, false/*FindClosestMatch*/ );
 475             }
 476             if( m_pDefaultLocaleItem == pRemoveItem )
 477             {
 478                 setDefaultLocale( pFallbackItem->m_locale );
 479             }
 480         }
 481     }
 482     auto it = std::find_if(m_aLocaleItemVector.begin(), m_aLocaleItemVector.end(),
 483         [&pRemoveItem](const std::unique_ptr<LocaleItem>& rxItem) { return rxItem.get() == pRemoveItem; });
 484     if (it == m_aLocaleItemVector.end())
 485         return;
 486
 487     // Remember locale item to delete file while storing
 488     m_aDeletedLocaleItemVector.push_back( std::move(*it) );
 489
 490     // Last locale?
 491     if( nLocaleCount == 1 )
 492     {
 493         m_nNextUniqueNumericId = 0;
 494         if( m_pDefaultLocaleItem )
 495         {
 496             m_aChangedDefaultLocaleVector.push_back(
 497                     std::make_unique<LocaleItem>( m_pDefaultLocaleItem->m_locale ) );
 498         }
 499         m_pCurrentLocaleItem = nullptr;
 500         m_pDefaultLocaleItem = nullptr;
 501     }
 502
 503     m_aLocaleItemVector.erase( it );
 504
 505     implModified(aGuard);
 506 }
 507
 508 void StringResourceImpl::implScanIdForNumber( const OUString& ResourceID )
 509 {
 510     const sal_Unicode* pSrc = ResourceID.getStr();
 511     sal_Int32 nLen = ResourceID.getLength();
 512
 513     sal_Int32 nNumber = 0;
 514     for( sal_Int32 i = 0 ; i < nLen ; i++ )
 515     {
 516         sal_Unicode c = pSrc[i];
 517         if( c >= '0' && c <= '9' )
 518         {
 519             sal_uInt16 nDigitVal = c - '0';
 520             nNumber = 10*nNumber + nDigitVal;
 521         }
 522         else
 523             break;
 524     }
 525
 526     if( m_nNextUniqueNumericId < nNumber + 1 )
 527         m_nNextUniqueNumericId = nNumber + 1;
 528 }
 529
 530 sal_Int32 StringResourceImpl::getUniqueNumericId(  )
 531 {
 532     if( m_nNextUniqueNumericId == UNIQUE_NUMBER_NEEDS_INITIALISATION )
 533     {
 534         implLoadAllLocales();
 535         m_nNextUniqueNumericId = 0;
 536     }
 537
 538     if( m_nNextUniqueNumericId < UNIQUE_NUMBER_NEEDS_INITIALISATION )
 539     {
 540         throw NoSupportException( "getUniqueNumericId: Extended sal_Int32 range" );
 541     }
 542     return m_nNextUniqueNumericId;
 543 }
 544
 545
 546 // Private helper methods
 547
 548 LocaleItem* StringResourceImpl::getItemForLocale
 549     ( const Locale& locale, bool bException )
 550 {
 551     LocaleItem* pRetItem = nullptr;
 552
 553     // Search for locale
 554     for( auto& pLocaleItem : m_aLocaleItemVector )
 555     {
 556         if( pLocaleItem )
 557         {
 558             Locale& cmp_locale = pLocaleItem->m_locale;
 559             if( cmp_locale.Language == locale.Language &&
 560                 cmp_locale.Country  == locale.Country &&
 561                 cmp_locale.Variant  == locale.Variant )
 562             {
 563                 pRetItem = pLocaleItem.get();
 564                 break;
 565             }
 566         }
 567     }
 568
 569     if( pRetItem == nullptr && bException )
 570     {
 571         throw IllegalArgumentException( "StringResourceImpl: Invalid locale", Reference< XInterface >(), 0 );
 572     }
 573     return pRetItem;
 574 }
 575
 576 // Returns the LocaleItem for a given locale, if it exists, otherwise NULL.
 577 // This method performs a closest match search, at least the language must match.
 578 LocaleItem* StringResourceImpl::getClosestMatchItemForLocale( const Locale& locale )
 579 {
 580     LocaleItem* pRetItem = nullptr;
 581
 582     ::std::vector< Locale > aLocales( m_aLocaleItemVector.size());
 583     size_t i = 0;
 584     for( const auto& pLocaleItem : m_aLocaleItemVector )
 585     {
 586         aLocales[i] = (pLocaleItem ? pLocaleItem->m_locale : Locale());
 587         ++i;
 588     }
 589     ::std::vector< Locale >::const_iterator iFound( LanguageTag::getMatchingFallback( aLocales, locale));
 590     if (iFound != aLocales.end())
 591         pRetItem = (m_aLocaleItemVector.begin() + (iFound - aLocales.begin()))->get();
 592
 593     return pRetItem;
 594 }
 595
 596 void StringResourceImpl::implModified(std::unique_lock<std::mutex>& rGuard)
 597 {
 598     m_bModified = true;
 599     implNotifyListeners(rGuard);
 600 }
 601
 602 void StringResourceImpl::implNotifyListeners(std::unique_lock<std::mutex>& rGuard)
 603 {
 604     EventObject aEvent;
 605     aEvent.Source = getXWeak();
 606     m_aListenerContainer.forEach(rGuard,
 607         [&aEvent](const css::uno::Reference<XModifyListener>& xListener)
 608         {
 609             xListener->modified(aEvent);
 610         }
 611     );
 612 }
 613
 614
 615 // Loading
 616
 617 bool StringResourceImpl::loadLocale( LocaleItem* )
 618 {
 619     // Base implementation has nothing to load
 620     return true;
 621 }
 622
 623 void StringResourceImpl::implLoadAllLocales()
 624 {
 625     // Base implementation has nothing to load
 626 }
 627
 628
 629 // StringResourcePersistenceImpl
 630
 631
 632 StringResourcePersistenceImpl::StringResourcePersistenceImpl( const Reference< XComponentContext >& rxContext )
 633     : StringResourcePersistenceImpl_BASE( rxContext )
 634 {
 635 }
 636
 637
 638 StringResourcePersistenceImpl::~StringResourcePersistenceImpl()
 639 {
 640 }
 641
 642
 643 // XServiceInfo
 644
 645
 646 OUString StringResourcePersistenceImpl::getImplementationName(  )
 647 {
 648     return "com.sun.star.comp.scripting.StringResource";
 649 }
 650
 651
 652 sal_Bool StringResourcePersistenceImpl::supportsService( const OUString& rServiceName )
 653 {
 654     return cppu::supportsService( this, rServiceName );
 655 }
 656
 657
 658 Sequence< OUString > StringResourcePersistenceImpl::getSupportedServiceNames(  )
 659 {
 660     return StringResourceImpl::getSupportedServiceNames();
 661 }
 662
 663
 664 // XInitialization base functionality for derived classes
 665
 666
 667 constexpr OUString aNameBaseDefaultStr = u"strings"_ustr;
 668
 669 void StringResourcePersistenceImpl::implInitializeCommonParameters
 670     ( std::unique_lock<std::mutex>& rGuard, const Sequence< Any >& aArguments )
 671 {
 672     bool bReadOnlyOk = (aArguments[1] >>= m_bReadOnly);
 673     if( !bReadOnlyOk )
 674     {
 675         throw IllegalArgumentException( "XInitialization::initialize: Expected ReadOnly flag", Reference< XInterface >(), 1 );
 676     }
 677
 678     css::lang::Locale aCurrentLocale;
 679     bool bLocaleOk = (aArguments[2] >>= aCurrentLocale);
 680     if( !bLocaleOk )
 681     {
 682         throw IllegalArgumentException( "XInitialization::initialize: Expected Locale", Reference< XInterface >(), 2 );
 683     }
 684
 685     bool bNameBaseOk = (aArguments[3] >>= m_aNameBase);
 686     if( !bNameBaseOk )
 687     {
 688         throw IllegalArgumentException( "XInitialization::initialize: Expected NameBase string", Reference< XInterface >(), 3 );
 689     }
 690     if( m_aNameBase.isEmpty() )
 691         m_aNameBase = aNameBaseDefaultStr;
 692
 693     bool bCommentOk = (aArguments[4] >>= m_aComment);
 694     if( !bCommentOk )
 695     {
 696         throw IllegalArgumentException( "XInitialization::initialize: Expected Comment string", Reference< XInterface >(), 4 );
 697     }
 698
 699     implScanLocales();
 700
 701     implSetCurrentLocale( rGuard, aCurrentLocale, true/*FindClosestMatch*/, true/*bUseDefaultIfNoMatch*/ );
 702 }
 703
 704
 705 // Forwarding calls to base class
 706
 707 // XModifyBroadcaster
 708 void StringResourcePersistenceImpl::addModifyListener( const Reference< XModifyListener >& aListener )
 709 {
 710     StringResourceImpl::addModifyListener( aListener );
 711 }
 712 void StringResourcePersistenceImpl::removeModifyListener( const Reference< XModifyListener >& aListener )
 713 {
 714     StringResourceImpl::removeModifyListener( aListener );
 715 }
 716
 717 // XStringResourceResolver
 718 OUString StringResourcePersistenceImpl::resolveString( const OUString& ResourceID )
 719 {
 720     return StringResourceImpl::resolveString( ResourceID ) ;
 721 }
 722 OUString StringResourcePersistenceImpl::resolveStringForLocale( const OUString& ResourceID, const Locale& locale )
 723 {
 724     return StringResourceImpl::resolveStringForLocale( ResourceID, locale );
 725 }
 726 sal_Bool StringResourcePersistenceImpl::hasEntryForId( const OUString& ResourceID )
 727 {
 728     return StringResourceImpl::hasEntryForId( ResourceID ) ;
 729 }
 730 sal_Bool StringResourcePersistenceImpl::hasEntryForIdAndLocale( const OUString& ResourceID,
 731     const Locale& locale )
 732 {
 733     return StringResourceImpl::hasEntryForIdAndLocale( ResourceID, locale );
 734 }
 735 Locale StringResourcePersistenceImpl::getCurrentLocale()
 736 {
 737     return StringResourceImpl::getCurrentLocale();
 738 }
 739 Locale StringResourcePersistenceImpl::getDefaultLocale(  )
 740 {
 741     return StringResourceImpl::getDefaultLocale();
 742 }
 743 Sequence< Locale > StringResourcePersistenceImpl::getLocales(  )
 744 {
 745     return StringResourceImpl::getLocales();
 746 }
 747
 748 // XStringResourceManager
 749 sal_Bool StringResourcePersistenceImpl::isReadOnly()
 750 {
 751     return StringResourceImpl::isReadOnly();
 752 }
 753 void StringResourcePersistenceImpl::setCurrentLocale( const Locale& locale, sal_Bool FindClosestMatch )
 754 {
 755     StringResourceImpl::setCurrentLocale( locale, FindClosestMatch );
 756 }
 757 void StringResourcePersistenceImpl::setDefaultLocale( const Locale& locale )
 758 {
 759     StringResourceImpl::setDefaultLocale( locale );
 760 }
 761 Sequence< OUString > StringResourcePersistenceImpl::getResourceIDs(  )
 762 {
 763     return StringResourceImpl::getResourceIDs();
 764 }
 765 void StringResourcePersistenceImpl::setString( const OUString& ResourceID, const OUString& Str )
 766 {
 767     StringResourceImpl::setString( ResourceID, Str );
 768 }
 769 void StringResourcePersistenceImpl::setStringForLocale
 770     ( const OUString& ResourceID, const OUString& Str, const Locale& locale )
 771 {
 772     StringResourceImpl::setStringForLocale( ResourceID, Str, locale );
 773 }
 774 Sequence< OUString > StringResourcePersistenceImpl::getResourceIDsForLocale
 775     ( const Locale& locale )
 776 {
 777     return StringResourceImpl::getResourceIDsForLocale( locale );
 778 }
 779 void StringResourcePersistenceImpl::removeId( const OUString& ResourceID )
 780 {
 781     StringResourceImpl::removeId( ResourceID );
 782 }
 783 void StringResourcePersistenceImpl::removeIdForLocale( const OUString& ResourceID, const Locale& locale )
 784 {
 785     StringResourceImpl::removeIdForLocale( ResourceID, locale );
 786 }
 787 void StringResourcePersistenceImpl::newLocale( const Locale& locale )
 788 {
 789     StringResourceImpl::newLocale( locale );
 790 }
 791 void StringResourcePersistenceImpl::removeLocale( const Locale& locale )
 792 {
 793     StringResourceImpl::removeLocale( locale );
 794 }
 795 sal_Int32 StringResourcePersistenceImpl::getUniqueNumericId(  )
 796 {
 797     return StringResourceImpl::getUniqueNumericId();
 798 }
 799
 800
 801 // XStringResourcePersistence
 802
 803 void StringResourcePersistenceImpl::store()
 804 {
 805 }
 806
 807 sal_Bool StringResourcePersistenceImpl::isModified(  )
 808 {
 809     std::unique_lock aGuard( m_aMutex );
 810
 811     return m_bModified;
 812 }
 813
 814 void StringResourcePersistenceImpl::setComment( const OUString& Comment )
 815 {
 816     m_aComment = Comment;
 817 }
 818
 819 void StringResourcePersistenceImpl::storeToStorage( const Reference< XStorage >& Storage,
 820     const OUString& NameBase, const OUString& Comment )
 821 {
 822     std::unique_lock aGuard( m_aMutex );
 823
 824     implStoreAtStorage( NameBase, Comment, Storage, false/*bUsedForStore*/, true/*bStoreAll*/ );
 825 }
 826
 827 void StringResourcePersistenceImpl::implStoreAtStorage
 828 (
 829     const OUString& aNameBase,
 830     const OUString& aComment,
 831     const Reference< css::embed::XStorage >& Storage,
 832     bool bUsedForStore,
 833     bool bStoreAll
 834 )
 835 {
 836     // Delete files for deleted locales
 837     if( bUsedForStore )
 838     {
 839         for( auto& pLocaleItem : m_aDeletedLocaleItemVector )
 840         {
 841             if( pLocaleItem )
 842             {
 843                 OUString aStreamName = implGetFileNameForLocaleItem( pLocaleItem.get(), m_aNameBase ) + ".properties";
 844
 845                 try
 846                 {
 847                     Storage->removeElement( aStreamName );
 848                 }
 849                 catch( Exception& )
 850                 {}
 851
 852                 pLocaleItem.reset();
 853             }
 854         }
 855         m_aDeletedLocaleItemVector.clear();
 856     }
 857
 858     for( auto& pLocaleItem : m_aLocaleItemVector )
 859     {
 860         if( pLocaleItem != nullptr && (bStoreAll || pLocaleItem->m_bModified) &&
 861             loadLocale( pLocaleItem.get() ) )
 862         {
 863             OUString aStreamName = implGetFileNameForLocaleItem( pLocaleItem.get(), aNameBase ) + ".properties";
 864
 865             Reference< io::XStream > xElementStream =
 866                     Storage->openStreamElement( aStreamName, ElementModes::READWRITE );
 867
 868             uno::Reference< beans::XPropertySet > xProps( xElementStream, uno::UNO_QUERY );
 869             OSL_ENSURE( xProps.is(), "The StorageStream must implement XPropertySet interface!" );
 870             if ( xProps.is() )
 871             {
 872                 OUString aPropName("MediaType");
 873                 xProps->setPropertyValue( aPropName, uno::Any( OUString("text/plain") ) );
 874
 875                 aPropName = "UseCommonStoragePasswordEncryption";
 876                 xProps->setPropertyValue( aPropName, uno::Any( true ) );
 877             }
 878
 879             Reference< io::XOutputStream > xOutputStream = xElementStream->getOutputStream();
 880             if( xOutputStream.is() )
 881                 implWritePropertiesFile( pLocaleItem.get(), xOutputStream, aComment );
 882             xOutputStream->closeOutput();
 883
 884             if( bUsedForStore )
 885                 pLocaleItem->m_bModified = false;
 886         }
 887     }
 888
 889     // Delete files for changed defaults
 890     if( bUsedForStore )
 891     {
 892         for( auto& pLocaleItem : m_aChangedDefaultLocaleVector )
 893         {
 894             OUString aStreamName = implGetFileNameForLocaleItem( pLocaleItem.get(), m_aNameBase ) + ".default";
 895
 896             try
 897             {
 898                 Storage->removeElement( aStreamName );
 899             }
 900             catch( Exception& )
 901             {}
 902
 903             pLocaleItem.reset();
 904         }
 905         m_aChangedDefaultLocaleVector.clear();
 906     }
 907
 908     // Default locale
 909     if( !(m_pDefaultLocaleItem != nullptr && (bStoreAll || m_bDefaultModified)) )
 910         return;
 911
 912     OUString aStreamName = implGetFileNameForLocaleItem( m_pDefaultLocaleItem, aNameBase ) + ".default";
 913
 914     Reference< io::XStream > xElementStream =
 915             Storage->openStreamElement( aStreamName, ElementModes::READWRITE );
 916
 917     // Only create stream without content
 918     Reference< io::XOutputStream > xOutputStream = xElementStream->getOutputStream();
 919     xOutputStream->closeOutput();
 920
 921     if( bUsedForStore )
 922         m_bDefaultModified = false;
 923 }
 924
 925 void StringResourcePersistenceImpl::storeToURL( const OUString& URL,
 926     const OUString& NameBase, const OUString& Comment,
 927     const Reference< css::task::XInteractionHandler >& Handler )
 928 {
 929     std::unique_lock aGuard( m_aMutex );
 930
 931     Reference< ucb::XSimpleFileAccess3 > xFileAccess = ucb::SimpleFileAccess::create(m_xContext);
 932     if( xFileAccess.is() && Handler.is() )
 933         xFileAccess->setInteractionHandler( Handler );
 934
 935     implStoreAtLocation( URL, NameBase, Comment, xFileAccess, false/*bUsedForStore*/, true/*bStoreAll*/ );
 936 }
 937
 938 void StringResourcePersistenceImpl::implKillRemovedLocaleFiles
 939 (
 940     std::u16string_view Location,
 941     const OUString& aNameBase,
 942     const css::uno::Reference< css::ucb::XSimpleFileAccess3 >& xFileAccess
 943 )
 944 {
 945     // Delete files for deleted locales
 946     for( auto& pLocaleItem : m_aDeletedLocaleItemVector )
 947     {
 948         if( pLocaleItem )
 949         {
 950             OUString aCompleteFileName =
 951                 implGetPathForLocaleItem( pLocaleItem.get(), aNameBase, Location );
 952             if( xFileAccess->exists( aCompleteFileName ) )
 953                 xFileAccess->kill( aCompleteFileName );
 954
 955             pLocaleItem.reset();
 956         }
 957     }
 958     m_aDeletedLocaleItemVector.clear();
 959 }
 960
 961 void StringResourcePersistenceImpl::implKillChangedDefaultFiles
 962 (
 963     std::u16string_view Location,
 964     const OUString& aNameBase,
 965     const css::uno::Reference< css::ucb::XSimpleFileAccess3 >& xFileAccess
 966 )
 967 {
 968     // Delete files for changed defaults
 969     for( auto& pLocaleItem : m_aChangedDefaultLocaleVector )
 970     {
 971         OUString aCompleteFileName =
 972             implGetPathForLocaleItem( pLocaleItem.get(), aNameBase, Location, true );
 973         if( xFileAccess->exists( aCompleteFileName ) )
 974             xFileAccess->kill( aCompleteFileName );
 975         pLocaleItem.reset();
 976     }
 977     m_aChangedDefaultLocaleVector.clear();
 978 }
 979
 980 void StringResourcePersistenceImpl::implStoreAtLocation
 981 (
 982     std::u16string_view Location,
 983     const OUString& aNameBase,
 984     const OUString& aComment,
 985     const Reference< ucb::XSimpleFileAccess3 >& xFileAccess,
 986     bool bUsedForStore,
 987     bool bStoreAll,
 988     bool bKillAll
 989 )
 990 {
 991     // Delete files for deleted locales
 992     if( bUsedForStore || bKillAll )
 993         implKillRemovedLocaleFiles( Location, aNameBase, xFileAccess );
 994
 995     for( auto& pLocaleItem : m_aLocaleItemVector )
 996     {
 997         if( pLocaleItem != nullptr && (bStoreAll || bKillAll || pLocaleItem->m_bModified) &&
 998             loadLocale( pLocaleItem.get() ) )
 999         {
1000             OUString aCompleteFileName =
1001                 implGetPathForLocaleItem( pLocaleItem.get(), aNameBase, Location );
1002             if( xFileAccess->exists( aCompleteFileName ) )
1003                 xFileAccess->kill( aCompleteFileName );
1004
1005             if( !bKillAll )
1006             {
1007                 // Create Output stream
1008                 Reference< io::XOutputStream > xOutputStream = xFileAccess->openFileWrite( aCompleteFileName );
1009                 if( xOutputStream.is() )
1010                 {
1011                     implWritePropertiesFile( pLocaleItem.get(), xOutputStream, aComment );
1012                     xOutputStream->closeOutput();
1013                 }
1014                 if( bUsedForStore )
1015                     pLocaleItem->m_bModified = false;
1016             }
1017         }
1018     }
1019
1020     // Delete files for changed defaults
1021     if( bUsedForStore || bKillAll )
1022         implKillChangedDefaultFiles( Location, aNameBase, xFileAccess );
1023
1024     // Default locale
1025     if( !(m_pDefaultLocaleItem != nullptr && (bStoreAll || bKillAll || m_bDefaultModified)) )
1026         return;
1027
1028     OUString aCompleteFileName =
1029         implGetPathForLocaleItem( m_pDefaultLocaleItem, aNameBase, Location, true );
1030     if( xFileAccess->exists( aCompleteFileName ) )
1031         xFileAccess->kill( aCompleteFileName );
1032
1033     if( !bKillAll )
1034     {
1035         // Create Output stream
1036         Reference< io::XOutputStream > xOutputStream = xFileAccess->openFileWrite( aCompleteFileName );
1037         if( xOutputStream.is() )
1038             xOutputStream->closeOutput();
1039
1040         if( bUsedForStore )
1041             m_bDefaultModified = false;
1042     }
1043 }
1044
1045
1046 // BinaryOutput, helper class for exportBinary
1047
1048 class BinaryOutput
1049 {
1050     rtl::Reference< utl::TempFileFastService > m_xTempFile;
1051     Reference< io::XOutputStream >          m_xOutputStream;
1052
1053 public:
1054     explicit BinaryOutput();
1055
1056     const Reference< io::XOutputStream >& getOutputStream() const
1057         { return m_xOutputStream; }
1058
1059     Sequence< ::sal_Int8 > closeAndGetData();
1060
1061     // Template to be used with sal_Int16 and sal_Unicode
1062     template< class T >
1063     void write16BitInt( T n );
1064     void writeInt16( sal_Int16 n )
1065         { write16BitInt( n ); }
1066     void writeUnicodeChar( sal_Unicode n )
1067         { write16BitInt( n ); }
1068     void writeInt32( sal_Int32 n );
1069     void writeString( const OUString& aStr );
1070 };
1071
1072 BinaryOutput::BinaryOutput()
1073 {
1074     m_xTempFile = new utl::TempFileFastService;
1075     m_xOutputStream = m_xTempFile;
1076 }
1077
1078 template< class T >
1079 void BinaryOutput::write16BitInt( T n )
1080 {
1081     if( !m_xOutputStream.is() )
1082         return;
1083
1084     Sequence< sal_Int8 > aSeq( 2 );
1085     sal_Int8* p = aSeq.getArray();
1086
1087     sal_Int8 nLow  = sal_Int8( n & 0xff );
1088     sal_Int8 nHigh = sal_Int8( n >> 8 );
1089
1090     p[0] = nLow;
1091     p[1] = nHigh;
1092     m_xOutputStream->writeBytes( aSeq );
1093 }
1094
1095 void BinaryOutput::writeInt32( sal_Int32 n )
1096 {
1097     if( !m_xOutputStream.is() )
1098         return;
1099
1100     Sequence< sal_Int8 > aSeq( 4 );
1101     sal_Int8* p = aSeq.getArray();
1102
1103     for( sal_Int16 i = 0 ; i < 4 ; i++ )
1104     {
1105         p[i] = sal_Int8( n & 0xff );
1106         n >>= 8;
1107     }
1108     m_xOutputStream->writeBytes( aSeq );
1109 }
1110
1111 void BinaryOutput::writeString( const OUString& aStr )
1112 {
1113     sal_Int32 nLen = aStr.getLength();
1114     const sal_Unicode* pStr = aStr.getStr();
1115
1116     for( sal_Int32 i = 0 ; i < nLen ; i++ )
1117         writeUnicodeChar( pStr[i] );
1118
1119     writeUnicodeChar( 0 );
1120 }
1121
1122 Sequence< ::sal_Int8 > BinaryOutput::closeAndGetData()
1123 {
1124     Sequence< ::sal_Int8 > aRetSeq;
1125     if( !m_xOutputStream.is() )
1126         return aRetSeq;
1127
1128     m_xOutputStream->closeOutput();
1129
1130     sal_Int32 nSize = static_cast<sal_Int32>(m_xTempFile->getPosition());
1131
1132     m_xTempFile->seek( 0 );
1133     sal_Int32 nRead = m_xTempFile->readBytes( aRetSeq, nSize );
1134     OSL_ENSURE( nRead == nSize, "BinaryOutput::closeAndGetData: nRead != nSize" );
1135
1136     return aRetSeq;
1137 }
1138
1139
1140 // Binary format:
1141
1142 // Header
1143 // Byte         Content
1144 // 0 + 1        sal_Int16:  Version, currently 0, low byte first
1145 // 2 + 3        sal_Int16:  Locale count = n, low byte first
1146 // 4 + 5        sal_Int16:  Default Locale position in Locale list, == n if none
1147 // 6 - 7        sal_Int32:  Start index locale block 0, lowest byte first
1148 // (n-1) *      sal_Int32:  Start index locale block 1 to n, lowest byte first
1149 // 6 + 4*n      sal_Int32:  "Start index" non existing locale block n+1,
1150 //                          marks the first invalid index, kind of EOF
1151
1152 // Locale block
1153 // All strings are stored as 2-Byte-0 terminated sequence
1154 // of 16 bit Unicode characters, each with low byte first
1155 // Empty strings only contain the 2-Byte-0
1156
1157 // Members of com.sun.star.lang.Locale
1158 // with l1 = Locale.Language.getLength()
1159 // with l2 = Locale.Country.getLength()
1160 // with l3 = Locale.Variant.getLength()
1161 // pos0 = 0                     Locale.Language
1162 // pos1 = 2 * (l1 + 1)          Locale.Country
1163 // pos2 = pos1 + 2 * (l2 + 1)   Locale.Variant
1164 // pos3 = pos2 + 2 * (l3 + 1)
1165 // pos3                         Properties file written by implWritePropertiesFile
1166
1167 Sequence< sal_Int8 > StringResourcePersistenceImpl::exportBinary(  )
1168 {
1169     BinaryOutput aOut;
1170
1171     sal_Int32 nLocaleCount = m_aLocaleItemVector.size();
1172     std::vector<Sequence< sal_Int8 >> aLocaleDataSeq(nLocaleCount);
1173
1174     sal_Int32 iLocale = 0;
1175     sal_Int32 iDefault = 0;
1176     for( auto& pLocaleItem : m_aLocaleItemVector )
1177     {
1178         if( pLocaleItem != nullptr && loadLocale( pLocaleItem.get() ) )
1179         {
1180             if( m_pDefaultLocaleItem == pLocaleItem.get() )
1181                 iDefault = iLocale;
1182
1183             BinaryOutput aLocaleOut;
1184             implWriteLocaleBinary( pLocaleItem.get(), aLocaleOut );
1185
1186             aLocaleDataSeq[iLocale] = aLocaleOut.closeAndGetData();
1187         }
1188         ++iLocale;
1189     }
1190
1191     // Write header
1192     sal_Int16 nLocaleCount16 = static_cast<sal_Int16>(nLocaleCount);
1193     sal_Int16 iDefault16 = static_cast<sal_Int16>(iDefault);
1194     aOut.writeInt16( 0 ); // nVersion
1195     aOut.writeInt16( nLocaleCount16 );
1196     aOut.writeInt16( iDefault16 );
1197
1198     // Write data positions
1199     sal_Int32 nDataPos = 6 + 4 * (nLocaleCount + 1);
1200     for( iLocale = 0; iLocale < nLocaleCount; iLocale++ )
1201     {
1202         aOut.writeInt32( nDataPos );
1203
1204         Sequence< sal_Int8 >& rSeq = aLocaleDataSeq[iLocale];
1205         sal_Int32 nSeqLen = rSeq.getLength();
1206         nDataPos += nSeqLen;
1207     }
1208     // Write final position
1209     aOut.writeInt32( nDataPos );
1210
1211     // Write data
1212     Reference< io::XOutputStream > xOutputStream = aOut.getOutputStream();
1213     if( xOutputStream.is() )
1214     {
1215         for( iLocale = 0; iLocale < nLocaleCount; iLocale++ )
1216         {
1217             Sequence< sal_Int8 >& rSeq = aLocaleDataSeq[iLocale];
1218             xOutputStream->writeBytes( rSeq );
1219         }
1220     }
1221
1222     Sequence< sal_Int8 > aRetSeq = aOut.closeAndGetData();
1223     return aRetSeq;
1224 }
1225
1226 void StringResourcePersistenceImpl::implWriteLocaleBinary
1227     ( LocaleItem* pLocaleItem, BinaryOutput& rOut )
1228 {
1229     Reference< io::XOutputStream > xOutputStream = rOut.getOutputStream();
1230     if( !xOutputStream.is() )
1231         return;
1232
1233     Locale& rLocale = pLocaleItem->m_locale;
1234     rOut.writeString( rLocale.Language );
1235     rOut.writeString( rLocale.Country );
1236     rOut.writeString( rLocale.Variant );
1237     implWritePropertiesFile( pLocaleItem, xOutputStream, m_aComment );
1238 }
1239
1240
1241 // BinaryOutput, helper class for exportBinary
1242
1243 namespace {
1244
1245 class BinaryInput
1246 {
1247     Sequence< sal_Int8 >                    m_aData;
1248
1249     const sal_Int8*                         m_pData;
1250     sal_Int32                               m_nCurPos;
1251     sal_Int32                               m_nSize;
1252
1253 public:
1254     BinaryInput( const Sequence< ::sal_Int8 >& aData );
1255
1256     Reference< io::XInputStream > getInputStreamForSection( sal_Int32 nSize );
1257
1258     void seek( sal_Int32 nPos );
1259     sal_Int32 getPosition() const
1260         { return m_nCurPos; }
1261
1262     sal_Int16 readInt16();
1263     sal_Int32 readInt32();
1264     sal_Unicode readUnicodeChar();
1265     OUString readString();
1266 };
1267
1268 }
1269
1270 BinaryInput::BinaryInput( const Sequence< ::sal_Int8 >& aData )
1271         : m_aData( aData )
1272 {
1273     m_pData = m_aData.getConstArray();
1274     m_nCurPos = 0;
1275     m_nSize = m_aData.getLength();
1276 }
1277
1278 Reference< io::XInputStream > BinaryInput::getInputStreamForSection( sal_Int32 nSize )
1279 {
1280     Reference< io::XInputStream > xIn;
1281     if( m_nCurPos + nSize <= m_nSize )
1282     {
1283         rtl::Reference< utl::TempFileFastService > xTempOut = new utl::TempFileFastService;
1284         Sequence< sal_Int8 > aSection( m_pData + m_nCurPos, nSize );
1285         xTempOut->writeBytes( aSection );
1286         xTempOut->seek( 0 );
1287         xIn = xTempOut;
1288     }
1289     else
1290         OSL_FAIL( "BinaryInput::getInputStreamForSection(): Read past end" );
1291
1292     return xIn;
1293 }
1294
1295 void BinaryInput::seek( sal_Int32 nPos )
1296 {
1297     if( nPos <= m_nSize )
1298         m_nCurPos = nPos;
1299     else
1300         OSL_FAIL( "BinaryInput::seek(): Position past end" );
1301 }
1302
1303
1304 sal_Int16 BinaryInput::readInt16()
1305 {
1306     sal_Int16 nRet = 0;
1307     if( m_nCurPos + 2 <= m_nSize )
1308     {
1309         nRet = nRet + sal_Int16( sal_uInt8( m_pData[m_nCurPos++] ) );
1310         nRet += 256 * sal_Int16( sal_uInt8( m_pData[m_nCurPos++] ) );
1311     }
1312     else
1313         OSL_FAIL( "BinaryInput::readInt16(): Read past end" );
1314
1315     return nRet;
1316 }
1317
1318 sal_Int32 BinaryInput::readInt32()
1319 {
1320     sal_Int32 nRet = 0;
1321     if( m_nCurPos + 4 <= m_nSize )
1322     {
1323         sal_Int32 nFactor = 1;
1324         for( sal_Int16 i = 0; i < 4; i++ )
1325         {
1326             nRet += sal_uInt8( m_pData[m_nCurPos++] ) * nFactor;
1327             nFactor *= 256;
1328         }
1329     }
1330     else
1331         OSL_FAIL( "BinaryInput::readInt32(): Read past end" );
1332
1333     return nRet;
1334 }
1335
1336 sal_Unicode BinaryInput::readUnicodeChar()
1337 {
1338     sal_uInt16 nRet = 0;
1339     if( m_nCurPos + 2 <= m_nSize )
1340     {
1341         nRet = nRet + sal_uInt8( m_pData[m_nCurPos++] );
1342         nRet += 256 * sal_uInt8( m_pData[m_nCurPos++] );
1343     }
1344     else
1345         OSL_FAIL( "BinaryInput::readUnicodeChar(): Read past end" );
1346
1347     sal_Unicode cRet = nRet;
1348     return cRet;
1349 }
1350
1351 OUString BinaryInput::readString()
1352 {
1353     OUStringBuffer aBuf;
1354     sal_Unicode c;
1355     do
1356     {
1357         c = readUnicodeChar();
1358         if( c != 0 )
1359             aBuf.append( c );
1360     }
1361     while( c != 0 );
1362
1363     OUString aRetStr = aBuf.makeStringAndClear();
1364     return aRetStr;
1365 }
1366
1367 void StringResourcePersistenceImpl::importBinary( const Sequence< ::sal_Int8 >& Data )
1368 {
1369     // Init: Remove all locales
1370     sal_Int32 nOldLocaleCount = 0;
1371     do
1372     {
1373         Sequence< Locale > aLocaleSeq = getLocales();
1374         nOldLocaleCount = aLocaleSeq.getLength();
1375         if( nOldLocaleCount > 0 )
1376         {
1377             Locale aLocale = aLocaleSeq[0];
1378             removeLocale( aLocale );
1379         }
1380     }
1381     while( nOldLocaleCount > 0 );
1382
1383     // Import data
1384     BinaryInput aIn( Data );
1385
1386     aIn.readInt16(); // version
1387     sal_Int32 nLocaleCount = aIn.readInt16();
1388     sal_Int32 iDefault = aIn.readInt16();
1389
1390     std::unique_ptr<sal_Int32[]> pPositions( new sal_Int32[nLocaleCount + 1] );
1391     for( sal_Int32 i = 0; i < nLocaleCount + 1; i++ )
1392         pPositions[i] = aIn.readInt32();
1393
1394     // Import locales
1395     LocaleItem* pUseAsDefaultItem = nullptr;
1396     for( sal_Int32 i = 0; i < nLocaleCount; i++ )
1397     {
1398         sal_Int32 nPos = pPositions[i];
1399         aIn.seek( nPos );
1400
1401         Locale aLocale;
1402         aLocale.Language = aIn.readString();
1403         aLocale.Country = aIn.readString();
1404         aLocale.Variant = aIn.readString();
1405
1406         sal_Int32 nAfterStringPos = aIn.getPosition();
1407         sal_Int32 nSize = pPositions[i+1] - nAfterStringPos;
1408         Reference< io::XInputStream > xInput = aIn.getInputStreamForSection( nSize );
1409         if( xInput.is() )
1410         {
1411             LocaleItem* pLocaleItem = new LocaleItem( std::move(aLocale) );
1412             if( iDefault == i )
1413                 pUseAsDefaultItem = pLocaleItem;
1414             m_aLocaleItemVector.emplace_back( pLocaleItem );
1415             implReadPropertiesFile( pLocaleItem, xInput );
1416         }
1417     }
1418
1419     if( pUseAsDefaultItem != nullptr )
1420         setDefaultLocale( pUseAsDefaultItem->m_locale );
1421 }
1422
1423
1424 // Private helper methods
1425
1426 static bool checkNamingSceme( std::u16string_view aName, std::u16string_view aNameBase,
1427                        Locale& aLocale )
1428 {
1429     bool bSuccess = false;
1430
1431     size_t nNameLen = aName.size();
1432     size_t nNameBaseLen = aNameBase.size();
1433
1434     // Name has to start with NameBase followed
1435     // by a '_' and at least one more character
1436     if( o3tl::starts_with(aName, aNameBase) && nNameBaseLen < nNameLen-1 &&
1437         aName[nNameBaseLen] == '_' )
1438     {
1439         bSuccess = true;
1440
1441         /* FIXME-BCP47: this uses '_' underscore character as separator and
1442          * also appends Variant, which can't be blindly changed as it would
1443          * violate the naming scheme in use. */
1444
1445         sal_Int32 iStart = nNameBaseLen + 1;
1446         size_t iNext_ = aName.find( '_', iStart );
1447         if( iNext_ != std::u16string_view::npos && iNext_ < nNameLen-1 )
1448         {
1449             aLocale.Language = aName.substr( iStart, iNext_ - iStart );
1450
1451             iStart = iNext_ + 1;
1452             iNext_ = aName.find( '_', iStart );
1453             if( iNext_ != std::u16string_view::npos && iNext_ < nNameLen-1 )
1454             {
1455                 aLocale.Country = aName.substr( iStart, iNext_ - iStart );
1456                 aLocale.Variant = aName.substr( iNext_ + 1 );
1457             }
1458             else
1459                 aLocale.Country = aName.substr( iStart );
1460         }
1461         else
1462             aLocale.Language = aName.substr( iStart );
1463     }
1464     return bSuccess;
1465 }
1466
1467 void StringResourcePersistenceImpl::implLoadAllLocales()
1468 {
1469     for( auto& pLocaleItem : m_aLocaleItemVector )
1470         if( pLocaleItem )
1471             loadLocale( pLocaleItem.get() );
1472 }
1473
1474 // Scan locale properties files helper
1475 void StringResourcePersistenceImpl::implScanLocaleNames( const Sequence< OUString >& aContentSeq )
1476 {
1477     Locale aDefaultLocale;
1478     bool bDefaultFound = false;
1479
1480     for( const OUString& aCompleteName : aContentSeq )
1481     {
1482         OUString aPureName;
1483         OUString aExtension;
1484         sal_Int32 iDot = aCompleteName.lastIndexOf( '.' );
1485         sal_Int32 iSlash = aCompleteName.lastIndexOf( '/' );
1486         if( iDot != -1 && iDot > iSlash)
1487         {
1488             sal_Int32 iCopyFrom = (iSlash != -1) ? iSlash + 1 : 0;
1489             aPureName = aCompleteName.copy( iCopyFrom, iDot-iCopyFrom );
1490             aExtension = aCompleteName.copy( iDot + 1 );
1491         }
1492
1493         if ( aExtension == "properties" )
1494         {
1495             //OUString aName = aInetObj.getBase();
1496             Locale aLocale;
1497
1498             if( checkNamingSceme( aPureName, m_aNameBase, aLocale ) )
1499             {
1500                 LocaleItem* pLocaleItem = new LocaleItem( std::move(aLocale), false );
1501                 m_aLocaleItemVector.emplace_back( pLocaleItem );
1502
1503                 if( m_pCurrentLocaleItem == nullptr )
1504                     m_pCurrentLocaleItem = pLocaleItem;
1505
1506                 if( m_pDefaultLocaleItem == nullptr )
1507                 {
1508                     m_pDefaultLocaleItem = pLocaleItem;
1509                     m_bDefaultModified = true;
1510                 }
1511             }
1512         }
1513         else if( !bDefaultFound && aExtension == "default" )
1514         {
1515             if( checkNamingSceme( aPureName, m_aNameBase, aDefaultLocale ) )
1516                 bDefaultFound = true;
1517         }
1518     }
1519     if( bDefaultFound )
1520     {
1521         LocaleItem* pLocaleItem = getItemForLocale( aDefaultLocale, false );
1522         if( pLocaleItem )
1523         {
1524             m_pDefaultLocaleItem = pLocaleItem;
1525             m_bDefaultModified = false;
1526         }
1527     }
1528 }
1529
1530 // Scan locale properties files
1531 void StringResourcePersistenceImpl::implScanLocales()
1532 {
1533     // Dummy implementation, method not called for this
1534     // base class, but pure virtual not possible-
1535 }
1536
1537 bool StringResourcePersistenceImpl::loadLocale( LocaleItem* pLocaleItem )
1538 {
1539     bool bSuccess = false;
1540
1541     OSL_ENSURE( pLocaleItem, "StringResourcePersistenceImpl::loadLocale(): pLocaleItem == NULL" );
1542     if( pLocaleItem )
1543     {
1544         if( pLocaleItem->m_bLoaded )
1545         {
1546             bSuccess = true;
1547         }
1548         else
1549         {
1550             bSuccess = implLoadLocale( pLocaleItem );
1551             pLocaleItem->m_bLoaded = true;      // = bSuccess??? -> leads to more tries
1552         }
1553     }
1554     return bSuccess;
1555 }
1556
1557 bool StringResourcePersistenceImpl::implLoadLocale( LocaleItem* )
1558 {
1559     // Dummy implementation, method not called for this
1560     // base class, but pure virtual not possible-
1561     return false;
1562 }
1563
1564 static OUString implGetNameScemeForLocaleItem( const LocaleItem* pLocaleItem )
1565 {
1566     /* FIXME-BCP47: this uses '_' underscore character as separator and
1567      * also appends Variant, which can't be blindly changed as it would
1568      * violate the naming scheme in use. */
1569
1570     static const char aUnder[] = "_";
1571
1572     OSL_ENSURE( pLocaleItem,
1573         "StringResourcePersistenceImpl::implGetNameScemeForLocaleItem(): pLocaleItem == NULL" );
1574     Locale aLocale = pLocaleItem->m_locale;
1575
1576     OUString aRetStr = aUnder + aLocale.Language;
1577
1578     OUString aCountry  = aLocale.Country;
1579     if( !aCountry.isEmpty() )
1580     {
1581         aRetStr += aUnder + aCountry;
1582     }
1583
1584     OUString aVariant  = aLocale.Variant;
1585     if( !aVariant.isEmpty() )
1586     {
1587         aRetStr += aUnder + aVariant;
1588     }
1589     return aRetStr;
1590 }
1591
1592 OUString StringResourcePersistenceImpl::implGetFileNameForLocaleItem
1593     ( LocaleItem const * pLocaleItem, const OUString& aNameBase )
1594 {
1595     OUString aFileName = aNameBase;
1596     if( aFileName.isEmpty() )
1597         aFileName = aNameBaseDefaultStr;
1598
1599     aFileName += implGetNameScemeForLocaleItem( pLocaleItem );
1600     return aFileName;
1601 }
1602
1603 OUString StringResourcePersistenceImpl::implGetPathForLocaleItem
1604     ( LocaleItem const * pLocaleItem, const OUString& aNameBase,
1605       std::u16string_view aLocation, bool bDefaultFile )
1606 {
1607     OUString aFileName = implGetFileNameForLocaleItem( pLocaleItem, aNameBase );
1608     INetURLObject aInetObj( aLocation );
1609     aInetObj.insertName( aFileName, true, INetURLObject::LAST_SEGMENT, INetURLObject::EncodeMechanism::All );
1610     if( bDefaultFile )
1611         aInetObj.setExtension( u"default" );
1612     else
1613         aInetObj.setExtension( u"properties" );
1614     OUString aCompleteFileName = aInetObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
1615     return aCompleteFileName;
1616 }
1617
1618 // White space according to Java property files specification in
1619 // http://java.sun.com/j2se/1.4.2/docs/api/java/util/Properties.html#load(java.io.InputStream)
1620 static bool isWhiteSpace( sal_Unicode c )
1621 {
1622     bool bWhite = ( c == 0x0020 ||      // space
1623                     c == 0x0009 ||      // tab
1624                     c == 0x000a ||      // line feed, not always handled by TextInputStream
1625                     c == 0x000d ||      // carriage return, not always handled by TextInputStream
1626                     c == 0x000C );      // form feed
1627     return bWhite;
1628 }
1629
1630 static void skipWhites( const sal_Unicode* pBuf, sal_Int32 nLen, sal_Int32& ri )
1631 {
1632     while( ri < nLen )
1633     {
1634         if( !isWhiteSpace( pBuf[ri] ) )
1635             break;
1636         ri++;
1637     }
1638 }
1639
1640 static bool isHexDigit( sal_Unicode c, sal_uInt16& nDigitVal )
1641 {
1642     bool bRet = true;
1643     if( c >= '0' && c <= '9' )
1644         nDigitVal = c - '0';
1645     else if( c >= 'a' && c <= 'f' )
1646         nDigitVal = c - 'a' + 10;
1647     else if( c >= 'A' && c <= 'F' )
1648         nDigitVal = c - 'A' + 10;
1649     else
1650         bRet = false;
1651     return bRet;
1652 }
1653
1654 static sal_Unicode getEscapeChar( const sal_Unicode* pBuf, sal_Int32 nLen, sal_Int32& ri )
1655 {
1656     sal_Int32 i = ri;
1657
1658     sal_Unicode cRet = 0;
1659     sal_Unicode c = pBuf[i];
1660     switch( c )
1661     {
1662         case 't':
1663             cRet = 0x0009;
1664             break;
1665         case 'n':
1666             cRet = 0x000a;
1667             break;
1668         case 'f':
1669             cRet = 0x000c;
1670             break;
1671         case 'r':
1672             cRet = 0x000d;
1673             break;
1674         case '\\':
1675             cRet = '\\';
1676             break;
1677         case 'u':
1678         {
1679             // Skip multiple u
1680             i++;
1681             while( i < nLen && pBuf[i] == 'u' )
1682                 i++;
1683
1684             // Process hex digits
1685             sal_Int32 nDigitCount = 0;
1686             sal_uInt16 nDigitVal;
1687             while( i < nLen && isHexDigit( pBuf[i], nDigitVal ) )
1688             {
1689                 cRet = 16 * cRet + nDigitVal;
1690
1691                 nDigitCount++;
1692                 if( nDigitCount == 4 )
1693                 {
1694                     // Write back position
1695                     ri = i;
1696                     break;
1697                 }
1698                 i++;
1699             }
1700             break;
1701         }
1702         default:
1703             cRet = c;
1704     }
1705
1706     return cRet;
1707 }
1708
1709 static void CheckContinueInNextLine( const Reference< io::XTextInputStream2 >& xTextInputStream,
1710     OUString& aLine, bool& bEscapePending, const sal_Unicode*& pBuf,
1711     sal_Int32& nLen, sal_Int32& i )
1712 {
1713     if( !(i == nLen && bEscapePending) )
1714         return;
1715
1716     bEscapePending = false;
1717
1718     if( !xTextInputStream->isEOF() )
1719     {
1720         aLine = xTextInputStream->readLine();
1721         nLen = aLine.getLength();
1722         pBuf = aLine.getStr();
1723         i = 0;
1724
1725         skipWhites( pBuf, nLen, i );
1726     }
1727 }
1728
1729 bool StringResourcePersistenceImpl::implReadPropertiesFile
1730     ( LocaleItem* pLocaleItem, const Reference< io::XInputStream >& xInputStream )
1731 {
1732     if( !xInputStream.is() || pLocaleItem == nullptr )
1733         return false;
1734
1735     Reference< io::XTextInputStream2 > xTextInputStream = io::TextInputStream::create( m_xContext );
1736
1737     xTextInputStream->setInputStream( xInputStream );
1738
1739     OUString aEncodingStr = OUString::createFromAscii
1740         ( rtl_getMimeCharsetFromTextEncoding( RTL_TEXTENCODING_ISO_8859_1 ) );
1741     xTextInputStream->setEncoding( aEncodingStr );
1742
1743     OUString aLine;
1744     while( !xTextInputStream->isEOF() )
1745     {
1746         aLine = xTextInputStream->readLine();
1747
1748         sal_Int32 nLen = aLine.getLength();
1749         if( 0 == nLen )
1750             continue;
1751         const sal_Unicode* pBuf = aLine.getStr();
1752         OUStringBuffer aBuf;
1753         sal_Unicode c = 0;
1754         sal_Int32 i = 0;
1755
1756         skipWhites( pBuf, nLen, i );
1757         if( i == nLen )
1758             continue;   // line contains only white spaces
1759
1760         // Comment?
1761         c = pBuf[i];
1762         if( c == '#' || c == '!' )
1763             continue;
1764
1765         // Scan key
1766         OUString aResourceID;
1767         bool bEscapePending = false;
1768         bool bStrComplete = false;
1769         while( i < nLen && !bStrComplete )
1770         {
1771             c = pBuf[i];
1772             if( bEscapePending )
1773             {
1774                 aBuf.append( getEscapeChar( pBuf, nLen, i ) );
1775                 bEscapePending = false;
1776             }
1777             else
1778             {
1779                 if( c == '\\' )
1780                 {
1781                     bEscapePending = true;
1782                 }
1783                 else
1784                 {
1785                     if( c == ':' || c == '=' || isWhiteSpace( c ) )
1786                         bStrComplete = true;
1787                     else
1788                         aBuf.append( c );
1789                 }
1790             }
1791             i++;
1792
1793             CheckContinueInNextLine( xTextInputStream, aLine, bEscapePending, pBuf, nLen, i );
1794             if( i == nLen )
1795                 bStrComplete = true;
1796
1797             if( bStrComplete )
1798                 aResourceID = aBuf.makeStringAndClear();
1799         }
1800
1801         // Ignore lines with empty keys
1802         if( aResourceID.isEmpty() )
1803             continue;
1804
1805         // Scan value
1806         skipWhites( pBuf, nLen, i );
1807
1808         OUString aValueStr;
1809         bEscapePending = false;
1810         bStrComplete = false;
1811         while( i < nLen && !bStrComplete )
1812         {
1813             c = pBuf[i];
1814             if( c == 0x000a || c == 0x000d )    // line feed/carriage return, not always handled by TextInputStream
1815             {
1816                 i++;
1817             }
1818             else
1819             {
1820                 if( bEscapePending )
1821                 {
1822                     aBuf.append( getEscapeChar( pBuf, nLen, i ) );
1823                     bEscapePending = false;
1824                 }
1825                 else if( c == '\\' )
1826                     bEscapePending = true;
1827                 else
1828                     aBuf.append( c );
1829                 i++;
1830
1831                 CheckContinueInNextLine( xTextInputStream, aLine, bEscapePending, pBuf, nLen, i );
1832             }
1833             if( i == nLen )
1834                 bStrComplete = true;
1835
1836             if( bStrComplete )
1837                 aValueStr = aBuf.makeStringAndClear();
1838         }
1839
1840         // Push into table
1841         pLocaleItem->m_aIdToStringMap[ aResourceID ] = aValueStr;
1842         implScanIdForNumber( aResourceID );
1843         IdToIndexMap& rIndexMap = pLocaleItem->m_aIdToIndexMap;
1844         rIndexMap[ aResourceID ] = pLocaleItem->m_nNextIndex++;
1845     }
1846
1847     return true;
1848 }
1849
1850
1851 static sal_Unicode getHexCharForDigit( sal_uInt16 nDigitVal )
1852 {
1853     sal_Unicode cRet = ( nDigitVal < 10 ) ? ('0' + nDigitVal) : ('a' + (nDigitVal-10));
1854     return cRet;
1855 }
1856
1857 static void implWriteCharToBuffer( OUStringBuffer& aBuf, sal_Unicode cu, bool bKey )
1858 {
1859     if( cu == '\\' )
1860     {
1861         aBuf.append( '\\' );
1862         aBuf.append( '\\' );
1863     }
1864     else if( cu == 0x000a )
1865     {
1866         aBuf.append( '\\' );
1867         aBuf.append( 'n' );
1868     }
1869     else if( cu == 0x000d )
1870     {
1871         aBuf.append( '\\' );
1872         aBuf.append( 'r' );
1873     }
1874     else if( bKey && cu == '=' )
1875     {
1876         aBuf.append( '\\' );
1877         aBuf.append( '=' );
1878     }
1879     else if( bKey && cu == ':' )
1880     {
1881         aBuf.append( '\\' );
1882         aBuf.append( ':' );
1883     }
1884     // ISO/IEC 8859-1 range according to:
1885     // http://en.wikipedia.org/wiki/ISO/IEC_8859-1
1886     else if( cu >= 0x20 && cu <= 0x7e )
1887     //TODO: Check why (cu >= 0xa0 && cu <= 0xFF)
1888     //is encoded in sample properties files
1889     //else if( (cu >= 0x20 && cu <= 0x7e) ||
1890     //       (cu >= 0xa0 && cu <= 0xFF) )
1891     {
1892         aBuf.append( cu );
1893     }
1894     else
1895     {
1896         // Unicode encoding
1897         aBuf.append( '\\' );
1898         aBuf.append( 'u' );
1899
1900         sal_uInt16 nVal = cu;
1901         for( sal_uInt16 i = 0 ; i < 4 ; i++ )
1902         {
1903             sal_uInt16 nDigit = nVal / 0x1000;
1904             nVal -= nDigit * 0x1000;
1905             nVal *= 0x10;
1906             aBuf.append( getHexCharForDigit( nDigit ) );
1907         }
1908     }
1909 }
1910
1911 static void implWriteStringWithEncoding( const OUString& aStr,
1912     Reference< io::XTextOutputStream2 > const & xTextOutputStream, bool bKey )
1913 {
1914     static const sal_Unicode cLineFeed = 0xa;
1915
1916     OUStringBuffer aBuf;
1917     sal_Int32 nLen = aStr.getLength();
1918     const sal_Unicode* pSrc = aStr.getStr();
1919     for( sal_Int32 i = 0 ; i < nLen ; i++ )
1920     {
1921         sal_Unicode cu = pSrc[i];
1922         implWriteCharToBuffer( aBuf, cu, bKey );
1923         // TODO?: split long lines
1924     }
1925     if( !bKey )
1926         aBuf.append( cLineFeed );
1927
1928     OUString aWriteStr = aBuf.makeStringAndClear();
1929     xTextOutputStream->writeString( aWriteStr );
1930 }
1931
1932 bool StringResourcePersistenceImpl::implWritePropertiesFile( LocaleItem const * pLocaleItem,
1933     const Reference< io::XOutputStream >& xOutputStream, const OUString& aComment )
1934 {
1935     if( !xOutputStream.is() || pLocaleItem == nullptr )
1936         return false;
1937
1938     bool bSuccess = false;
1939     Reference< io::XTextOutputStream2 > xTextOutputStream = io::TextOutputStream::create(m_xContext);
1940
1941     xTextOutputStream->setOutputStream( xOutputStream );
1942
1943     OUString aEncodingStr = OUString::createFromAscii
1944         ( rtl_getMimeCharsetFromTextEncoding( RTL_TEXTENCODING_ISO_8859_1 ) );
1945     xTextOutputStream->setEncoding( aEncodingStr );
1946
1947     xTextOutputStream->writeString( aComment );
1948     xTextOutputStream->writeString( "\n" );
1949
1950     const IdToStringMap& rHashMap = pLocaleItem->m_aIdToStringMap;
1951     if( !rHashMap.empty() )
1952     {
1953         // Sort ids according to read order
1954         const IdToIndexMap& rIndexMap = pLocaleItem->m_aIdToIndexMap;
1955
1956         // Find max/min index
1957         auto itMinMax = std::minmax_element(rIndexMap.begin(), rIndexMap.end(),
1958             [](const IdToIndexMap::value_type& a, const IdToIndexMap::value_type& b) { return a.second < b.second; });
1959         sal_Int32 nMinIndex = itMinMax.first->second;
1960         sal_Int32 nMaxIndex = itMinMax.second->second;
1961         sal_Int32 nTabSize = nMaxIndex - nMinIndex + 1;
1962
1963         // Create sorted array of pointers to the id strings
1964         std::unique_ptr<const OUString*[]> pIdPtrs( new const OUString*[nTabSize] );
1965         for(sal_Int32 i = 0 ; i < nTabSize ; i++ )
1966             pIdPtrs[i] = nullptr;
1967         for( const auto& rIndex : rIndexMap )
1968         {
1969             sal_Int32 nIndex = rIndex.second;
1970             pIdPtrs[nIndex - nMinIndex] = &(rIndex.first);
1971         }
1972
1973         // Write lines in correct order
1974         for(sal_Int32 i = 0 ; i < nTabSize ; i++ )
1975         {
1976             const OUString* pStr = pIdPtrs[i];
1977             if( pStr != nullptr )
1978             {
1979                 OUString aResourceID = *pStr;
1980                 IdToStringMap::const_iterator it = rHashMap.find( aResourceID );
1981                 if( it != rHashMap.end() )
1982                 {
1983                     implWriteStringWithEncoding( aResourceID, xTextOutputStream, true );
1984                     xTextOutputStream->writeString( "=" );
1985                     OUString aValStr = (*it).second;
1986                     implWriteStringWithEncoding( aValStr, xTextOutputStream, false );
1987                 }
1988             }
1989         }
1990     }
1991
1992     bSuccess = true;
1993
1994     return bSuccess;
1995 }
1996
1997
1998 // StringResourceWithStorageImpl
1999
2000 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
2001 scripting_StringResourceWithStorageImpl_get_implementation(
2002     css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const&)
2003 {
2004     return cppu::acquire(new StringResourceWithStorageImpl(context));
2005 }
2006
2007
2008 StringResourceWithStorageImpl::StringResourceWithStorageImpl( const Reference< XComponentContext >& rxContext )
2009     : StringResourceWithStorageImpl_BASE( rxContext )
2010     , m_bStorageChanged( false )
2011 {
2012 }
2013
2014
2015 StringResourceWithStorageImpl::~StringResourceWithStorageImpl()
2016 {
2017 }
2018
2019
2020 // XServiceInfo
2021
2022
2023 OUString StringResourceWithStorageImpl::getImplementationName(  )
2024 {
2025     return "com.sun.star.comp.scripting.StringResourceWithStorage";
2026 }
2027
2028 sal_Bool StringResourceWithStorageImpl::supportsService( const OUString& rServiceName )
2029 {
2030     return cppu::supportsService(this, rServiceName);
2031 }
2032
2033 Sequence< OUString > StringResourceWithStorageImpl::getSupportedServiceNames(  )
2034 {
2035     return { "com.sun.star.resource.StringResourceWithStorage" };
2036 }
2037
2038
2039 // XInitialization
2040
2041
2042 void StringResourceWithStorageImpl::initialize( const Sequence< Any >& aArguments )
2043 {
2044     std::unique_lock aGuard( m_aMutex );
2045
2046     if ( aArguments.getLength() != 5 )
2047     {
2048         throw RuntimeException(
2049             "StringResourceWithStorageImpl::initialize: invalid number of arguments!" );
2050     }
2051
2052     bool bOk = (aArguments[0] >>= m_xStorage);
2053     if( bOk && !m_xStorage.is() )
2054         bOk = false;
2055
2056     if( !bOk )
2057     {
2058         throw IllegalArgumentException( "StringResourceWithStorageImpl::initialize: invalid storage", Reference< XInterface >(), 0 );
2059     }
2060
2061     implInitializeCommonParameters( aGuard, aArguments );
2062 }
2063
2064
2065 // Forwarding calls to base class
2066
2067 // XModifyBroadcaster
2068 void StringResourceWithStorageImpl::addModifyListener( const Reference< XModifyListener >& aListener )
2069 {
2070     StringResourceImpl::addModifyListener( aListener );
2071 }
2072 void StringResourceWithStorageImpl::removeModifyListener( const Reference< XModifyListener >& aListener )
2073 {
2074     StringResourceImpl::removeModifyListener( aListener );
2075 }
2076
2077 // XStringResourceResolver
2078 OUString StringResourceWithStorageImpl::resolveString( const OUString& ResourceID )
2079 {
2080     return StringResourceImpl::resolveString( ResourceID ) ;
2081 }
2082 OUString StringResourceWithStorageImpl::resolveStringForLocale( const OUString& ResourceID, const Locale& locale )
2083 {
2084     return StringResourceImpl::resolveStringForLocale( ResourceID, locale );
2085 }
2086 sal_Bool StringResourceWithStorageImpl::hasEntryForId( const OUString& ResourceID )
2087 {
2088     return StringResourceImpl::hasEntryForId( ResourceID ) ;
2089 }
2090 sal_Bool StringResourceWithStorageImpl::hasEntryForIdAndLocale( const OUString& ResourceID,
2091     const Locale& locale )
2092 {
2093     return StringResourceImpl::hasEntryForIdAndLocale( ResourceID, locale );
2094 }
2095 Sequence< OUString > StringResourceWithStorageImpl::getResourceIDs(  )
2096 {
2097     return StringResourceImpl::getResourceIDs();
2098 }
2099 Sequence< OUString > StringResourceWithStorageImpl::getResourceIDsForLocale
2100     ( const Locale& locale )
2101 {
2102     return StringResourceImpl::getResourceIDsForLocale( locale );
2103 }
2104 Locale StringResourceWithStorageImpl::getCurrentLocale()
2105 {
2106     return StringResourceImpl::getCurrentLocale();
2107 }
2108 Locale StringResourceWithStorageImpl::getDefaultLocale(  )
2109 {
2110     return StringResourceImpl::getDefaultLocale();
2111 }
2112 Sequence< Locale > StringResourceWithStorageImpl::getLocales(  )
2113 {
2114     return StringResourceImpl::getLocales();
2115 }
2116
2117 // XStringResourceManager
2118 sal_Bool StringResourceWithStorageImpl::isReadOnly()
2119 {
2120     return StringResourceImpl::isReadOnly();
2121 }
2122 void StringResourceWithStorageImpl::setCurrentLocale( const Locale& locale, sal_Bool FindClosestMatch )
2123 {
2124     StringResourceImpl::setCurrentLocale( locale, FindClosestMatch );
2125 }
2126 void StringResourceWithStorageImpl::setDefaultLocale( const Locale& locale )
2127 {
2128     StringResourceImpl::setDefaultLocale( locale );
2129 }
2130 void StringResourceWithStorageImpl::setString( const OUString& ResourceID, const OUString& Str )
2131 {
2132     StringResourceImpl::setString( ResourceID, Str );
2133 }
2134 void StringResourceWithStorageImpl::setStringForLocale
2135     ( const OUString& ResourceID, const OUString& Str, const Locale& locale )
2136 {
2137     StringResourceImpl::setStringForLocale( ResourceID, Str, locale );
2138 }
2139 void StringResourceWithStorageImpl::removeId( const OUString& ResourceID )
2140 {
2141     StringResourceImpl::removeId( ResourceID );
2142 }
2143 void StringResourceWithStorageImpl::removeIdForLocale( const OUString& ResourceID, const Locale& locale )
2144 {
2145     StringResourceImpl::removeIdForLocale( ResourceID, locale );
2146 }
2147 void StringResourceWithStorageImpl::newLocale( const Locale& locale )
2148 {
2149     StringResourceImpl::newLocale( locale );
2150 }
2151 void StringResourceWithStorageImpl::removeLocale( const Locale& locale )
2152 {
2153     StringResourceImpl::removeLocale( locale );
2154 }
2155 sal_Int32 StringResourceWithStorageImpl::getUniqueNumericId(  )
2156 {
2157     return StringResourceImpl::getUniqueNumericId();
2158 }
2159
2160 // XStringResourcePersistence
2161 void StringResourceWithStorageImpl::store()
2162 {
2163     std::unique_lock aGuard( m_aMutex );
2164     implCheckReadOnly( "StringResourceWithStorageImpl::store(): Read only" );
2165
2166     bool bStoreAll = m_bStorageChanged;
2167     m_bStorageChanged = false;
2168     if( !m_bModified && !bStoreAll )
2169         return;
2170
2171     implStoreAtStorage( m_aNameBase, m_aComment, m_xStorage, true/*bUsedForStore*/, bStoreAll );
2172     m_bModified = false;
2173 }
2174
2175 sal_Bool StringResourceWithStorageImpl::isModified(  )
2176 {
2177     return StringResourcePersistenceImpl::isModified();
2178 }
2179 void StringResourceWithStorageImpl::setComment( const OUString& Comment )
2180 {
2181     StringResourcePersistenceImpl::setComment( Comment );
2182 }
2183 void StringResourceWithStorageImpl::storeToStorage( const Reference< XStorage >& Storage,
2184     const OUString& NameBase, const OUString& Comment )
2185 {
2186     StringResourcePersistenceImpl::storeToStorage( Storage, NameBase, Comment );
2187 }
2188 void StringResourceWithStorageImpl::storeToURL( const OUString& URL,
2189     const OUString& NameBase, const OUString& Comment,
2190     const Reference< css::task::XInteractionHandler >& Handler )
2191 {
2192     StringResourcePersistenceImpl::storeToURL( URL, NameBase, Comment, Handler );
2193 }
2194 Sequence< ::sal_Int8 > StringResourceWithStorageImpl::exportBinary(  )
2195 {
2196     return StringResourcePersistenceImpl::exportBinary();
2197 }
2198 void StringResourceWithStorageImpl::importBinary( const Sequence< ::sal_Int8 >& Data )
2199 {
2200     StringResourcePersistenceImpl::importBinary( Data );
2201 }
2202
2203
2204 // XStringResourceWithStorage
2205
2206 void StringResourceWithStorageImpl::storeAsStorage( const Reference< XStorage >& Storage )
2207 {
2208     setStorage( Storage );
2209     store();
2210 }
2211
2212 void StringResourceWithStorageImpl::setStorage( const Reference< XStorage >& Storage )
2213 {
2214     std::unique_lock aGuard( m_aMutex );
2215
2216     if( !Storage.is() )
2217     {
2218         throw IllegalArgumentException( "StringResourceWithStorageImpl::setStorage: invalid storage", Reference< XInterface >(), 0 );
2219     }
2220
2221     implLoadAllLocales();
2222
2223     m_xStorage = Storage;
2224     m_bStorageChanged = true;
2225 }
2226
2227
2228 // Private helper methods
2229
2230
2231 // Scan locale properties files
2232 void StringResourceWithStorageImpl::implScanLocales()
2233 {
2234     if( m_xStorage.is() )
2235     {
2236         Sequence< OUString > aContentSeq = m_xStorage->getElementNames();
2237         implScanLocaleNames( aContentSeq );
2238     }
2239
2240     implLoadAllLocales();
2241 }
2242
2243 // Loading
2244 bool StringResourceWithStorageImpl::implLoadLocale( LocaleItem* pLocaleItem )
2245 {
2246     bool bSuccess = false;
2247     try
2248     {
2249         OUString aStreamName = implGetFileNameForLocaleItem( pLocaleItem, m_aNameBase ) + ".properties";
2250
2251         Reference< io::XStream > xElementStream =
2252             m_xStorage->openStreamElement( aStreamName, ElementModes::READ );
2253
2254         if( xElementStream.is() )
2255         {
2256             Reference< io::XInputStream > xInputStream = xElementStream->getInputStream();
2257             if( xInputStream.is() )
2258             {
2259                 bSuccess = StringResourcePersistenceImpl::implReadPropertiesFile( pLocaleItem, xInputStream );
2260                 xInputStream->closeInput();
2261             }
2262         }
2263     }
2264     catch( uno::Exception& )
2265     {}
2266
2267     return bSuccess;
2268 }
2269
2270
2271 // StringResourceWithLocationImpl
2272
2273
2274 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
2275 scripting_StringResourceWithLocationImpl_get_implementation(
2276     css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const&)
2277 {
2278     return cppu::acquire(new StringResourceWithLocationImpl(context));
2279 }
2280
2281
2282
2283 StringResourceWithLocationImpl::StringResourceWithLocationImpl( const Reference< XComponentContext >& rxContext )
2284     : StringResourceWithLocationImpl_BASE( rxContext )
2285     , m_bLocationChanged( false )
2286 {
2287 }
2288
2289
2290 StringResourceWithLocationImpl::~StringResourceWithLocationImpl()
2291 {
2292 }
2293
2294
2295 // XServiceInfo
2296
2297
2298 OUString StringResourceWithLocationImpl::getImplementationName(  )
2299 {
2300     return "com.sun.star.comp.scripting.StringResourceWithLocation";
2301 }
2302
2303 sal_Bool StringResourceWithLocationImpl::supportsService( const OUString& rServiceName )
2304 {
2305     return cppu::supportsService(this, rServiceName);
2306 }
2307
2308 Sequence< OUString > StringResourceWithLocationImpl::getSupportedServiceNames(  )
2309 {
2310     return { "com.sun.star.resource.StringResourceWithLocation" };
2311 }
2312
2313
2314 // XInitialization
2315
2316
2317 void StringResourceWithLocationImpl::initialize( const Sequence< Any >& aArguments )
2318 {
2319     std::unique_lock aGuard( m_aMutex );
2320
2321     if ( aArguments.getLength() != 6 )
2322     {
2323         throw RuntimeException(
2324             "XInitialization::initialize: invalid number of arguments!" );
2325     }
2326
2327     bool bOk = (aArguments[0] >>= m_aLocation);
2328     sal_Int32 nLen = m_aLocation.getLength();
2329     if( bOk && nLen == 0 )
2330     {
2331         bOk = false;
2332     }
2333     else
2334     {
2335         if( m_aLocation[nLen - 1] != '/' )
2336             m_aLocation += "/";
2337     }
2338
2339     if( !bOk )
2340     {
2341         throw IllegalArgumentException( "XInitialization::initialize: invalid URL", Reference< XInterface >(), 0 );
2342     }
2343
2344
2345     bOk = (aArguments[5] >>= m_xInteractionHandler);
2346     if( !bOk )
2347     {
2348         throw IllegalArgumentException( "StringResourceWithStorageImpl::initialize: invalid type", Reference< XInterface >(), 5 );
2349     }
2350
2351     implInitializeCommonParameters( aGuard, aArguments );
2352 }
2353
2354
2355 // Forwarding calls to base class
2356
2357 // XModifyBroadcaster
2358 void StringResourceWithLocationImpl::addModifyListener( const Reference< XModifyListener >& aListener )
2359 {
2360     StringResourceImpl::addModifyListener( aListener );
2361 }
2362 void StringResourceWithLocationImpl::removeModifyListener( const Reference< XModifyListener >& aListener )
2363 {
2364     StringResourceImpl::removeModifyListener( aListener );
2365 }
2366
2367 // XStringResourceResolver
2368 OUString StringResourceWithLocationImpl::resolveString( const OUString& ResourceID )
2369 {
2370     return StringResourceImpl::resolveString( ResourceID ) ;
2371 }
2372 OUString StringResourceWithLocationImpl::resolveStringForLocale( const OUString& ResourceID, const Locale& locale )
2373 {
2374     return StringResourceImpl::resolveStringForLocale( ResourceID, locale );
2375 }
2376 sal_Bool StringResourceWithLocationImpl::hasEntryForId( const OUString& ResourceID )
2377 {
2378     return StringResourceImpl::hasEntryForId( ResourceID ) ;
2379 }
2380 sal_Bool StringResourceWithLocationImpl::hasEntryForIdAndLocale( const OUString& ResourceID,
2381     const Locale& locale )
2382 {
2383     return StringResourceImpl::hasEntryForIdAndLocale( ResourceID, locale );
2384 }
2385 Sequence< OUString > StringResourceWithLocationImpl::getResourceIDs(  )
2386 {
2387     return StringResourceImpl::getResourceIDs();
2388 }
2389 Sequence< OUString > StringResourceWithLocationImpl::getResourceIDsForLocale
2390     ( const Locale& locale )
2391 {
2392     return StringResourceImpl::getResourceIDsForLocale( locale );
2393 }
2394 Locale StringResourceWithLocationImpl::getCurrentLocale()
2395 {
2396     return StringResourceImpl::getCurrentLocale();
2397 }
2398 Locale StringResourceWithLocationImpl::getDefaultLocale(  )
2399 {
2400     return StringResourceImpl::getDefaultLocale();
2401 }
2402 Sequence< Locale > StringResourceWithLocationImpl::getLocales(  )
2403 {
2404     return StringResourceImpl::getLocales();
2405 }
2406
2407 // XStringResourceManager
2408 sal_Bool StringResourceWithLocationImpl::isReadOnly()
2409 {
2410     return StringResourceImpl::isReadOnly();
2411 }
2412 void StringResourceWithLocationImpl::setCurrentLocale( const Locale& locale, sal_Bool FindClosestMatch )
2413 {
2414     StringResourceImpl::setCurrentLocale( locale, FindClosestMatch );
2415 }
2416 void StringResourceWithLocationImpl::setDefaultLocale( const Locale& locale )
2417 {
2418     StringResourceImpl::setDefaultLocale( locale );
2419 }
2420 void StringResourceWithLocationImpl::setString( const OUString& ResourceID, const OUString& Str )
2421 {
2422     StringResourceImpl::setString( ResourceID, Str );
2423 }
2424 void StringResourceWithLocationImpl::setStringForLocale
2425     ( const OUString& ResourceID, const OUString& Str, const Locale& locale )
2426 {
2427     StringResourceImpl::setStringForLocale( ResourceID, Str, locale );
2428 }
2429 void StringResourceWithLocationImpl::removeId( const OUString& ResourceID )
2430 {
2431     StringResourceImpl::removeId( ResourceID );
2432 }
2433 void StringResourceWithLocationImpl::removeIdForLocale( const OUString& ResourceID, const Locale& locale )
2434 {
2435     StringResourceImpl::removeIdForLocale( ResourceID, locale );
2436 }
2437 void StringResourceWithLocationImpl::newLocale( const Locale& locale )
2438 {
2439     StringResourceImpl::newLocale( locale );
2440 }
2441 void StringResourceWithLocationImpl::removeLocale( const Locale& locale )
2442 {
2443     StringResourceImpl::removeLocale( locale );
2444 }
2445 sal_Int32 StringResourceWithLocationImpl::getUniqueNumericId(  )
2446 {
2447     return StringResourceImpl::getUniqueNumericId();
2448 }
2449
2450 // XStringResourcePersistence
2451 void StringResourceWithLocationImpl::store()
2452 {
2453     std::unique_lock aGuard( m_aMutex );
2454     implCheckReadOnly( "StringResourceWithLocationImpl::store(): Read only" );
2455
2456     bool bStoreAll = m_bLocationChanged;
2457     m_bLocationChanged = false;
2458     if( !m_bModified && !bStoreAll )
2459         return;
2460
2461     Reference< ucb::XSimpleFileAccess3 > xFileAccess = getFileAccessImpl();
2462     implStoreAtLocation( m_aLocation, m_aNameBase, m_aComment,
2463         xFileAccess, true/*bUsedForStore*/, bStoreAll );
2464     m_bModified = false;
2465 }
2466
2467 sal_Bool StringResourceWithLocationImpl::isModified(  )
2468 {
2469     return StringResourcePersistenceImpl::isModified();
2470 }
2471 void StringResourceWithLocationImpl::setComment( const OUString& Comment )
2472 {
2473     StringResourcePersistenceImpl::setComment( Comment );
2474 }
2475 void StringResourceWithLocationImpl::storeToStorage( const Reference< XStorage >& Storage,
2476     const OUString& NameBase, const OUString& Comment )
2477 {
2478     StringResourcePersistenceImpl::storeToStorage( Storage, NameBase, Comment );
2479 }
2480 void StringResourceWithLocationImpl::storeToURL( const OUString& URL,
2481     const OUString& NameBase, const OUString& Comment,
2482     const Reference< css::task::XInteractionHandler >& Handler )
2483 {
2484     StringResourcePersistenceImpl::storeToURL( URL, NameBase, Comment, Handler );
2485 }
2486 Sequence< ::sal_Int8 > StringResourceWithLocationImpl::exportBinary(  )
2487 {
2488     return StringResourcePersistenceImpl::exportBinary();
2489 }
2490 void StringResourceWithLocationImpl::importBinary( const Sequence< ::sal_Int8 >& Data )
2491 {
2492     StringResourcePersistenceImpl::importBinary( Data );
2493 }
2494
2495
2496 // XStringResourceWithLocation
2497
2498 // XStringResourceWithLocation
2499 void StringResourceWithLocationImpl::storeAsURL( const OUString& URL )
2500 {
2501     setURL( URL );
2502     store();
2503 }
2504
2505 void StringResourceWithLocationImpl::setURL( const OUString& URL )
2506 {
2507     std::unique_lock aGuard( m_aMutex );
2508     implCheckReadOnly( "StringResourceWithLocationImpl::setURL(): Read only" );
2509
2510     sal_Int32 nLen = URL.getLength();
2511     if( nLen == 0 )
2512     {
2513         throw IllegalArgumentException( "StringResourceWithLocationImpl::setURL: invalid URL", Reference< XInterface >(), 0 );
2514     }
2515
2516     implLoadAllLocales();
2517
2518     // Delete files at old location
2519     implStoreAtLocation( m_aLocation, m_aNameBase, m_aComment,
2520         getFileAccessImpl(), false/*bUsedForStore*/, false/*bStoreAll*/, true/*bKillAll*/ );
2521
2522     m_aLocation = URL;
2523     m_bLocationChanged = true;
2524 }
2525
2526
2527 // Private helper methods
2528
2529
2530 // Scan locale properties files
2531 void StringResourceWithLocationImpl::implScanLocales()
2532 {
2533     const Reference< ucb::XSimpleFileAccess3 > xFileAccess = getFileAccessImpl();
2534     if( xFileAccess.is() && xFileAccess->isFolder( m_aLocation ) )
2535     {
2536         Sequence< OUString > aContentSeq = xFileAccess->getFolderContents( m_aLocation, false );
2537         implScanLocaleNames( aContentSeq );
2538     }
2539 }
2540
2541 // Loading
2542 bool StringResourceWithLocationImpl::implLoadLocale( LocaleItem* pLocaleItem )
2543 {
2544     bool bSuccess = false;
2545
2546     const Reference< ucb::XSimpleFileAccess3 > xFileAccess = getFileAccessImpl();
2547     if( xFileAccess.is() )
2548     {
2549         OUString aCompleteFileName =
2550             implGetPathForLocaleItem( pLocaleItem, m_aNameBase, m_aLocation );
2551
2552         Reference< io::XInputStream > xInputStream;
2553         try
2554         {
2555             xInputStream = xFileAccess->openFileRead( aCompleteFileName );
2556         }
2557         catch( Exception& )
2558         {}
2559         if( xInputStream.is() )
2560         {
2561             bSuccess = StringResourcePersistenceImpl::implReadPropertiesFile( pLocaleItem, xInputStream );
2562             xInputStream->closeInput();
2563         }
2564     }
2565
2566     return bSuccess;
2567 }
2568
2569 const Reference< ucb::XSimpleFileAccess3 > & StringResourceWithLocationImpl::getFileAccessImpl()
2570 {
2571     if( !m_xSFI.is() )
2572     {
2573         m_xSFI = ucb::SimpleFileAccess::create(m_xContext);
2574
2575         if( m_xSFI.is() && m_xInteractionHandler.is() )
2576             m_xSFI->setInteractionHandler( m_xInteractionHandler );
2577     }
2578     return m_xSFI;
2579 }
2580
2581 }   // namespace stringresource
2582
2583
2584 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */