Move Thread classes from Tracker to shared
So that they may be utilized outside of Tracker
This commit is contained in:
John Scipione
@@ -0,0 +1,573 @@
|
||||
/*
|
||||
Open Tracker License
|
||||
|
||||
Terms and Conditions
|
||||
|
||||
Copyright (c) 1991-2000, Be Incorporated. All rights reserved.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
this software and associated documentation files (the "Software"), to deal in
|
||||
the Software without restriction, including without limitation the rights to
|
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||
of the Software, and to permit persons to whom the Software is furnished to do
|
||||
so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice applies to all licensees
|
||||
and shall be included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF TITLE, MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
BE INCORPORATED BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION
|
||||
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of Be Incorporated shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings in
|
||||
this Software without prior written authorization from Be Incorporated.
|
||||
|
||||
Tracker(TM), Be(R), BeOS(R), and BeIA(TM) are trademarks or registered trademarks
|
||||
of Be Incorporated in the United States and other countries. Other brand product
|
||||
names are registered trademarks or trademarks of their respective holders.
|
||||
All rights reserved.
|
||||
*/
|
||||
#ifndef __FUNCTION_OBJECT__
|
||||
#define __FUNCTION_OBJECT__
|
||||
|
||||
|
||||
#include <Message.h>
|
||||
#include <Messenger.h>
|
||||
#include <MessageFilter.h>
|
||||
|
||||
#include <Entry.h>
|
||||
#include <Node.h>
|
||||
|
||||
|
||||
// parameter binders serve to store a copy of a struct and
|
||||
// pass it in and out by pointers, allowing struct parameters to share
|
||||
// the same syntax as scalar ones
|
||||
|
||||
// You will mostly want to use the NewFunctionObject... convenience
|
||||
// factories
|
||||
//
|
||||
|
||||
// add more function objects and specialized binders as needed
|
||||
|
||||
namespace BPrivate {
|
||||
|
||||
template<class P>
|
||||
class ParameterBinder {
|
||||
// primitive default binder for scalars
|
||||
public:
|
||||
ParameterBinder() {}
|
||||
ParameterBinder(P p)
|
||||
: p(p)
|
||||
{}
|
||||
|
||||
P Pass() const
|
||||
{ return p; }
|
||||
private:
|
||||
P p;
|
||||
};
|
||||
|
||||
|
||||
template<>
|
||||
class ParameterBinder<const BEntry*> {
|
||||
public:
|
||||
ParameterBinder() {}
|
||||
ParameterBinder(const BEntry* p)
|
||||
: p(*p)
|
||||
{}
|
||||
|
||||
ParameterBinder &operator=(const BEntry* newp)
|
||||
{ p = *newp; return *this; }
|
||||
|
||||
const BEntry* Pass() const
|
||||
{ return &p; }
|
||||
private:
|
||||
BEntry p;
|
||||
};
|
||||
|
||||
|
||||
template<>
|
||||
class ParameterBinder<const entry_ref*> {
|
||||
public:
|
||||
ParameterBinder() {}
|
||||
ParameterBinder(const entry_ref* p)
|
||||
{
|
||||
if (p)
|
||||
this->p = *p;
|
||||
}
|
||||
|
||||
ParameterBinder &operator=(const entry_ref* newp)
|
||||
{ p = *newp; return *this; }
|
||||
|
||||
const entry_ref* Pass() const
|
||||
{ return &p; }
|
||||
private:
|
||||
entry_ref p;
|
||||
};
|
||||
|
||||
|
||||
template<>
|
||||
class ParameterBinder<const node_ref*> {
|
||||
public:
|
||||
ParameterBinder() {}
|
||||
ParameterBinder(const node_ref* p)
|
||||
: p(*p)
|
||||
{}
|
||||
|
||||
ParameterBinder &operator=(const node_ref* newp)
|
||||
{ p = *newp; return *this; }
|
||||
|
||||
const node_ref* Pass() const
|
||||
{ return &p; }
|
||||
private:
|
||||
node_ref p;
|
||||
};
|
||||
|
||||
|
||||
template<>
|
||||
class ParameterBinder<const BMessage*> {
|
||||
public:
|
||||
ParameterBinder() {}
|
||||
ParameterBinder(const BMessage* p)
|
||||
: p(p ? new BMessage(*p) : NULL)
|
||||
{}
|
||||
|
||||
~ParameterBinder()
|
||||
{
|
||||
delete p;
|
||||
}
|
||||
|
||||
ParameterBinder &operator=(const BMessage* newp)
|
||||
{
|
||||
delete p;
|
||||
p = (newp ? new BMessage(*newp) : NULL);
|
||||
return *this;
|
||||
}
|
||||
|
||||
const BMessage* Pass() const
|
||||
{ return p; }
|
||||
|
||||
private:
|
||||
BMessage* p;
|
||||
};
|
||||
|
||||
|
||||
class FunctionObject {
|
||||
public:
|
||||
virtual void operator()() = 0;
|
||||
virtual ~FunctionObject() {}
|
||||
};
|
||||
|
||||
|
||||
template<class R>
|
||||
class FunctionObjectWithResult : public FunctionObject {
|
||||
public:
|
||||
const R &Result() const { return result; }
|
||||
|
||||
protected:
|
||||
R result;
|
||||
};
|
||||
|
||||
|
||||
template <class Param1>
|
||||
class SingleParamFunctionObject : public FunctionObject {
|
||||
public:
|
||||
SingleParamFunctionObject(void (*callThis)(Param1),
|
||||
Param1 p1)
|
||||
: function(callThis),
|
||||
p1(p1)
|
||||
{
|
||||
}
|
||||
|
||||
virtual void operator()() { (function)(p1.Pass()); }
|
||||
|
||||
private:
|
||||
void (*function)(Param1);
|
||||
ParameterBinder<Param1> p1;
|
||||
};
|
||||
|
||||
|
||||
template <class Result, class Param1>
|
||||
class SingleParamFunctionObjectWithResult : public
|
||||
FunctionObjectWithResult<Result> {
|
||||
public:
|
||||
SingleParamFunctionObjectWithResult(Result (*function)(Param1), Param1 p1)
|
||||
: function(function),
|
||||
p1(p1)
|
||||
{
|
||||
}
|
||||
|
||||
virtual void operator()()
|
||||
{ FunctionObjectWithResult<Result>::result = (function)(p1.Pass()); }
|
||||
|
||||
private:
|
||||
Result (*function)(Param1);
|
||||
ParameterBinder<Param1> p1;
|
||||
};
|
||||
|
||||
|
||||
template <class Param1, class Param2>
|
||||
class TwoParamFunctionObject : public FunctionObject {
|
||||
public:
|
||||
TwoParamFunctionObject(void (*callThis)(Param1, Param2),
|
||||
Param1 p1, Param2 p2)
|
||||
: function(callThis),
|
||||
p1(p1),
|
||||
p2(p2)
|
||||
{
|
||||
}
|
||||
|
||||
virtual void operator()() { (function)(p1.Pass(), p2.Pass()); }
|
||||
|
||||
private:
|
||||
void (*function)(Param1, Param2);
|
||||
ParameterBinder<Param1> p1;
|
||||
ParameterBinder<Param2> p2;
|
||||
};
|
||||
|
||||
|
||||
template <class Param1, class Param2, class Param3>
|
||||
class ThreeParamFunctionObject : public FunctionObject {
|
||||
public:
|
||||
ThreeParamFunctionObject(void (*callThis)(Param1, Param2, Param3),
|
||||
Param1 p1, Param2 p2, Param3 p3)
|
||||
: function(callThis),
|
||||
p1(p1),
|
||||
p2(p2),
|
||||
p3(p3)
|
||||
{
|
||||
}
|
||||
|
||||
virtual void operator()() { (function)(p1.Pass(), p2.Pass(), p3.Pass()); }
|
||||
|
||||
private:
|
||||
void (*function)(Param1, Param2, Param3);
|
||||
ParameterBinder<Param1> p1;
|
||||
ParameterBinder<Param2> p2;
|
||||
ParameterBinder<Param3> p3;
|
||||
};
|
||||
|
||||
|
||||
template <class Result, class Param1, class Param2, class Param3>
|
||||
class ThreeParamFunctionObjectWithResult : public
|
||||
FunctionObjectWithResult<Result> {
|
||||
public:
|
||||
ThreeParamFunctionObjectWithResult(
|
||||
Result (*callThis)(Param1, Param2, Param3),
|
||||
Param1 p1, Param2 p2, Param3 p3)
|
||||
: function(callThis),
|
||||
p1(p1),
|
||||
p2(p2),
|
||||
p3(p3)
|
||||
{
|
||||
}
|
||||
|
||||
virtual void operator()()
|
||||
{ FunctionObjectWithResult<Result>::result
|
||||
= (function)(p1.Pass(), p2.Pass(), p3.Pass()); }
|
||||
|
||||
private:
|
||||
Result (*function)(Param1, Param2, Param3);
|
||||
ParameterBinder<Param1> p1;
|
||||
ParameterBinder<Param2> p2;
|
||||
ParameterBinder<Param3> p3;
|
||||
};
|
||||
|
||||
|
||||
template <class Param1, class Param2, class Param3, class Param4>
|
||||
class FourParamFunctionObject : public FunctionObject {
|
||||
public:
|
||||
FourParamFunctionObject(void (*callThis)(Param1, Param2, Param3, Param4),
|
||||
Param1 p1, Param2 p2, Param3 p3, Param4 p4)
|
||||
: function(callThis),
|
||||
p1(p1),
|
||||
p2(p2),
|
||||
p3(p3),
|
||||
p4(p4)
|
||||
{
|
||||
}
|
||||
|
||||
virtual void operator()()
|
||||
{ (function)(p1.Pass(), p2.Pass(), p3.Pass(), p4.Pass()); }
|
||||
|
||||
private:
|
||||
void (*function)(Param1, Param2, Param3, Param4);
|
||||
ParameterBinder<Param1> p1;
|
||||
ParameterBinder<Param2> p2;
|
||||
ParameterBinder<Param3> p3;
|
||||
ParameterBinder<Param4> p4;
|
||||
};
|
||||
|
||||
|
||||
template <class Result, class Param1, class Param2, class Param3,
|
||||
class Param4>
|
||||
class FourParamFunctionObjectWithResult : public
|
||||
FunctionObjectWithResult<Result> {
|
||||
public:
|
||||
FourParamFunctionObjectWithResult(
|
||||
Result (*callThis)(Param1, Param2, Param3, Param4),
|
||||
Param1 p1, Param2 p2, Param3 p3, Param4 p4)
|
||||
: function(callThis),
|
||||
p1(p1),
|
||||
p2(p2),
|
||||
p3(p3),
|
||||
p4(p4)
|
||||
{
|
||||
}
|
||||
|
||||
virtual void operator()()
|
||||
{ FunctionObjectWithResult<Result>::result
|
||||
= (function)(p1.Pass(), p2.Pass(), p3.Pass(), p4.Pass()); }
|
||||
|
||||
private:
|
||||
Result (*function)(Param1, Param2, Param3, Param4);
|
||||
ParameterBinder<Param1> p1;
|
||||
ParameterBinder<Param2> p2;
|
||||
ParameterBinder<Param3> p3;
|
||||
ParameterBinder<Param4> p4;
|
||||
};
|
||||
|
||||
|
||||
template<class T>
|
||||
class PlainMemberFunctionObject : public FunctionObject {
|
||||
public:
|
||||
PlainMemberFunctionObject(void (T::*function)(), T* onThis)
|
||||
: function(function),
|
||||
target(onThis)
|
||||
{
|
||||
}
|
||||
|
||||
virtual void operator()()
|
||||
{ (target->*function)(); }
|
||||
|
||||
private:
|
||||
void (T::*function)();
|
||||
T* target;
|
||||
};
|
||||
|
||||
|
||||
template<class T>
|
||||
class PlainLockingMemberFunctionObject : public FunctionObject {
|
||||
public:
|
||||
PlainLockingMemberFunctionObject(void (T::*function)(), T* target)
|
||||
: function(function),
|
||||
messenger(target)
|
||||
{
|
||||
}
|
||||
|
||||
virtual void operator()()
|
||||
{
|
||||
T* target = dynamic_cast<T*>(messenger.Target(NULL));
|
||||
if (!target || !messenger.LockTarget())
|
||||
return;
|
||||
(target->*function)();
|
||||
target->Looper()->Unlock();
|
||||
}
|
||||
|
||||
private:
|
||||
void (T::*function)();
|
||||
BMessenger messenger;
|
||||
};
|
||||
|
||||
|
||||
template<class T, class R>
|
||||
class PlainMemberFunctionObjectWithResult : public
|
||||
FunctionObjectWithResult<R> {
|
||||
public:
|
||||
PlainMemberFunctionObjectWithResult(R (T::*function)(), T* onThis)
|
||||
: function(function),
|
||||
target(onThis)
|
||||
{
|
||||
}
|
||||
|
||||
virtual void operator()()
|
||||
{ FunctionObjectWithResult<R>::result = (target->*function)(); }
|
||||
|
||||
|
||||
private:
|
||||
R (T::*function)();
|
||||
T* target;
|
||||
};
|
||||
|
||||
|
||||
template<class T, class Param1>
|
||||
class SingleParamMemberFunctionObject : public FunctionObject {
|
||||
public:
|
||||
SingleParamMemberFunctionObject(void (T::*function)(Param1),
|
||||
T* onThis, Param1 p1)
|
||||
: function(function),
|
||||
target(onThis),
|
||||
p1(p1)
|
||||
{
|
||||
}
|
||||
|
||||
virtual void operator()()
|
||||
{ (target->*function)(p1.Pass()); }
|
||||
|
||||
private:
|
||||
void (T::*function)(Param1);
|
||||
T* target;
|
||||
ParameterBinder<Param1> p1;
|
||||
};
|
||||
|
||||
|
||||
template<class T, class Param1, class Param2>
|
||||
class TwoParamMemberFunctionObject : public FunctionObject {
|
||||
public:
|
||||
TwoParamMemberFunctionObject(void (T::*function)(Param1, Param2),
|
||||
T* onThis, Param1 p1, Param2 p2)
|
||||
: function(function),
|
||||
target(onThis),
|
||||
p1(p1),
|
||||
p2(p2)
|
||||
{
|
||||
}
|
||||
|
||||
virtual void operator()()
|
||||
{ (target->*function)(p1.Pass(), p2.Pass()); }
|
||||
|
||||
|
||||
protected:
|
||||
void (T::*function)(Param1, Param2);
|
||||
T* target;
|
||||
ParameterBinder<Param1> p1;
|
||||
ParameterBinder<Param2> p2;
|
||||
};
|
||||
|
||||
|
||||
template<class T, class R, class Param1>
|
||||
class SingleParamMemberFunctionObjectWithResult : public
|
||||
FunctionObjectWithResult<R> {
|
||||
public:
|
||||
SingleParamMemberFunctionObjectWithResult(R (T::*function)(Param1),
|
||||
T* onThis, Param1 p1)
|
||||
: function(function),
|
||||
target(onThis),
|
||||
p1(p1)
|
||||
{
|
||||
}
|
||||
|
||||
virtual void operator()()
|
||||
{ FunctionObjectWithResult<R>::result
|
||||
= (target->*function)(p1.Pass()); }
|
||||
|
||||
protected:
|
||||
R (T::*function)(Param1);
|
||||
T* target;
|
||||
ParameterBinder<Param1> p1;
|
||||
};
|
||||
|
||||
|
||||
template<class T, class R, class Param1, class Param2>
|
||||
class TwoParamMemberFunctionObjectWithResult : public
|
||||
FunctionObjectWithResult<R> {
|
||||
public:
|
||||
TwoParamMemberFunctionObjectWithResult(R (T::*function)(Param1, Param2),
|
||||
T* onThis, Param1 p1, Param2 p2)
|
||||
: function(function),
|
||||
target(onThis),
|
||||
p1(p1),
|
||||
p2(p2)
|
||||
{
|
||||
}
|
||||
|
||||
virtual void operator()()
|
||||
{ FunctionObjectWithResult<R>::result
|
||||
= (target->*function)(p1.Pass(), p2.Pass()); }
|
||||
|
||||
protected:
|
||||
R (T::*function)(Param1, Param2);
|
||||
T* target;
|
||||
ParameterBinder<Param1> p1;
|
||||
ParameterBinder<Param2> p2;
|
||||
};
|
||||
|
||||
|
||||
// convenience factory functions
|
||||
// NewFunctionObject
|
||||
// NewMemberFunctionObject
|
||||
// NewMemberFunctionObjectWithResult
|
||||
// NewLockingMemberFunctionObject
|
||||
//
|
||||
// ... add the missing ones as needed
|
||||
|
||||
template<class Param1>
|
||||
SingleParamFunctionObject<Param1>*
|
||||
NewFunctionObject(void (*function)(Param1), Param1 p1)
|
||||
{
|
||||
return new SingleParamFunctionObject<Param1>(function, p1);
|
||||
}
|
||||
|
||||
|
||||
template<class Param1, class Param2>
|
||||
TwoParamFunctionObject<Param1, Param2>*
|
||||
NewFunctionObject(void (*function)(Param1, Param2), Param1 p1, Param2 p2)
|
||||
{
|
||||
return new TwoParamFunctionObject<Param1, Param2>(function, p1, p2);
|
||||
}
|
||||
|
||||
|
||||
template<class Param1, class Param2, class Param3>
|
||||
ThreeParamFunctionObject<Param1, Param2, Param3>*
|
||||
NewFunctionObject(void (*function)(Param1, Param2, Param3),
|
||||
Param1 p1, Param2 p2, Param3 p3)
|
||||
{
|
||||
return new ThreeParamFunctionObject<Param1, Param2, Param3>
|
||||
(function, p1, p2, p3);
|
||||
}
|
||||
|
||||
|
||||
template<class T>
|
||||
PlainMemberFunctionObject<T>*
|
||||
NewMemberFunctionObject(void (T::*function)(), T* onThis)
|
||||
{
|
||||
return new PlainMemberFunctionObject<T>(function, onThis);
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Param1>
|
||||
SingleParamMemberFunctionObject<T, Param1>*
|
||||
NewMemberFunctionObject(void (T::*function)(Param1), T* onThis, Param1 p1)
|
||||
{
|
||||
return new SingleParamMemberFunctionObject<T, Param1>
|
||||
(function, onThis, p1);
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Param1, class Param2>
|
||||
TwoParamMemberFunctionObject<T, Param1, Param2>*
|
||||
NewMemberFunctionObject(void (T::*function)(Param1, Param2), T* onThis,
|
||||
Param1 p1, Param2 p2)
|
||||
{
|
||||
return new TwoParamMemberFunctionObject<T, Param1, Param2>
|
||||
(function, onThis, p1, p2);
|
||||
}
|
||||
|
||||
|
||||
template<class T, class R, class Param1, class Param2>
|
||||
TwoParamMemberFunctionObjectWithResult<T, R, Param1, Param2>*
|
||||
NewMemberFunctionObjectWithResult(R (T::*function)(Param1, Param2),
|
||||
T* onThis, Param1 p1, Param2 p2)
|
||||
{
|
||||
return new TwoParamMemberFunctionObjectWithResult<T, R, Param1, Param2>
|
||||
(function, onThis, p1, p2);
|
||||
}
|
||||
|
||||
|
||||
template<class HandlerOrSubclass>
|
||||
PlainLockingMemberFunctionObject<HandlerOrSubclass>*
|
||||
NewLockingMemberFunctionObject(void (HandlerOrSubclass::*function)(),
|
||||
HandlerOrSubclass* onThis)
|
||||
{
|
||||
return new PlainLockingMemberFunctionObject<HandlerOrSubclass>
|
||||
(function, onThis);
|
||||
}
|
||||
|
||||
} // namespace BPrivate
|
||||
|
||||
using namespace BPrivate;
|
||||
|
||||
#endif // __FUNCTION_OBJECT__
|
||||
Reference in New Issue
Block a user