Add missing files to QGpgME
* lang/qt/src/gpgme_backend_debug.cpp, lang/qt/src/gpgme_backend_debug.h, lang/qt/src/predicates.h, lang/qt/src/stl_util.h: New.
This commit is contained in:
Andre Heinecke
parent
226e51052a
commit
a440050fc2
10
lang/qt/src/gpgme_backend_debug.cpp
Normal file
10
lang/qt/src/gpgme_backend_debug.cpp
Normal file
@ -0,0 +1,10 @@
|
||||
// This file is autogenerated by CMake: DO NOT EDIT
|
||||
|
||||
#include "gpgme_backend_debug.h"
|
||||
|
||||
|
||||
#if QT_VERSION >= QT_VERSION_CHECK(5, 4, 0)
|
||||
Q_LOGGING_CATEGORY(GPGPME_BACKEND_LOG, "log_gpgme_backend", QtWarningMsg)
|
||||
#else
|
||||
Q_LOGGING_CATEGORY(GPGPME_BACKEND_LOG, "log_gpgme_backend")
|
||||
#endif
|
||||
11
lang/qt/src/gpgme_backend_debug.h
Normal file
11
lang/qt/src/gpgme_backend_debug.h
Normal file
@ -0,0 +1,11 @@
|
||||
// This file is autogenerated by CMake: DO NOT EDIT
|
||||
|
||||
#ifndef GPGPME_BACKEND_LOG_H
|
||||
#define GPGPME_BACKEND_LOG_H
|
||||
|
||||
#include <QLoggingCategory>
|
||||
|
||||
Q_DECLARE_LOGGING_CATEGORY(GPGPME_BACKEND_LOG)
|
||||
|
||||
|
||||
#endif
|
||||
205
lang/qt/src/predicates.h
Normal file
205
lang/qt/src/predicates.h
Normal file
@ -0,0 +1,205 @@
|
||||
/* -*- mode: c++; c-basic-offset:4 -*-
|
||||
models/predicates.h
|
||||
|
||||
This file is part of Kleopatra, the KDE keymanager
|
||||
Copyright (c) 2007 Klarälvdalens Datakonsult AB
|
||||
Copyright (c) 2016 Intevation GmbH
|
||||
|
||||
Kleopatra 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 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Kleopatra 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 this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
In addition, as a special exception, the copyright holders give
|
||||
permission to link the code of this program with any edition of
|
||||
the Qt library by Trolltech AS, Norway (or with modified versions
|
||||
of Qt that use the same license as Qt), and distribute linked
|
||||
combinations including the two. You must obey the GNU General
|
||||
Public License in all respects for all of the code used other than
|
||||
Qt. If you modify this file, you may extend this exception to
|
||||
your version of the file, but you are not obligated to do so. If
|
||||
you do not wish to do so, delete this exception statement from
|
||||
your version.
|
||||
*/
|
||||
|
||||
#ifndef __QGPGME_PREDICATES_H__
|
||||
#define __QGPGME_PREDICATES_H__
|
||||
|
||||
#include <stl_util.h>
|
||||
|
||||
#include <string>
|
||||
|
||||
#ifdef BUILDING_QGPGME
|
||||
# include "global.h"
|
||||
#else
|
||||
# include <gpgme++/key.h>
|
||||
#endif
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <iterator>
|
||||
|
||||
namespace QGpgME
|
||||
{
|
||||
namespace _detail
|
||||
{
|
||||
|
||||
inline int mystrcmp(const char *s1, const char *s2)
|
||||
{
|
||||
using namespace std;
|
||||
return s1 ? s2 ? strcmp(s1, s2) : 1 : s2 ? -1 : 0;
|
||||
}
|
||||
|
||||
#define make_comparator_str_impl( Name, expr, cmp ) \
|
||||
template <template <typename U> class Op> \
|
||||
struct Name { \
|
||||
typedef bool result_type; \
|
||||
\
|
||||
bool operator()( const char * lhs, const char * rhs ) const { \
|
||||
return Op<int>()( cmp, 0 ); \
|
||||
} \
|
||||
\
|
||||
bool operator()( const std::string & lhs, const std::string & rhs ) const { \
|
||||
return operator()( lhs.c_str(), rhs.c_str() ); \
|
||||
} \
|
||||
bool operator()( const char * lhs, const std::string & rhs ) const { \
|
||||
return operator()( lhs, rhs.c_str() ); \
|
||||
} \
|
||||
bool operator()( const std::string & lhs, const char * rhs ) const { \
|
||||
return operator()( lhs.c_str(), rhs ); \
|
||||
} \
|
||||
\
|
||||
template <typename T> \
|
||||
bool operator()( const T & lhs, const T & rhs ) const { \
|
||||
return operator()( (lhs expr), (rhs expr) ); \
|
||||
} \
|
||||
template <typename T> \
|
||||
bool operator()( const T & lhs, const char * rhs ) const { \
|
||||
return operator()( (lhs expr), rhs ); \
|
||||
} \
|
||||
template <typename T> \
|
||||
bool operator()( const char * lhs, const T & rhs ) const { \
|
||||
return operator()( lhs, (rhs expr) ); \
|
||||
} \
|
||||
template <typename T> \
|
||||
bool operator()( const T & lhs, const std::string & rhs ) const { \
|
||||
return operator()( (lhs expr), rhs ); \
|
||||
} \
|
||||
template <typename T> \
|
||||
bool operator()( const std::string & lhs, const T & rhs ) const { \
|
||||
return operator()( lhs, (rhs expr) ); \
|
||||
} \
|
||||
}
|
||||
|
||||
#define make_comparator_str_fast( Name, expr ) \
|
||||
make_comparator_str_impl( Name, expr, _detail::mystrcmp( lhs, rhs ) )
|
||||
#define make_comparator_str( Name, expr ) \
|
||||
make_comparator_str_impl( Name, expr, qstricmp( lhs, rhs ) )
|
||||
|
||||
make_comparator_str_fast(ByFingerprint, .primaryFingerprint());
|
||||
make_comparator_str_fast(ByKeyID, .keyID());
|
||||
make_comparator_str_fast(ByShortKeyID, .shortKeyID());
|
||||
make_comparator_str_fast(ByChainID, .chainID());
|
||||
|
||||
template <typename T>
|
||||
void sort_by_fpr(T &t)
|
||||
{
|
||||
std::sort(t.begin(), t.end(), ByFingerprint<std::less>());
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void remove_duplicates_by_fpr(T &t)
|
||||
{
|
||||
t.erase(std::unique(t.begin(), t.end(), ByFingerprint<std::equal_to>()), t.end());
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
T union_by_fpr(const T &t1, const T &t2)
|
||||
{
|
||||
T result;
|
||||
result.reserve(t1.size() + t2.size());
|
||||
std::set_union(t1.begin(), t1.end(),
|
||||
t2.begin(), t2.end(),
|
||||
std::back_inserter(result),
|
||||
ByFingerprint<std::less>());
|
||||
return result;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
T union_by_fpr_dirty(const T &t1, const T &t2)
|
||||
{
|
||||
T cleaned(t1);
|
||||
sort_by_fpr(cleaned);
|
||||
remove_duplicates_by_fpr(cleaned);
|
||||
return union_by_fpr(cleaned, t2);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void grep_protocol(T &t, GpgME::Protocol proto)
|
||||
{
|
||||
t.erase(std::remove_if(t.begin(), t.end(), boost::bind(&GpgME::Key::protocol, _1) != proto), t.end());
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
bool any_protocol(const T &t, GpgME::Protocol proto)
|
||||
{
|
||||
return kdtools::any(t, boost::bind(&GpgME::Key::protocol, _1) == proto);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
bool all_protocol(const T &t, GpgME::Protocol proto)
|
||||
{
|
||||
return kdtools::all(t, boost::bind(&GpgME::Key::protocol, _1) == proto);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
bool none_of_protocol(const T &t, GpgME::Protocol proto)
|
||||
{
|
||||
return kdtools::none_of(t, boost::bind(&GpgME::Key::protocol, _1) == proto);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void grep_secret(T &t)
|
||||
{
|
||||
t.erase(std::remove_if(t.begin(), t.end(), boost::mem_fn(&GpgME::Key::hasSecret)), t.end());
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
bool any_secret(const T &t)
|
||||
{
|
||||
return kdtools::any(t, boost::mem_fn(&GpgME::Key::hasSecret));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
bool all_secret(const T &t)
|
||||
{
|
||||
return kdtools::all(t, boost::mem_fn(&GpgME::Key::hasSecret));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
bool none_of_secret(const T &t)
|
||||
{
|
||||
return kdtools::none_of(t, boost::mem_fn(&GpgME::Key::hasSecret));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void grep_can_encrypt(T &t)
|
||||
{
|
||||
t.erase(std::remove_if(t.begin(), t.end(), !boost::bind(&GpgME::Key::canEncrypt, _1)), t.end());
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* __QGPGME_PREDICATES_H__ */
|
||||
631
lang/qt/src/stl_util.h
Normal file
631
lang/qt/src/stl_util.h
Normal file
@ -0,0 +1,631 @@
|
||||
/****************************************************************************
|
||||
** Copyright (C) 2001-2007 Klarälvdalens Datakonsult AB
|
||||
Copyright (c) 2016 Intevation GmbH. All rights reserved.
|
||||
**
|
||||
** This file is part of the KD Tools library.
|
||||
**
|
||||
** This file may be distributed and/or modified under the terms of the
|
||||
** GNU General Public License version 2 as published by the Free Software
|
||||
** Foundation and appearing in the file LICENSE.GPL included in the
|
||||
** packaging of this file.
|
||||
**
|
||||
** Licensees holding valid commercial KD Tools licenses may use this file in
|
||||
** accordance with the KD Tools Commercial License Agreement provided with
|
||||
** the Software.
|
||||
**
|
||||
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
|
||||
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||||
**
|
||||
** Contact info@klaralvdalens-datakonsult.se if any conditions of this
|
||||
** licensing are not clear to you.
|
||||
**
|
||||
**********************************************************************/
|
||||
#ifndef __KDTOOLSCORE_STL_UTIL_H__
|
||||
#define __KDTOOLSCORE_STL_UTIL_H__
|
||||
|
||||
#include <boost/range.hpp>
|
||||
#include <boost/iterator/filter_iterator.hpp>
|
||||
#include <boost/iterator/transform_iterator.hpp>
|
||||
#include <boost/call_traits.hpp>
|
||||
#include <boost/version.hpp>
|
||||
|
||||
#include <algorithm>
|
||||
#include <numeric>
|
||||
#include <utility>
|
||||
#include <iterator>
|
||||
#include <functional>
|
||||
|
||||
namespace kdtools
|
||||
{
|
||||
|
||||
struct nodelete {
|
||||
template <typename T>
|
||||
void operator()(const T *) const {}
|
||||
};
|
||||
|
||||
struct identity {
|
||||
template <typename T>
|
||||
T *operator()(T *t) const
|
||||
{
|
||||
return t;
|
||||
}
|
||||
template <typename T>
|
||||
const T *operator()(const T *t) const
|
||||
{
|
||||
return t;
|
||||
}
|
||||
template <typename T>
|
||||
T &operator()(T &t) const
|
||||
{
|
||||
return t;
|
||||
}
|
||||
template <typename T>
|
||||
const T &operator()(const T &t) const
|
||||
{
|
||||
return t;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Pair>
|
||||
struct select1st;
|
||||
|
||||
template <typename U, typename V>
|
||||
struct select1st< std::pair<U, V> >
|
||||
: std::unary_function<std::pair<U, V>, U> {
|
||||
typename boost::call_traits<U>::param_type
|
||||
operator()(const std::pair<U, V> &pair) const
|
||||
{
|
||||
return pair.first;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Pair>
|
||||
struct select2nd;
|
||||
|
||||
template <typename U, typename V>
|
||||
struct select2nd< std::pair<U, V> >
|
||||
: std::unary_function<std::pair<U, V>, V> {
|
||||
typename boost::call_traits<V>::param_type
|
||||
operator()(const std::pair<U, V> &pair) const
|
||||
{
|
||||
return pair.second;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename InputIterator, typename OutputIterator, typename UnaryPredicate>
|
||||
OutputIterator copy_if(InputIterator first, InputIterator last, OutputIterator dest, UnaryPredicate pred)
|
||||
{
|
||||
while (first != last) {
|
||||
if (pred(*first)) {
|
||||
*dest = *first;
|
||||
++dest;
|
||||
}
|
||||
++first;
|
||||
}
|
||||
return dest;
|
||||
}
|
||||
|
||||
template <typename OutputIterator, typename InputIterator, typename UnaryFunction, typename UnaryPredicate>
|
||||
OutputIterator transform_if(InputIterator first, InputIterator last, OutputIterator dest, UnaryPredicate pred, UnaryFunction filter)
|
||||
{
|
||||
return std::transform(boost::make_filter_iterator(filter, first, last),
|
||||
boost::make_filter_iterator(filter, last, last),
|
||||
dest, pred);
|
||||
}
|
||||
|
||||
template <typename InputIterator, typename OutputIterator>
|
||||
OutputIterator copy_1st(InputIterator first, InputIterator last, OutputIterator dest)
|
||||
{
|
||||
return std::copy(boost::make_transform_iterator(first, select1st<typename std::iterator_traits<InputIterator>::value_type>()),
|
||||
boost::make_transform_iterator(last, select1st<typename std::iterator_traits<InputIterator>::value_type>()),
|
||||
dest);
|
||||
}
|
||||
|
||||
template <typename InputIterator, typename OutputIterator>
|
||||
OutputIterator copy_2nd(InputIterator first, InputIterator last, OutputIterator dest)
|
||||
{
|
||||
return std::copy(boost::make_transform_iterator(first, select2nd<typename std::iterator_traits<InputIterator>::value_type>()),
|
||||
boost::make_transform_iterator(last, select2nd<typename std::iterator_traits<InputIterator>::value_type>()),
|
||||
dest);
|
||||
}
|
||||
|
||||
template <typename InputIterator, typename OutputIterator, typename Predicate>
|
||||
OutputIterator copy_1st_if(InputIterator first, InputIterator last, OutputIterator dest, Predicate pred)
|
||||
{
|
||||
return kdtools::copy_if(boost::make_transform_iterator(first, select1st<typename std::iterator_traits<InputIterator>::value_type>()),
|
||||
boost::make_transform_iterator(last, select1st<typename std::iterator_traits<InputIterator>::value_type>()),
|
||||
dest, pred);
|
||||
}
|
||||
|
||||
template <typename InputIterator, typename OutputIterator, typename Predicate>
|
||||
OutputIterator copy_2nd_if(InputIterator first, InputIterator last, OutputIterator dest, Predicate pred)
|
||||
{
|
||||
return kdtools::copy_if(boost::make_transform_iterator(first, select2nd<typename std::iterator_traits<InputIterator>::value_type>()),
|
||||
boost::make_transform_iterator(last, select2nd<typename std::iterator_traits<InputIterator>::value_type>()),
|
||||
dest, pred);
|
||||
}
|
||||
|
||||
template <typename OutputIterator, typename InputIterator, typename UnaryFunction>
|
||||
OutputIterator transform_1st(InputIterator first, InputIterator last, OutputIterator dest, UnaryFunction func)
|
||||
{
|
||||
return std::transform(boost::make_transform_iterator(first, select1st<typename std::iterator_traits<InputIterator>::value_type>()),
|
||||
boost::make_transform_iterator(last, select1st<typename std::iterator_traits<InputIterator>::value_type>()),
|
||||
dest, func);
|
||||
}
|
||||
|
||||
template <typename OutputIterator, typename InputIterator, typename UnaryFunction>
|
||||
OutputIterator transform_2nd(InputIterator first, InputIterator last, OutputIterator dest, UnaryFunction func)
|
||||
{
|
||||
return std::transform(boost::make_transform_iterator(first, select2nd<typename std::iterator_traits<InputIterator>::value_type>()),
|
||||
boost::make_transform_iterator(last, select2nd<typename std::iterator_traits<InputIterator>::value_type>()),
|
||||
dest, func);
|
||||
}
|
||||
|
||||
template <typename Value, typename InputIterator, typename UnaryPredicate>
|
||||
Value accumulate_if(InputIterator first, InputIterator last, UnaryPredicate filter, const Value &value = Value())
|
||||
{
|
||||
return std::accumulate(boost::make_filter_iterator(filter, first, last),
|
||||
boost::make_filter_iterator(filter, last, last), value);
|
||||
}
|
||||
|
||||
template <typename Value, typename InputIterator, typename UnaryPredicate, typename BinaryOperation>
|
||||
Value accumulate_if(InputIterator first, InputIterator last, UnaryPredicate filter, const Value &value, BinaryOperation op)
|
||||
{
|
||||
return std::accumulate(boost::make_filter_iterator(filter, first, last),
|
||||
boost::make_filter_iterator(filter, last, last), value, op);
|
||||
}
|
||||
|
||||
template <typename Value, typename InputIterator, typename UnaryFunction>
|
||||
Value accumulate_transform(InputIterator first, InputIterator last, UnaryFunction map, const Value &value = Value())
|
||||
{
|
||||
return std::accumulate(boost::make_transform_iterator(first, map),
|
||||
boost::make_transform_iterator(last, map), value);
|
||||
}
|
||||
|
||||
template <typename Value, typename InputIterator, typename UnaryFunction, typename BinaryOperation>
|
||||
Value accumulate_transform(InputIterator first, InputIterator last, UnaryFunction map, const Value &value, BinaryOperation op)
|
||||
{
|
||||
return std::accumulate(boost::make_transform_iterator(first, map),
|
||||
boost::make_transform_iterator(last, map), value, op);
|
||||
}
|
||||
|
||||
template <typename Value, typename InputIterator, typename UnaryFunction, typename UnaryPredicate>
|
||||
Value accumulate_transform_if(InputIterator first, InputIterator last, UnaryFunction map, UnaryPredicate pred, const Value &value = Value())
|
||||
{
|
||||
return std::accumulate(boost::make_transform_iterator(first, map),
|
||||
boost::make_transform_iterator(last, map), value);
|
||||
}
|
||||
|
||||
template <typename Value, typename InputIterator, typename UnaryFunction, typename UnaryPredicate, typename BinaryOperation>
|
||||
Value accumulate_transform_if(InputIterator first, InputIterator last, UnaryFunction map, UnaryPredicate filter, const Value &value, BinaryOperation op)
|
||||
{
|
||||
return std::accumulate(boost::make_transform_iterator(boost::make_filter_iterator(filter, first, last), map),
|
||||
boost::make_transform_iterator(boost::make_filter_iterator(filter, last, last), map), value, op);
|
||||
}
|
||||
|
||||
template <typename InputIterator, typename OutputIterator1, typename OutputIterator2, typename UnaryPredicate>
|
||||
std::pair<OutputIterator1, OutputIterator2> separate_if(InputIterator first, InputIterator last, OutputIterator1 dest1, OutputIterator2 dest2, UnaryPredicate pred)
|
||||
{
|
||||
while (first != last) {
|
||||
if (pred(*first)) {
|
||||
*dest1 = *first;
|
||||
++dest1;
|
||||
} else {
|
||||
*dest2 = *first;
|
||||
++dest2;
|
||||
}
|
||||
++first;
|
||||
}
|
||||
return std::make_pair(dest1, dest2);
|
||||
}
|
||||
|
||||
template <typename InputIterator>
|
||||
bool any(InputIterator first, InputIterator last)
|
||||
{
|
||||
while (first != last)
|
||||
if (*first) {
|
||||
return true;
|
||||
} else {
|
||||
++first;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
template <typename InputIterator, typename UnaryPredicate>
|
||||
bool any(InputIterator first, InputIterator last, UnaryPredicate pred)
|
||||
{
|
||||
while (first != last)
|
||||
if (pred(*first)) {
|
||||
return true;
|
||||
} else {
|
||||
++first;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
template <typename InputIterator>
|
||||
bool all(InputIterator first, InputIterator last)
|
||||
{
|
||||
while (first != last)
|
||||
if (*first) {
|
||||
++first;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename InputIterator, typename UnaryPredicate>
|
||||
bool all(InputIterator first, InputIterator last, UnaryPredicate pred)
|
||||
{
|
||||
while (first != last)
|
||||
if (pred(*first)) {
|
||||
++first;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename InputIterator>
|
||||
bool none_of(InputIterator first, InputIterator last)
|
||||
{
|
||||
return !any(first, last);
|
||||
}
|
||||
|
||||
template <typename InputIterator, typename UnaryPredicate>
|
||||
bool none_of(InputIterator first, InputIterator last, UnaryPredicate pred)
|
||||
{
|
||||
return !any(first, last, pred);
|
||||
}
|
||||
|
||||
template <typename InputIterator, typename BinaryOperation>
|
||||
BinaryOperation for_each_adjacent_pair(InputIterator first, InputIterator last, BinaryOperation op)
|
||||
{
|
||||
typedef typename std::iterator_traits<InputIterator>::value_type ValueType;
|
||||
if (first == last) {
|
||||
return op;
|
||||
}
|
||||
ValueType value = *first;
|
||||
while (++first != last) {
|
||||
ValueType tmp = *first;
|
||||
op(value, tmp);
|
||||
value = tmp;
|
||||
}
|
||||
return op;
|
||||
}
|
||||
|
||||
template <typename ForwardIterator, typename UnaryPredicate, typename UnaryFunction>
|
||||
UnaryFunction for_each_if(ForwardIterator first, ForwardIterator last, UnaryPredicate pred, UnaryFunction func)
|
||||
{
|
||||
return std::for_each(boost::make_filter_iterator(pred, first, last),
|
||||
boost::make_filter_iterator(pred, last, last),
|
||||
func);
|
||||
}
|
||||
|
||||
//@{
|
||||
/**
|
||||
Versions of std::set_intersection optimized for ForwardIterator's
|
||||
*/
|
||||
template <typename ForwardIterator, typename ForwardIterator2, typename OutputIterator, typename BinaryPredicate>
|
||||
OutputIterator set_intersection(ForwardIterator first1, ForwardIterator last1, ForwardIterator2 first2, ForwardIterator2 last2, OutputIterator result)
|
||||
{
|
||||
while (first1 != last1 && first2 != last2) {
|
||||
if (*first1 < *first2) {
|
||||
first1 = std::lower_bound(++first1, last1, *first2);
|
||||
} else if (*first2 < *first1) {
|
||||
first2 = std::lower_bound(++first2, last2, *first1);
|
||||
} else {
|
||||
*result = *first1;
|
||||
++first1;
|
||||
++first2;
|
||||
++result;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
template <typename ForwardIterator, typename ForwardIterator2, typename OutputIterator, typename BinaryPredicate>
|
||||
OutputIterator set_intersection(ForwardIterator first1, ForwardIterator last1, ForwardIterator2 first2, ForwardIterator2 last2, OutputIterator result, BinaryPredicate pred)
|
||||
{
|
||||
while (first1 != last1 && first2 != last2) {
|
||||
if (pred(*first1, *first2)) {
|
||||
first1 = std::lower_bound(++first1, last1, *first2, pred);
|
||||
} else if (pred(*first2, *first1)) {
|
||||
first2 = std::lower_bound(++first2, last2, *first1, pred);
|
||||
} else {
|
||||
*result = *first1;
|
||||
++first1;
|
||||
++first2;
|
||||
++result;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
//@}
|
||||
|
||||
template <typename ForwardIterator, typename ForwardIterator2, typename BinaryPredicate>
|
||||
bool set_intersects(ForwardIterator first1, ForwardIterator last1,
|
||||
ForwardIterator2 first2, ForwardIterator2 last2,
|
||||
BinaryPredicate pred)
|
||||
{
|
||||
while (first1 != last1 && first2 != last2) {
|
||||
if (pred(*first1, *first2)) {
|
||||
first1 = std::lower_bound(++first1, last1, *first2, pred);
|
||||
} else if (pred(*first2, *first1)) {
|
||||
first2 = std::lower_bound(++first2, last2, *first1, pred);
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
//@{
|
||||
/*! Versions of std algorithms that take ranges */
|
||||
|
||||
template <typename C, typename V>
|
||||
typename boost::range_iterator<C>::type
|
||||
find(C &c, const V &v)
|
||||
{
|
||||
return std::find(boost::begin(c), boost::end(c), v);
|
||||
}
|
||||
|
||||
#if BOOST_VERSION < 103500
|
||||
template <typename C, typename V>
|
||||
typename boost::range_const_iterator<C>::type
|
||||
find(const C &c, const V &v)
|
||||
{
|
||||
return std::find(boost::begin(c), boost::end(c), v);
|
||||
}
|
||||
#endif
|
||||
|
||||
template <typename C, typename P>
|
||||
typename boost::range_iterator<C>::type
|
||||
find_if(C &c, P p)
|
||||
{
|
||||
return std::find_if(boost::begin(c), boost::end(c), p);
|
||||
}
|
||||
|
||||
#if BOOST_VERSION < 103500
|
||||
template <typename C, typename P>
|
||||
typename boost::range_const_iterator<C>::type
|
||||
find_if(const C &c, P p)
|
||||
{
|
||||
return std::find_if(boost::begin(c), boost::end(c), p);
|
||||
}
|
||||
#endif
|
||||
|
||||
template <typename C, typename V>
|
||||
bool contains(const C &c, const V &v)
|
||||
{
|
||||
return find(c, v) != boost::end(c);
|
||||
}
|
||||
|
||||
template <typename C, typename P>
|
||||
bool contains_if(const C &c, P p)
|
||||
{
|
||||
return find_if(c, p) != boost::end(c);
|
||||
}
|
||||
|
||||
template <typename C, typename V>
|
||||
bool binary_search(const C &c, const V &v)
|
||||
{
|
||||
return std::binary_search(boost::begin(c), boost::end(c), v);
|
||||
}
|
||||
|
||||
template <typename C, typename V>
|
||||
size_t count(const C &c, const V &v)
|
||||
{
|
||||
return std::count(boost::begin(c), boost::end(c), v);
|
||||
}
|
||||
|
||||
template <typename C, typename P>
|
||||
size_t count_if(const C &c, P p)
|
||||
{
|
||||
return std::count_if(boost::begin(c), boost::end(c), p);
|
||||
}
|
||||
|
||||
template <typename O, typename I, typename P>
|
||||
O transform(const I &i, P p)
|
||||
{
|
||||
O o;
|
||||
std::transform(boost::begin(i), boost::end(i),
|
||||
std::back_inserter(o), p);
|
||||
return o;
|
||||
}
|
||||
|
||||
template <typename I, typename OutputIterator, typename P>
|
||||
OutputIterator transform(const I &i, OutputIterator out, P p)
|
||||
{
|
||||
return std::transform(boost::begin(i), boost::end(i), out, p);
|
||||
}
|
||||
|
||||
template <typename O, typename I, typename P, typename F>
|
||||
O transform_if(const I &i, P p, F f)
|
||||
{
|
||||
O o;
|
||||
transform_if(boost::begin(i), boost::end(i),
|
||||
std::back_inserter(o), p, f);
|
||||
return o;
|
||||
}
|
||||
|
||||
template <typename V, typename I, typename F>
|
||||
V accumulate_if(const I &i, F f, V v = V())
|
||||
{
|
||||
return accumulate_if(boost::begin(i), boost::end(i), f, v);
|
||||
}
|
||||
|
||||
template <typename V, typename I, typename F, typename B>
|
||||
V accumulate_if(const I &i, F f, V v, B b)
|
||||
{
|
||||
return accumulate_if(boost::begin(i), boost::end(i), f, v, b);
|
||||
}
|
||||
|
||||
template <typename V, typename I, typename F>
|
||||
V accumulate_transform(const I &i, F f, V v = V())
|
||||
{
|
||||
return accumulate_transform(boost::begin(i), boost::end(i), f, v);
|
||||
}
|
||||
|
||||
template <typename V, typename I, typename F, typename B>
|
||||
V accumulate_transform(const I &i, F f, V v, B b)
|
||||
{
|
||||
return accumulate_transform(boost::begin(i), boost::end(i), f, v, b);
|
||||
}
|
||||
|
||||
template <typename V, typename I, typename F, typename P>
|
||||
V accumulate_transform_if(const I &i, F f, P p, V v = V())
|
||||
{
|
||||
return accumulate_transform_if(boost::begin(i), boost::end(i), f, p, v);
|
||||
}
|
||||
|
||||
template <typename V, typename I, typename F, typename P, typename B>
|
||||
V accumulate_transform_if(const I &i, F f, P p, V v, B b)
|
||||
{
|
||||
return accumulate_transform_if(boost::begin(i), boost::end(i), f, p, v, b);
|
||||
}
|
||||
|
||||
template <typename O, typename I>
|
||||
O copy(const I &i)
|
||||
{
|
||||
O o;
|
||||
std::copy(boost::begin(i), boost::end(i), std::back_inserter(o));
|
||||
return o;
|
||||
}
|
||||
|
||||
template <typename O, typename I, typename P>
|
||||
O copy_if(const I &i, P p)
|
||||
{
|
||||
O o;
|
||||
kdtools::copy_if(boost::begin(i), boost::end(i), std::back_inserter(o), p);
|
||||
return o;
|
||||
}
|
||||
|
||||
template <typename I, typename P>
|
||||
P for_each(const I &i, P p)
|
||||
{
|
||||
return std::for_each(boost::begin(i), boost::end(i), p);
|
||||
}
|
||||
|
||||
template <typename I, typename P>
|
||||
P for_each(I &i, P p)
|
||||
{
|
||||
return std::for_each(boost::begin(i), boost::end(i), p);
|
||||
}
|
||||
|
||||
template <typename C1, typename C2>
|
||||
bool equal(const C1 &c1, const C2 &c2)
|
||||
{
|
||||
return boost::size(c1) == boost::size(c2)
|
||||
&& std::equal(boost::begin(c1), boost::end(c1),
|
||||
boost::begin(c2));
|
||||
}
|
||||
|
||||
template <typename C1, typename C2, typename P>
|
||||
bool equal(const C1 &c1, const C2 &c2, P p)
|
||||
{
|
||||
return boost::size(c1) == boost::size(c2)
|
||||
&& std::equal(boost::begin(c1), boost::end(c1),
|
||||
boost::begin(c2), p);
|
||||
}
|
||||
|
||||
template <typename C, typename O1, typename O2, typename P>
|
||||
std::pair<O1, O2> separate_if(const C &c, O1 o1, O2 o2, P p)
|
||||
{
|
||||
return separate_if(boost::begin(c), boost::end(c), o1, o2, p);
|
||||
}
|
||||
|
||||
//@}
|
||||
|
||||
template <typename C>
|
||||
bool any(const C &c)
|
||||
{
|
||||
return any(boost::begin(c), boost::end(c));
|
||||
}
|
||||
|
||||
template <typename C, typename P>
|
||||
bool any(const C &c, P p)
|
||||
{
|
||||
return any(boost::begin(c), boost::end(c), p);
|
||||
}
|
||||
|
||||
template <typename C>
|
||||
bool all(const C &c)
|
||||
{
|
||||
return all(boost::begin(c), boost::end(c));
|
||||
}
|
||||
|
||||
template <typename C, typename P>
|
||||
bool all(const C &c, P p)
|
||||
{
|
||||
return all(boost::begin(c), boost::end(c), p);
|
||||
}
|
||||
|
||||
template <typename C>
|
||||
bool none_of(const C &c)
|
||||
{
|
||||
return none_of(boost::begin(c), boost::end(c));
|
||||
}
|
||||
|
||||
template <typename C, typename P>
|
||||
bool none_of(const C &c, P p)
|
||||
{
|
||||
return kdtools::none_of(boost::begin(c), boost::end(c), p);
|
||||
}
|
||||
|
||||
template <typename C, typename B>
|
||||
B for_each_adjacent_pair(const C &c, B b)
|
||||
{
|
||||
return for_each_adjacent_pair(boost::begin(c), boost::end(c), b);
|
||||
}
|
||||
|
||||
template <typename C, typename B>
|
||||
B for_each_adjacent_pair(C &c, B b)
|
||||
{
|
||||
return for_each_adjacent_pair(boost::begin(c), boost::end(c), b);
|
||||
}
|
||||
|
||||
template <typename C, typename P, typename F>
|
||||
P for_each_if(const C &c, P p, F f)
|
||||
{
|
||||
return for_each_if(boost::begin(c), boost::end(c), p, f);
|
||||
}
|
||||
|
||||
template <typename C, typename P, typename F>
|
||||
P for_each_if(C &c, P p, F f)
|
||||
{
|
||||
return for_each_if(boost::begin(c), boost::end(c), p, f);
|
||||
}
|
||||
|
||||
template <typename C>
|
||||
void sort(C &c)
|
||||
{
|
||||
return std::sort(boost::begin(c), boost::end(c));
|
||||
}
|
||||
|
||||
template <typename C, typename P>
|
||||
void sort(C &c, P p)
|
||||
{
|
||||
return std::sort(boost::begin(c), boost::end(c), p);
|
||||
}
|
||||
|
||||
template <typename C>
|
||||
C sorted(const C &c)
|
||||
{
|
||||
C copy(c);
|
||||
kdtools::sort(copy);
|
||||
return copy;
|
||||
}
|
||||
|
||||
template <typename C, typename P>
|
||||
C sorted(const C &c, P p)
|
||||
{
|
||||
C copy(c);
|
||||
kdtools::sort(copy, p);
|
||||
return copy;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif /* __KDTOOLSCORE_STL_UTIL_H__ */
|
||||
Loading…
Reference in New Issue
Block a user