Tesseract4.0+VS2017+win10编译库文件

/////////////////////////////////////////////////////////////////////// // 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 NULL. 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_ = NULL; 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_ = NULL; 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_ = NULL; 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_ = NULL; 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_ = NULL; 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_ = NULL; 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_ = NULL; 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_; typename remov