filter/source/config/cache/basecontainer.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "basecontainer.hxx"
  22
  23 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  24 #include <com/sun/star/uno/Type.h>
  25 #include <comphelper/enumhelper.hxx>
  26 #include <comphelper/sequence.hxx>
  27 #include <cppuhelper/supportsservice.hxx>
  28 #include <osl/diagnose.h>
  29
  30 namespace filter::config{
  31
  32 BaseContainer::BaseContainer()
  33     : m_eType()
  34 {
  35     GetTheFilterCache().load(FilterCache::E_CONTAINS_STANDARD);
  36 }
  37
  38
  39 BaseContainer::~BaseContainer()
  40 {
  41 }
  42
  43
  44 void BaseContainer::init(const OUString&                                        sImplementationName,
  45                          const css::uno::Sequence< OUString >&                  lServiceNames      ,
  46                                FilterCache::EItemType                                  eType              )
  47 {
  48     m_sImplementationName = sImplementationName;
  49     m_lServiceNames       = lServiceNames      ;
  50     m_eType               = eType              ;
  51 }
  52
  53
  54 void BaseContainer::impl_loadOnDemand(std::unique_lock<std::mutex>& /*rGuard*/)
  55 {
  56     // A generic container needs all items of a set of our cache!
  57     // Of course it can block for a while, till the cache is really filled.
  58     // Note: don't load all sets supported by the cache here!
  59
  60     FilterCache::EFillState eRequiredState = FilterCache::E_CONTAINS_NOTHING;
  61     switch(m_eType)
  62     {
  63         case FilterCache::E_TYPE :
  64             eRequiredState = FilterCache::E_CONTAINS_TYPES;
  65             break;
  66
  67         case FilterCache::E_FILTER :
  68             eRequiredState = FilterCache::E_CONTAINS_FILTERS;
  69             break;
  70
  71         case FilterCache::E_FRAMELOADER :
  72             eRequiredState = FilterCache::E_CONTAINS_FRAMELOADERS;
  73             break;
  74
  75         case FilterCache::E_CONTENTHANDLER :
  76             eRequiredState = FilterCache::E_CONTAINS_CONTENTHANDLERS;
  77             break;
  78     }
  79
  80     GetTheFilterCache().load(eRequiredState);
  81 }
  82
  83
  84 void BaseContainer::impl_initFlushMode(std::unique_lock<std::mutex>& /*rGuard*/)
  85 {
  86     if (!m_pFlushCache)
  87         m_pFlushCache = GetTheFilterCache().clone();
  88     if (!m_pFlushCache)
  89         throw css::uno::RuntimeException( u"Can not create write copy of internal used cache on demand."_ustr,
  90                 getXWeak());
  91 }
  92
  93
  94 FilterCache* BaseContainer::impl_getWorkingCache(std::unique_lock<std::mutex>& /*rGuard*/) const
  95 {
  96     if (m_pFlushCache)
  97         return m_pFlushCache.get();
  98     else
  99         return &GetTheFilterCache();
 100 }
 101
 102
 103 OUString SAL_CALL BaseContainer::getImplementationName()
 104 {
 105     return m_sImplementationName;
 106 }
 107
 108
 109 sal_Bool SAL_CALL BaseContainer::supportsService(const OUString& sServiceName)
 110 {
 111     return cppu::supportsService(this, sServiceName);
 112 }
 113
 114 css::uno::Sequence< OUString > SAL_CALL BaseContainer::getSupportedServiceNames()
 115 {
 116     return m_lServiceNames;
 117 }
 118
 119
 120 void SAL_CALL BaseContainer::insertByName(const OUString& sItem ,
 121                                           const css::uno::Any&   aValue)
 122 {
 123     if (sItem.isEmpty())
 124         throw css::lang::IllegalArgumentException(u"empty value not allowed as item name."_ustr,
 125             static_cast< css::container::XNameContainer* >(this),
 126             1);
 127
 128     CacheItem aItem;
 129     try
 130     {
 131         aItem << aValue;
 132     }
 133     catch(const css::uno::Exception& ex)
 134     {
 135         throw css::lang::IllegalArgumentException(ex.Message, static_cast< css::container::XNameContainer* >(this), 2);
 136     }
 137
 138     // SAFE -> ----------------------------------
 139     std::unique_lock aLock(m_aMutex);
 140
 141     impl_loadOnDemand(aLock);
 142
 143     // create write copy of used cache on demand ...
 144     impl_initFlushMode(aLock);
 145
 146     FilterCache* pCache = impl_getWorkingCache(aLock);
 147     if (pCache->hasItem(m_eType, sItem))
 148         throw css::container::ElementExistException(OUString(), static_cast< css::container::XNameContainer* >(this));
 149     pCache->setItem(m_eType, sItem, aItem);
 150     // <- SAFE ----------------------------------
 151 }
 152
 153
 154 void SAL_CALL BaseContainer::removeByName(const OUString& sItem)
 155 {
 156     // SAFE -> ----------------------------------
 157     std::unique_lock aLock(m_aMutex);
 158
 159     impl_loadOnDemand(aLock);
 160
 161     // create write copy of used cache on demand ...
 162     impl_initFlushMode(aLock);
 163
 164     FilterCache* pCache = impl_getWorkingCache(aLock);
 165     pCache->removeItem(m_eType, sItem); // throw exceptions automatically
 166     // <- SAFE ----------------------------------
 167 }
 168
 169
 170 void SAL_CALL BaseContainer::replaceByName(const OUString& sItem ,
 171                                            const css::uno::Any&   aValue)
 172 {
 173     if (sItem.isEmpty())
 174         throw css::lang::IllegalArgumentException(u"empty value not allowed as item name."_ustr,
 175             static_cast< css::container::XNameContainer* >(this),
 176             1);
 177
 178     CacheItem aItem;
 179     try
 180     {
 181         aItem << aValue;
 182     }
 183     catch(const css::uno::Exception& ex)
 184     {
 185         throw css::lang::IllegalArgumentException(ex.Message, static_cast< css::container::XNameContainer* >(this), 2);
 186     }
 187
 188     // SAFE -> ----------------------------------
 189     std::unique_lock aLock(m_aMutex);
 190
 191     impl_loadOnDemand(aLock);
 192
 193     // create write copy of used cache on demand ...
 194     impl_initFlushMode(aLock);
 195
 196     FilterCache* pCache = impl_getWorkingCache(aLock);
 197     if (!pCache->hasItem(m_eType, sItem))
 198         throw css::container::NoSuchElementException(OUString(), static_cast< css::container::XNameContainer* >(this));
 199     pCache->setItem(m_eType, sItem, aItem);
 200     // <- SAFE ----------------------------------
 201 }
 202
 203
 204 css::uno::Any SAL_CALL BaseContainer::getByName(const OUString& sItem)
 205 {
 206     if (sItem.isEmpty())
 207         throw css::container::NoSuchElementException( u"An empty item can't be part of this cache!"_ustr,
 208                 static_cast< css::container::XNameAccess* >(this));
 209
 210     css::uno::Any aValue;
 211
 212     // SAFE ->
 213     std::unique_lock aLock(m_aMutex);
 214
 215     impl_loadOnDemand(aLock);
 216
 217     try
 218     {
 219         FilterCache* pCache = impl_getWorkingCache(aLock);
 220         aValue = pCache->getItemWithStateProps(m_eType, sItem);
 221     }
 222     catch(const css::container::NoSuchElementException&)
 223     {
 224         throw;
 225     }
 226     catch(const css::uno::Exception&)
 227     {
 228         // TODO invalid cache!? How should it be handled right?
 229     }
 230
 231     // <- SAFE
 232
 233     return aValue;
 234 }
 235
 236
 237 css::uno::Sequence< OUString > SAL_CALL BaseContainer::getElementNames()
 238 {
 239     css::uno::Sequence< OUString > lNames;
 240
 241     // SAFE ->
 242     std::unique_lock aLock(m_aMutex);
 243
 244     impl_loadOnDemand(aLock);
 245
 246     try
 247     {
 248         FilterCache* pCache = impl_getWorkingCache(aLock);
 249         std::vector<OUString> lKeys  = pCache->getItemNames(m_eType);
 250         lNames = comphelper::containerToSequence(lKeys);
 251     }
 252     catch(const css::uno::Exception&)
 253     {
 254         // invalid cache!?
 255         lNames.realloc(0);
 256     }
 257
 258     // <- SAFE
 259
 260     return lNames;
 261 }
 262
 263
 264 sal_Bool SAL_CALL BaseContainer::hasByName(const OUString& sItem)
 265 {
 266     bool bHasOne = false;
 267
 268     // SAFE ->
 269     std::unique_lock aLock(m_aMutex);
 270
 271     impl_loadOnDemand(aLock);
 272
 273     try
 274     {
 275         FilterCache* pCache = impl_getWorkingCache(aLock);
 276         bHasOne = pCache->hasItem(m_eType, sItem);
 277     }
 278     catch(const css::uno::Exception&)
 279     {
 280         // invalid cache!?
 281         bHasOne = false;
 282     }
 283
 284     // <- SAFE
 285
 286     return bHasOne;
 287 }
 288
 289
 290 css::uno::Type SAL_CALL BaseContainer::getElementType()
 291 {
 292     // no lock necessary - because the type of our items
 293     // is fix! no internal call or member needed ...
 294     return cppu::UnoType<css::uno::Sequence< css::beans::PropertyValue >>::get();
 295 }
 296
 297
 298 sal_Bool SAL_CALL BaseContainer::hasElements()
 299 {
 300     bool bHasSome = false;
 301
 302     // SAFE ->
 303     std::unique_lock aLock(m_aMutex);
 304
 305     impl_loadOnDemand(aLock);
 306
 307     try
 308     {
 309         FilterCache* pCache = impl_getWorkingCache(aLock);
 310         bHasSome = pCache->hasItems(m_eType);
 311     }
 312     catch(const css::uno::Exception&)
 313     {
 314         // invalid cache?!
 315         bHasSome = false;
 316     }
 317
 318     // <- SAFE
 319
 320     return bHasSome;
 321 }
 322
 323
 324 css::uno::Reference< css::container::XEnumeration > SAL_CALL BaseContainer::createSubSetEnumerationByQuery(const OUString& /* sQuery */ )
 325 {
 326     OSL_FAIL("not pure virtual ... but not really implemented .-)");
 327
 328     return new ::comphelper::OEnumerationByName(this, {});
 329 }
 330
 331
 332 css::uno::Reference< css::container::XEnumeration > SAL_CALL BaseContainer::createSubSetEnumerationByProperties(const css::uno::Sequence< css::beans::NamedValue >& lProperties)
 333 {
 334     std::vector<OUString>                               lKeys;
 335
 336     // SAFE ->
 337     std::unique_lock aLock(m_aMutex);
 338
 339     impl_loadOnDemand(aLock);
 340
 341     try
 342     {
 343         // search the key names of all items, where its properties match
 344         // the given ones in its minimum
 345         FilterCache* pCache = impl_getWorkingCache(aLock);
 346         lKeys = pCache->getMatchingItemsByProps(m_eType, std::span<const css::beans::NamedValue>( lProperties.getConstArray(), lProperties.getLength() ));
 347     }
 348     catch(const css::uno::Exception&)
 349     {
 350         // invalid cache, internal failure, wrong conversion ...!?
 351         // doesn't matter
 352         lKeys.clear();
 353     }
 354
 355     // <- SAFE
 356
 357     // create a specialized enumeration helper, which
 358     // provides the collected information outside.
 359     // It hold a reference to us ... and call our container interface directly.
 360     // be aware of some direct callbacks if it will be created :-)
 361
 362     /* Note: It's not allowed to return NULL. Because an empty enumeration
 363              transport the same information but make no trouble outside.
 364              Further its easier to work directly with the return value
 365              instead of checking of NULL returns! */
 366
 367     return new ::comphelper::OEnumerationByName(this, std::move(lKeys));
 368 }
 369
 370
 371 void SAL_CALL BaseContainer::flush()
 372 {
 373     // SAFE ->
 374     std::unique_lock aLock(m_aMutex);
 375
 376     if (!m_pFlushCache)
 377         throw css::lang::WrappedTargetRuntimeException(
 378                 u"Can not guarantee cache consistency. Special flush container does not exists!"_ustr,
 379                 getXWeak(),
 380                 css::uno::Any());
 381
 382     try
 383     {
 384         m_pFlushCache->flush();
 385         // Take over all changes into the global cache and
 386         // forget the clone.
 387         /* TODO
 388             -think about me
 389                 If the global cache gets this information via listener,
 390                 we should remove this method!
 391         */
 392         GetTheFilterCache().takeOver(*m_pFlushCache);
 393     }
 394     catch(const css::uno::Exception& ex)
 395     {
 396         // Don't remove the clone. May be the outside
 397         // user wish to repair it now and calls flush()
 398         // later again ...
 399
 400         throw css::lang::WrappedTargetRuntimeException( u"Flush rejected by internal container."_ustr,
 401                 getXWeak(),
 402                 css::uno::Any(ex));
 403     }
 404
 405     m_pFlushCache.reset();
 406
 407     css::lang::EventObject             aSource    (static_cast< css::util::XFlushable* >(this));
 408     m_lListener.notifyEach( aLock, &css::util::XFlushListener::flushed, aSource);
 409
 410     // <- SAFE
 411 }
 412
 413
 414 void SAL_CALL BaseContainer::addFlushListener(const css::uno::Reference< css::util::XFlushListener >& xListener)
 415 {
 416     std::unique_lock g(m_aMutex);
 417     m_lListener.addInterface(g, xListener);
 418 }
 419
 420
 421 void SAL_CALL BaseContainer::removeFlushListener(const css::uno::Reference< css::util::XFlushListener >& xListener)
 422 {
 423     std::unique_lock g(m_aMutex);
 424     m_lListener.removeInterface(g, xListener);
 425 }
 426
 427 } // namespace filter::config
 428
 429 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */