1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
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: */
|
