///////////////////////////////////////////////////////////////////////
// File: tesscallback.h
// Description: classes and functions to replace pointer-to-functions
// Author: Samuel Charron
//
// (C) Copyright 2006, Google Inc.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
///////////////////////////////////////////////////////////////////////
#ifndef TESS_CALLBACK_SPECIALIZATIONS_H_
#define TESS_CALLBACK_SPECIALIZATIONS_H_
#include "host.h" // For nullptr.
struct TessCallbackUtils_ {
static void FailIsRepeatable(const char* name);
};
class TessClosure {
public:
virtual ~TessClosure();
virtual void Run() = 0;
};
template <class R>
class TessResultCallback {
public:
virtual ~TessResultCallback() { }
virtual R Run() = 0;
};
template <bool del, class R, class T>
class _ConstTessMemberResultCallback_0_0 : public TessResultCallback<R> {
public:
typedef TessResultCallback<R> base;
typedef R (T::*MemberSignature)() const;
private:
const T* object_;
MemberSignature member_;
public:
inline _ConstTessMemberResultCallback_0_0(
const T* object, MemberSignature member)
: object_(object),
member_(member) {
}
virtual R Run() {
if (!del) {
R result = (object_->*member_)();
return result;
} else {
R result = (object_->*member_)();
// zero out the pointer to ensure segfault if used again
member_ = nullptr;
delete this;
return result;
}
}
};
template <bool del, class T>
class _ConstTessMemberResultCallback_0_0<del, void, T>
: public TessClosure {
public:
typedef TessClosure base;
typedef void (T::*MemberSignature)() const;
private:
const T* object_;
MemberSignature member_;
public:
inline _ConstTessMemberResultCallback_0_0(
const T* object, MemberSignature member)
: object_(object),
member_(member) {
}
virtual void Run() {
if (!del) {
(object_->*member_)();
} else {
(object_->*member_)();
// zero out the pointer to ensure segfault if used again
member_ = nullptr;
delete this;
}
}
};
#ifndef SWIG
template <class T1, class T2, class R>
inline typename _ConstTessMemberResultCallback_0_0<true,R,T1>::base*
NewTessCallback(
const T1* obj, R (T2::*member)() const) {
return new _ConstTessMemberResultCallback_0_0<true,R,T1>(
obj, member);
}
#endif
#ifndef SWIG
template <class T1, class T2, class R>
inline typename _ConstTessMemberResultCallback_0_0<false,R,T1>::base*
NewPermanentTessCallback(
const T1* obj, R (T2::*member)() const) {
return new _ConstTessMemberResultCallback_0_0<false,R,T1>(
obj, member);
}
#endif
template <bool del, class R, class T>
class _TessMemberResultCallback_0_0 : public TessResultCallback<R> {
public:
typedef TessResultCallback<R> base;
typedef R (T::*MemberSignature)() ;
private:
T* object_;
MemberSignature member_;
public:
inline _TessMemberResultCallback_0_0(
T* object, MemberSignature member)
: object_(object),
member_(member) {
}
virtual R Run() {
if (!del) {
R result = (object_->*member_)();
return result;
} else {
R result = (object_->*member_)();
// zero out the pointer to ensure segfault if used again
member_ = nullptr;
delete this;
return result;
}
}
};
template <bool del, class T>
class _TessMemberResultCallback_0_0<del, void, T>
: public TessClosure {
public:
typedef TessClosure base;
typedef void (T::*MemberSignature)() ;
private:
T* object_;
MemberSignature member_;
public:
inline _TessMemberResultCallback_0_0(
T* object, MemberSignature member)
: object_(object),
member_(member) {
}
virtual void Run() {
if (!del) {
(object_->*member_)();
} else {
(object_->*member_)();
// zero out the pointer to ensure segfault if used again
member_ = nullptr;
delete this;
}
}
};
#ifndef SWIG
template <class T1, class T2, class R>
inline typename _TessMemberResultCallback_0_0<true,R,T1>::base*
NewTessCallback(
T1* obj, R (T2::*member)()) {
return new _TessMemberResultCallback_0_0<true,R,T1>(
obj, member);
}
#endif
#ifndef SWIG
template <class T1, class T2, class R>
inline typename _TessMemberResultCallback_0_0<false,R,T1>::base*
NewPermanentTessCallback(
T1* obj, R (T2::*member)()) {
return new _TessMemberResultCallback_0_0<false,R,T1>(
obj, member);
}
#endif
template <bool del, class R>
class _TessFunctionResultCallback_0_0 : public TessResultCallback<R> {
public:
typedef TessResultCallback<R> base;
typedef R (*FunctionSignature)();
private:
FunctionSignature function_;
public:
inline _TessFunctionResultCallback_0_0(
FunctionSignature function)
: function_(function) {
}
virtual R Run() {
if (!del) {
R result = (*function_)();
return result;
} else {
R result = (*function_)();
// zero out the pointer to ensure segfault if used again
function_ = nullptr;
delete this;
return result;
}
}
};
template <bool del>
class _TessFunctionResultCallback_0_0<del, void>
: public TessClosure {
public:
typedef TessClosure base;
typedef void (*FunctionSignature)();
private:
FunctionSignature function_;
public:
inline _TessFunctionResultCallback_0_0(
FunctionSignature function)
: function_(function) {
}
virtual void Run() {
if (!del) {
(*function_)();
} else {
(*function_)();
// zero out the pointer to ensure segfault if used again
function_ = nullptr;
delete this;
}
}
};
template <class R>
inline typename _TessFunctionResultCallback_0_0<true,R>::base*
NewTessCallback(R (*function)()) {
return new _TessFunctionResultCallback_0_0<true,R>(function);
}
template <class R>
inline typename _TessFunctionResultCallback_0_0<false,R>::base*
NewPermanentTessCallback(R (*function)()) {
return new _TessFunctionResultCallback_0_0<false,R>(function);
}
// Specified by TR1 [4.7.2] Reference modifications.
template <class T> struct remove_reference;
template<typename T> struct remove_reference { typedef T type; };
template<typename T> struct remove_reference<T&> { typedef T type; };
// Identity<T>::type is a typedef of T. Useful for preventing the
// compiler from inferring the type of an argument in templates.
template <typename T>
struct Identity {
typedef T type;
};
template <bool del, class R, class T, class P1>
class _ConstTessMemberResultCallback_1_0 : public TessResultCallback<R> {
public:
typedef TessResultCallback<R> base;
typedef R (T::*MemberSignature)(P1) const;
private:
const T* object_;
MemberSignature member_;
typename remove_reference<P1>::type p1_;
public:
inline _ConstTessMemberResultCallback_1_0(const T* object, MemberSignature member, P1 p1)
: object_(object),
member_(member), p1_(p1) { }
virtual R Run() {
if (!del) {
R result = (object_->*member_)(p1_);
return result;
} else {
R result = (object_->*member_)(p1_);
// zero out the pointer to ensure segfault if used again
member_ = nullptr;
delete this;
return result;
}
}
};
template <bool del, class T, class P1>
class _ConstTessMemberResultCallback_1_0<del, void, T, P1> : public TessClosure {
public:
typedef TessClosure base;
typedef void (T::*MemberSignature)(P1) const;
private:
const T* object_;
MemberSignature member
评论5
最新资源