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
147
148
149
150
151
152
153
154
155
156
|
/************************************************************************
*
* Copyright (C) 2021-2024 IRCAD France
*
* This file is part of Sight.
*
* Sight is free software: you can redistribute it and/or modify it under
* the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Sight 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with Sight. If not, see <https://www.gnu.org/licenses/>.
*
***********************************************************************/
#include "session_reader.hpp"
#include "io/session/detail/core/session_deserializer.hpp"
#include <core/crypto/password_keeper.hpp>
namespace sight::io::session
{
using core::crypto::password_keeper;
using core::crypto::secure_string;
using sight::io::zip::archive;
class session_reader::session_reader_impl
{
public:
/// Delete default constructors and assignment operators
session_reader_impl() = delete;
session_reader_impl(const session_reader_impl&) = delete;
session_reader_impl(session_reader_impl&&) = delete;
session_reader_impl& operator=(const session_reader_impl&) = delete;
session_reader_impl& operator=(session_reader_impl&&) = delete;
/// Constructor
inline explicit session_reader_impl(session_reader* const _session_reader) :
m_session_reader(_session_reader),
m_password(std::make_unique<password_keeper>()),
m_encryption_policy(password_keeper::encryption_policy::password),
m_archive_format(archive::archive_format::DEFAULT)
{
}
/// Default destructor
inline ~session_reader_impl() = default;
/// Read the session from archive.
inline void read()
{
// Deserialize the root object
m_object = m_session_deserializer.deserialize(
m_session_reader->get_file(),
m_archive_format,
m_password->get_password(),
m_encryption_policy
);
}
/// Session deserializer which perform the deserialization
detail::session_deserializer m_session_deserializer;
/// Use a shared_ptr to keep the object alive as it is the read() return value
core::object::sptr m_object;
/// Pointer to the public interface
session_reader* const m_session_reader;
/// Keep the password in a vault
const std::unique_ptr<password_keeper> m_password;
/// The encryption policy
password_keeper::encryption_policy m_encryption_policy;
/// Archive format to use
archive::archive_format m_archive_format;
};
session_reader::session_reader() :
m_pimpl(std::make_unique<session_reader_impl>(this))
{
}
// Defining the destructor here, allows us to use PImpl with a unique_ptr
session_reader::~session_reader() = default;
//------------------------------------------------------------------------------
void session_reader::read()
{
m_pimpl->read();
// Save the object so the caller can get it with get_object();
set_object(m_pimpl->m_object);
}
//------------------------------------------------------------------------------
std::string session_reader::extension() const
{
return ".zip";
}
//------------------------------------------------------------------------------
void session_reader::set_password(const secure_string& _password)
{
m_pimpl->m_password->set_password(_password);
}
//------------------------------------------------------------------------------
void session_reader::set_encryption_policy(const password_keeper::encryption_policy _policy)
{
m_pimpl->m_encryption_policy = _policy;
}
//------------------------------------------------------------------------------
void session_reader::set_archive_format(const archive::archive_format _archive_format)
{
m_pimpl->m_archive_format = _archive_format;
}
//------------------------------------------------------------------------------
void session_reader::set_custom_deserializer(const std::string& _class_name, deserializer_t _deserializer)
{
m_pimpl->m_session_deserializer.set_custom_deserializer(_class_name, _deserializer);
}
//------------------------------------------------------------------------------
void session_reader::set_deserializer(const std::string& _class_name, deserializer_t _deserializer)
{
detail::session_deserializer::set_deserializer(_class_name, _deserializer);
}
//------------------------------------------------------------------------------
deserializer_t session_reader::deserializer(const std::string& _class_name)
{
return detail::session_deserializer::deserializer(_class_name);
}
} // namespace sight::io::session
|
