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
|
/**
* Copyright (C) 2021 Saturneric <[email protected]>
*
* This file is part of GpgFrontend.
*
* GpgFrontend is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GpgFrontend is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GpgFrontend. If not, see <https://www.gnu.org/licenses/>.
*
* The initial version of the source code is inherited from
* the gpg4usb project, which is under GPL-3.0-or-later.
*
* All the source code of GpgFrontend was modified and released by
* Saturneric <[email protected]> starting on May 12, 2021.
*
* SPDX-License-Identifier: GPL-3.0-or-later
*
*/
#include "SingletonStorage.h"
#include <shared_mutex>
#include "core/function/basic/ChannelObject.h"
namespace GpgFrontend {
class SingletonStorage::Impl {
public:
void ReleaseChannel(int channel) {
decltype(instances_map_.end()) ins_it;
{
std::shared_lock<std::shared_mutex> lock(instances_mutex_);
ins_it = instances_map_.find(channel);
}
if (ins_it != instances_map_.end()) instances_map_.erase(ins_it);
}
auto FindObjectInChannel(int channel) -> GpgFrontend::ChannelObject* {
// read instances_map_
decltype(instances_map_.end()) ins_it;
{
std::shared_lock<std::shared_mutex> lock(instances_mutex_);
ins_it = instances_map_.find(channel);
if (ins_it == instances_map_.end()) {
SPDLOG_TRACE("cannot find channel object, channel: {}", channel);
return nullptr;
}
return ins_it->second.get();
}
}
auto GetAllChannelId() -> std::vector<int> {
std::vector<int> channels;
channels.reserve(instances_map_.size());
for (const auto& [key, value] : instances_map_) {
channels.push_back(key);
}
return channels;
}
auto SetObjectInChannel(int channel, ChannelObjectPtr p_obj)
-> GpgFrontend::ChannelObject* {
SPDLOG_TRACE("set channel object, type: {} in channel: {}, address: {}",
typeid(p_obj.get()).name(), channel,
static_cast<void*>(p_obj.get()));
assert(p_obj != nullptr);
if (p_obj == nullptr) {
SPDLOG_ERROR("cannot set a nullptr as a channel obejct of channel: {}",
channel);
return nullptr;
}
p_obj->SetChannel(channel);
auto* raw_obj = p_obj.get();
{
SPDLOG_TRACE(
"register channel object to instances map, "
"channel: {}, address: {}",
channel, static_cast<void*>(p_obj.get()));
std::unique_lock<std::shared_mutex> lock(instances_mutex_);
instances_map_[channel] = std::move(p_obj);
}
SPDLOG_TRACE("set channel: {} success, current channel object address: {}",
channel, static_cast<void*>(raw_obj));
return raw_obj;
}
private:
std::shared_mutex instances_mutex_; ///< mutex for _instances_map
std::map<int, ChannelObjectPtr>
instances_map_; ///< map of singleton instances
};
SingletonStorage::SingletonStorage() noexcept : p_(std::make_unique<Impl>()) {}
SingletonStorage::~SingletonStorage() = default;
void SingletonStorage::ReleaseChannel(int channel) {
p_->ReleaseChannel(channel);
}
auto SingletonStorage::FindObjectInChannel(int channel)
-> GpgFrontend::ChannelObject* {
return p_->FindObjectInChannel(channel);
}
auto SingletonStorage::GetAllChannelId() -> std::vector<int> {
return p_->GetAllChannelId();
}
auto SingletonStorage::SetObjectInChannel(int channel, ChannelObjectPtr p_obj)
-> GpgFrontend::ChannelObject* {
return p_->SetObjectInChannel(channel, std::move(p_obj));
}
}; // namespace GpgFrontend
|
