Qt: Add static factor methods for protocol
[gpgme.git] / lang / qt / src / predicates.h
1 /* -*- mode: c++; c-basic-offset:4 -*-
2     models/predicates.h
3
4     This file is part of Kleopatra, the KDE keymanager
5     Copyright (c) 2007 Klarälvdalens Datakonsult AB
6     Copyright (c) 2016 Intevation GmbH
7
8     Kleopatra is free software; you can redistribute it and/or modify
9     it under the terms of the GNU General Public License as published by
10     the Free Software Foundation; either version 2 of the License, or
11     (at your option) any later version.
12
13     Kleopatra is distributed in the hope that it will be useful,
14     but WITHOUT ANY WARRANTY; without even the implied warranty of
15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16     General Public License for more details.
17
18     You should have received a copy of the GNU General Public License
19     along with this program; if not, write to the Free Software
20     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
21
22     In addition, as a special exception, the copyright holders give
23     permission to link the code of this program with any edition of
24     the Qt library by Trolltech AS, Norway (or with modified versions
25     of Qt that use the same license as Qt), and distribute linked
26     combinations including the two.  You must obey the GNU General
27     Public License in all respects for all of the code used other than
28     Qt.  If you modify this file, you may extend this exception to
29     your version of the file, but you are not obligated to do so.  If
30     you do not wish to do so, delete this exception statement from
31     your version.
32 */
33
34 #ifndef __QGPGME_PREDICATES_H__
35 #define __QGPGME_PREDICATES_H__
36
37 #include <stl_util.h>
38
39 #include <string>
40
41 #ifdef BUILDING_QGPGME
42 # include "global.h"
43 #else
44 # include <gpgme++/key.h>
45 #endif
46
47 #include <boost/bind.hpp>
48
49 #include <cstring>
50 #include <algorithm>
51 #include <iterator>
52
53 namespace QGpgME
54 {
55 namespace _detail
56 {
57
58 inline int mystrcmp(const char *s1, const char *s2)
59 {
60     using namespace std;
61     return s1 ? s2 ? strcmp(s1, s2) : 1 : s2 ? -1 : 0;
62 }
63
64 #define make_comparator_str_impl( Name, expr, cmp )                     \
65     template <template <typename U> class Op>                           \
66     struct Name {                                                       \
67         typedef bool result_type;                                       \
68         \
69         bool operator()( const char * lhs, const char * rhs ) const {   \
70             return Op<int>()( cmp, 0 );                                 \
71         }                                                               \
72         \
73         bool operator()( const std::string & lhs, const std::string & rhs ) const { \
74             return operator()( lhs.c_str(), rhs.c_str() );              \
75         }                                                               \
76         bool operator()( const char * lhs, const std::string & rhs ) const { \
77             return operator()( lhs, rhs.c_str() );                      \
78         }                                                               \
79         bool operator()( const std::string & lhs, const char * rhs ) const { \
80             return operator()( lhs.c_str(), rhs );                      \
81         }                                                               \
82         \
83         template <typename T>                                           \
84         bool operator()( const T & lhs, const T & rhs ) const {         \
85             return operator()( (lhs expr), (rhs expr) );                \
86         }                                                               \
87         template <typename T>                                           \
88         bool operator()( const T & lhs, const char * rhs ) const {      \
89             return operator()( (lhs expr), rhs );                       \
90         }                                                               \
91         template <typename T>                                           \
92         bool operator()( const char * lhs, const T & rhs ) const {      \
93             return operator()( lhs, (rhs expr) );                       \
94         }                                                               \
95         template <typename T>                                           \
96         bool operator()( const T & lhs, const std::string & rhs ) const { \
97             return operator()( (lhs expr), rhs );                       \
98         }                                                               \
99         template <typename T>                                           \
100         bool operator()( const std::string & lhs, const T & rhs ) const {    \
101             return operator()( lhs, (rhs expr) );                       \
102         }                                                               \
103     }
104
105 #define make_comparator_str_fast( Name, expr )                          \
106     make_comparator_str_impl( Name, expr, _detail::mystrcmp( lhs, rhs ) )
107 #define make_comparator_str( Name, expr )                               \
108     make_comparator_str_impl( Name, expr, qstricmp( lhs, rhs ) )
109
110 make_comparator_str_fast(ByFingerprint, .primaryFingerprint());
111 make_comparator_str_fast(ByKeyID, .keyID());
112 make_comparator_str_fast(ByShortKeyID, .shortKeyID());
113 make_comparator_str_fast(ByChainID, .chainID());
114
115 template <typename T>
116 void sort_by_fpr(T &t)
117 {
118     std::sort(t.begin(), t.end(), ByFingerprint<std::less>());
119 }
120
121 template <typename T>
122 void remove_duplicates_by_fpr(T &t)
123 {
124     t.erase(std::unique(t.begin(), t.end(), ByFingerprint<std::equal_to>()), t.end());
125 }
126
127 template <typename T>
128 T union_by_fpr(const T &t1, const T &t2)
129 {
130     T result;
131     result.reserve(t1.size() + t2.size());
132     std::set_union(t1.begin(), t1.end(),
133                    t2.begin(), t2.end(),
134                    std::back_inserter(result),
135                    ByFingerprint<std::less>());
136     return result;
137 }
138
139 template <typename T>
140 T union_by_fpr_dirty(const T &t1, const T &t2)
141 {
142     T cleaned(t1);
143     sort_by_fpr(cleaned);
144     remove_duplicates_by_fpr(cleaned);
145     return union_by_fpr(cleaned, t2);
146 }
147
148 template <typename T>
149 void grep_protocol(T &t, GpgME::Protocol proto)
150 {
151     t.erase(std::remove_if(t.begin(), t.end(), boost::bind(&GpgME::Key::protocol, _1) != proto), t.end());
152 }
153
154 template <typename T>
155 bool any_protocol(const T &t, GpgME::Protocol proto)
156 {
157     return kdtools::any(t, boost::bind(&GpgME::Key::protocol, _1) == proto);
158 }
159
160 template <typename T>
161 bool all_protocol(const T &t, GpgME::Protocol proto)
162 {
163     return kdtools::all(t, boost::bind(&GpgME::Key::protocol, _1) == proto);
164 }
165
166 template <typename T>
167 bool none_of_protocol(const T &t, GpgME::Protocol proto)
168 {
169     return kdtools::none_of(t, boost::bind(&GpgME::Key::protocol, _1) == proto);
170 }
171
172 template <typename T>
173 void grep_secret(T &t)
174 {
175     t.erase(std::remove_if(t.begin(), t.end(), boost::mem_fn(&GpgME::Key::hasSecret)), t.end());
176 }
177
178 template <typename T>
179 bool any_secret(const T &t)
180 {
181     return kdtools::any(t, boost::mem_fn(&GpgME::Key::hasSecret));
182 }
183
184 template <typename T>
185 bool all_secret(const T &t)
186 {
187     return kdtools::all(t, boost::mem_fn(&GpgME::Key::hasSecret));
188 }
189
190 template <typename T>
191 bool none_of_secret(const T &t)
192 {
193     return kdtools::none_of(t, boost::mem_fn(&GpgME::Key::hasSecret));
194 }
195
196 template <typename T>
197 void grep_can_encrypt(T &t)
198 {
199     t.erase(std::remove_if(t.begin(), t.end(), !boost::bind(&GpgME::Key::canEncrypt, _1)), t.end());
200 }
201
202 }
203 }
204
205 #endif /* __QGPGME_PREDICATES_H__ */