filtercache.hxx

Go to the documentation of this file.

/* -*- 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 <memory>
#include <mutex>
 
#include "cacheitem.hxx"
#include <com/sun/star/beans/NamedValue.hpp>
#include <com/sun/star/util/URL.hpp>
#include <com/sun/star/uno/XInterface.hpp>
#include <com/sun/star/container/XNameAccess.hpp>
#include <com/sun/star/container/XNameReplace.hpp>
#include <com/sun/star/uno/Reference.h>
#include <com/sun/star/uno/Any.h>
#include <comphelper/documentconstants.hxx>
#include <cppuhelper/basemutex.hxx>
#include <rtl/ref.hxx>
#include <rtl/ustring.hxx>
 
 
namespace filter::config {
 
class CacheUpdateListener;
 
 
class FilterCache
{
 
    // public types
 
    public:
 
 
        enum EItemType
        {
            E_TYPE          ,
            E_FILTER        ,
            E_FRAMELOADER   ,
            E_CONTENTHANDLER
        };
 
 
        enum EFillState
        {
            E_CONTAINS_NOTHING          = 0,
            E_CONTAINS_STANDARD         = 1,
            E_CONTAINS_TYPES            = 2,
            E_CONTAINS_FILTERS          = 4,
            E_CONTAINS_FRAMELOADERS     = 8,
            E_CONTAINS_CONTENTHANDLERS  = 16
        };
 
 
    // private types
 
    private:
 
 
        enum EReadOption
        {
            E_READ_STANDARD = 1,
            E_READ_UPDATE   = 2,
            E_READ_ALL      = 3
        };
 
 
        enum EItemFlushState
        {
            E_ITEM_UNCHANGED = 0,
            E_ITEM_REMOVED = 1,
            E_ITEM_CHANGED = 2,
            E_ITEM_ADDED = 3
        };
 
 
        enum EConfigProvider
        {
            E_PROVIDER_TYPES = 0,
            E_PROVIDER_FILTERS = 1,
            E_PROVIDER_OTHERS = 2,
            E_PROVIDER_OLD = 3
        };
 
 
    // member
 
    private:
 
        mutable std::mutex m_aMutex;
 
        mutable css::uno::Reference< css::uno::XInterface > m_xConfigTypes;
 
 
        mutable css::uno::Reference< css::uno::XInterface > m_xConfigFilters;
 
 
        mutable css::uno::Reference< css::uno::XInterface > m_xConfigOthers;
 
 
        mutable CacheItemList m_lTypes;
 
 
        mutable CacheItemList m_lFilters;
 
 
        mutable CacheItemList m_lFrameLoaders;
 
 
        mutable CacheItemList m_lContentHandlers;
 
 
        mutable CacheItemRegistration m_lExtensions2Types;
 
 
        mutable CacheItemRegistration m_lURLPattern2Types;
 
 
        OUString m_sActLocale;
 
 
        EFillState m_eFillState;
 
 
        std::vector<OUString> m_lChangedTypes;
        std::vector<OUString> m_lChangedFilters;
        std::vector<OUString> m_lChangedFrameLoaders;
        std::vector<OUString> m_lChangedContentHandlers;
 
        css::uno::Sequence< OUString > m_aStandardProps[4];
 
        css::uno::Sequence< OUString > m_aTypeProps[4];
 
        css::uno::Reference< css::container::XNameAccess > m_xModuleCfg;
 
        rtl::Reference< CacheUpdateListener > m_xTypesChglisteners;
        rtl::Reference< CacheUpdateListener > m_xFiltersChgListener;
 
 
    // interface
 
    public:
 
 
        // ctor/dtor
 
        FilterCache();
 
 
        ~FilterCache();
 
 
        std::unique_ptr<FilterCache> clone() const;
 
 
        void takeOver(const FilterCache& rClone);
 
 
        void load(EFillState eRequired);
 
 
        bool isFillState(EFillState eRequired) const;
 
 
        std::vector<OUString> getMatchingItemsByProps( EItemType  eType,
                                                     o3tl::span< const css::beans::NamedValue > lIProps,
                                                     o3tl::span< const css::beans::NamedValue > lEProps = {}) const;
 
 
        bool hasItems(EItemType eType) const;
 
 
        std::vector<OUString> getItemNames(EItemType eType) const;
 
 
        bool hasItem(      EItemType        eType,
                                 const OUString& sItem);
 
 
        CacheItem getItem(      EItemType        eType,
                                  const OUString& sItem);
 
 
        void removeItem(      EItemType        eType,
                                const OUString& sItem);
 
 
        void setItem(      EItemType        eType ,
                             const OUString& sItem ,
                             const CacheItem&       aValue);
 
 
        void refreshItem(      EItemType        eType,
                                 const OUString& sItem);
 
 
        css::uno::Any getItemWithStateProps( EItemType        eType,
                                             const OUString& sItem);
 
        static void removeStatePropsFromItem(CacheItem& aValue);
 
 
        void flush();
 
 
        void detectFlatForURL(const css::util::URL& aURL      ,
                                            FlatDetection&  rFlatTypes) const;
 
 
    // private helper
 
    private:
 
        std::vector<OUString> getItemNames(std::unique_lock<std::mutex>& rGuard, EItemType eType) const;
 
        const CacheItemList& impl_getItemList(std::unique_lock<std::mutex>& rGuard, EItemType eType) const;
 
        CacheItemList& impl_getItemList(std::unique_lock<std::mutex>& rGuard, EItemType eType);
 
        CacheItem& impl_getItem( std::unique_lock<std::mutex>& rGuard, EItemType eType, const OUString& sItem);
 
        css::uno::Reference< css::uno::XInterface > impl_openConfig(std::unique_lock<std::mutex>& rGuard, EConfigProvider eProvide);
 
 
        static css::uno::Reference< css::uno::XInterface > impl_createConfigAccess(std::unique_lock<std::mutex>& rGuard,
                                                                                  const OUString& sRoot       ,
                                                                                  bool         bReadOnly   ,
                                                                                  bool         bLocalesMode);
 
 
        static css::uno::Any impl_getDirectCFGValue(std::unique_lock<std::mutex>& rGuard, std::u16string_view sDirectKey);
 
 
        void impl_load(std::unique_lock<std::mutex>& rGuard, EFillState eRequiredState);
 
 
        void impl_validateAndOptimize(std::unique_lock<std::mutex>& rGuard);
 
    private:
 
 
        void impl_loadSet(std::unique_lock<std::mutex>& rGuard,
                          const css::uno::Reference< css::container::XNameAccess >& xConfig,
                                EItemType                                           eType  ,
                                EReadOption                                         eOption,
                                CacheItemList*                                      pCache );
 
 
        CacheItem impl_loadItem(std::unique_lock<std::mutex>& rGuard,
                                const css::uno::Reference< css::container::XNameAccess >& xSet   ,
                                      EItemType                                           eType  ,
                                const OUString&                                    sItem  ,
                                      EReadOption                                         eOption);
 
 
        CacheItemList::iterator impl_loadItemOnDemand( std::unique_lock<std::mutex>& rGuard,
                                                      EItemType        eType,
                                                      const OUString& sItem);
 
 
        static void impl_saveItem(const css::uno::Reference< css::container::XNameReplace >& xSet  ,
                                 EItemType                                            eType ,
                           const CacheItem & aValue);
 
 
        void impl_addItem2FlushList(      EItemType        eType,
                                    const OUString& sItem);
 
 
        static void impl_flushByList(const css::uno::Reference< css::container::XNameAccess >& xSet  ,
                                    EItemType                                           eType ,
                              const CacheItemList&                                      rCache,
                              const std::vector<OUString>&                              lItems);
 
 
        static EItemFlushState impl_specifyFlushOperation(const css::uno::Reference< css::container::XNameAccess >& xSet ,
                                                   const CacheItemList&                                      rList,
                                                   const OUString&                                    sItem);
 
 
        void impl_readPatchUINames(std::unique_lock<std::mutex>& rGuard,
                                   const css::uno::Reference< css::container::XNameAccess >& xNode,
                                         CacheItem&                                          rItem);
 
 
        static void impl_savePatchUINames(const css::uno::Reference< css::container::XNameReplace >& xNode,
                                   const CacheItem&                                           rItem);
 
        void impl_readOldFormat(std::unique_lock<std::mutex>& rGuard);
 
        CacheItem impl_readOldItem(std::unique_lock<std::mutex>& rGuard,
                                   const css::uno::Reference< css::container::XNameAccess >& xSet ,
                                         EItemType                                           eType,
                                   const OUString&                                    sItem);
 
 
        static void impl_interpretDataVal4Type(const OUString& sValue,
                                              sal_Int32        nProp ,
                                              CacheItem&       rItem );
 
 
        static void impl_interpretDataVal4Filter(const OUString& sValue,
                                                sal_Int32        nProp ,
                                                CacheItem&       rItem );
 
 
        static std::vector<OUString> impl_tokenizeString(std::u16string_view sData     ,
                                               sal_Unicode      cSeparator);
 
 
#if OSL_DEBUG_LEVEL > 0
        OUString impl_searchFrameLoaderForType(const OUString& sType) const;
        OUString impl_searchContentHandlerForType(const OUString& sType) const;
#endif
 
 
        bool impl_isModuleInstalled(std::unique_lock<std::mutex>& rGuard, const OUString& sModule);
 
 
        static SfxFilterFlags impl_convertFlagNames2FlagField(const css::uno::Sequence< OUString >& lNames);
 
 
        static css::uno::Sequence< OUString > impl_convertFlagField2FlagNames(SfxFilterFlags nFlags);
};
 
FilterCache& GetTheFilterCache();
 
} // namespace filter::config
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */