oysteikt/mpd
0
0
Fork 0
Code Issues Pull Requests Releases Activity

util/BindMethod: new utility class for callbacks

Browse Source 
Replaces the old BoundMethod template.
This commit is contained in:
Max Kellermann 2016-06-17 17:00:05 +02:00
parent bdd0c3686d
commit 863f4d8366
8 changed files with 206 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile.am
View File

@ -391,7 +391,7 @@ endif
libutil_a_SOURCES = \
src/util/RuntimeError.hxx \
src/util/Macros.hxx \
src/util/BoundMethod.hxx \
src/util/BindMethod.hxx \
src/util/Cast.hxx \
src/util/Clamp.hxx \
src/util/DeleteDisposer.hxx \

4
src/Instance.hxx
View File

@ -65,7 +65,7 @@ struct Instance final
public NeighborListener
#endif
{
CallbackMaskMonitor<Instance> idle_monitor;
MaskMonitor idle_monitor;
#ifdef ENABLE_NEIGHBOR_PLUGINS
NeighborGlue *neighbors;
@ -90,7 +90,7 @@ struct Instance final
StateFile *state_file;
Instance()
:idle_monitor(event_loop, *this, &Instance::OnIdle) {}
:idle_monitor(event_loop, BIND_THIS_METHOD(OnIdle)) {}
/**
* Initiate shutdown. Wrapper for EventLoop::Break().

2
src/Partition.cxx
View File

@ -29,7 +29,7 @@ Partition::Partition(Instance &_instance,
unsigned buffer_chunks,
unsigned buffered_before_play)
:instance(_instance),
global_events(instance.event_loop, *this, &Partition::OnGlobalEvent),
global_events(instance.event_loop, BIND_THIS_METHOD(OnGlobalEvent)),
playlist(max_length, *this),
outputs(*this),
pc(*this, outputs, buffer_chunks, buffered_before_play)

2
src/Partition.hxx
View File

@ -44,7 +44,7 @@ struct Partition final : QueueListener, PlayerListener, MixerListener {
Instance &instance;
CallbackMaskMonitor<Partition> global_events;
MaskMonitor global_events;
struct playlist playlist;

2
src/event/MaskMonitor.cxx
View File

@ -32,5 +32,5 @@ MaskMonitor::RunDeferred()
{
const unsigned mask = pending_mask.exchange(0);
if (mask != 0)
HandleMask(mask);
callback(mask);
}

31
src/event/MaskMonitor.hxx
View File

@ -22,7 +22,7 @@
#include "check.h"
#include "DeferredMonitor.hxx"
#include "util/BoundMethod.hxx"
#include "util/BindMethod.hxx"
#include <atomic>
@ -32,12 +32,15 @@
*
* This class is thread-safe.
*/
class MaskMonitor : DeferredMonitor {
class MaskMonitor final : DeferredMonitor {
typedef BoundMethod<void(unsigned)> Callback;
const Callback callback;
std::atomic_uint pending_mask;
public:
explicit MaskMonitor(EventLoop &_loop)
:DeferredMonitor(_loop), pending_mask(0) {}
MaskMonitor(EventLoop &_loop, Callback _callback)
:DeferredMonitor(_loop), callback(_callback), pending_mask(0) {}
using DeferredMonitor::GetEventLoop;
using DeferredMonitor::Cancel;
@ -45,28 +48,8 @@ public:
void OrMask(unsigned new_mask);
protected:
virtual void HandleMask(unsigned mask) = 0;
/* virtual methode from class DeferredMonitor */
void RunDeferred() override;
};
/**
* A variant of #MaskMonitor which invokes a bound method.
*/
template<typename T>
class CallbackMaskMonitor final : public MaskMonitor {
BoundMethod<T, void, unsigned> callback;
public:
template<typename... Args>
explicit CallbackMaskMonitor(EventLoop &_loop, Args&&... args)
:MaskMonitor(_loop), callback(std::forward<Args>(args)...) {}
protected:
void HandleMask(unsigned mask) override {
callback(mask);
}
};
#endif

193
src/util/BindMethod.hxx Normal file
View File

@ -0,0 +1,193 @@
/*
* Copyright (C) 2016 Max Kellermann <max@duempel.org>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef BIND_METHOD_HXX
#define BIND_METHOD_HXX
#include <type_traits>
#include <utility>
/**
* This object stores a function pointer wrapping a method, and a
* reference to an instance of the method's class. It can be used to
* wrap instance methods as callback functions.
*
* @param S the plain function signature type
*/
template<typename S=void()>
class BoundMethod;
template<typename R, typename... Args>
class BoundMethod<R(Args...)> {
typedef R (*function_pointer)(void *instance, Args... args);
void *instance_;
function_pointer function;
public:
BoundMethod() = default;
constexpr
BoundMethod(void *_instance, function_pointer _function)
:instance_(_instance), function(_function) {}
R operator()(Args... args) const {
return function(instance_, std::forward<Args>(args)...);
}
};
namespace BindMethodDetail {
/**
* Helper class which converts a signature type to a method pointer
* type.
*
* @param T the wrapped class
* @param S the function signature type (plain, without instance
* pointer)
*/
template<typename T, typename S>
struct MethodWithSignature;
template<typename T, typename R, typename... Args>
struct MethodWithSignature<T, R(Args...)> {
typedef R (T::*method_pointer)(Args...);
};
/**
* Helper class which introspects a method pointer type.
*
* @param M the method pointer type
*/
template<typename M>
struct MethodSignatureHelper;
template<typename R, typename T, typename... Args>
struct MethodSignatureHelper<R (T::*)(Args...)> {
/**
* The class which contains the given method (signature).
*/
typedef T class_type;
/**
* A function type which describes the "plain" function
* signature.
*/
typedef R plain_signature(Args...);
};
/**
* Helper class which converts a plain function signature type to a
* wrapper function pointer type.
*/
template<typename S>
struct MethodWrapperWithSignature;
template<typename R, typename... Args>
struct MethodWrapperWithSignature<R(Args...)> {
typedef R (*function_pointer)(void *instance, Args...);
};
/**
* Generate a wrapper function. Helper class for
* #BindMethodWrapperGenerator.
*
* @param T the containing class
* @param M the method pointer type
* @param method the method pointer
* @param R the return type
* @param Args the method arguments
*/
template<typename T, typename M, M method, typename R, typename... Args>
struct BindMethodWrapperGenerator2 {
static R Invoke(void *_instance, Args... args) {
auto &t = *(T *)_instance;
return (t.*method)(std::forward<Args>(args)...);
}
};
/**
* Generate a wrapper function.
*
* @param T the containing class
* @param M the method pointer type
* @param method the method pointer
* @param S the plain function signature type
*/
template<typename T, typename M, M method, typename S>
struct BindMethodWrapperGenerator;
template<typename T, typename M, M method, typename R, typename... Args>
struct BindMethodWrapperGenerator<T, M, method, R(Args...)>
: BindMethodWrapperGenerator2<T, M, method, R, Args...> {
};
template<typename T, typename S,
typename MethodWithSignature<T, S>::method_pointer method>
typename MethodWrapperWithSignature<S>::function_pointer
MakeBindMethodWrapper()
{
return BindMethodWrapperGenerator<T, typename MethodWithSignature<T, S>::method_pointer, method, S>::Invoke;
}
} /* namespace BindMethodDetail */
/**
* Construct a #BoundMethod instance.
*
* @param T the containing class
* @param S the plain function signature type
* @param method the method pointer
* @param instance the instance of #T to be bound
*/
template<typename T, typename S,
typename BindMethodDetail::MethodWithSignature<T, S>::method_pointer method>
constexpr BoundMethod<S>
BindMethod(T &_instance)
{
return BoundMethod<S>(&_instance,
BindMethodDetail::MakeBindMethodWrapper<T, S, method>());
}
/**
* Shortcut macro which takes an instance and a method pointer and
* constructs a #BoundMethod instance.
*/
#define BIND_METHOD(instance, method) \
BindMethod<typename BindMethodDetail::MethodSignatureHelper<decltype(method)>::class_type, \
typename BindMethodDetail::MethodSignatureHelper<decltype(method)>::plain_signature, \
method>(instance)
/**
* Shortcut wrapper for BIND_METHOD() which assumes "*this" is the
* instance to be bound.
*/
#define BIND_THIS_METHOD(method) BIND_METHOD(*this, &std::remove_reference<decltype(*this)>::type::method)
#endif

62
src/util/BoundMethod.hxx
View File

@ -1,62 +0,0 @@
/*
* Copyright (C) 2016 Max Kellermann <max@duempel.org>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef BOUND_METHOD_HXX
#define BOUND_METHOD_HXX
#include <utility>
/**
* This class can invoke a method of a given object. To do this, it
* stores a pointer to the member function and a reference to the
* object.
*
* This is a utility to build callbacks.
*
* @param T the class whose method is going to be invoked
* @param R the method's return type
* @param Args argument types
*/
template<typename T, typename R, typename... Args>
class BoundMethod final {
T &instance;
R (T::*method)(Args... args);
public:
explicit constexpr BoundMethod(T &_instance,
R (T::*_method)(Args... args))
:instance(_instance), method(_method) {}
template<typename... Args2>
R operator()(Args2&&... args) {
return (instance.*method)(std::forward<Args2>(args)...);
}
};
#endif