Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

3 files changed, 3117 insertions, 0 deletions

diff --git a/scripting/source/stringresource/stringresource.component b/scripting/source/stringresource/stringresource.component
new file mode 100644
index 000000000..a2b2a24f3
--- /dev/null
+++ b/scripting/source/stringresource/stringresource.component
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ -->
+
+<component loader="com.sun.star.loader.SharedLibrary" environment="@CPPU_ENV@"
+    xmlns="http://openoffice.org/2010/uno-components">
+  <implementation name="com.sun.star.comp.scripting.StringResource"
+    constructor="scripting_StringResourcePersistenceImpl_implementation">
+    <service name="com.sun.star.resource.StringResource"/>
+  </implementation>
+  <implementation name="com.sun.star.comp.scripting.StringResourceWithLocation"
+    constructor="scripting_StringResourceWithLocationImpl_get_implementation">
+    <service name="com.sun.star.resource.StringResourceWithLocation"/>
+  </implementation>
+  <implementation name="com.sun.star.comp.scripting.StringResourceWithStorage"
+    constructor="scripting_StringResourceWithStorageImpl_get_implementation">
+    <service name="com.sun.star.resource.StringResourceWithStorage"/>
+  </implementation>
+</component>
diff --git a/scripting/source/stringresource/stringresource.cxx b/scripting/source/stringresource/stringresource.cxx
new file mode 100644
index 000000000..06b52b037
--- /dev/null
+++ b/scripting/source/stringresource/stringresource.cxx
@@ -0,0 +1,2598 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <memory>
+#include "stringresource.hxx"
+#include <com/sun/star/io/TempFile.hpp>
+#include <com/sun/star/io/TextInputStream.hpp>
+#include <com/sun/star/io/TextOutputStream.hpp>
+#include <com/sun/star/io/XStream.hpp>
+#include <com/sun/star/io/XSeekable.hpp>
+#include <com/sun/star/embed/ElementModes.hpp>
+#include <com/sun/star/lang/NoSupportException.hpp>
+#include <com/sun/star/resource/MissingResourceException.hpp>
+#include <cppuhelper/supportsservice.hxx>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/container/ElementExistException.hpp>
+#include <com/sun/star/ucb/SimpleFileAccess.hpp>
+
+#include <osl/diagnose.h>
+#include <rtl/tencinfo.h>
+#include <rtl/ustrbuf.hxx>
+#include <tools/urlobj.hxx>
+#include <i18nlangtag/languagetag.hxx>
+#include <sal/log.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::ucb;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::embed;
+using namespace ::com::sun::star::container;
+
+
+namespace stringresource
+{
+
+// StringResourceImpl
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+scripting_StringResourcePersistenceImpl_implementation(
+    css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const&)
+{
+    return cppu::acquire(new StringResourcePersistenceImpl(context));
+}
+
+
+StringResourceImpl::StringResourceImpl( const Reference< XComponentContext >& rxContext )
+    : m_xContext( rxContext )
+    , m_pCurrentLocaleItem( nullptr )
+    , m_pDefaultLocaleItem( nullptr )
+    , m_bDefaultModified( false )
+    , m_bModified( false )
+    , m_bReadOnly( false )
+    , m_nNextUniqueNumericId( UNIQUE_NUMBER_NEEDS_INITIALISATION )
+{
+}
+
+
+StringResourceImpl::~StringResourceImpl()
+{
+}
+
+
+// XServiceInfo
+
+OUString StringResourceImpl::getImplementationName(  )
+{
+    return "com.sun.star.comp.scripting.StringResource";
+}
+
+sal_Bool StringResourceImpl::supportsService( const OUString& rServiceName )
+{
+    return cppu::supportsService(this, rServiceName);
+}
+
+Sequence< OUString > StringResourceImpl::getSupportedServiceNames(  )
+{
+    return { "com.sun.star.resource.StringResource" };
+}
+
+
+// XModifyBroadcaster
+
+void StringResourceImpl::addModifyListener( const Reference< XModifyListener >& aListener )
+{
+    if( !aListener.is() )
+        throw RuntimeException();
+
+    std::unique_lock aGuard( m_aMutex );
+    m_aListenerContainer.addInterface( aGuard, aListener );
+}
+
+void StringResourceImpl::removeModifyListener( const Reference< XModifyListener >& aListener )
+{
+    if( !aListener.is() )
+        throw RuntimeException();
+
+    std::unique_lock aGuard( m_aMutex );
+    m_aListenerContainer.removeInterface( aGuard, aListener );
+}
+
+
+// XStringResourceResolver
+
+OUString StringResourceImpl::implResolveString
+    ( const OUString& ResourceID, LocaleItem* pLocaleItem )
+{
+    OUString aRetStr;
+    bool bSuccess = false;
+    if( pLocaleItem != nullptr && loadLocale( pLocaleItem ) )
+    {
+        IdToStringMap::iterator it = pLocaleItem->m_aIdToStringMap.find( ResourceID );
+        if( it != pLocaleItem->m_aIdToStringMap.end() )
+        {
+            aRetStr = (*it).second;
+            bSuccess = true;
+        }
+    }
+    if( !bSuccess )
+    {
+        throw css::resource::MissingResourceException( "StringResourceImpl: No entry for ResourceID: " + ResourceID );
+    }
+    return aRetStr;
+}
+
+OUString StringResourceImpl::resolveString( const OUString& ResourceID )
+{
+    std::unique_lock aGuard( m_aMutex );
+    return implResolveString( ResourceID, m_pCurrentLocaleItem );
+}
+
+OUString StringResourceImpl::resolveStringForLocale( const OUString& ResourceID, const Locale& locale )
+{
+    std::unique_lock aGuard( m_aMutex );
+    LocaleItem* pLocaleItem = getItemForLocale( locale, false );
+    return implResolveString( ResourceID, pLocaleItem );
+}
+
+bool StringResourceImpl::implHasEntryForId( const OUString& ResourceID, LocaleItem* pLocaleItem )
+{
+    bool bSuccess = false;
+    if( pLocaleItem != nullptr && loadLocale( pLocaleItem ) )
+    {
+        IdToStringMap::iterator it = pLocaleItem->m_aIdToStringMap.find( ResourceID );
+        if( it != pLocaleItem->m_aIdToStringMap.end() )
+            bSuccess = true;
+    }
+    return bSuccess;
+}
+
+sal_Bool StringResourceImpl::hasEntryForId( const OUString& ResourceID )
+{
+    std::unique_lock aGuard( m_aMutex );
+    return implHasEntryForId( ResourceID, m_pCurrentLocaleItem );
+}
+
+sal_Bool StringResourceImpl::hasEntryForIdAndLocale( const OUString& ResourceID,
+    const Locale& locale )
+{
+    std::unique_lock aGuard( m_aMutex );
+    LocaleItem* pLocaleItem = getItemForLocale( locale, false );
+    return implHasEntryForId( ResourceID, pLocaleItem );
+}
+
+Sequence< OUString > StringResourceImpl::implGetResourceIDs( LocaleItem* pLocaleItem )
+{
+    Sequence< OUString > aIDSeq( 0 );
+    if( pLocaleItem && loadLocale( pLocaleItem ) )
+    {
+        const IdToStringMap& rHashMap = pLocaleItem->m_aIdToStringMap;
+        sal_Int32 nResourceIDCount = rHashMap.size();
+        aIDSeq.realloc( nResourceIDCount );
+        OUString* pStrings = aIDSeq.getArray();
+
+        int iTarget = 0;
+        for( const auto& rEntry : rHashMap )
+        {
+            OUString aStr = rEntry.first;
+            pStrings[iTarget] = aStr;
+            iTarget++;
+        }
+    }
+    return aIDSeq;
+}
+
+Sequence< OUString > StringResourceImpl::getResourceIDsForLocale
+    ( const Locale& locale )
+{
+    std::unique_lock aGuard( m_aMutex );
+    LocaleItem* pLocaleItem = getItemForLocale( locale, false );
+    return implGetResourceIDs( pLocaleItem );
+}
+
+Sequence< OUString > StringResourceImpl::getResourceIDs(  )
+{
+    std::unique_lock aGuard( m_aMutex );
+    return implGetResourceIDs( m_pCurrentLocaleItem );
+}
+
+Locale StringResourceImpl::getCurrentLocale()
+{
+    std::unique_lock aGuard( m_aMutex );
+
+    Locale aRetLocale;
+    if( m_pCurrentLocaleItem != nullptr )
+        aRetLocale = m_pCurrentLocaleItem->m_locale;
+    return aRetLocale;
+}
+
+Locale StringResourceImpl::getDefaultLocale(  )
+{
+    std::unique_lock aGuard( m_aMutex );
+
+    Locale aRetLocale;
+    if( m_pDefaultLocaleItem != nullptr )
+        aRetLocale = m_pDefaultLocaleItem->m_locale;
+    return aRetLocale;
+}
+
+Sequence< Locale > StringResourceImpl::getLocales(  )
+{
+    std::unique_lock aGuard( m_aMutex );
+
+    sal_Int32 nSize = m_aLocaleItemVector.size();
+    Sequence< Locale > aLocalSeq( nSize );
+    Locale* pLocales = aLocalSeq.getArray();
+    int iTarget = 0;
+    for( const auto& pLocaleItem : m_aLocaleItemVector )
+    {
+        pLocales[iTarget] = pLocaleItem->m_locale;
+        iTarget++;
+    }
+    return aLocalSeq;
+}
+
+
+// XStringResourceManager
+
+void StringResourceImpl::implCheckReadOnly( const char* pExceptionMsg )
+{
+    if( m_bReadOnly )
+    {
+        OUString errorMsg = OUString::createFromAscii( pExceptionMsg );
+        throw NoSupportException( errorMsg );
+    }
+}
+
+sal_Bool StringResourceImpl::isReadOnly()
+{
+    return m_bReadOnly;
+}
+
+void StringResourceImpl::implSetCurrentLocale( std::unique_lock<std::mutex>& rGuard, const Locale& locale,
+    bool FindClosestMatch, bool bUseDefaultIfNoMatch )
+{
+    LocaleItem* pLocaleItem = nullptr;
+    if( FindClosestMatch )
+        pLocaleItem = getClosestMatchItemForLocale( locale );
+    else
+        pLocaleItem = getItemForLocale( locale, true );
+
+    if( pLocaleItem == nullptr && bUseDefaultIfNoMatch )
+        pLocaleItem = m_pDefaultLocaleItem;
+
+    if( pLocaleItem != nullptr )
+    {
+        (void)loadLocale( pLocaleItem );
+        m_pCurrentLocaleItem = pLocaleItem;
+
+        // Only notify without modifying
+        implNotifyListeners(rGuard);
+    }
+}
+
+void StringResourceImpl::setCurrentLocale( const Locale& locale, sal_Bool FindClosestMatch )
+{
+    std::unique_lock aGuard( m_aMutex );
+    implSetCurrentLocale( aGuard, locale, FindClosestMatch, false/*bUseDefaultIfNoMatch*/ );
+}
+
+void StringResourceImpl::setDefaultLocale( const Locale& locale )
+{
+    std::unique_lock aGuard( m_aMutex );
+    implCheckReadOnly( "StringResourceImpl::setDefaultLocale(): Read only" );
+
+    LocaleItem* pLocaleItem = getItemForLocale( locale, true );
+    if( pLocaleItem && pLocaleItem != m_pDefaultLocaleItem )
+    {
+        if( m_pDefaultLocaleItem )
+        {
+            m_aChangedDefaultLocaleVector.push_back(
+                std::make_unique<LocaleItem>( m_pDefaultLocaleItem->m_locale ) );
+        }
+
+        m_pDefaultLocaleItem = pLocaleItem;
+        m_bDefaultModified = true;
+        implModified(aGuard);
+    }
+}
+
+void StringResourceImpl::implSetString( std::unique_lock<std::mutex>& rGuard, const OUString& ResourceID,
+    const OUString& Str, LocaleItem* pLocaleItem )
+{
+    if( !(pLocaleItem != nullptr && loadLocale( pLocaleItem )) )
+        return;
+
+    IdToStringMap& rHashMap = pLocaleItem->m_aIdToStringMap;
+
+    IdToStringMap::iterator it = rHashMap.find( ResourceID );
+    bool bNew = ( it == rHashMap.end() );
+    if( bNew )
+    {
+        IdToIndexMap& rIndexMap = pLocaleItem->m_aIdToIndexMap;
+        rIndexMap[ ResourceID ] = pLocaleItem->m_nNextIndex++;
+        implScanIdForNumber( ResourceID );
+    }
+    rHashMap[ ResourceID ] = Str;
+    pLocaleItem->m_bModified = true;
+    implModified(rGuard);
+}
+
+void StringResourceImpl::setString( const OUString& ResourceID, const OUString& Str )
+{
+    std::unique_lock aGuard( m_aMutex );
+    implCheckReadOnly( "StringResourceImpl::setString(): Read only" );
+    implSetString( aGuard, ResourceID, Str, m_pCurrentLocaleItem );
+}
+
+void StringResourceImpl::setStringForLocale
+    ( const OUString& ResourceID, const OUString& Str, const Locale& locale )
+{
+    std::unique_lock aGuard( m_aMutex );
+    implCheckReadOnly( "StringResourceImpl::setStringForLocale(): Read only" );
+    LocaleItem* pLocaleItem = getItemForLocale( locale, false );
+    implSetString( aGuard, ResourceID, Str, pLocaleItem );
+}
+
+void StringResourceImpl::implRemoveId( std::unique_lock<std::mutex>& rGuard, const OUString& ResourceID, LocaleItem* pLocaleItem )
+{
+    if( pLocaleItem != nullptr && loadLocale( pLocaleItem ) )
+    {
+        IdToStringMap& rHashMap = pLocaleItem->m_aIdToStringMap;
+        IdToStringMap::iterator it = rHashMap.find( ResourceID );
+        if( it == rHashMap.end() )
+        {
+            throw css::resource::MissingResourceException( "StringResourceImpl: No entries for ResourceID: " + ResourceID );
+        }
+        rHashMap.erase( it );
+        pLocaleItem->m_bModified = true;
+        implModified(rGuard);
+    }
+}
+
+void StringResourceImpl::removeId( const OUString& ResourceID )
+{
+    std::unique_lock aGuard( m_aMutex );
+    implCheckReadOnly( "StringResourceImpl::removeId(): Read only" );
+    implRemoveId( aGuard, ResourceID, m_pCurrentLocaleItem );
+}
+
+void StringResourceImpl::removeIdForLocale( const OUString& ResourceID, const Locale& locale )
+{
+    std::unique_lock aGuard( m_aMutex );
+    implCheckReadOnly( "StringResourceImpl::removeIdForLocale(): Read only" );
+    LocaleItem* pLocaleItem = getItemForLocale( locale, false );
+    implRemoveId( aGuard, ResourceID, pLocaleItem );
+}
+
+void StringResourceImpl::newLocale( const Locale& locale )
+{
+    std::unique_lock aGuard( m_aMutex );
+    implCheckReadOnly( "StringResourceImpl::newLocale(): Read only" );
+
+    if( getItemForLocale( locale, false ) != nullptr )
+    {
+        throw ElementExistException( "StringResourceImpl: locale already exists" );
+    }
+
+    // TODO?: Check if locale is valid? How?
+    //if (!bValid)
+    //{
+    //    OUString errorMsg("StringResourceImpl: Invalid locale");
+    //    throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 0 );
+    //}
+
+    LocaleItem* pLocaleItem = new LocaleItem( locale );
+    m_aLocaleItemVector.emplace_back( pLocaleItem );
+    pLocaleItem->m_bModified = true;
+
+    // Copy strings from default locale
+    LocaleItem* pCopyFromItem = m_pDefaultLocaleItem;
+    if( pCopyFromItem == nullptr )
+        pCopyFromItem = m_pCurrentLocaleItem;
+    if( pCopyFromItem != nullptr && loadLocale( pCopyFromItem ) )
+    {
+        const IdToStringMap& rSourceMap = pCopyFromItem->m_aIdToStringMap;
+        IdToStringMap& rTargetMap = pLocaleItem->m_aIdToStringMap;
+        for( const auto& rEntry : rSourceMap )
+        {
+            OUString aId  = rEntry.first;
+            OUString aStr = rEntry.second;
+            rTargetMap[ aId ] = aStr;
+        }
+
+        const IdToIndexMap& rSourceIndexMap = pCopyFromItem->m_aIdToIndexMap;
+        IdToIndexMap& rTargetIndexMap = pLocaleItem->m_aIdToIndexMap;
+        for( const auto& rIndex : rSourceIndexMap )
+        {
+            OUString aId = rIndex.first;
+            sal_Int32 nIndex = rIndex.second;
+            rTargetIndexMap[ aId ] = nIndex;
+        }
+        pLocaleItem->m_nNextIndex = pCopyFromItem->m_nNextIndex;
+    }
+
+    if( m_pCurrentLocaleItem == nullptr )
+        m_pCurrentLocaleItem = pLocaleItem;
+
+    if( m_pDefaultLocaleItem == nullptr )
+    {
+        m_pDefaultLocaleItem = pLocaleItem;
+        m_bDefaultModified = true;
+    }
+
+    implModified(aGuard);
+}
+
+void StringResourceImpl::removeLocale( const Locale& locale )
+{
+    std::unique_lock aGuard( m_aMutex );
+    implCheckReadOnly( "StringResourceImpl::removeLocale(): Read only" );
+
+    LocaleItem* pRemoveItem = getItemForLocale( locale, true );
+    if( !pRemoveItem )
+        return;
+
+    // Last locale?
+    sal_Int32 nLocaleCount = m_aLocaleItemVector.size();
+    if( nLocaleCount > 1 )
+    {
+        if( m_pCurrentLocaleItem == pRemoveItem ||
+            m_pDefaultLocaleItem  == pRemoveItem )
+        {
+            LocaleItem* pFallbackItem = nullptr;
+            for( const auto& pLocaleItem : m_aLocaleItemVector )
+            {
+                if( pLocaleItem.get() != pRemoveItem )
+                {
+                    pFallbackItem = pLocaleItem.get();
+                    break;
+                }
+            }
+            if( m_pCurrentLocaleItem == pRemoveItem )
+            {
+                setCurrentLocale( pFallbackItem->m_locale, false/*FindClosestMatch*/ );
+            }
+            if( m_pDefaultLocaleItem == pRemoveItem )
+            {
+                setDefaultLocale( pFallbackItem->m_locale );
+            }
+        }
+    }
+    auto it = std::find_if(m_aLocaleItemVector.begin(), m_aLocaleItemVector.end(),
+        [&pRemoveItem](const std::unique_ptr<LocaleItem>& rxItem) { return rxItem.get() == pRemoveItem; });
+    if (it == m_aLocaleItemVector.end())
+        return;
+
+    // Remember locale item to delete file while storing
+    m_aDeletedLocaleItemVector.push_back( std::move(*it) );
+
+    // Last locale?
+    if( nLocaleCount == 1 )
+    {
+        m_nNextUniqueNumericId = 0;
+        if( m_pDefaultLocaleItem )
+        {
+            m_aChangedDefaultLocaleVector.push_back(
+                    std::make_unique<LocaleItem>( m_pDefaultLocaleItem->m_locale ) );
+        }
+        m_pCurrentLocaleItem = nullptr;
+        m_pDefaultLocaleItem = nullptr;
+    }
+
+    m_aLocaleItemVector.erase( it );
+
+    implModified(aGuard);
+}
+
+void StringResourceImpl::implScanIdForNumber( const OUString& ResourceID )
+{
+    const sal_Unicode* pSrc = ResourceID.getStr();
+    sal_Int32 nLen = ResourceID.getLength();
+
+    sal_Int32 nNumber = 0;
+    for( sal_Int32 i = 0 ; i < nLen ; i++ )
+    {
+        sal_Unicode c = pSrc[i];
+        if( c >= '0' && c <= '9' )
+        {
+            sal_uInt16 nDigitVal = c - '0';
+            nNumber = 10*nNumber + nDigitVal;
+        }
+        else
+            break;
+    }
+
+    if( m_nNextUniqueNumericId < nNumber + 1 )
+        m_nNextUniqueNumericId = nNumber + 1;
+}
+
+sal_Int32 StringResourceImpl::getUniqueNumericId(  )
+{
+    if( m_nNextUniqueNumericId == UNIQUE_NUMBER_NEEDS_INITIALISATION )
+    {
+        implLoadAllLocales();
+        m_nNextUniqueNumericId = 0;
+    }
+
+    if( m_nNextUniqueNumericId < UNIQUE_NUMBER_NEEDS_INITIALISATION )
+    {
+        throw NoSupportException( "getUniqueNumericId: Extended sal_Int32 range" );
+    }
+    return m_nNextUniqueNumericId;
+}
+
+
+// Private helper methods
+
+LocaleItem* StringResourceImpl::getItemForLocale
+    ( const Locale& locale, bool bException )
+{
+    LocaleItem* pRetItem = nullptr;
+
+    // Search for locale
+    for( auto& pLocaleItem : m_aLocaleItemVector )
+    {
+        if( pLocaleItem )
+        {
+            Locale& cmp_locale = pLocaleItem->m_locale;
+            if( cmp_locale.Language == locale.Language &&
+                cmp_locale.Country  == locale.Country &&
+                cmp_locale.Variant  == locale.Variant )
+            {
+                pRetItem = pLocaleItem.get();
+                break;
+            }
+        }
+    }
+
+    if( pRetItem == nullptr && bException )
+    {
+        throw IllegalArgumentException( "StringResourceImpl: Invalid locale", Reference< XInterface >(), 0 );
+    }
+    return pRetItem;
+}
+
+// Returns the LocaleItem for a given locale, if it exists, otherwise NULL.
+// This method performs a closest match search, at least the language must match.
+LocaleItem* StringResourceImpl::getClosestMatchItemForLocale( const Locale& locale )
+{
+    LocaleItem* pRetItem = nullptr;
+
+    ::std::vector< Locale > aLocales( m_aLocaleItemVector.size());
+    size_t i = 0;
+    for( const auto& pLocaleItem : m_aLocaleItemVector )
+    {
+        aLocales[i] = (pLocaleItem ? pLocaleItem->m_locale : Locale());
+        ++i;
+    }
+    ::std::vector< Locale >::const_iterator iFound( LanguageTag::getMatchingFallback( aLocales, locale));
+    if (iFound != aLocales.end())
+        pRetItem = (m_aLocaleItemVector.begin() + (iFound - aLocales.begin()))->get();
+
+    return pRetItem;
+}
+
+void StringResourceImpl::implModified(std::unique_lock<std::mutex>& rGuard)
+{
+    m_bModified = true;
+    implNotifyListeners(rGuard);
+}
+
+void StringResourceImpl::implNotifyListeners(std::unique_lock<std::mutex>& rGuard)
+{
+    EventObject aEvent;
+    aEvent.Source = static_cast< XInterface* >( static_cast<OWeakObject*>(this) );
+    m_aListenerContainer.forEach(rGuard,
+        [&aEvent](const css::uno::Reference<XModifyListener>& xListener)
+        {
+            xListener->modified(aEvent);
+        }
+    );
+}
+
+
+// Loading
+
+bool StringResourceImpl::loadLocale( LocaleItem* )
+{
+    // Base implementation has nothing to load
+    return true;
+}
+
+void StringResourceImpl::implLoadAllLocales()
+{
+    // Base implementation has nothing to load
+}
+
+
+// StringResourcePersistenceImpl
+
+
+StringResourcePersistenceImpl::StringResourcePersistenceImpl( const Reference< XComponentContext >& rxContext )
+    : StringResourcePersistenceImpl_BASE( rxContext )
+{
+}
+
+
+StringResourcePersistenceImpl::~StringResourcePersistenceImpl()
+{
+}
+
+
+// XServiceInfo
+
+
+OUString StringResourcePersistenceImpl::getImplementationName(  )
+{
+    return "com.sun.star.comp.scripting.StringResource";
+}
+
+
+sal_Bool StringResourcePersistenceImpl::supportsService( const OUString& rServiceName )
+{
+    return cppu::supportsService( this, rServiceName );
+}
+
+
+Sequence< OUString > StringResourcePersistenceImpl::getSupportedServiceNames(  )
+{
+    return StringResourceImpl::getSupportedServiceNames();
+}
+
+
+// XInitialization base functionality for derived classes
+
+
+constexpr OUStringLiteral aNameBaseDefaultStr = u"strings";
+
+void StringResourcePersistenceImpl::implInitializeCommonParameters
+    ( std::unique_lock<std::mutex>& rGuard, const Sequence< Any >& aArguments )
+{
+    bool bReadOnlyOk = (aArguments[1] >>= m_bReadOnly);
+    if( !bReadOnlyOk )
+    {
+        throw IllegalArgumentException( "XInitialization::initialize: Expected ReadOnly flag", Reference< XInterface >(), 1 );
+    }
+
+    css::lang::Locale aCurrentLocale;
+    bool bLocaleOk = (aArguments[2] >>= aCurrentLocale);
+    if( !bLocaleOk )
+    {
+        throw IllegalArgumentException( "XInitialization::initialize: Expected Locale", Reference< XInterface >(), 2 );
+    }
+
+    bool bNameBaseOk = (aArguments[3] >>= m_aNameBase);
+    if( !bNameBaseOk )
+    {
+        throw IllegalArgumentException( "XInitialization::initialize: Expected NameBase string", Reference< XInterface >(), 3 );
+    }
+    if( m_aNameBase.isEmpty() )
+        m_aNameBase = aNameBaseDefaultStr;
+
+    bool bCommentOk = (aArguments[4] >>= m_aComment);
+    if( !bCommentOk )
+    {
+        throw IllegalArgumentException( "XInitialization::initialize: Expected Comment string", Reference< XInterface >(), 4 );
+    }
+
+    implScanLocales();
+
+    implSetCurrentLocale( rGuard, aCurrentLocale, true/*FindClosestMatch*/, true/*bUseDefaultIfNoMatch*/ );
+}
+
+
+// Forwarding calls to base class
+
+// XModifyBroadcaster
+void StringResourcePersistenceImpl::addModifyListener( const Reference< XModifyListener >& aListener )
+{
+    StringResourceImpl::addModifyListener( aListener );
+}
+void StringResourcePersistenceImpl::removeModifyListener( const Reference< XModifyListener >& aListener )
+{
+    StringResourceImpl::removeModifyListener( aListener );
+}
+
+// XStringResourceResolver
+OUString StringResourcePersistenceImpl::resolveString( const OUString& ResourceID )
+{
+    return StringResourceImpl::resolveString( ResourceID ) ;
+}
+OUString StringResourcePersistenceImpl::resolveStringForLocale( const OUString& ResourceID, const Locale& locale )
+{
+    return StringResourceImpl::resolveStringForLocale( ResourceID, locale );
+}
+sal_Bool StringResourcePersistenceImpl::hasEntryForId( const OUString& ResourceID )
+{
+    return StringResourceImpl::hasEntryForId( ResourceID ) ;
+}
+sal_Bool StringResourcePersistenceImpl::hasEntryForIdAndLocale( const OUString& ResourceID,
+    const Locale& locale )
+{
+    return StringResourceImpl::hasEntryForIdAndLocale( ResourceID, locale );
+}
+Locale StringResourcePersistenceImpl::getCurrentLocale()
+{
+    return StringResourceImpl::getCurrentLocale();
+}
+Locale StringResourcePersistenceImpl::getDefaultLocale(  )
+{
+    return StringResourceImpl::getDefaultLocale();
+}
+Sequence< Locale > StringResourcePersistenceImpl::getLocales(  )
+{
+    return StringResourceImpl::getLocales();
+}
+
+// XStringResourceManager
+sal_Bool StringResourcePersistenceImpl::isReadOnly()
+{
+    return StringResourceImpl::isReadOnly();
+}
+void StringResourcePersistenceImpl::setCurrentLocale( const Locale& locale, sal_Bool FindClosestMatch )
+{
+    StringResourceImpl::setCurrentLocale( locale, FindClosestMatch );
+}
+void StringResourcePersistenceImpl::setDefaultLocale( const Locale& locale )
+{
+    StringResourceImpl::setDefaultLocale( locale );
+}
+Sequence< OUString > StringResourcePersistenceImpl::getResourceIDs(  )
+{
+    return StringResourceImpl::getResourceIDs();
+}
+void StringResourcePersistenceImpl::setString( const OUString& ResourceID, const OUString& Str )
+{
+    StringResourceImpl::setString( ResourceID, Str );
+}
+void StringResourcePersistenceImpl::setStringForLocale
+    ( const OUString& ResourceID, const OUString& Str, const Locale& locale )
+{
+    StringResourceImpl::setStringForLocale( ResourceID, Str, locale );
+}
+Sequence< OUString > StringResourcePersistenceImpl::getResourceIDsForLocale
+    ( const Locale& locale )
+{
+    return StringResourceImpl::getResourceIDsForLocale( locale );
+}
+void StringResourcePersistenceImpl::removeId( const OUString& ResourceID )
+{
+    StringResourceImpl::removeId( ResourceID );
+}
+void StringResourcePersistenceImpl::removeIdForLocale( const OUString& ResourceID, const Locale& locale )
+{
+    StringResourceImpl::removeIdForLocale( ResourceID, locale );
+}
+void StringResourcePersistenceImpl::newLocale( const Locale& locale )
+{
+    StringResourceImpl::newLocale( locale );
+}
+void StringResourcePersistenceImpl::removeLocale( const Locale& locale )
+{
+    StringResourceImpl::removeLocale( locale );
+}
+sal_Int32 StringResourcePersistenceImpl::getUniqueNumericId(  )
+{
+    return StringResourceImpl::getUniqueNumericId();
+}
+
+
+// XStringResourcePersistence
+
+void StringResourcePersistenceImpl::store()
+{
+}
+
+sal_Bool StringResourcePersistenceImpl::isModified(  )
+{
+    std::unique_lock aGuard( m_aMutex );
+
+    return m_bModified;
+}
+
+void StringResourcePersistenceImpl::setComment( const OUString& Comment )
+{
+    m_aComment = Comment;
+}
+
+void StringResourcePersistenceImpl::storeToStorage( const Reference< XStorage >& Storage,
+    const OUString& NameBase, const OUString& Comment )
+{
+    std::unique_lock aGuard( m_aMutex );
+
+    implStoreAtStorage( NameBase, Comment, Storage, false/*bUsedForStore*/, true/*bStoreAll*/ );
+}
+
+void StringResourcePersistenceImpl::implStoreAtStorage
+(
+    const OUString& aNameBase,
+    const OUString& aComment,
+    const Reference< css::embed::XStorage >& Storage,
+    bool bUsedForStore,
+    bool bStoreAll
+)
+{
+    // Delete files for deleted locales
+    if( bUsedForStore )
+    {
+        for( auto& pLocaleItem : m_aDeletedLocaleItemVector )
+        {
+            if( pLocaleItem )
+            {
+                OUString aStreamName = implGetFileNameForLocaleItem( pLocaleItem.get(), m_aNameBase ) + ".properties";
+
+                try
+                {
+                    Storage->removeElement( aStreamName );
+                }
+                catch( Exception& )
+                {}
+
+                pLocaleItem.reset();
+            }
+        }
+        m_aDeletedLocaleItemVector.clear();
+    }
+
+    for( auto& pLocaleItem : m_aLocaleItemVector )
+    {
+        if( pLocaleItem != nullptr && (bStoreAll || pLocaleItem->m_bModified) &&
+            loadLocale( pLocaleItem.get() ) )
+        {
+            OUString aStreamName = implGetFileNameForLocaleItem( pLocaleItem.get(), aNameBase ) + ".properties";
+
+            Reference< io::XStream > xElementStream =
+                    Storage->openStreamElement( aStreamName, ElementModes::READWRITE );
+
+            uno::Reference< beans::XPropertySet > xProps( xElementStream, uno::UNO_QUERY );
+            OSL_ENSURE( xProps.is(), "The StorageStream must implement XPropertySet interface!" );
+            if ( xProps.is() )
+            {
+                OUString aPropName("MediaType");
+                xProps->setPropertyValue( aPropName, uno::Any( OUString("text/plain") ) );
+
+                aPropName = "UseCommonStoragePasswordEncryption";
+                xProps->setPropertyValue( aPropName, uno::Any( true ) );
+            }
+
+            Reference< io::XOutputStream > xOutputStream = xElementStream->getOutputStream();
+            if( xOutputStream.is() )
+                implWritePropertiesFile( pLocaleItem.get(), xOutputStream, aComment );
+            xOutputStream->closeOutput();
+
+            if( bUsedForStore )
+                pLocaleItem->m_bModified = false;
+        }
+    }
+
+    // Delete files for changed defaults
+    if( bUsedForStore )
+    {
+        for( auto& pLocaleItem : m_aChangedDefaultLocaleVector )
+        {
+            OUString aStreamName = implGetFileNameForLocaleItem( pLocaleItem.get(), m_aNameBase ) + ".default";
+
+            try
+            {
+                Storage->removeElement( aStreamName );
+            }
+            catch( Exception& )
+            {}
+
+            pLocaleItem.reset();
+        }
+        m_aChangedDefaultLocaleVector.clear();
+    }
+
+    // Default locale
+    if( !(m_pDefaultLocaleItem != nullptr && (bStoreAll || m_bDefaultModified)) )
+        return;
+
+    OUString aStreamName = implGetFileNameForLocaleItem( m_pDefaultLocaleItem, aNameBase ) + ".default";
+
+    Reference< io::XStream > xElementStream =
+            Storage->openStreamElement( aStreamName, ElementModes::READWRITE );
+
+    // Only create stream without content
+    Reference< io::XOutputStream > xOutputStream = xElementStream->getOutputStream();
+    xOutputStream->closeOutput();
+
+    if( bUsedForStore )
+        m_bDefaultModified = false;
+}
+
+void StringResourcePersistenceImpl::storeToURL( const OUString& URL,
+    const OUString& NameBase, const OUString& Comment,
+    const Reference< css::task::XInteractionHandler >& Handler )
+{
+    std::unique_lock aGuard( m_aMutex );
+
+    Reference< ucb::XSimpleFileAccess3 > xFileAccess = ucb::SimpleFileAccess::create(m_xContext);
+    if( xFileAccess.is() && Handler.is() )
+        xFileAccess->setInteractionHandler( Handler );
+
+    implStoreAtLocation( URL, NameBase, Comment, xFileAccess, false/*bUsedForStore*/, true/*bStoreAll*/ );
+}
+
+void StringResourcePersistenceImpl::implKillRemovedLocaleFiles
+(
+    std::u16string_view Location,
+    const OUString& aNameBase,
+    const css::uno::Reference< css::ucb::XSimpleFileAccess3 >& xFileAccess
+)
+{
+    // Delete files for deleted locales
+    for( auto& pLocaleItem : m_aDeletedLocaleItemVector )
+    {
+        if( pLocaleItem )
+        {
+            OUString aCompleteFileName =
+                implGetPathForLocaleItem( pLocaleItem.get(), aNameBase, Location );
+            if( xFileAccess->exists( aCompleteFileName ) )
+                xFileAccess->kill( aCompleteFileName );
+
+            pLocaleItem.reset();
+        }
+    }
+    m_aDeletedLocaleItemVector.clear();
+}
+
+void StringResourcePersistenceImpl::implKillChangedDefaultFiles
+(
+    std::u16string_view Location,
+    const OUString& aNameBase,
+    const css::uno::Reference< css::ucb::XSimpleFileAccess3 >& xFileAccess
+)
+{
+    // Delete files for changed defaults
+    for( auto& pLocaleItem : m_aChangedDefaultLocaleVector )
+    {
+        OUString aCompleteFileName =
+            implGetPathForLocaleItem( pLocaleItem.get(), aNameBase, Location, true );
+        if( xFileAccess->exists( aCompleteFileName ) )
+            xFileAccess->kill( aCompleteFileName );
+        pLocaleItem.reset();
+    }
+    m_aChangedDefaultLocaleVector.clear();
+}
+
+void StringResourcePersistenceImpl::implStoreAtLocation
+(
+    std::u16string_view Location,
+    const OUString& aNameBase,
+    const OUString& aComment,
+    const Reference< ucb::XSimpleFileAccess3 >& xFileAccess,
+    bool bUsedForStore,
+    bool bStoreAll,
+    bool bKillAll
+)
+{
+    // Delete files for deleted locales
+    if( bUsedForStore || bKillAll )
+        implKillRemovedLocaleFiles( Location, aNameBase, xFileAccess );
+
+    for( auto& pLocaleItem : m_aLocaleItemVector )
+    {
+        if( pLocaleItem != nullptr && (bStoreAll || bKillAll || pLocaleItem->m_bModified) &&
+            loadLocale( pLocaleItem.get() ) )
+        {
+            OUString aCompleteFileName =
+                implGetPathForLocaleItem( pLocaleItem.get(), aNameBase, Location );
+            if( xFileAccess->exists( aCompleteFileName ) )
+                xFileAccess->kill( aCompleteFileName );
+
+            if( !bKillAll )
+            {
+                // Create Output stream
+                Reference< io::XOutputStream > xOutputStream = xFileAccess->openFileWrite( aCompleteFileName );
+                if( xOutputStream.is() )
+                {
+                    implWritePropertiesFile( pLocaleItem.get(), xOutputStream, aComment );
+                    xOutputStream->closeOutput();
+                }
+                if( bUsedForStore )
+                    pLocaleItem->m_bModified = false;
+            }
+        }
+    }
+
+    // Delete files for changed defaults
+    if( bUsedForStore || bKillAll )
+        implKillChangedDefaultFiles( Location, aNameBase, xFileAccess );
+
+    // Default locale
+    if( !(m_pDefaultLocaleItem != nullptr && (bStoreAll || bKillAll || m_bDefaultModified)) )
+        return;
+
+    OUString aCompleteFileName =
+        implGetPathForLocaleItem( m_pDefaultLocaleItem, aNameBase, Location, true );
+    if( xFileAccess->exists( aCompleteFileName ) )
+        xFileAccess->kill( aCompleteFileName );
+
+    if( !bKillAll )
+    {
+        // Create Output stream
+        Reference< io::XOutputStream > xOutputStream = xFileAccess->openFileWrite( aCompleteFileName );
+        if( xOutputStream.is() )
+            xOutputStream->closeOutput();
+
+        if( bUsedForStore )
+            m_bDefaultModified = false;
+    }
+}
+
+
+// BinaryOutput, helper class for exportBinary
+
+class BinaryOutput
+{
+    Reference< XComponentContext >          m_xContext;
+    Reference< XInterface >                 m_xTempFile;
+    Reference< io::XOutputStream >          m_xOutputStream;
+
+public:
+    explicit BinaryOutput( Reference< XComponentContext > const & xContext );
+
+    const Reference< io::XOutputStream >& getOutputStream() const
+        { return m_xOutputStream; }
+
+    Sequence< ::sal_Int8 > closeAndGetData();
+
+    // Template to be used with sal_Int16 and sal_Unicode
+    template< class T >
+    void write16BitInt( T n );
+    void writeInt16( sal_Int16 n )
+        { write16BitInt( n ); }
+    void writeUnicodeChar( sal_Unicode n )
+        { write16BitInt( n ); }
+    void writeInt32( sal_Int32 n );
+    void writeString( const OUString& aStr );
+};
+
+BinaryOutput::BinaryOutput( Reference< XComponentContext > const & xContext )
+        : m_xContext( xContext )
+{
+    m_xTempFile = io::TempFile::create( m_xContext );
+    m_xOutputStream.set( m_xTempFile, UNO_QUERY_THROW );
+}
+
+template< class T >
+void BinaryOutput::write16BitInt( T n )
+{
+    if( !m_xOutputStream.is() )
+        return;
+
+    Sequence< sal_Int8 > aSeq( 2 );
+    sal_Int8* p = aSeq.getArray();
+
+    sal_Int8 nLow  = sal_Int8( n & 0xff );
+    sal_Int8 nHigh = sal_Int8( n >> 8 );
+
+    p[0] = nLow;
+    p[1] = nHigh;
+    m_xOutputStream->writeBytes( aSeq );
+}
+
+void BinaryOutput::writeInt32( sal_Int32 n )
+{
+    if( !m_xOutputStream.is() )
+        return;
+
+    Sequence< sal_Int8 > aSeq( 4 );
+    sal_Int8* p = aSeq.getArray();
+
+    for( sal_Int16 i = 0 ; i < 4 ; i++ )
+    {
+        p[i] = sal_Int8( n & 0xff );
+        n >>= 8;
+    }
+    m_xOutputStream->writeBytes( aSeq );
+}
+
+void BinaryOutput::writeString( const OUString& aStr )
+{
+    sal_Int32 nLen = aStr.getLength();
+    const sal_Unicode* pStr = aStr.getStr();
+
+    for( sal_Int32 i = 0 ; i < nLen ; i++ )
+        writeUnicodeChar( pStr[i] );
+
+    writeUnicodeChar( 0 );
+}
+
+Sequence< ::sal_Int8 > BinaryOutput::closeAndGetData()
+{
+    Sequence< ::sal_Int8 > aRetSeq;
+    if( !m_xOutputStream.is() )
+        return aRetSeq;
+
+    m_xOutputStream->closeOutput();
+
+    Reference< io::XSeekable> xSeekable( m_xTempFile, UNO_QUERY );
+    if( !xSeekable.is() )
+        return aRetSeq;
+
+    sal_Int32 nSize = static_cast<sal_Int32>(xSeekable->getPosition());
+
+    Reference< io::XInputStream> xInputStream( m_xTempFile, UNO_QUERY );
+    if( !xInputStream.is() )
+        return aRetSeq;
+
+    xSeekable->seek( 0 );
+    sal_Int32 nRead = xInputStream->readBytes( aRetSeq, nSize );
+    OSL_ENSURE( nRead == nSize, "BinaryOutput::closeAndGetData: nRead != nSize" );
+
+    return aRetSeq;
+}
+
+
+// Binary format:
+
+// Header
+// Byte         Content
+// 0 + 1        sal_Int16:  Version, currently 0, low byte first
+// 2 + 3        sal_Int16:  Locale count = n, low byte first
+// 4 + 5        sal_Int16:  Default Locale position in Locale list, == n if none
+// 6 - 7        sal_Int32:  Start index locale block 0, lowest byte first
+// (n-1) *      sal_Int32:  Start index locale block 1 to n, lowest byte first
+// 6 + 4*n      sal_Int32:  "Start index" non existing locale block n+1,
+//                          marks the first invalid index, kind of EOF
+
+// Locale block
+// All strings are stored as 2-Byte-0 terminated sequence
+// of 16 bit Unicode characters, each with low byte first
+// Empty strings only contain the 2-Byte-0
+
+// Members of com.sun.star.lang.Locale
+// with l1 = Locale.Language.getLength()
+// with l2 = Locale.Country.getLength()
+// with l3 = Locale.Variant.getLength()
+// pos0 = 0                     Locale.Language
+// pos1 = 2 * (l1 + 1)          Locale.Country
+// pos2 = pos1 + 2 * (l2 + 1)   Locale.Variant
+// pos3 = pos2 + 2 * (l3 + 1)
+// pos3                         Properties file written by implWritePropertiesFile
+
+Sequence< sal_Int8 > StringResourcePersistenceImpl::exportBinary(  )
+{
+    BinaryOutput aOut( m_xContext );
+
+    sal_Int32 nLocaleCount = m_aLocaleItemVector.size();
+    std::vector<Sequence< sal_Int8 >> aLocaleDataSeq(nLocaleCount);
+
+    sal_Int32 iLocale = 0;
+    sal_Int32 iDefault = 0;
+    for( auto& pLocaleItem : m_aLocaleItemVector )
+    {
+        if( pLocaleItem != nullptr && loadLocale( pLocaleItem.get() ) )
+        {
+            if( m_pDefaultLocaleItem == pLocaleItem.get() )
+                iDefault = iLocale;
+
+            BinaryOutput aLocaleOut( m_xContext );
+            implWriteLocaleBinary( pLocaleItem.get(), aLocaleOut );
+
+            aLocaleDataSeq[iLocale] = aLocaleOut.closeAndGetData();
+        }
+        ++iLocale;
+    }
+
+    // Write header
+    sal_Int16 nLocaleCount16 = static_cast<sal_Int16>(nLocaleCount);
+    sal_Int16 iDefault16 = static_cast<sal_Int16>(iDefault);
+    aOut.writeInt16( 0 ); // nVersion
+    aOut.writeInt16( nLocaleCount16 );
+    aOut.writeInt16( iDefault16 );
+
+    // Write data positions
+    sal_Int32 nDataPos = 6 + 4 * (nLocaleCount + 1);
+    for( iLocale = 0; iLocale < nLocaleCount; iLocale++ )
+    {
+        aOut.writeInt32( nDataPos );
+
+        Sequence< sal_Int8 >& rSeq = aLocaleDataSeq[iLocale];
+        sal_Int32 nSeqLen = rSeq.getLength();
+        nDataPos += nSeqLen;
+    }
+    // Write final position
+    aOut.writeInt32( nDataPos );
+
+    // Write data
+    Reference< io::XOutputStream > xOutputStream = aOut.getOutputStream();
+    if( xOutputStream.is() )
+    {
+        for( iLocale = 0; iLocale < nLocaleCount; iLocale++ )
+        {
+            Sequence< sal_Int8 >& rSeq = aLocaleDataSeq[iLocale];
+            xOutputStream->writeBytes( rSeq );
+        }
+    }
+
+    Sequence< sal_Int8 > aRetSeq = aOut.closeAndGetData();
+    return aRetSeq;
+}
+
+void StringResourcePersistenceImpl::implWriteLocaleBinary
+    ( LocaleItem* pLocaleItem, BinaryOutput& rOut )
+{
+    Reference< io::XOutputStream > xOutputStream = rOut.getOutputStream();
+    if( !xOutputStream.is() )
+        return;
+
+    Locale& rLocale = pLocaleItem->m_locale;
+    rOut.writeString( rLocale.Language );
+    rOut.writeString( rLocale.Country );
+    rOut.writeString( rLocale.Variant );
+    implWritePropertiesFile( pLocaleItem, xOutputStream, m_aComment );
+}
+
+
+// BinaryOutput, helper class for exportBinary
+
+namespace {
+
+class BinaryInput
+{
+    Sequence< sal_Int8 >                    m_aData;
+    Reference< XComponentContext >          m_xContext;
+
+    const sal_Int8*                         m_pData;
+    sal_Int32                               m_nCurPos;
+    sal_Int32                               m_nSize;
+
+public:
+    BinaryInput( const Sequence< ::sal_Int8 >& aData, Reference< XComponentContext > const & xContext );
+
+    Reference< io::XInputStream > getInputStreamForSection( sal_Int32 nSize );
+
+    void seek( sal_Int32 nPos );
+    sal_Int32 getPosition() const
+        { return m_nCurPos; }
+
+    sal_Int16 readInt16();
+    sal_Int32 readInt32();
+    sal_Unicode readUnicodeChar();
+    OUString readString();
+};
+
+}
+
+BinaryInput::BinaryInput( const Sequence< ::sal_Int8 >& aData, Reference< XComponentContext > const & xContext )
+        : m_aData( aData )
+        , m_xContext( xContext )
+{
+    m_pData = m_aData.getConstArray();
+    m_nCurPos = 0;
+    m_nSize = m_aData.getLength();
+}
+
+Reference< io::XInputStream > BinaryInput::getInputStreamForSection( sal_Int32 nSize )
+{
+    Reference< io::XInputStream > xIn;
+    if( m_nCurPos + nSize <= m_nSize )
+    {
+        Reference< io::XOutputStream > xTempOut( io::TempFile::create(m_xContext), UNO_QUERY_THROW );
+        Sequence< sal_Int8 > aSection( m_pData + m_nCurPos, nSize );
+        xTempOut->writeBytes( aSection );
+
+        Reference< io::XSeekable> xSeekable( xTempOut, UNO_QUERY );
+        if( xSeekable.is() )
+            xSeekable->seek( 0 );
+
+        xIn.set( xTempOut, UNO_QUERY );
+    }
+    else
+        OSL_FAIL( "BinaryInput::getInputStreamForSection(): Read past end" );
+
+    return xIn;
+}
+
+void BinaryInput::seek( sal_Int32 nPos )
+{
+    if( nPos <= m_nSize )
+        m_nCurPos = nPos;
+    else
+        OSL_FAIL( "BinaryInput::seek(): Position past end" );
+}
+
+
+sal_Int16 BinaryInput::readInt16()
+{
+    sal_Int16 nRet = 0;
+    if( m_nCurPos + 2 <= m_nSize )
+    {
+        nRet = nRet + sal_Int16( sal_uInt8( m_pData[m_nCurPos++] ) );
+        nRet += 256 * sal_Int16( sal_uInt8( m_pData[m_nCurPos++] ) );
+    }
+    else
+        OSL_FAIL( "BinaryInput::readInt16(): Read past end" );
+
+    return nRet;
+}
+
+sal_Int32 BinaryInput::readInt32()
+{
+    sal_Int32 nRet = 0;
+    if( m_nCurPos + 4 <= m_nSize )
+    {
+        sal_Int32 nFactor = 1;
+        for( sal_Int16 i = 0; i < 4; i++ )
+        {
+            nRet += sal_uInt8( m_pData[m_nCurPos++] ) * nFactor;
+            nFactor *= 256;
+        }
+    }
+    else
+        OSL_FAIL( "BinaryInput::readInt32(): Read past end" );
+
+    return nRet;
+}
+
+sal_Unicode BinaryInput::readUnicodeChar()
+{
+    sal_uInt16 nRet = 0;
+    if( m_nCurPos + 2 <= m_nSize )
+    {
+        nRet = nRet + sal_uInt8( m_pData[m_nCurPos++] );
+        nRet += 256 * sal_uInt8( m_pData[m_nCurPos++] );
+    }
+    else
+        OSL_FAIL( "BinaryInput::readUnicodeChar(): Read past end" );
+
+    sal_Unicode cRet = nRet;
+    return cRet;
+}
+
+OUString BinaryInput::readString()
+{
+    OUStringBuffer aBuf;
+    sal_Unicode c;
+    do
+    {
+        c = readUnicodeChar();
+        if( c != 0 )
+            aBuf.append( c );
+    }
+    while( c != 0 );
+
+    OUString aRetStr = aBuf.makeStringAndClear();
+    return aRetStr;
+}
+
+void StringResourcePersistenceImpl::importBinary( const Sequence< ::sal_Int8 >& Data )
+{
+    // Init: Remove all locales
+    sal_Int32 nOldLocaleCount = 0;
+    do
+    {
+        Sequence< Locale > aLocaleSeq = getLocales();
+        nOldLocaleCount = aLocaleSeq.getLength();
+        if( nOldLocaleCount > 0 )
+        {
+            Locale aLocale = aLocaleSeq[0];
+            removeLocale( aLocale );
+        }
+    }
+    while( nOldLocaleCount > 0 );
+
+    // Import data
+    BinaryInput aIn( Data, m_xContext );
+
+    aIn.readInt16(); // version
+    sal_Int32 nLocaleCount = aIn.readInt16();
+    sal_Int32 iDefault = aIn.readInt16();
+
+    std::unique_ptr<sal_Int32[]> pPositions( new sal_Int32[nLocaleCount + 1] );
+    for( sal_Int32 i = 0; i < nLocaleCount + 1; i++ )
+        pPositions[i] = aIn.readInt32();
+
+    // Import locales
+    LocaleItem* pUseAsDefaultItem = nullptr;
+    for( sal_Int32 i = 0; i < nLocaleCount; i++ )
+    {
+        sal_Int32 nPos = pPositions[i];
+        aIn.seek( nPos );
+
+        Locale aLocale;
+        aLocale.Language = aIn.readString();
+        aLocale.Country = aIn.readString();
+        aLocale.Variant = aIn.readString();
+
+        sal_Int32 nAfterStringPos = aIn.getPosition();
+        sal_Int32 nSize = pPositions[i+1] - nAfterStringPos;
+        Reference< io::XInputStream > xInput = aIn.getInputStreamForSection( nSize );
+        if( xInput.is() )
+        {
+            LocaleItem* pLocaleItem = new LocaleItem( std::move(aLocale) );
+            if( iDefault == i )
+                pUseAsDefaultItem = pLocaleItem;
+            m_aLocaleItemVector.emplace_back( pLocaleItem );
+            implReadPropertiesFile( pLocaleItem, xInput );
+        }
+    }
+
+    if( pUseAsDefaultItem != nullptr )
+        setDefaultLocale( pUseAsDefaultItem->m_locale );
+}
+
+
+// Private helper methods
+
+static bool checkNamingSceme( const OUString& aName, const OUString& aNameBase,
+                       Locale& aLocale )
+{
+    bool bSuccess = false;
+
+    sal_Int32 nNameLen = aName.getLength();
+    sal_Int32 nNameBaseLen = aNameBase.getLength();
+
+    // Name has to start with NameBase followed
+    // by a '_' and at least one more character
+    if( aName.startsWith( aNameBase ) && nNameBaseLen < nNameLen-1 &&
+        aName[nNameBaseLen] == '_' )
+    {
+        bSuccess = true;
+
+        /* FIXME-BCP47: this uses '_' underscore character as separator and
+         * also appends Variant, which can't be blindly changed as it would
+         * violate the naming scheme in use. */
+
+        sal_Int32 iStart = nNameBaseLen + 1;
+        sal_Int32 iNext_ = aName.indexOf( '_', iStart );
+        if( iNext_ != -1 && iNext_ < nNameLen-1 )
+        {
+            aLocale.Language = aName.copy( iStart, iNext_ - iStart );
+
+            iStart = iNext_ + 1;
+            iNext_ = aName.indexOf( '_', iStart );
+            if( iNext_ != -1 && iNext_ < nNameLen-1 )
+            {
+                aLocale.Country = aName.copy( iStart, iNext_ - iStart );
+                aLocale.Variant = aName.copy( iNext_ + 1 );
+            }
+            else
+                aLocale.Country = aName.copy( iStart );
+        }
+        else
+            aLocale.Language = aName.copy( iStart );
+    }
+    return bSuccess;
+}
+
+void StringResourcePersistenceImpl::implLoadAllLocales()
+{
+    for( auto& pLocaleItem : m_aLocaleItemVector )
+        if( pLocaleItem )
+            loadLocale( pLocaleItem.get() );
+}
+
+// Scan locale properties files helper
+void StringResourcePersistenceImpl::implScanLocaleNames( const Sequence< OUString >& aContentSeq )
+{
+    Locale aDefaultLocale;
+    bool bDefaultFound = false;
+
+    for( const OUString& aCompleteName : aContentSeq )
+    {
+        OUString aPureName;
+        OUString aExtension;
+        sal_Int32 iDot = aCompleteName.lastIndexOf( '.' );
+        sal_Int32 iSlash = aCompleteName.lastIndexOf( '/' );
+        if( iDot != -1 && iDot > iSlash)
+        {
+            sal_Int32 iCopyFrom = (iSlash != -1) ? iSlash + 1 : 0;
+            aPureName = aCompleteName.copy( iCopyFrom, iDot-iCopyFrom );
+            aExtension = aCompleteName.copy( iDot + 1 );
+        }
+
+        if ( aExtension == "properties" )
+        {
+            //OUString aName = aInetObj.getBase();
+            Locale aLocale;
+
+            if( checkNamingSceme( aPureName, m_aNameBase, aLocale ) )
+            {
+                LocaleItem* pLocaleItem = new LocaleItem( std::move(aLocale), false );
+                m_aLocaleItemVector.emplace_back( pLocaleItem );
+
+                if( m_pCurrentLocaleItem == nullptr )
+                    m_pCurrentLocaleItem = pLocaleItem;
+
+                if( m_pDefaultLocaleItem == nullptr )
+                {
+                    m_pDefaultLocaleItem = pLocaleItem;
+                    m_bDefaultModified = true;
+                }
+            }
+        }
+        else if( !bDefaultFound && aExtension == "default" )
+        {
+            if( checkNamingSceme( aPureName, m_aNameBase, aDefaultLocale ) )
+                bDefaultFound = true;
+        }
+    }
+    if( bDefaultFound )
+    {
+        LocaleItem* pLocaleItem = getItemForLocale( aDefaultLocale, false );
+        if( pLocaleItem )
+        {
+            m_pDefaultLocaleItem = pLocaleItem;
+            m_bDefaultModified = false;
+        }
+    }
+}
+
+// Scan locale properties files
+void StringResourcePersistenceImpl::implScanLocales()
+{
+    // Dummy implementation, method not called for this
+    // base class, but pure virtual not possible-
+}
+
+bool StringResourcePersistenceImpl::loadLocale( LocaleItem* pLocaleItem )
+{
+    bool bSuccess = false;
+
+    OSL_ENSURE( pLocaleItem, "StringResourcePersistenceImpl::loadLocale(): pLocaleItem == NULL" );
+    if( pLocaleItem )
+    {
+        if( pLocaleItem->m_bLoaded )
+        {
+            bSuccess = true;
+        }
+        else
+        {
+            bSuccess = implLoadLocale( pLocaleItem );
+            pLocaleItem->m_bLoaded = true;      // = bSuccess??? -> leads to more tries
+        }
+    }
+    return bSuccess;
+}
+
+bool StringResourcePersistenceImpl::implLoadLocale( LocaleItem* )
+{
+    // Dummy implementation, method not called for this
+    // base class, but pure virtual not possible-
+    return false;
+}
+
+static OUString implGetNameScemeForLocaleItem( const LocaleItem* pLocaleItem )
+{
+    /* FIXME-BCP47: this uses '_' underscore character as separator and
+     * also appends Variant, which can't be blindly changed as it would
+     * violate the naming scheme in use. */
+
+    static const char aUnder[] = "_";
+
+    OSL_ENSURE( pLocaleItem,
+        "StringResourcePersistenceImpl::implGetNameScemeForLocaleItem(): pLocaleItem == NULL" );
+    Locale aLocale = pLocaleItem->m_locale;
+
+    OUString aRetStr = aUnder + aLocale.Language;
+
+    OUString aCountry  = aLocale.Country;
+    if( !aCountry.isEmpty() )
+    {
+        aRetStr += aUnder + aCountry;
+    }
+
+    OUString aVariant  = aLocale.Variant;
+    if( !aVariant.isEmpty() )
+    {
+        aRetStr += aUnder + aVariant;
+    }
+    return aRetStr;
+}
+
+OUString StringResourcePersistenceImpl::implGetFileNameForLocaleItem
+    ( LocaleItem const * pLocaleItem, const OUString& aNameBase )
+{
+    OUString aFileName = aNameBase;
+    if( aFileName.isEmpty() )
+        aFileName = aNameBaseDefaultStr;
+
+    aFileName += implGetNameScemeForLocaleItem( pLocaleItem );
+    return aFileName;
+}
+
+OUString StringResourcePersistenceImpl::implGetPathForLocaleItem
+    ( LocaleItem const * pLocaleItem, const OUString& aNameBase,
+      std::u16string_view aLocation, bool bDefaultFile )
+{
+    OUString aFileName = implGetFileNameForLocaleItem( pLocaleItem, aNameBase );
+    INetURLObject aInetObj( aLocation );
+    aInetObj.insertName( aFileName, true, INetURLObject::LAST_SEGMENT, INetURLObject::EncodeMechanism::All );
+    if( bDefaultFile )
+        aInetObj.setExtension( u"default" );
+    else
+        aInetObj.setExtension( u"properties" );
+    OUString aCompleteFileName = aInetObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
+    return aCompleteFileName;
+}
+
+// White space according to Java property files specification in
+// http://java.sun.com/j2se/1.4.2/docs/api/java/util/Properties.html#load(java.io.InputStream)
+static bool isWhiteSpace( sal_Unicode c )
+{
+    bool bWhite = ( c == 0x0020 ||      // space
+                    c == 0x0009 ||      // tab
+                    c == 0x000a ||      // line feed, not always handled by TextInputStream
+                    c == 0x000d ||      // carriage return, not always handled by TextInputStream
+                    c == 0x000C );      // form feed
+    return bWhite;
+}
+
+static void skipWhites( const sal_Unicode* pBuf, sal_Int32 nLen, sal_Int32& ri )
+{
+    while( ri < nLen )
+    {
+        if( !isWhiteSpace( pBuf[ri] ) )
+            break;
+        ri++;
+    }
+}
+
+static bool isHexDigit( sal_Unicode c, sal_uInt16& nDigitVal )
+{
+    bool bRet = true;
+    if( c >= '0' && c <= '9' )
+        nDigitVal = c - '0';
+    else if( c >= 'a' && c <= 'f' )
+        nDigitVal = c - 'a' + 10;
+    else if( c >= 'A' && c <= 'F' )
+        nDigitVal = c - 'A' + 10;
+    else
+        bRet = false;
+    return bRet;
+}
+
+static sal_Unicode getEscapeChar( const sal_Unicode* pBuf, sal_Int32 nLen, sal_Int32& ri )
+{
+    sal_Int32 i = ri;
+
+    sal_Unicode cRet = 0;
+    sal_Unicode c = pBuf[i];
+    switch( c )
+    {
+        case 't':
+            cRet = 0x0009;
+            break;
+        case 'n':
+            cRet = 0x000a;
+            break;
+        case 'f':
+            cRet = 0x000c;
+            break;
+        case 'r':
+            cRet = 0x000d;
+            break;
+        case '\\':
+            cRet = '\\';
+            break;
+        case 'u':
+        {
+            // Skip multiple u
+            i++;
+            while( i < nLen && pBuf[i] == 'u' )
+                i++;
+
+            // Process hex digits
+            sal_Int32 nDigitCount = 0;
+            sal_uInt16 nDigitVal;
+            while( i < nLen && isHexDigit( pBuf[i], nDigitVal ) )
+            {
+                cRet = 16 * cRet + nDigitVal;
+
+                nDigitCount++;
+                if( nDigitCount == 4 )
+                {
+                    // Write back position
+                    ri = i;
+                    break;
+                }
+                i++;
+            }
+            break;
+        }
+        default:
+            cRet = c;
+    }
+
+    return cRet;
+}
+
+static void CheckContinueInNextLine( const Reference< io::XTextInputStream2 >& xTextInputStream,
+    OUString& aLine, bool& bEscapePending, const sal_Unicode*& pBuf,
+    sal_Int32& nLen, sal_Int32& i )
+{
+    if( !(i == nLen && bEscapePending) )
+        return;
+
+    bEscapePending = false;
+
+    if( !xTextInputStream->isEOF() )
+    {
+        aLine = xTextInputStream->readLine();
+        nLen = aLine.getLength();
+        pBuf = aLine.getStr();
+        i = 0;
+
+        skipWhites( pBuf, nLen, i );
+    }
+}
+
+bool StringResourcePersistenceImpl::implReadPropertiesFile
+    ( LocaleItem* pLocaleItem, const Reference< io::XInputStream >& xInputStream )
+{
+    if( !xInputStream.is() || pLocaleItem == nullptr )
+        return false;
+
+    Reference< io::XTextInputStream2 > xTextInputStream = io::TextInputStream::create( m_xContext );
+
+    xTextInputStream->setInputStream( xInputStream );
+
+    OUString aEncodingStr = OUString::createFromAscii
+        ( rtl_getMimeCharsetFromTextEncoding( RTL_TEXTENCODING_ISO_8859_1 ) );
+    xTextInputStream->setEncoding( aEncodingStr );
+
+    OUString aLine;
+    while( !xTextInputStream->isEOF() )
+    {
+        aLine = xTextInputStream->readLine();
+
+        sal_Int32 nLen = aLine.getLength();
+        if( 0 == nLen )
+            continue;
+        const sal_Unicode* pBuf = aLine.getStr();
+        OUStringBuffer aBuf;
+        sal_Unicode c = 0;
+        sal_Int32 i = 0;
+
+        skipWhites( pBuf, nLen, i );
+        if( i == nLen )
+            continue;   // line contains only white spaces
+
+        // Comment?
+        c = pBuf[i];
+        if( c == '#' || c == '!' )
+            continue;
+
+        // Scan key
+        OUString aResourceID;
+        bool bEscapePending = false;
+        bool bStrComplete = false;
+        while( i < nLen && !bStrComplete )
+        {
+            c = pBuf[i];
+            if( bEscapePending )
+            {
+                aBuf.append( getEscapeChar( pBuf, nLen, i ) );
+                bEscapePending = false;
+            }
+            else
+            {
+                if( c == '\\' )
+                {
+                    bEscapePending = true;
+                }
+                else
+                {
+                    if( c == ':' || c == '=' || isWhiteSpace( c ) )
+                        bStrComplete = true;
+                    else
+                        aBuf.append( c );
+                }
+            }
+            i++;
+
+            CheckContinueInNextLine( xTextInputStream, aLine, bEscapePending, pBuf, nLen, i );
+            if( i == nLen )
+                bStrComplete = true;
+
+            if( bStrComplete )
+                aResourceID = aBuf.makeStringAndClear();
+        }
+
+        // Ignore lines with empty keys
+        if( aResourceID.isEmpty() )
+            continue;
+
+        // Scan value
+        skipWhites( pBuf, nLen, i );
+
+        OUString aValueStr;
+        bEscapePending = false;
+        bStrComplete = false;
+        while( i < nLen && !bStrComplete )
+        {
+            c = pBuf[i];
+            if( c == 0x000a || c == 0x000d )    // line feed/carriage return, not always handled by TextInputStream
+            {
+                i++;
+            }
+            else
+            {
+                if( bEscapePending )
+                {
+                    aBuf.append( getEscapeChar( pBuf, nLen, i ) );
+                    bEscapePending = false;
+                }
+                else if( c == '\\' )
+                    bEscapePending = true;
+                else
+                    aBuf.append( c );
+                i++;
+
+                CheckContinueInNextLine( xTextInputStream, aLine, bEscapePending, pBuf, nLen, i );
+            }
+            if( i == nLen )
+                bStrComplete = true;
+
+            if( bStrComplete )
+                aValueStr = aBuf.makeStringAndClear();
+        }
+
+        // Push into table
+        pLocaleItem->m_aIdToStringMap[ aResourceID ] = aValueStr;
+        implScanIdForNumber( aResourceID );
+        IdToIndexMap& rIndexMap = pLocaleItem->m_aIdToIndexMap;
+        rIndexMap[ aResourceID ] = pLocaleItem->m_nNextIndex++;
+    }
+
+    return true;
+}
+
+
+static sal_Unicode getHexCharForDigit( sal_uInt16 nDigitVal )
+{
+    sal_Unicode cRet = ( nDigitVal < 10 ) ? ('0' + nDigitVal) : ('a' + (nDigitVal-10));
+    return cRet;
+}
+
+static void implWriteCharToBuffer( OUStringBuffer& aBuf, sal_Unicode cu, bool bKey )
+{
+    if( cu == '\\' )
+    {
+        aBuf.append( '\\' );
+        aBuf.append( '\\' );
+    }
+    else if( cu == 0x000a )
+    {
+        aBuf.append( '\\' );
+        aBuf.append( 'n' );
+    }
+    else if( cu == 0x000d )
+    {
+        aBuf.append( '\\' );
+        aBuf.append( 'r' );
+    }
+    else if( bKey && cu == '=' )
+    {
+        aBuf.append( '\\' );
+        aBuf.append( '=' );
+    }
+    else if( bKey && cu == ':' )
+    {
+        aBuf.append( '\\' );
+        aBuf.append( ':' );
+    }
+    // ISO/IEC 8859-1 range according to:
+    // http://en.wikipedia.org/wiki/ISO/IEC_8859-1
+    else if( cu >= 0x20 && cu <= 0x7e )
+    //TODO: Check why (cu >= 0xa0 && cu <= 0xFF)
+    //is encoded in sample properties files
+    //else if( (cu >= 0x20 && cu <= 0x7e) ||
+    //       (cu >= 0xa0 && cu <= 0xFF) )
+    {
+        aBuf.append( cu );
+    }
+    else
+    {
+        // Unicode encoding
+        aBuf.append( '\\' );
+        aBuf.append( 'u' );
+
+        sal_uInt16 nVal = cu;
+        for( sal_uInt16 i = 0 ; i < 4 ; i++ )
+        {
+            sal_uInt16 nDigit = nVal / 0x1000;
+            nVal -= nDigit * 0x1000;
+            nVal *= 0x10;
+            aBuf.append( getHexCharForDigit( nDigit ) );
+        }
+    }
+}
+
+static void implWriteStringWithEncoding( const OUString& aStr,
+    Reference< io::XTextOutputStream2 > const & xTextOutputStream, bool bKey )
+{
+    static const sal_Unicode cLineFeed = 0xa;
+
+    OUStringBuffer aBuf;
+    sal_Int32 nLen = aStr.getLength();
+    const sal_Unicode* pSrc = aStr.getStr();
+    for( sal_Int32 i = 0 ; i < nLen ; i++ )
+    {
+        sal_Unicode cu = pSrc[i];
+        implWriteCharToBuffer( aBuf, cu, bKey );
+        // TODO?: split long lines
+    }
+    if( !bKey )
+        aBuf.append( cLineFeed );
+
+    OUString aWriteStr = aBuf.makeStringAndClear();
+    xTextOutputStream->writeString( aWriteStr );
+}
+
+bool StringResourcePersistenceImpl::implWritePropertiesFile( LocaleItem const * pLocaleItem,
+    const Reference< io::XOutputStream >& xOutputStream, const OUString& aComment )
+{
+    if( !xOutputStream.is() || pLocaleItem == nullptr )
+        return false;
+
+    bool bSuccess = false;
+    Reference< io::XTextOutputStream2 > xTextOutputStream = io::TextOutputStream::create(m_xContext);
+
+    xTextOutputStream->setOutputStream( xOutputStream );
+
+    OUString aEncodingStr = OUString::createFromAscii
+        ( rtl_getMimeCharsetFromTextEncoding( RTL_TEXTENCODING_ISO_8859_1 ) );
+    xTextOutputStream->setEncoding( aEncodingStr );
+
+    xTextOutputStream->writeString( aComment );
+    xTextOutputStream->writeString( "\n" );
+
+    const IdToStringMap& rHashMap = pLocaleItem->m_aIdToStringMap;
+    if( !rHashMap.empty() )
+    {
+        // Sort ids according to read order
+        const IdToIndexMap& rIndexMap = pLocaleItem->m_aIdToIndexMap;
+
+        // Find max/min index
+        auto itMinMax = std::minmax_element(rIndexMap.begin(), rIndexMap.end(),
+            [](const IdToIndexMap::value_type& a, const IdToIndexMap::value_type& b) { return a.second < b.second; });
+        sal_Int32 nMinIndex = itMinMax.first->second;
+        sal_Int32 nMaxIndex = itMinMax.second->second;
+        sal_Int32 nTabSize = nMaxIndex - nMinIndex + 1;
+
+        // Create sorted array of pointers to the id strings
+        std::unique_ptr<const OUString*[]> pIdPtrs( new const OUString*[nTabSize] );
+        for(sal_Int32 i = 0 ; i < nTabSize ; i++ )
+            pIdPtrs[i] = nullptr;
+        for( const auto& rIndex : rIndexMap )
+        {
+            sal_Int32 nIndex = rIndex.second;
+            pIdPtrs[nIndex - nMinIndex] = &(rIndex.first);
+        }
+
+        // Write lines in correct order
+        for(sal_Int32 i = 0 ; i < nTabSize ; i++ )
+        {
+            const OUString* pStr = pIdPtrs[i];
+            if( pStr != nullptr )
+            {
+                OUString aResourceID = *pStr;
+                IdToStringMap::const_iterator it = rHashMap.find( aResourceID );
+                if( it != rHashMap.end() )
+                {
+                    implWriteStringWithEncoding( aResourceID, xTextOutputStream, true );
+                    xTextOutputStream->writeString( "=" );
+                    OUString aValStr = (*it).second;
+                    implWriteStringWithEncoding( aValStr, xTextOutputStream, false );
+                }
+            }
+        }
+    }
+
+    bSuccess = true;
+
+    return bSuccess;
+}
+
+
+// StringResourceWithStorageImpl
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+scripting_StringResourceWithStorageImpl_get_implementation(
+    css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const&)
+{
+    return cppu::acquire(new StringResourceWithStorageImpl(context));
+}
+
+
+StringResourceWithStorageImpl::StringResourceWithStorageImpl( const Reference< XComponentContext >& rxContext )
+    : StringResourceWithStorageImpl_BASE( rxContext )
+    , m_bStorageChanged( false )
+{
+}
+
+
+StringResourceWithStorageImpl::~StringResourceWithStorageImpl()
+{
+}
+
+
+// XServiceInfo
+
+
+OUString StringResourceWithStorageImpl::getImplementationName(  )
+{
+    return "com.sun.star.comp.scripting.StringResourceWithStorage";
+}
+
+sal_Bool StringResourceWithStorageImpl::supportsService( const OUString& rServiceName )
+{
+    return cppu::supportsService(this, rServiceName);
+}
+
+Sequence< OUString > StringResourceWithStorageImpl::getSupportedServiceNames(  )
+{
+    return { "com.sun.star.resource.StringResourceWithStorage" };
+}
+
+
+// XInitialization
+
+
+void StringResourceWithStorageImpl::initialize( const Sequence< Any >& aArguments )
+{
+    std::unique_lock aGuard( m_aMutex );
+
+    if ( aArguments.getLength() != 5 )
+    {
+        throw RuntimeException(
+            "StringResourceWithStorageImpl::initialize: invalid number of arguments!" );
+    }
+
+    bool bOk = (aArguments[0] >>= m_xStorage);
+    if( bOk && !m_xStorage.is() )
+        bOk = false;
+
+    if( !bOk )
+    {
+        throw IllegalArgumentException( "StringResourceWithStorageImpl::initialize: invalid storage", Reference< XInterface >(), 0 );
+    }
+
+    implInitializeCommonParameters( aGuard, aArguments );
+}
+
+
+// Forwarding calls to base class
+
+// XModifyBroadcaster
+void StringResourceWithStorageImpl::addModifyListener( const Reference< XModifyListener >& aListener )
+{
+    StringResourceImpl::addModifyListener( aListener );
+}
+void StringResourceWithStorageImpl::removeModifyListener( const Reference< XModifyListener >& aListener )
+{
+    StringResourceImpl::removeModifyListener( aListener );
+}
+
+// XStringResourceResolver
+OUString StringResourceWithStorageImpl::resolveString( const OUString& ResourceID )
+{
+    return StringResourceImpl::resolveString( ResourceID ) ;
+}
+OUString StringResourceWithStorageImpl::resolveStringForLocale( const OUString& ResourceID, const Locale& locale )
+{
+    return StringResourceImpl::resolveStringForLocale( ResourceID, locale );
+}
+sal_Bool StringResourceWithStorageImpl::hasEntryForId( const OUString& ResourceID )
+{
+    return StringResourceImpl::hasEntryForId( ResourceID ) ;
+}
+sal_Bool StringResourceWithStorageImpl::hasEntryForIdAndLocale( const OUString& ResourceID,
+    const Locale& locale )
+{
+    return StringResourceImpl::hasEntryForIdAndLocale( ResourceID, locale );
+}
+Sequence< OUString > StringResourceWithStorageImpl::getResourceIDs(  )
+{
+    return StringResourceImpl::getResourceIDs();
+}
+Sequence< OUString > StringResourceWithStorageImpl::getResourceIDsForLocale
+    ( const Locale& locale )
+{
+    return StringResourceImpl::getResourceIDsForLocale( locale );
+}
+Locale StringResourceWithStorageImpl::getCurrentLocale()
+{
+    return StringResourceImpl::getCurrentLocale();
+}
+Locale StringResourceWithStorageImpl::getDefaultLocale(  )
+{
+    return StringResourceImpl::getDefaultLocale();
+}
+Sequence< Locale > StringResourceWithStorageImpl::getLocales(  )
+{
+    return StringResourceImpl::getLocales();
+}
+
+// XStringResourceManager
+sal_Bool StringResourceWithStorageImpl::isReadOnly()
+{
+    return StringResourceImpl::isReadOnly();
+}
+void StringResourceWithStorageImpl::setCurrentLocale( const Locale& locale, sal_Bool FindClosestMatch )
+{
+    StringResourceImpl::setCurrentLocale( locale, FindClosestMatch );
+}
+void StringResourceWithStorageImpl::setDefaultLocale( const Locale& locale )
+{
+    StringResourceImpl::setDefaultLocale( locale );
+}
+void StringResourceWithStorageImpl::setString( const OUString& ResourceID, const OUString& Str )
+{
+    StringResourceImpl::setString( ResourceID, Str );
+}
+void StringResourceWithStorageImpl::setStringForLocale
+    ( const OUString& ResourceID, const OUString& Str, const Locale& locale )
+{
+    StringResourceImpl::setStringForLocale( ResourceID, Str, locale );
+}
+void StringResourceWithStorageImpl::removeId( const OUString& ResourceID )
+{
+    StringResourceImpl::removeId( ResourceID );
+}
+void StringResourceWithStorageImpl::removeIdForLocale( const OUString& ResourceID, const Locale& locale )
+{
+    StringResourceImpl::removeIdForLocale( ResourceID, locale );
+}
+void StringResourceWithStorageImpl::newLocale( const Locale& locale )
+{
+    StringResourceImpl::newLocale( locale );
+}
+void StringResourceWithStorageImpl::removeLocale( const Locale& locale )
+{
+    StringResourceImpl::removeLocale( locale );
+}
+sal_Int32 StringResourceWithStorageImpl::getUniqueNumericId(  )
+{
+    return StringResourceImpl::getUniqueNumericId();
+}
+
+// XStringResourcePersistence
+void StringResourceWithStorageImpl::store()
+{
+    std::unique_lock aGuard( m_aMutex );
+    implCheckReadOnly( "StringResourceWithStorageImpl::store(): Read only" );
+
+    bool bStoreAll = m_bStorageChanged;
+    m_bStorageChanged = false;
+    if( !m_bModified && !bStoreAll )
+        return;
+
+    implStoreAtStorage( m_aNameBase, m_aComment, m_xStorage, true/*bUsedForStore*/, bStoreAll );
+    m_bModified = false;
+}
+
+sal_Bool StringResourceWithStorageImpl::isModified(  )
+{
+    return StringResourcePersistenceImpl::isModified();
+}
+void StringResourceWithStorageImpl::setComment( const OUString& Comment )
+{
+    StringResourcePersistenceImpl::setComment( Comment );
+}
+void StringResourceWithStorageImpl::storeToStorage( const Reference< XStorage >& Storage,
+    const OUString& NameBase, const OUString& Comment )
+{
+    StringResourcePersistenceImpl::storeToStorage( Storage, NameBase, Comment );
+}
+void StringResourceWithStorageImpl::storeToURL( const OUString& URL,
+    const OUString& NameBase, const OUString& Comment,
+    const Reference< css::task::XInteractionHandler >& Handler )
+{
+    StringResourcePersistenceImpl::storeToURL( URL, NameBase, Comment, Handler );
+}
+Sequence< ::sal_Int8 > StringResourceWithStorageImpl::exportBinary(  )
+{
+    return StringResourcePersistenceImpl::exportBinary();
+}
+void StringResourceWithStorageImpl::importBinary( const Sequence< ::sal_Int8 >& Data )
+{
+    StringResourcePersistenceImpl::importBinary( Data );
+}
+
+
+// XStringResourceWithStorage
+
+void StringResourceWithStorageImpl::storeAsStorage( const Reference< XStorage >& Storage )
+{
+    setStorage( Storage );
+    store();
+}
+
+void StringResourceWithStorageImpl::setStorage( const Reference< XStorage >& Storage )
+{
+    std::unique_lock aGuard( m_aMutex );
+
+    if( !Storage.is() )
+    {
+        throw IllegalArgumentException( "StringResourceWithStorageImpl::setStorage: invalid storage", Reference< XInterface >(), 0 );
+    }
+
+    implLoadAllLocales();
+
+    m_xStorage = Storage;
+    m_bStorageChanged = true;
+}
+
+
+// Private helper methods
+
+
+// Scan locale properties files
+void StringResourceWithStorageImpl::implScanLocales()
+{
+    if( m_xStorage.is() )
+    {
+        Sequence< OUString > aContentSeq = m_xStorage->getElementNames();
+        implScanLocaleNames( aContentSeq );
+    }
+
+    implLoadAllLocales();
+}
+
+// Loading
+bool StringResourceWithStorageImpl::implLoadLocale( LocaleItem* pLocaleItem )
+{
+    bool bSuccess = false;
+    try
+    {
+        OUString aStreamName = implGetFileNameForLocaleItem( pLocaleItem, m_aNameBase ) + ".properties";
+
+        Reference< io::XStream > xElementStream =
+            m_xStorage->openStreamElement( aStreamName, ElementModes::READ );
+
+        if( xElementStream.is() )
+        {
+            Reference< io::XInputStream > xInputStream = xElementStream->getInputStream();
+            if( xInputStream.is() )
+            {
+                bSuccess = StringResourcePersistenceImpl::implReadPropertiesFile( pLocaleItem, xInputStream );
+                xInputStream->closeInput();
+            }
+        }
+    }
+    catch( uno::Exception& )
+    {}
+
+    return bSuccess;
+}
+
+
+// StringResourceWithLocationImpl
+
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+scripting_StringResourceWithLocationImpl_get_implementation(
+    css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const&)
+{
+    return cppu::acquire(new StringResourceWithLocationImpl(context));
+}
+
+
+
+StringResourceWithLocationImpl::StringResourceWithLocationImpl( const Reference< XComponentContext >& rxContext )
+    : StringResourceWithLocationImpl_BASE( rxContext )
+    , m_bLocationChanged( false )
+{
+}
+
+
+StringResourceWithLocationImpl::~StringResourceWithLocationImpl()
+{
+}
+
+
+// XServiceInfo
+
+
+OUString StringResourceWithLocationImpl::getImplementationName(  )
+{
+    return "com.sun.star.comp.scripting.StringResourceWithLocation";
+}
+
+sal_Bool StringResourceWithLocationImpl::supportsService( const OUString& rServiceName )
+{
+    return cppu::supportsService(this, rServiceName);
+}
+
+Sequence< OUString > StringResourceWithLocationImpl::getSupportedServiceNames(  )
+{
+    return { "com.sun.star.resource.StringResourceWithLocation" };
+}
+
+
+// XInitialization
+
+
+void StringResourceWithLocationImpl::initialize( const Sequence< Any >& aArguments )
+{
+    std::unique_lock aGuard( m_aMutex );
+
+    if ( aArguments.getLength() != 6 )
+    {
+        throw RuntimeException(
+            "XInitialization::initialize: invalid number of arguments!" );
+    }
+
+    bool bOk = (aArguments[0] >>= m_aLocation);
+    sal_Int32 nLen = m_aLocation.getLength();
+    if( bOk && nLen == 0 )
+    {
+        bOk = false;
+    }
+    else
+    {
+        if( m_aLocation[nLen - 1] != '/' )
+            m_aLocation += "/";
+    }
+
+    if( !bOk )
+    {
+        throw IllegalArgumentException( "XInitialization::initialize: invalid URL", Reference< XInterface >(), 0 );
+    }
+
+
+    bOk = (aArguments[5] >>= m_xInteractionHandler);
+    if( !bOk )
+    {
+        throw IllegalArgumentException( "StringResourceWithStorageImpl::initialize: invalid type", Reference< XInterface >(), 5 );
+    }
+
+    implInitializeCommonParameters( aGuard, aArguments );
+}
+
+
+// Forwarding calls to base class
+
+// XModifyBroadcaster
+void StringResourceWithLocationImpl::addModifyListener( const Reference< XModifyListener >& aListener )
+{
+    StringResourceImpl::addModifyListener( aListener );
+}
+void StringResourceWithLocationImpl::removeModifyListener( const Reference< XModifyListener >& aListener )
+{
+    StringResourceImpl::removeModifyListener( aListener );
+}
+
+// XStringResourceResolver
+OUString StringResourceWithLocationImpl::resolveString( const OUString& ResourceID )
+{
+    return StringResourceImpl::resolveString( ResourceID ) ;
+}
+OUString StringResourceWithLocationImpl::resolveStringForLocale( const OUString& ResourceID, const Locale& locale )
+{
+    return StringResourceImpl::resolveStringForLocale( ResourceID, locale );
+}
+sal_Bool StringResourceWithLocationImpl::hasEntryForId( const OUString& ResourceID )
+{
+    return StringResourceImpl::hasEntryForId( ResourceID ) ;
+}
+sal_Bool StringResourceWithLocationImpl::hasEntryForIdAndLocale( const OUString& ResourceID,
+    const Locale& locale )
+{
+    return StringResourceImpl::hasEntryForIdAndLocale( ResourceID, locale );
+}
+Sequence< OUString > StringResourceWithLocationImpl::getResourceIDs(  )
+{
+    return StringResourceImpl::getResourceIDs();
+}
+Sequence< OUString > StringResourceWithLocationImpl::getResourceIDsForLocale
+    ( const Locale& locale )
+{
+    return StringResourceImpl::getResourceIDsForLocale( locale );
+}
+Locale StringResourceWithLocationImpl::getCurrentLocale()
+{
+    return StringResourceImpl::getCurrentLocale();
+}
+Locale StringResourceWithLocationImpl::getDefaultLocale(  )
+{
+    return StringResourceImpl::getDefaultLocale();
+}
+Sequence< Locale > StringResourceWithLocationImpl::getLocales(  )
+{
+    return StringResourceImpl::getLocales();
+}
+
+// XStringResourceManager
+sal_Bool StringResourceWithLocationImpl::isReadOnly()
+{
+    return StringResourceImpl::isReadOnly();
+}
+void StringResourceWithLocationImpl::setCurrentLocale( const Locale& locale, sal_Bool FindClosestMatch )
+{
+    StringResourceImpl::setCurrentLocale( locale, FindClosestMatch );
+}
+void StringResourceWithLocationImpl::setDefaultLocale( const Locale& locale )
+{
+    StringResourceImpl::setDefaultLocale( locale );
+}
+void StringResourceWithLocationImpl::setString( const OUString& ResourceID, const OUString& Str )
+{
+    StringResourceImpl::setString( ResourceID, Str );
+}
+void StringResourceWithLocationImpl::setStringForLocale
+    ( const OUString& ResourceID, const OUString& Str, const Locale& locale )
+{
+    StringResourceImpl::setStringForLocale( ResourceID, Str, locale );
+}
+void StringResourceWithLocationImpl::removeId( const OUString& ResourceID )
+{
+    StringResourceImpl::removeId( ResourceID );
+}
+void StringResourceWithLocationImpl::removeIdForLocale( const OUString& ResourceID, const Locale& locale )
+{
+    StringResourceImpl::removeIdForLocale( ResourceID, locale );
+}
+void StringResourceWithLocationImpl::newLocale( const Locale& locale )
+{
+    StringResourceImpl::newLocale( locale );
+}
+void StringResourceWithLocationImpl::removeLocale( const Locale& locale )
+{
+    StringResourceImpl::removeLocale( locale );
+}
+sal_Int32 StringResourceWithLocationImpl::getUniqueNumericId(  )
+{
+    return StringResourceImpl::getUniqueNumericId();
+}
+
+// XStringResourcePersistence
+void StringResourceWithLocationImpl::store()
+{
+    std::unique_lock aGuard( m_aMutex );
+    implCheckReadOnly( "StringResourceWithLocationImpl::store(): Read only" );
+
+    bool bStoreAll = m_bLocationChanged;
+    m_bLocationChanged = false;
+    if( !m_bModified && !bStoreAll )
+        return;
+
+    Reference< ucb::XSimpleFileAccess3 > xFileAccess = getFileAccessImpl();
+    implStoreAtLocation( m_aLocation, m_aNameBase, m_aComment,
+        xFileAccess, true/*bUsedForStore*/, bStoreAll );
+    m_bModified = false;
+}
+
+sal_Bool StringResourceWithLocationImpl::isModified(  )
+{
+    return StringResourcePersistenceImpl::isModified();
+}
+void StringResourceWithLocationImpl::setComment( const OUString& Comment )
+{
+    StringResourcePersistenceImpl::setComment( Comment );
+}
+void StringResourceWithLocationImpl::storeToStorage( const Reference< XStorage >& Storage,
+    const OUString& NameBase, const OUString& Comment )
+{
+    StringResourcePersistenceImpl::storeToStorage( Storage, NameBase, Comment );
+}
+void StringResourceWithLocationImpl::storeToURL( const OUString& URL,
+    const OUString& NameBase, const OUString& Comment,
+    const Reference< css::task::XInteractionHandler >& Handler )
+{
+    StringResourcePersistenceImpl::storeToURL( URL, NameBase, Comment, Handler );
+}
+Sequence< ::sal_Int8 > StringResourceWithLocationImpl::exportBinary(  )
+{
+    return StringResourcePersistenceImpl::exportBinary();
+}
+void StringResourceWithLocationImpl::importBinary( const Sequence< ::sal_Int8 >& Data )
+{
+    StringResourcePersistenceImpl::importBinary( Data );
+}
+
+
+// XStringResourceWithLocation
+
+// XStringResourceWithLocation
+void StringResourceWithLocationImpl::storeAsURL( const OUString& URL )
+{
+    setURL( URL );
+    store();
+}
+
+void StringResourceWithLocationImpl::setURL( const OUString& URL )
+{
+    std::unique_lock aGuard( m_aMutex );
+    implCheckReadOnly( "StringResourceWithLocationImpl::setURL(): Read only" );
+
+    sal_Int32 nLen = URL.getLength();
+    if( nLen == 0 )
+    {
+        throw IllegalArgumentException( "StringResourceWithLocationImpl::setURL: invalid URL", Reference< XInterface >(), 0 );
+    }
+
+    implLoadAllLocales();
+
+    // Delete files at old location
+    implStoreAtLocation( m_aLocation, m_aNameBase, m_aComment,
+        getFileAccessImpl(), false/*bUsedForStore*/, false/*bStoreAll*/, true/*bKillAll*/ );
+
+    m_aLocation = URL;
+    m_bLocationChanged = true;
+}
+
+
+// Private helper methods
+
+
+// Scan locale properties files
+void StringResourceWithLocationImpl::implScanLocales()
+{
+    const Reference< ucb::XSimpleFileAccess3 > xFileAccess = getFileAccessImpl();
+    if( xFileAccess.is() && xFileAccess->isFolder( m_aLocation ) )
+    {
+        Sequence< OUString > aContentSeq = xFileAccess->getFolderContents( m_aLocation, false );
+        implScanLocaleNames( aContentSeq );
+    }
+}
+
+// Loading
+bool StringResourceWithLocationImpl::implLoadLocale( LocaleItem* pLocaleItem )
+{
+    bool bSuccess = false;
+
+    const Reference< ucb::XSimpleFileAccess3 > xFileAccess = getFileAccessImpl();
+    if( xFileAccess.is() )
+    {
+        OUString aCompleteFileName =
+            implGetPathForLocaleItem( pLocaleItem, m_aNameBase, m_aLocation );
+
+        Reference< io::XInputStream > xInputStream;
+        try
+        {
+            xInputStream = xFileAccess->openFileRead( aCompleteFileName );
+        }
+        catch( Exception& )
+        {}
+        if( xInputStream.is() )
+        {
+            bSuccess = StringResourcePersistenceImpl::implReadPropertiesFile( pLocaleItem, xInputStream );
+            xInputStream->closeInput();
+        }
+    }
+
+    return bSuccess;
+}
+
+const Reference< ucb::XSimpleFileAccess3 > & StringResourceWithLocationImpl::getFileAccessImpl()
+{
+    if( !m_xSFI.is() )
+    {
+        m_xSFI = ucb::SimpleFileAccess::create(m_xContext);
+
+        if( m_xSFI.is() && m_xInteractionHandler.is() )
+            m_xSFI->setInteractionHandler( m_xInteractionHandler );
+    }
+    return m_xSFI;
+}
+
+}   // namespace stringresource
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/scripting/source/stringresource/stringresource.hxx b/scripting/source/stringresource/stringresource.hxx
new file mode 100644
index 000000000..7722da62f
--- /dev/null
+++ b/scripting/source/stringresource/stringresource.hxx
@@ -0,0 +1,485 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#pragma once
+
+#include <com/sun/star/resource/XStringResourceWithStorage.hpp>
+#include <com/sun/star/resource/XStringResourceWithLocation.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <com/sun/star/ucb/XSimpleFileAccess3.hpp>
+#include <com/sun/star/io/XInputStream.hpp>
+#include <com/sun/star/io/XOutputStream.hpp>
+#include <cppuhelper/implbase.hxx>
+#include <comphelper/interfacecontainer4.hxx>
+#include <mutex>
+#include <unordered_map>
+#include <vector>
+
+
+namespace stringresource
+{
+
+
+// class stringresourceImpl
+
+
+// Hashtable to map string ids to string
+typedef std::unordered_map
+<
+    OUString,
+    OUString
+>
+IdToStringMap;
+
+typedef std::unordered_map
+<
+    OUString,
+    sal_Int32
+>
+IdToIndexMap;
+
+
+struct LocaleItem
+{
+    css::lang::Locale      m_locale;
+    IdToStringMap          m_aIdToStringMap;
+    IdToIndexMap           m_aIdToIndexMap;
+    sal_Int32              m_nNextIndex;
+    bool                   m_bLoaded;
+    bool                   m_bModified;
+
+    LocaleItem( css::lang::Locale locale, bool bLoaded=true )
+        : m_locale( locale )
+        , m_nNextIndex( 0 )
+        , m_bLoaded( bLoaded )
+        , m_bModified( false )
+    {}
+};
+
+typedef ::cppu::WeakImplHelper<
+    css::lang::XServiceInfo,
+    css::resource::XStringResourceManager > StringResourceImpl_BASE;
+
+class StringResourceImpl : public StringResourceImpl_BASE
+{
+protected:
+    std::mutex                                                m_aMutex;
+    css::uno::Reference< css::uno::XComponentContext >        m_xContext;
+
+    LocaleItem*                                               m_pCurrentLocaleItem;
+    LocaleItem*                                               m_pDefaultLocaleItem;
+    bool                                                      m_bDefaultModified;
+
+    ::comphelper::OInterfaceContainerHelper4<css::util::XModifyListener> m_aListenerContainer;
+
+    std::vector< std::unique_ptr<LocaleItem> >                m_aLocaleItemVector;
+    std::vector< std::unique_ptr<LocaleItem> >                m_aDeletedLocaleItemVector;
+    std::vector< std::unique_ptr<LocaleItem> >                m_aChangedDefaultLocaleVector;
+
+    bool                                                      m_bModified;
+    bool                                                      m_bReadOnly;
+
+    sal_Int32                                                 m_nNextUniqueNumericId;
+
+    // Scans ResourceID to start with number and adapt m_nNextUniqueNumericId
+    void implScanIdForNumber( const OUString& ResourceID );
+    const static sal_Int32 UNIQUE_NUMBER_NEEDS_INITIALISATION = -1;
+
+    // Checks read only status and throws exception if it's true
+    /// @throws css::lang::NoSupportException
+    void implCheckReadOnly( const char* pExceptionMsg );
+
+    // Returns the LocalItem for a given locale, if it exists, otherwise NULL
+    // This method compares the locales exactly, no closest match search is performed
+    /// @throws css::lang::IllegalArgumentException
+    LocaleItem* getItemForLocale( const css::lang::Locale& locale, bool bException );
+
+    // Returns the LocalItem for a given locale, if it exists, otherwise NULL
+    // This method performs a closest match search, at least the language must match
+    LocaleItem* getClosestMatchItemForLocale( const css::lang::Locale& locale );
+    /// @throws css::lang::IllegalArgumentException
+    /// @throws css::uno::RuntimeException
+    void implSetCurrentLocale( std::unique_lock<std::mutex>& rGuard, const css::lang::Locale& locale,
+        bool FindClosestMatch, bool bUseDefaultIfNoMatch );
+
+    void implModified(std::unique_lock<std::mutex>&);
+    void implNotifyListeners(std::unique_lock<std::mutex>&);
+
+    //=== Impl methods for ...ForLocale methods ===
+    /// @throws css::resource::MissingResourceException
+    OUString implResolveString( const OUString& ResourceID, LocaleItem* pLocaleItem );
+    bool implHasEntryForId( const OUString& ResourceID, LocaleItem* pLocaleItem );
+    css::uno::Sequence< OUString > implGetResourceIDs( LocaleItem* pLocaleItem );
+    void implSetString( std::unique_lock<std::mutex>& rGuard, const OUString& ResourceID,
+        const OUString& Str, LocaleItem* pLocaleItem );
+    /// @throws css::resource::MissingResourceException
+    void implRemoveId( std::unique_lock<std::mutex>& rGuard, const OUString& ResourceID, LocaleItem* pLocaleItem );
+
+    // Method to load a locale if necessary, returns true if loading was
+    // successful. Default implementation in base class just returns true.
+    virtual bool loadLocale( LocaleItem* pLocaleItem );
+
+    virtual void implLoadAllLocales();
+
+public:
+    explicit StringResourceImpl(
+        const css::uno::Reference< css::uno::XComponentContext >& rxContext );
+    virtual ~StringResourceImpl() override;
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName(  ) override;
+    virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+    virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames(  ) override;
+
+    // XModifyBroadcaster
+    virtual void SAL_CALL addModifyListener( const css::uno::Reference< css::util::XModifyListener >& aListener ) override;
+    virtual void SAL_CALL removeModifyListener( const css::uno::Reference< css::util::XModifyListener >& aListener ) override;
+
+     // XStringResourceResolver
+    virtual OUString SAL_CALL resolveString( const OUString& ResourceID ) override;
+    virtual OUString SAL_CALL resolveStringForLocale( const OUString& ResourceID,
+        const css::lang::Locale& locale ) override;
+    virtual sal_Bool SAL_CALL hasEntryForId( const OUString& ResourceID ) override;
+    virtual sal_Bool SAL_CALL hasEntryForIdAndLocale( const OUString& ResourceID,
+        const css::lang::Locale& locale ) override;
+    virtual css::uno::Sequence< OUString > SAL_CALL getResourceIDs(  ) override;
+    virtual css::uno::Sequence< OUString > SAL_CALL getResourceIDsForLocale
+        ( const css::lang::Locale& locale ) override;
+    virtual css::lang::Locale SAL_CALL getCurrentLocale(  ) override;
+    virtual css::lang::Locale SAL_CALL getDefaultLocale(  ) override;
+    virtual css::uno::Sequence< css::lang::Locale > SAL_CALL getLocales(  ) override;
+
+    // XStringResourceManager
+    virtual sal_Bool SAL_CALL isReadOnly() override;
+    virtual void SAL_CALL setCurrentLocale( const css::lang::Locale& locale, sal_Bool FindClosestMatch ) override;
+    virtual void SAL_CALL setDefaultLocale( const css::lang::Locale& locale ) override;
+    virtual void SAL_CALL setString( const OUString& ResourceID, const OUString& Str ) override;
+    virtual void SAL_CALL setStringForLocale( const OUString& ResourceID, const OUString& Str,
+        const css::lang::Locale& locale ) override;
+    virtual void SAL_CALL removeId( const OUString& ResourceID ) override;
+    virtual void SAL_CALL removeIdForLocale( const OUString& ResourceID,
+        const css::lang::Locale& locale ) override;
+    virtual void SAL_CALL newLocale( const css::lang::Locale& locale ) override;
+    virtual void SAL_CALL removeLocale( const css::lang::Locale& locale ) override;
+    virtual ::sal_Int32 SAL_CALL getUniqueNumericId(  ) override;
+ };
+
+typedef ::cppu::ImplInheritanceHelper<
+        StringResourceImpl,
+        css::resource::XStringResourcePersistence > StringResourcePersistenceImpl_BASE;
+
+class BinaryOutput;
+
+class StringResourcePersistenceImpl : public StringResourcePersistenceImpl_BASE
+{
+protected:
+    OUString                                                             m_aNameBase;
+    OUString                                                             m_aComment;
+
+    /// @throws css::uno::Exception
+    /// @throws css::uno::RuntimeException
+    void implInitializeCommonParameters( std::unique_lock<std::mutex>& rGuard, const css::uno::Sequence< css::uno::Any >& aArguments );
+
+    // Scan locale properties files
+    virtual void implScanLocales();
+
+    // Method to load a locale if necessary, returns true if loading was successful
+    virtual bool loadLocale( LocaleItem* pLocaleItem ) override;
+
+    // does the actual loading
+    virtual bool implLoadLocale( LocaleItem* pLocaleItem );
+
+    virtual void implLoadAllLocales() override;
+
+    void implScanLocaleNames( const css::uno::Sequence< OUString >& aContentSeq );
+    static OUString implGetFileNameForLocaleItem( LocaleItem const * pLocaleItem, const OUString& aNameBase );
+    static OUString implGetPathForLocaleItem( LocaleItem const * pLocaleItem, const OUString& aNameBase,
+        std::u16string_view aLocation, bool bDefaultFile=false );
+
+    bool implReadPropertiesFile( LocaleItem* pLocaleItem,
+        const css::uno::Reference< css::io::XInputStream >& xInput );
+
+    bool implWritePropertiesFile( LocaleItem const * pLocaleItem,
+              const css::uno::Reference< css::io::XOutputStream >& xOutputStream,
+              const OUString& aComment );
+
+    void implWriteLocaleBinary( LocaleItem* pLocaleItem, BinaryOutput& rOut );
+
+    /// @throws css::uno::Exception
+    /// @throws css::uno::RuntimeException
+    void implStoreAtStorage
+    (
+        const OUString& aNameBase,
+        const OUString& aComment,
+        const css::uno::Reference< css::embed::XStorage >& Storage,
+        bool bUsedForStore,
+        bool bStoreAll
+    );
+
+    /// @throws css::uno::Exception
+    /// @throws css::uno::RuntimeException
+    void implKillRemovedLocaleFiles
+    (
+        std::u16string_view Location,
+        const OUString& aNameBase,
+        const css::uno::Reference< css::ucb::XSimpleFileAccess3 >& xFileAccess
+    );
+
+    /// @throws css::uno::Exception
+    /// @throws css::uno::RuntimeException
+    void implKillChangedDefaultFiles
+    (
+        std::u16string_view Location,
+        const OUString& aNameBase,
+        const css::uno::Reference< css::ucb::XSimpleFileAccess3 >& xFileAccess
+    );
+
+    /// @throws css::uno::Exception
+    /// @throws css::uno::RuntimeException
+    void implStoreAtLocation
+    (
+        std::u16string_view Location,
+        const OUString& aNameBase,
+        const OUString& aComment,
+        const css::uno::Reference< css::ucb::XSimpleFileAccess3 >& xFileAccess,
+        bool bUsedForStore,
+        bool bStoreAll,
+        bool bKillAll = false
+    );
+
+public:
+    explicit StringResourcePersistenceImpl(
+        const css::uno::Reference< css::uno::XComponentContext >& rxContext );
+    virtual ~StringResourcePersistenceImpl() override;
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName(  ) override;
+    virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+    virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames(  ) override;
+
+    // XModifyBroadcaster
+    virtual void SAL_CALL addModifyListener( const css::uno::Reference< css::util::XModifyListener >& aListener ) override;
+    virtual void SAL_CALL removeModifyListener( const css::uno::Reference< css::util::XModifyListener >& aListener ) override;
+
+     // XStringResourceResolver
+    virtual OUString SAL_CALL resolveString( const OUString& ResourceID ) override;
+    virtual OUString SAL_CALL resolveStringForLocale( const OUString& ResourceID,
+        const css::lang::Locale& locale ) override;
+    virtual sal_Bool SAL_CALL hasEntryForId( const OUString& ResourceID ) override;
+    virtual sal_Bool SAL_CALL hasEntryForIdAndLocale( const OUString& ResourceID,
+        const css::lang::Locale& locale ) override;
+    virtual css::uno::Sequence< OUString > SAL_CALL getResourceIDs(  ) override;
+    virtual css::uno::Sequence< OUString > SAL_CALL getResourceIDsForLocale
+        ( const css::lang::Locale& locale ) override;
+    virtual css::lang::Locale SAL_CALL getCurrentLocale(  ) override;
+    virtual css::lang::Locale SAL_CALL getDefaultLocale(  ) override;
+    virtual css::uno::Sequence< css::lang::Locale > SAL_CALL getLocales(  ) override;
+
+    // XStringResourceManager
+    virtual sal_Bool SAL_CALL isReadOnly() override;
+    virtual void SAL_CALL setCurrentLocale( const css::lang::Locale& locale, sal_Bool FindClosestMatch ) override;
+    virtual void SAL_CALL setDefaultLocale( const css::lang::Locale& locale ) override;
+    virtual void SAL_CALL setString( const OUString& ResourceID, const OUString& Str ) override;
+    virtual void SAL_CALL setStringForLocale( const OUString& ResourceID, const OUString& Str,
+        const css::lang::Locale& locale ) override;
+    virtual void SAL_CALL removeId( const OUString& ResourceID ) override;
+    virtual void SAL_CALL removeIdForLocale( const OUString& ResourceID,
+        const css::lang::Locale& locale ) override;
+    virtual void SAL_CALL newLocale( const css::lang::Locale& locale ) override;
+    virtual void SAL_CALL removeLocale( const css::lang::Locale& locale ) override;
+    virtual ::sal_Int32 SAL_CALL getUniqueNumericId(  ) override;
+
+    // XStringResourcePersistence
+    virtual void SAL_CALL store(  ) override;
+    virtual sal_Bool SAL_CALL isModified(  ) override;
+    virtual void SAL_CALL setComment( const OUString& Comment ) override;
+    virtual void SAL_CALL storeToStorage
+        ( const css::uno::Reference< css::embed::XStorage >& Storage,
+          const OUString& NameBase, const OUString& Comment ) override;
+    virtual void SAL_CALL storeToURL( const OUString& URL, const OUString& NameBase,
+        const OUString& Comment, const css::uno::Reference
+        < css::task::XInteractionHandler >& Handler ) override;
+    virtual css::uno::Sequence< ::sal_Int8 > SAL_CALL exportBinary(  ) override;
+    virtual void SAL_CALL importBinary( const css::uno::Sequence< ::sal_Int8 >& Data ) override;
+};
+
+
+typedef ::cppu::ImplInheritanceHelper<
+        StringResourcePersistenceImpl,
+        css::lang::XInitialization,
+        css::resource::XStringResourceWithStorage > StringResourceWithStorageImpl_BASE;
+
+class StringResourceWithStorageImpl : public StringResourceWithStorageImpl_BASE
+{
+    css::uno::Reference< css::embed::XStorage >       m_xStorage;
+    bool                                              m_bStorageChanged;
+
+    virtual void implScanLocales() override;
+    virtual bool implLoadLocale( LocaleItem* pLocaleItem ) override;
+
+public:
+    explicit StringResourceWithStorageImpl( const css::uno::Reference< css::uno::XComponentContext >& rxContext );
+    virtual ~StringResourceWithStorageImpl() override;
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName(  ) override;
+    virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+    virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames(  ) override;
+
+    // XInitialization
+    virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& aArguments ) override;
+
+    // XModifyBroadcaster
+    virtual void SAL_CALL addModifyListener( const css::uno::Reference< css::util::XModifyListener >& aListener ) override;
+    virtual void SAL_CALL removeModifyListener( const css::uno::Reference< css::util::XModifyListener >& aListener ) override;
+
+     // XStringResourceResolver
+    virtual OUString SAL_CALL resolveString( const OUString& ResourceID ) override;
+    virtual OUString SAL_CALL resolveStringForLocale( const OUString& ResourceID,
+        const css::lang::Locale& locale ) override;
+    virtual sal_Bool SAL_CALL hasEntryForId( const OUString& ResourceID ) override;
+    virtual sal_Bool SAL_CALL hasEntryForIdAndLocale( const OUString& ResourceID,
+        const css::lang::Locale& locale ) override;
+    virtual css::uno::Sequence< OUString > SAL_CALL getResourceIDs(  ) override;
+    virtual css::uno::Sequence< OUString > SAL_CALL getResourceIDsForLocale
+        ( const css::lang::Locale& locale ) override;
+    virtual css::lang::Locale SAL_CALL getCurrentLocale(  ) override;
+    virtual css::lang::Locale SAL_CALL getDefaultLocale(  ) override;
+    virtual css::uno::Sequence< css::lang::Locale > SAL_CALL getLocales(  ) override;
+
+    // XStringResourceManager
+    virtual sal_Bool SAL_CALL isReadOnly() override;
+    virtual void SAL_CALL setCurrentLocale( const css::lang::Locale& locale, sal_Bool FindClosestMatch ) override;
+    virtual void SAL_CALL setDefaultLocale( const css::lang::Locale& locale ) override;
+    virtual void SAL_CALL setString( const OUString& ResourceID, const OUString& Str ) override;
+    virtual void SAL_CALL setStringForLocale( const OUString& ResourceID, const OUString& Str,
+        const css::lang::Locale& locale ) override;
+    virtual void SAL_CALL removeId( const OUString& ResourceID ) override;
+    virtual void SAL_CALL removeIdForLocale( const OUString& ResourceID,
+        const css::lang::Locale& locale ) override;
+    virtual void SAL_CALL newLocale( const css::lang::Locale& locale ) override;
+    virtual void SAL_CALL removeLocale( const css::lang::Locale& locale ) override;
+    virtual ::sal_Int32 SAL_CALL getUniqueNumericId(  ) override;
+
+    // XStringResourcePersistence
+    virtual void SAL_CALL store(  ) override;
+    virtual sal_Bool SAL_CALL isModified(  ) override;
+    virtual void SAL_CALL setComment( const OUString& Comment ) override;
+    virtual void SAL_CALL storeToStorage
+        ( const css::uno::Reference< css::embed::XStorage >& Storage,
+          const OUString& NameBase, const OUString& Comment ) override;
+    virtual void SAL_CALL storeToURL( const OUString& URL, const OUString& NameBase,
+        const OUString& Comment, const css::uno::Reference
+        < css::task::XInteractionHandler >& Handler ) override;
+    virtual css::uno::Sequence< ::sal_Int8 > SAL_CALL exportBinary(  ) override;
+    virtual void SAL_CALL importBinary( const css::uno::Sequence< ::sal_Int8 >& Data ) override;
+
+    // XStringResourceWithStorage
+    virtual void SAL_CALL storeAsStorage
+        ( const css::uno::Reference< css::embed::XStorage >& Storage ) override;
+    virtual void SAL_CALL setStorage
+        ( const css::uno::Reference< css::embed::XStorage >& Storage ) override;
+};
+
+
+typedef ::cppu::ImplInheritanceHelper<
+        StringResourcePersistenceImpl,
+        css::lang::XInitialization,
+        css::resource::XStringResourceWithLocation > StringResourceWithLocationImpl_BASE;
+
+class StringResourceWithLocationImpl : public StringResourceWithLocationImpl_BASE
+{
+    OUString                                              m_aLocation;
+    bool                                                  m_bLocationChanged;
+    css::uno::Reference< css::ucb::XSimpleFileAccess3 >   m_xSFI;
+    css::uno::Reference< css::task::XInteractionHandler > m_xInteractionHandler;
+
+    const css::uno::Reference< css::ucb::XSimpleFileAccess3 > & getFileAccessImpl();
+
+    virtual void implScanLocales() override;
+    virtual bool implLoadLocale( LocaleItem* pLocaleItem ) override;
+
+public:
+    explicit StringResourceWithLocationImpl( const css::uno::Reference< css::uno::XComponentContext >& rxContext );
+    virtual ~StringResourceWithLocationImpl() override;
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName(  ) override;
+    virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+    virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames(  ) override;
+
+    // XInitialization
+    virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& aArguments ) override;
+
+    // XModifyBroadcaster
+    virtual void SAL_CALL addModifyListener( const css::uno::Reference< css::util::XModifyListener >& aListener ) override;
+    virtual void SAL_CALL removeModifyListener( const css::uno::Reference< css::util::XModifyListener >& aListener ) override;
+
+     // XStringResourceResolver
+    virtual OUString SAL_CALL resolveString( const OUString& ResourceID ) override;
+    virtual OUString SAL_CALL resolveStringForLocale( const OUString& ResourceID,
+        const css::lang::Locale& locale ) override;
+    virtual sal_Bool SAL_CALL hasEntryForId( const OUString& ResourceID ) override;
+    virtual sal_Bool SAL_CALL hasEntryForIdAndLocale( const OUString& ResourceID,
+        const css::lang::Locale& locale ) override;
+    virtual css::uno::Sequence< OUString > SAL_CALL getResourceIDs(  ) override;
+    virtual css::uno::Sequence< OUString > SAL_CALL getResourceIDsForLocale
+        ( const css::lang::Locale& locale ) override;
+    virtual css::lang::Locale SAL_CALL getCurrentLocale(  ) override;
+    virtual css::lang::Locale SAL_CALL getDefaultLocale(  ) override;
+    virtual css::uno::Sequence< css::lang::Locale > SAL_CALL getLocales(  ) override;
+
+    // XStringResourceManager
+    virtual sal_Bool SAL_CALL isReadOnly() override;
+    virtual void SAL_CALL setCurrentLocale( const css::lang::Locale& locale, sal_Bool FindClosestMatch ) override;
+    virtual void SAL_CALL setDefaultLocale( const css::lang::Locale& locale ) override;
+    virtual void SAL_CALL setString( const OUString& ResourceID, const OUString& Str ) override;
+    virtual void SAL_CALL setStringForLocale( const OUString& ResourceID, const OUString& Str,
+        const css::lang::Locale& locale ) override;
+    virtual void SAL_CALL removeId( const OUString& ResourceID ) override;
+    virtual void SAL_CALL removeIdForLocale( const OUString& ResourceID,
+        const css::lang::Locale& locale ) override;
+    virtual void SAL_CALL newLocale( const css::lang::Locale& locale ) override;
+    virtual void SAL_CALL removeLocale( const css::lang::Locale& locale ) override;
+    virtual ::sal_Int32 SAL_CALL getUniqueNumericId(  ) override;
+
+    // XStringResourcePersistence
+    virtual void SAL_CALL store(  ) override;
+    virtual sal_Bool SAL_CALL isModified(  ) override;
+    virtual void SAL_CALL setComment( const OUString& Comment ) override;
+    virtual void SAL_CALL storeToStorage
+        ( const css::uno::Reference< css::embed::XStorage >& Storage,
+          const OUString& NameBase, const OUString& Comment ) override;
+    virtual void SAL_CALL storeToURL( const OUString& URL, const OUString& NameBase,
+        const OUString& Comment, const css::uno::Reference
+        < css::task::XInteractionHandler >& Handler ) override;
+    virtual css::uno::Sequence< ::sal_Int8 > SAL_CALL exportBinary(  ) override;
+    virtual void SAL_CALL importBinary( const css::uno::Sequence< ::sal_Int8 >& Data ) override;
+
+    // XStringResourceWithLocation
+    virtual void SAL_CALL storeAsURL( const OUString& URL ) override;
+    virtual void SAL_CALL setURL( const OUString& URL ) override;
+};
+
+
+}   // namespace stringtable
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */