cpp, qt: Include config.h
[gpgme.git] / lang / cpp / src / importresult.cpp
1 /*
2   importresult.cpp - wraps a gpgme import result
3   Copyright (C) 2004 Klarälvdalens Datakonsult AB
4
5   This file is part of GPGME++.
6
7   GPGME++ is free software; you can redistribute it and/or
8   modify it under the terms of the GNU Library General Public
9   License as published by the Free Software Foundation; either
10   version 2 of the License, or (at your option) any later version.
11
12   GPGME++ is distributed in the hope that it will be useful,
13   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   GNU Library General Public License for more details.
16
17   You should have received a copy of the GNU Library General Public License
18   along with GPGME++; see the file COPYING.LIB.  If not, write to the
19   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20   Boston, MA 02110-1301, USA.
21 */
22
23
24 #ifdef HAVE_CONFIG_H
25  #include "config.h"
26 #endif
27
28 #include <importresult.h>
29 #include "result_p.h"
30
31 #include <gpgme.h>
32 #include <cstdlib>
33 #include <cstring>
34
35 #include <string.h>
36
37 class GpgME::ImportResult::Private
38 {
39 public:
40     Private(const _gpgme_op_import_result &r) : res(r)
41     {
42         // copy recursively, using compiler-generated copy ctor.
43         // We just need to handle the pointers in the structs:
44         for (gpgme_import_status_t is = r.imports ; is ; is = is->next) {
45             gpgme_import_status_t copy = new _gpgme_import_status(*is);
46             copy->fpr = strdup(is->fpr);
47             copy->next = 0;
48             imports.push_back(copy);
49         }
50         res.imports = 0;
51     }
52     ~Private()
53     {
54         for (std::vector<gpgme_import_status_t>::iterator it = imports.begin() ; it != imports.end() ; ++it) {
55             std::free((*it)->fpr);
56             delete *it; *it = 0;
57         }
58     }
59
60     _gpgme_op_import_result res;
61     std::vector<gpgme_import_status_t> imports;
62 };
63
64 GpgME::ImportResult::ImportResult(gpgme_ctx_t ctx, int error)
65     : GpgME::Result(error), d()
66 {
67     init(ctx);
68 }
69
70 GpgME::ImportResult::ImportResult(gpgme_ctx_t ctx, const Error &error)
71     : GpgME::Result(error), d()
72 {
73     init(ctx);
74 }
75
76 void GpgME::ImportResult::init(gpgme_ctx_t ctx)
77 {
78     if (!ctx) {
79         return;
80     }
81     gpgme_import_result_t res = gpgme_op_import_result(ctx);
82     if (!res) {
83         return;
84     }
85     d.reset(new Private(*res));
86 }
87
88 make_standard_stuff(ImportResult)
89
90 int GpgME::ImportResult::numConsidered() const
91 {
92     return d ? d->res.considered : 0 ;
93 }
94
95 int GpgME::ImportResult::numKeysWithoutUserID() const
96 {
97     return d ? d->res.no_user_id : 0 ;
98 }
99
100 int GpgME::ImportResult::numImported() const
101 {
102     return d ? d->res.imported : 0 ;
103 }
104
105 int GpgME::ImportResult::numRSAImported() const
106 {
107     return d ? d->res.imported_rsa : 0 ;
108 }
109
110 int GpgME::ImportResult::numUnchanged() const
111 {
112     return d ? d->res.unchanged : 0 ;
113 }
114
115 int GpgME::ImportResult::newUserIDs() const
116 {
117     return d ? d->res.new_user_ids : 0 ;
118 }
119
120 int GpgME::ImportResult::newSubkeys() const
121 {
122     return d ? d->res.new_sub_keys : 0 ;
123 }
124
125 int GpgME::ImportResult::newSignatures() const
126 {
127     return d ? d->res.new_signatures : 0 ;
128 }
129
130 int GpgME::ImportResult::newRevocations() const
131 {
132     return d ? d->res.new_revocations : 0 ;
133 }
134
135 int GpgME::ImportResult::numSecretKeysConsidered() const
136 {
137     return d ? d->res.secret_read : 0 ;
138 }
139
140 int GpgME::ImportResult::numSecretKeysImported() const
141 {
142     return d ? d->res.secret_imported : 0 ;
143 }
144
145 int GpgME::ImportResult::numSecretKeysUnchanged() const
146 {
147     return d ? d->res.secret_unchanged : 0 ;
148 }
149
150 int GpgME::ImportResult::notImported() const
151 {
152     return d ? d->res.not_imported : 0 ;
153 }
154
155 GpgME::Import GpgME::ImportResult::import(unsigned int idx) const
156 {
157     return Import(d, idx);
158 }
159
160 std::vector<GpgME::Import> GpgME::ImportResult::imports() const
161 {
162     if (!d) {
163         return std::vector<Import>();
164     }
165     std::vector<Import> result;
166     result.reserve(d->imports.size());
167     for (unsigned int i = 0 ; i < d->imports.size() ; ++i) {
168         result.push_back(Import(d, i));
169     }
170     return result;
171 }
172
173 GpgME::Import::Import(const std::shared_ptr<ImportResult::Private> &parent, unsigned int i)
174     : d(parent), idx(i)
175 {
176
177 }
178
179 GpgME::Import::Import() : d(), idx(0) {}
180
181 bool GpgME::Import::isNull() const
182 {
183     return !d || idx >= d->imports.size() ;
184 }
185
186 const char *GpgME::Import::fingerprint() const
187 {
188     return isNull() ? 0 : d->imports[idx]->fpr ;
189 }
190
191 GpgME::Error GpgME::Import::error() const
192 {
193     return Error(isNull() ? 0 : d->imports[idx]->result);
194 }
195
196 GpgME::Import::Status GpgME::Import::status() const
197 {
198     if (isNull()) {
199         return Unknown;
200     }
201     const unsigned int s = d->imports[idx]->status;
202     unsigned int result = Unknown;
203     if (s & GPGME_IMPORT_NEW) {
204         result |= NewKey;
205     }
206     if (s & GPGME_IMPORT_UID) {
207         result |= NewUserIDs;
208     }
209     if (s & GPGME_IMPORT_SIG) {
210         result |= NewSignatures;
211     }
212     if (s & GPGME_IMPORT_SUBKEY) {
213         result |= NewSubkeys;
214     }
215     if (s & GPGME_IMPORT_SECRET) {
216         result |= ContainedSecretKey;
217     }
218     return static_cast<Status>(result);
219 }