mirror of https://github.com/aria2/aria2
431 lines
12 KiB
C++
431 lines
12 KiB
C++
/* <!-- copyright */
|
|
/*
|
|
* aria2 - The high speed download utility
|
|
*
|
|
* Copyright (C) 2006 Tatsuhiro Tsujikawa
|
|
*
|
|
* This program 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.
|
|
*
|
|
* This program 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 portions of this program with the
|
|
* OpenSSL library under certain conditions as described in each
|
|
* individual source file, 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 OpenSSL. If you modify
|
|
* file(s) with this exception, you may extend this exception to your
|
|
* version of the file(s), but you are not obligated to do so. If you
|
|
* do not wish to do so, delete this exception statement from your
|
|
* version. If you delete this exception statement from all source
|
|
* files in the program, then also delete it here.
|
|
*/
|
|
/* copyright --> */
|
|
#ifndef _D_A2_FUNCTIONAL_H_
|
|
#define _D_A2_FUNCTIONAL_H_
|
|
|
|
#include <functional>
|
|
#include <string>
|
|
#include <algorithm>
|
|
|
|
#include "SharedHandle.h"
|
|
#include "A2STR.h"
|
|
|
|
namespace aria2 {
|
|
|
|
// mem_fun_t for SharedHandle
|
|
template <class ReturnType, typename ClassType>
|
|
class mem_fun_sh_t:public std::unary_function< SharedHandle<ClassType>, ReturnType>
|
|
{
|
|
private:
|
|
ReturnType (ClassType::*f)();
|
|
|
|
public:
|
|
mem_fun_sh_t(ReturnType (ClassType::*f)()):f(f) {}
|
|
|
|
ReturnType operator()(const SharedHandle<ClassType>& x) const
|
|
{
|
|
return (x.get()->*f)();
|
|
}
|
|
};
|
|
|
|
// const_mem_fun_t for SharedHandle
|
|
template <class ReturnType, typename ClassType>
|
|
class const_mem_fun_sh_t:public std::unary_function< SharedHandle<ClassType>, ReturnType>
|
|
{
|
|
private:
|
|
ReturnType (ClassType::*f)() const;
|
|
|
|
public:
|
|
const_mem_fun_sh_t(ReturnType (ClassType::*f)() const):f(f) {}
|
|
|
|
ReturnType operator()(const SharedHandle<ClassType>& x) const
|
|
{
|
|
return (x.get()->*f)();
|
|
}
|
|
};
|
|
|
|
template <class ReturnType, typename ClassType>
|
|
mem_fun_sh_t<ReturnType, ClassType>
|
|
mem_fun_sh(ReturnType (ClassType::*f)())
|
|
{
|
|
return mem_fun_sh_t<ReturnType, ClassType>(f);
|
|
};
|
|
|
|
template <class ReturnType, typename ClassType>
|
|
const_mem_fun_sh_t<ReturnType, ClassType>
|
|
mem_fun_sh(ReturnType (ClassType::*f)() const)
|
|
{
|
|
return const_mem_fun_sh_t<ReturnType, ClassType>(f);
|
|
};
|
|
|
|
// mem_fun1_t for SharedHandle
|
|
template<typename ReturnType, typename ClassType, typename ArgType>
|
|
class mem_fun1_sh_t:public std::binary_function<SharedHandle<ClassType>,
|
|
ArgType,
|
|
ReturnType>
|
|
{
|
|
private:
|
|
ReturnType (ClassType::*f)(ArgType);
|
|
|
|
public:
|
|
mem_fun1_sh_t(ReturnType (ClassType::*f)(ArgType)):f(f) {}
|
|
|
|
ReturnType operator()(const SharedHandle<ClassType>& x, ArgType a) const
|
|
{
|
|
return (x.get()->*f)(a);
|
|
}
|
|
};
|
|
|
|
template<typename ReturnType, typename ClassType, typename ArgType>
|
|
mem_fun1_sh_t<ReturnType, ClassType, ArgType>
|
|
mem_fun_sh(ReturnType (ClassType::*f)(ArgType))
|
|
{
|
|
return mem_fun1_sh_t<ReturnType, ClassType, ArgType>(f);
|
|
};
|
|
|
|
template<class BinaryOp, class UnaryOp>
|
|
class adopt2nd_t:public std::binary_function<typename BinaryOp::first_argument_type,
|
|
typename UnaryOp::argument_type,
|
|
typename BinaryOp::result_type> {
|
|
private:
|
|
BinaryOp binaryOp_;
|
|
UnaryOp unaryOp_;
|
|
public:
|
|
adopt2nd_t(const BinaryOp& b, const UnaryOp& u):
|
|
binaryOp_(b), unaryOp_(u) {}
|
|
|
|
typename BinaryOp::result_type
|
|
operator()(const typename BinaryOp::first_argument_type& x,
|
|
const typename UnaryOp::argument_type& y)
|
|
{
|
|
return binaryOp_(x, unaryOp_(y));
|
|
}
|
|
|
|
};
|
|
|
|
template <class BinaryOp, class UnaryOp>
|
|
inline adopt2nd_t<BinaryOp, UnaryOp>
|
|
adopt2nd(const BinaryOp& binaryOp, const UnaryOp& unaryOp)
|
|
{
|
|
return adopt2nd_t<BinaryOp, UnaryOp>(binaryOp, unaryOp);
|
|
};
|
|
|
|
template<typename Pair>
|
|
class Ascend1st:public std::binary_function<Pair, Pair, bool>
|
|
{
|
|
public:
|
|
bool operator()(const Pair& p1, const Pair& p2) const
|
|
{
|
|
return p1.first < p2.first;
|
|
}
|
|
};
|
|
|
|
template<typename Pair>
|
|
class select2nd
|
|
{
|
|
public:
|
|
typename Pair::second_type operator()(const Pair& p) const
|
|
{
|
|
return p.second;
|
|
}
|
|
|
|
typename Pair::second_type operator()(Pair& p) const
|
|
{
|
|
return p.second;
|
|
}
|
|
};
|
|
|
|
class Deleter {
|
|
public:
|
|
template<class T>
|
|
void operator()(T* ptr) {
|
|
delete ptr;
|
|
}
|
|
};
|
|
|
|
template<typename T>
|
|
class Append {
|
|
private:
|
|
T& to_;
|
|
T delim_;
|
|
public:
|
|
template<typename S>
|
|
Append(T& to, const S& delim):to_(to), delim_(delim) {}
|
|
|
|
template<typename S>
|
|
void operator()(const S& s) {
|
|
to_ += s+delim_;
|
|
}
|
|
};
|
|
|
|
typedef Append<std::string> StringAppend;
|
|
|
|
template<typename T>
|
|
class auto_delete {
|
|
private:
|
|
T obj_;
|
|
void (*deleter_)(T);
|
|
public:
|
|
auto_delete(T obj, void (*deleter)(T)):obj_(obj), deleter_(deleter) {}
|
|
|
|
~auto_delete()
|
|
{
|
|
deleter_(obj_);
|
|
}
|
|
};
|
|
|
|
template<class Container>
|
|
class auto_delete_container {
|
|
private:
|
|
Container* c_;
|
|
public:
|
|
auto_delete_container(Container* c):c_(c) {}
|
|
|
|
~auto_delete_container()
|
|
{
|
|
std::for_each(c_->begin(), c_->end(), Deleter());
|
|
delete c_;
|
|
}
|
|
};
|
|
|
|
template<typename InputIterator, typename DelimiterType>
|
|
std::string strjoin(InputIterator first, InputIterator last,
|
|
const DelimiterType& delim)
|
|
{
|
|
std::string result;
|
|
if(first == last) {
|
|
return result;
|
|
}
|
|
InputIterator beforeLast = last-1;
|
|
for(; first != beforeLast; ++first) {
|
|
result += *first;
|
|
result += delim;
|
|
}
|
|
result += *beforeLast;
|
|
return result;
|
|
}
|
|
|
|
// Applies unaryOp through first to last and joins the result with
|
|
// delimiter delim.
|
|
template<typename InputIterator, typename DelimiterType, typename UnaryOp>
|
|
std::string strjoin(InputIterator first, InputIterator last,
|
|
const DelimiterType& delim, const UnaryOp& unaryOp)
|
|
{
|
|
std::string result;
|
|
if(first == last) {
|
|
return result;
|
|
}
|
|
InputIterator beforeLast = last-1;
|
|
for(; first != beforeLast; ++first) {
|
|
result += unaryOp(*first);
|
|
result += delim;
|
|
}
|
|
result += unaryOp(*beforeLast);
|
|
return result;
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
inline std::string strconcat(const T1& a1, const T2& a2)
|
|
{
|
|
std::string s(a1); s += a2; return s;
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3>
|
|
inline std::string strconcat(const T1& a1, const T2& a2, const T3& a3)
|
|
{
|
|
std::string s(a1); s += a2; s += a3; return s;
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4>
|
|
inline std::string
|
|
strconcat(const T1& a1, const T2& a2, const T3& a3, const T4& a4)
|
|
{
|
|
std::string s(a1); s += a2; s += a3; s += a4; return s;
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5>
|
|
inline std::string
|
|
strconcat(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
|
|
const T5& a5)
|
|
{
|
|
std::string s(a1); s += a2; s += a3; s += a4; s += a5; return s;
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5,
|
|
typename T6>
|
|
inline std::string
|
|
strconcat(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
|
|
const T5& a5, const T6& a6)
|
|
{
|
|
std::string s(a1); s += a2; s += a3; s += a4; s += a5; s += a6; return s;
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5,
|
|
typename T6, typename T7>
|
|
inline std::string
|
|
strconcat(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
|
|
const T5& a5, const T6& a6, const T7& a7)
|
|
{
|
|
std::string s(a1); s += a2; s += a3; s += a4; s += a5; s += a6; s += a7;
|
|
return s;
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5,
|
|
typename T6, typename T7, typename T8>
|
|
inline std::string
|
|
strconcat(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
|
|
const T5& a5, const T6& a6, const T7& a7, const T8& a8)
|
|
{
|
|
std::string s(a1); s += a2; s += a3; s += a4; s += a5; s += a6; s += a7;
|
|
s += a8; return s;
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5,
|
|
typename T6, typename T7, typename T8, typename T9>
|
|
inline std::string
|
|
strconcat(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
|
|
const T5& a5, const T6& a6, const T7& a7, const T8& a8,
|
|
const T9& a9)
|
|
{
|
|
std::string s(a1); s += a2; s += a3; s += a4; s += a5; s += a6; s += a7;
|
|
s += a8; s += a9; return s;
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5,
|
|
typename T6, typename T7, typename T8, typename T9, typename T10>
|
|
inline std::string
|
|
strconcat(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
|
|
const T5& a5, const T6& a6, const T7& a7, const T8& a8,
|
|
const T9& a9, const T10& a10)
|
|
{
|
|
std::string s(a1); s += a2; s += a3; s += a4; s += a5; s += a6; s += a7;
|
|
s += a8; s += a9; s += a10; return s;
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5,
|
|
typename T6, typename T7, typename T8, typename T9, typename T10,
|
|
typename T11>
|
|
inline std::string
|
|
strconcat(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
|
|
const T5& a5, const T6& a6, const T7& a7, const T8& a8,
|
|
const T9& a9, const T10& a10, const T11& a11)
|
|
{
|
|
std::string s(a1); s += a2; s += a3; s += a4; s += a5; s += a6; s += a7;
|
|
s += a8; s += a9; s += a10; s += a11; return s;
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5,
|
|
typename T6, typename T7, typename T8, typename T9, typename T10,
|
|
typename T11, typename T12>
|
|
inline std::string
|
|
strconcat(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
|
|
const T5& a5, const T6& a6, const T7& a7, const T8& a8,
|
|
const T9& a9, const T10& a10, const T11& a11,
|
|
const T12& a12)
|
|
{
|
|
std::string s(a1); s += a2; s += a3; s += a4; s += a5; s += a6; s += a7;
|
|
s += a8; s += a9; s += a10; s += a11; s += a12; return s;
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
inline void strappend(std::string& base, const T1& a1, const T2& a2)
|
|
{
|
|
base += a1; base += a2;
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3>
|
|
inline void strappend(std::string& base,
|
|
const T1& a1, const T2& a2, const T3& a3)
|
|
{
|
|
base += a1; base += a2; base += a3;
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4>
|
|
inline void strappend(std::string& base,
|
|
const T1& a1, const T2& a2, const T3& a3, const T4& a4)
|
|
{
|
|
base += a1; base += a2; base += a3; base += a4;
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5>
|
|
inline void strappend(std::string& base,
|
|
const T1& a1, const T2& a2, const T3& a3, const T4& a4,
|
|
const T5& a5)
|
|
{
|
|
base += a1; base += a2; base += a3; base += a4; base += a5;
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5,
|
|
typename T6>
|
|
inline void strappend(std::string& base,
|
|
const T1& a1, const T2& a2, const T3& a3, const T4& a4,
|
|
const T5& a5, const T6& a6)
|
|
{
|
|
base += a1; base += a2; base += a3; base += a4; base += a5; base += a6;
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5,
|
|
typename T6, typename T7>
|
|
inline void strappend(std::string& base,
|
|
const T1& a1, const T2& a2, const T3& a3, const T4& a4,
|
|
const T5& a5, const T6& a6, const T7& a7)
|
|
{
|
|
base += a1; base += a2; base += a3; base += a4; base += a5; base += a6;
|
|
base += a7;
|
|
}
|
|
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5,
|
|
typename T6, typename T7, typename T8>
|
|
inline void strappend(std::string& base,
|
|
const T1& a1, const T2& a2, const T3& a3, const T4& a4,
|
|
const T5& a5, const T6& a6, const T7& a7, const T8& a8)
|
|
{
|
|
base += a1; base += a2; base += a3; base += a4; base += a5; base += a6;
|
|
base += a7; base += a8;
|
|
}
|
|
|
|
template<typename T>
|
|
class LeastRecentAccess:public std::binary_function<T, T, bool> {
|
|
public:
|
|
bool operator()(const T& lhs, const T& rhs) const
|
|
{
|
|
return lhs.getLastAccess() < rhs.getLastAccess();
|
|
}
|
|
};
|
|
|
|
} // namespace aria2
|
|
|
|
#endif // _D_A2_FUNCTIONAL_H_
|