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