include/svl/ondemand.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_SVL_ONDEMAND_HXX
  21 #define INCLUDED_SVL_ONDEMAND_HXX
  22
  23 #include <memory>
  24 #include <unotools/syslocale.hxx>
  25 #include <i18nlangtag/lang.h>
  26 #include <unotools/localedatawrapper.hxx>
  27 #include <unotools/calendarwrapper.hxx>
  28 #include <unotools/transliterationwrapper.hxx>
  29 #include <unotools/nativenumberwrapper.hxx>
  30 #include <com/sun/star/uno/Reference.hxx>
  31 #include <i18nutil/transliteration.hxx>
  32
  33 /*
  34     On demand instantiation and initialization of several i18n wrappers,
  35     helping the number formatter to not perform worse than it already does.
  36  */
  37
  38 /** @short
  39     Switch between LANGUAGE_SYSTEM and LANGUAGE_ENGLISH_US and any other
  40     LocaleDataWrapper.
  41     SvNumberformatter uses it upon switching locales.
  42
  43     @descr
  44     Avoids reloading and analysing of locale data again and again.
  45
  46     @ATTENTION
  47     If the default ctor is used the init() method MUST be called before
  48     accessing any locale data. The passed parameters Locale and LanguageType
  49     must match each other.
  50  */
  51
  52 class OnDemandLocaleDataWrapper
  53 {
  54             css::uno::Reference< css::uno::XComponentContext > m_xContext;
  55             SvtSysLocale        aSysLocale;
  56             LanguageType        eCurrentLanguage;
  57             LanguageType        eLastAnyLanguage;
  58     const   LocaleDataWrapper*  pSystem;
  59     std::unique_ptr<const LocaleDataWrapper>  pEnglish;
  60     std::unique_ptr<      LocaleDataWrapper>  pAny;
  61     const   LocaleDataWrapper*  pCurrent;
  62             bool                bInitialized;
  63
  64 public:
  65                                 OnDemandLocaleDataWrapper()
  66                                     : eLastAnyLanguage( LANGUAGE_DONTKNOW )
  67                                     , bInitialized(false)
  68                                     {
  69                                         pCurrent = pSystem = aSysLocale.GetLocaleDataPtr();
  70                                         eCurrentLanguage = LANGUAGE_SYSTEM;
  71                                     }
  72
  73             bool                isInitialized() const   { return bInitialized; }
  74
  75             void                init(
  76                                     const css::uno::Reference< css::uno::XComponentContext >& rxContext,
  77                                     const LanguageTag& rLanguageTag
  78                                     )
  79                                     {
  80                                         m_xContext = rxContext;
  81                                         changeLocale( rLanguageTag );
  82                                         bInitialized = true;
  83                                     }
  84
  85             void                changeLocale( const LanguageTag& rLanguageTag )
  86                                     {
  87                                         LanguageType eLang = rLanguageTag.getLanguageType( false);
  88                                         if ( eLang == LANGUAGE_SYSTEM )
  89                                                 pCurrent = pSystem;
  90                                         else if ( eLang == LANGUAGE_ENGLISH_US )
  91                                         {
  92                                                 if ( !pEnglish )
  93                                                     pEnglish.reset( new LocaleDataWrapper( m_xContext, rLanguageTag ) );
  94                                                 pCurrent = pEnglish.get();
  95                                         }
  96                                         else
  97                                         {
  98                                             if ( !pAny )
  99                                             {
 100                                                 pAny.reset( new LocaleDataWrapper( m_xContext, rLanguageTag ) );
 101                                                 eLastAnyLanguage = eLang;
 102                                             }
 103                                             else if ( eLastAnyLanguage != eLang )
 104                                             {
 105                                                 pAny->setLanguageTag( rLanguageTag );
 106                                                 eLastAnyLanguage = eLang;
 107                                             }
 108                                             pCurrent = pAny.get();
 109                                         }
 110                                         eCurrentLanguage = eLang;
 111                                     }
 112
 113             LanguageType        getCurrentLanguage() const
 114                                     { return eCurrentLanguage; }
 115
 116     const   LocaleDataWrapper*  get() const         { return pCurrent; }
 117     const   LocaleDataWrapper*  operator->() const  { return get(); }
 118     const   LocaleDataWrapper&  operator*() const   { return *pCurrent; }
 119 };
 120
 121 /** Load a calendar only if it's needed. Keep calendar for "en-US" locale
 122     separately, as there can be alternation between locale dependent and
 123     locale independent formats.
 124     SvNumberformatter uses it upon switching locales.
 125
 126     @ATTENTION If the default ctor is used the init() method MUST be called
 127     before accessing the calendar.
 128  */
 129 class OnDemandCalendarWrapper
 130 {
 131             css::uno::Reference< css::uno::XComponentContext > m_xContext;
 132             css::lang::Locale  aEnglishLocale;
 133             css::lang::Locale  aLocale;
 134     mutable css::lang::Locale  aLastAnyLocale;
 135     mutable std::unique_ptr<CalendarWrapper> pEnglishPtr;
 136     mutable std::unique_ptr<CalendarWrapper> pAnyPtr;
 137
 138 public:
 139                                 OnDemandCalendarWrapper()
 140                                     {
 141                                         LanguageTag aEnglishLanguageTag(LANGUAGE_ENGLISH_US);
 142                                         aEnglishLocale = aEnglishLanguageTag.getLocale();
 143                                         aLastAnyLocale = aEnglishLocale;
 144                                     }
 145
 146             void                init(
 147                                     const css::uno::Reference< css::uno::XComponentContext >& rxContext,
 148                                     const css::lang::Locale& rLocale
 149                                     )
 150                                     {
 151                                         m_xContext = rxContext;
 152                                         changeLocale( rLocale );
 153                                         pEnglishPtr.reset();
 154                                         pAnyPtr.reset();
 155                                     }
 156
 157             void                changeLocale( const css::lang::Locale& rLocale )
 158                                     {
 159                                         aLocale = rLocale;
 160                                     }
 161
 162             CalendarWrapper*    get() const
 163                                     {
 164                                         CalendarWrapper* pPtr;
 165                                         if ( aLocale == aEnglishLocale )
 166                                         {
 167                                             if (!pEnglishPtr)
 168                                             {
 169                                                 pEnglishPtr.reset( new CalendarWrapper( m_xContext ));
 170                                                 pEnglishPtr->loadDefaultCalendar( aEnglishLocale );
 171                                             }
 172                                             pPtr = pEnglishPtr.get();
 173                                         }
 174                                         else
 175                                         {
 176                                             if ( !pAnyPtr )
 177                                             {
 178                                                 pAnyPtr.reset(new CalendarWrapper( m_xContext ));
 179                                                 pAnyPtr->loadDefaultCalendar(aLocale);
 180                                                 aLastAnyLocale = aLocale;
 181                                             }
 182                                             else if ( aLocale != aLastAnyLocale )
 183                                             {
 184                                                 pAnyPtr->loadDefaultCalendar( aLocale );
 185                                                 aLastAnyLocale = aLocale;
 186                                             }
 187                                             pPtr = pAnyPtr.get();
 188                                         }
 189                                         return pPtr;
 190                                     }
 191
 192 };
 193
 194 /** Load a transliteration only if it's needed.
 195     SvNumberformatter uses it upon switching locales.
 196     @ATTENTION If the default ctor is used the init() method MUST be called
 197     before accessing the transliteration.
 198  */
 199 class OnDemandTransliterationWrapper
 200 {
 201             css::uno::Reference< css::uno::XComponentContext > m_xContext;
 202             LanguageType        eLanguage;
 203             TransliterationFlags  nType;
 204     mutable std::unique_ptr<::utl::TransliterationWrapper>
 205                                 pPtr;
 206     mutable bool                bValid;
 207             bool                bInitialized;
 208
 209 public:
 210                                 OnDemandTransliterationWrapper()
 211                                     : eLanguage( LANGUAGE_SYSTEM )
 212                                     , nType(TransliterationFlags::NONE)
 213                                     , bValid(false)
 214                                     , bInitialized(false)
 215                                     {}
 216
 217             bool                isInitialized() const   { return bInitialized; }
 218
 219             void                init(
 220                                     const css::uno::Reference< css::uno::XComponentContext >& rxContext,
 221                                     LanguageType eLang
 222                                     )
 223                                     {
 224                                         m_xContext = rxContext;
 225                                         nType = TransliterationFlags::IGNORE_CASE;
 226                                         changeLocale( eLang );
 227                                         pPtr.reset();
 228                                         bInitialized = true;
 229                                     }
 230
 231             void                changeLocale( LanguageType eLang )
 232                                     {
 233                                         bValid = false;
 234                                         eLanguage = eLang;
 235                                     }
 236
 237     const   ::utl::TransliterationWrapper*  get() const
 238                                     {
 239                                         if ( !bValid )
 240                                         {
 241                                             if ( !pPtr )
 242                                                 pPtr.reset( new ::utl::TransliterationWrapper( m_xContext, nType ) );
 243                                             pPtr->loadModuleIfNeeded( eLanguage );
 244                                             bValid = true;
 245                                         }
 246                                         return pPtr.get();
 247                                     }
 248
 249     const   ::utl::TransliterationWrapper*  operator->() const  { return get(); }
 250 };
 251
 252 /** Load a native number service wrapper only if it's needed.
 253     SvNumberformatter uses it.
 254
 255     @ATTENTION
 256     If the default ctor is used the init() method MUST be called
 257     before accessing the native number supplier.
 258  */
 259 class OnDemandNativeNumberWrapper
 260 {
 261             css::uno::Reference< css::uno::XComponentContext > m_xContext;
 262     mutable std::unique_ptr<NativeNumberWrapper>
 263                                     pPtr;
 264
 265 public:
 266                                 OnDemandNativeNumberWrapper()
 267                                     {}
 268
 269             void                init(
 270                                     const css::uno::Reference< css::uno::XComponentContext >& rxContext
 271                                     )
 272                                     {
 273                                         m_xContext = rxContext;
 274                                         pPtr.reset();
 275                                     }
 276
 277             NativeNumberWrapper*    get() const
 278                                     {
 279                                         if ( !pPtr )
 280                                             pPtr.reset(new NativeNumberWrapper( m_xContext ));
 281                                         return pPtr.get();
 282                                     }
 283
 284 };
 285
 286 #endif // INCLUDED_SVL_ONDEMAND_HXX
 287
 288 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */