diff options
Diffstat (limited to '')
| -rw-r--r-- | framework/inc/classes/protocolhandlercache.hxx | 146 |
1 files changed, 146 insertions, 0 deletions
diff --git a/framework/inc/classes/protocolhandlercache.hxx b/framework/inc/classes/protocolhandlercache.hxx new file mode 100644 index 000000000..e156f9b0d --- /dev/null +++ b/framework/inc/classes/protocolhandlercache.hxx @@ -0,0 +1,146 @@ +/* -*- 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 <unordered_map> +#include <optional> + +#include <com/sun/star/util/URL.hpp> + +#include <unotools/configitem.hxx> +#include <rtl/ustring.hxx> + +namespace framework{ + +inline constexpr OUStringLiteral PACKAGENAME_PROTOCOLHANDLER = u"Office.ProtocolHandler"; /// name of our configuration package + +#define CFG_PATH_SEPARATOR "/" /// separator for configuration paths + +#define PROPERTY_PROTOCOLS "Protocols" /// properties of a protocol handler + +/** + Programmer can register his own services to handle different protocols. + Don't forget: It doesn't mean "handling of documents" ... these services could handle protocols ... + e.g. "mailto:", "file://", ".java:" + This struct holds the information about one such registered protocol handler. + A list of handler objects is defined as ProtocolHandlerHash. see below +*/ +struct ProtocolHandler +{ + /* member */ + public: + + /// the uno implementation name of this handler + OUString m_sUNOName; + /// list of URL pattern which defines the protocols which this handler is registered for + std::vector<OUString> m_lProtocols; +}; + +/** + This hash use registered pattern of all protocol handlers as keys and provide her + uno implementation names as value. Overloading of the index operator makes it possible + to search for a key by using a full qualified URL on list of all possible pattern keys. +*/ +typedef std::unordered_map<OUString, OUString> PatternHash; + +/** + This hash holds protocol handler structs by her names. +*/ +typedef std::unordered_map<OUString, ProtocolHandler> HandlerHash; + +/** + @short this hash makes it easy to find a protocol handler by using his uno implementation name. + @descr It holds two lists of information: + - first holds all handler by her uno implementation names and + can be used to get her other properties + - another one maps her registered pattern to her uno names to + perform search on such data + But this lists a static for all instances of this class. So it's possible to + create new objects without opening configuration twice and free memory automatically + if last object will gone. + + @attention We implement a singleton concept - so we don't need any mutex member here. + Because to safe access on static member we must use a static global lock + here too. + + @devstatus ready to use + @threadsafe yes +*/ + +class HandlerCFGAccess; +class HandlerCache final +{ + /* member */ + private: + + /// list of all registered handler registered by her uno implementation names + static std::optional<HandlerHash> s_pHandler; + /// maps URL pattern to handler names + static std::optional<PatternHash> s_pPattern; + /// informs about config updates + static HandlerCFGAccess* s_pConfig; + /// ref count to construct/destruct internal member lists on demand by using singleton mechanism + static sal_Int32 m_nRefCount; + + /* interface */ + public: + + HandlerCache(); + ~HandlerCache(); + + bool search( const OUString& sURL, ProtocolHandler* pReturn ) const; + bool search( const css::util::URL& aURL, ProtocolHandler* pReturn ) const; + + void takeOver(HandlerHash aHandler, PatternHash aPattern); +}; + +/** + @short implements configuration access for handler configuration + @descr We use the ConfigItem mechanism to read/write values from/to configuration. + We set a data container pointer for filling or reading ... this class use it temp. + After successfully calling of read(), we can use filled container directly or merge it with an existing one. + After successfully calling of write() all values of given data container are flushed to our configuration - + but current implementation doesn't support writing really. + + @base ::utl::ConfigItem + base mechanism for configuration access + + @devstatus ready to use + @threadsafe no +*/ +class HandlerCFGAccess final : public ::utl::ConfigItem +{ + private: + HandlerCache* m_pCache; + + virtual void ImplCommit() override; + + /* interface */ + public: + HandlerCFGAccess( const OUString& sPackage ); + void read ( HandlerHash& rHandlerHash, PatternHash& rPatternHash ); + + void setCache(HandlerCache* pCache) {m_pCache = pCache;}; + virtual void Notify(const css::uno::Sequence< OUString >& lPropertyNames) override; +}; + +} // namespace framework + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |