All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • srcnativelibs.Include.Tesseract.tesseract.tesscallback.h Maven / Gradle / Ivy

    ///////////////////////////////////////////////////////////////////////
// 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 TessResultCallback {
 public:
  virtual ~TessResultCallback() { }
  virtual R Run() = 0;
};

template 
class _ConstTessMemberResultCallback_0_0 : public TessResultCallback {
 public:
  typedef TessResultCallback 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 
class _ConstTessMemberResultCallback_0_0
  : 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 
inline typename _ConstTessMemberResultCallback_0_0::base*
NewTessCallback(
    const T1* obj, R (T2::*member)() const) {
  return new _ConstTessMemberResultCallback_0_0(
      obj, member);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_0_0::base*
NewPermanentTessCallback(
    const T1* obj, R (T2::*member)() const) {
  return new _ConstTessMemberResultCallback_0_0(
      obj, member);
}
#endif

template 
class _TessMemberResultCallback_0_0 : public TessResultCallback {
 public:
  typedef TessResultCallback 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 
class _TessMemberResultCallback_0_0
  : 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 
inline typename _TessMemberResultCallback_0_0::base*
NewTessCallback(
     T1* obj, R (T2::*member)() ) {
  return new _TessMemberResultCallback_0_0(
      obj, member);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_0_0::base*
NewPermanentTessCallback(
     T1* obj, R (T2::*member)() ) {
  return new _TessMemberResultCallback_0_0(
      obj, member);
}
#endif

template 
class _TessFunctionResultCallback_0_0 : public TessResultCallback {
 public:
  typedef TessResultCallback 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 
class _TessFunctionResultCallback_0_0
  : 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 
inline typename _TessFunctionResultCallback_0_0::base*
NewTessCallback(R (*function)()) {
  return new _TessFunctionResultCallback_0_0(function);
}

template 
inline typename _TessFunctionResultCallback_0_0::base*
NewPermanentTessCallback(R (*function)()) {
  return new _TessFunctionResultCallback_0_0(function);
}



// Specified by TR1 [4.7.2] Reference modifications.
template  struct remove_reference;
template struct remove_reference { typedef T type; };
template struct remove_reference { typedef T type; };

// Identity::type is a typedef of T. Useful for preventing the
// compiler from inferring the type of an argument in templates.
template 
struct Identity {
  typedef T type;
};

template 
class _ConstTessMemberResultCallback_1_0 : public TessResultCallback {
 public:
  typedef TessResultCallback base;
  typedef R (T::*MemberSignature)(P1) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::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 
class _ConstTessMemberResultCallback_1_0 : public TessClosure {
 public:
  typedef TessClosure base;
  typedef void (T::*MemberSignature)(P1) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _ConstTessMemberResultCallback_1_0(const T* object, MemberSignature member, P1 p1)
    : object_(object),
      member_(member),      p1_(p1) { }

  virtual void Run() {
    if (!del) {
      (object_->*member_)(p1_);
    } else {
      (object_->*member_)(p1_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_1_0::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1) const, typename Identity::type p1) {
  return new _ConstTessMemberResultCallback_1_0(obj, member, p1);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_1_0::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1) const, typename Identity::type p1) {
  return new _ConstTessMemberResultCallback_1_0(obj, member, p1);
}
#endif

template 
class _TessMemberResultCallback_1_0 : public TessResultCallback {
 public:
  typedef TessResultCallback base;
  typedef R (T::*MemberSignature)(P1) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _TessMemberResultCallback_1_0( 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 
class _TessMemberResultCallback_1_0 : public TessClosure {
 public:
  typedef TessClosure base;
  typedef void (T::*MemberSignature)(P1) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _TessMemberResultCallback_1_0( T* object, MemberSignature member, P1 p1)
    : object_(object),
      member_(member),      p1_(p1) { }

  virtual void Run() {
    if (!del) {
      (object_->*member_)(p1_);
    } else {
      (object_->*member_)(p1_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_1_0::base*
NewTessCallback( T1* obj, R (T2::*member)(P1) , typename Identity::type p1) {
  return new _TessMemberResultCallback_1_0(obj, member, p1);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_1_0::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1) , typename Identity::type p1) {
  return new _TessMemberResultCallback_1_0(obj, member, p1);
}
#endif

template 
class _TessFunctionResultCallback_1_0 : public TessResultCallback {
 public:
  typedef TessResultCallback base;
  typedef R (*FunctionSignature)(P1);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;

 public:
  inline _TessFunctionResultCallback_1_0(FunctionSignature function, P1 p1)
    : function_(function),      p1_(p1) { }

  virtual R Run() {
    if (!del) {
      R result = (*function_)(p1_);
      return result;
    } else {
      R result = (*function_)(p1_);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_1_0 : public TessClosure {
 public:
  typedef TessClosure base;
  typedef void (*FunctionSignature)(P1);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;

 public:
  inline _TessFunctionResultCallback_1_0(FunctionSignature function, P1 p1)
    : function_(function),      p1_(p1) { }

  virtual void Run() {
    if (!del) {
      (*function_)(p1_);
    } else {
      (*function_)(p1_);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_1_0::base*
NewTessCallback(R (*function)(P1), typename Identity::type p1) {
  return new _TessFunctionResultCallback_1_0(function, p1);
}

template 
inline typename _TessFunctionResultCallback_1_0::base*
NewPermanentTessCallback(R (*function)(P1), typename Identity::type p1) {
  return new _TessFunctionResultCallback_1_0(function, p1);
}

template 
class _ConstTessMemberResultCallback_2_0 : public TessResultCallback {
 public:
  typedef TessResultCallback base;
  typedef R (T::*MemberSignature)(P1,P2) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _ConstTessMemberResultCallback_2_0(const T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual R Run() {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_2_0 : public TessClosure {
 public:
  typedef TessClosure base;
  typedef void (T::*MemberSignature)(P1,P2) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _ConstTessMemberResultCallback_2_0(const T* object, MemberSignature member, P1 p1, P2 p2)
    :
      object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual void Run() {
    if (!del) {
      (object_->*member_)(p1_,p2_);
    } else {
      (object_->*member_)(p1_,p2_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_2_0::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2) const, typename Identity::type p1, typename Identity::type p2) {
  return new _ConstTessMemberResultCallback_2_0(obj, member, p1, p2);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_2_0::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2) const, typename Identity::type p1, typename Identity::type p2) {
  return new _ConstTessMemberResultCallback_2_0(obj, member, p1, p2);
}
#endif

template 
class _TessMemberResultCallback_2_0 : public TessResultCallback {
 public:
  typedef TessResultCallback base;
  typedef R (T::*MemberSignature)(P1,P2) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessMemberResultCallback_2_0( T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual R Run() {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_2_0 : public TessClosure {
 public:
  typedef TessClosure base;
  typedef void (T::*MemberSignature)(P1,P2) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessMemberResultCallback_2_0( T* object, MemberSignature member, P1 p1, P2 p2)
    :
      object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual void Run() {
    if (!del) {
      (object_->*member_)(p1_,p2_);
    } else {
      (object_->*member_)(p1_,p2_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_2_0::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2) , typename Identity::type p1, typename Identity::type p2) {
  return new _TessMemberResultCallback_2_0(obj, member, p1, p2);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_2_0::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2) , typename Identity::type p1, typename Identity::type p2) {
  return new _TessMemberResultCallback_2_0(obj, member, p1, p2);
}
#endif

template 
class _TessFunctionResultCallback_2_0 : public TessResultCallback {
 public:
  typedef TessResultCallback base;
  typedef R (*FunctionSignature)(P1,P2);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessFunctionResultCallback_2_0(FunctionSignature function, P1 p1, P2 p2)
    : function_(function),      p1_(p1),      p2_(p2) { }

  virtual R Run() {
    if (!del) {
      R result = (*function_)(p1_,p2_);
      return result;
    } else {
      R result = (*function_)(p1_,p2_);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_2_0 : public TessClosure {
 public:
  typedef TessClosure base;
  typedef void (*FunctionSignature)(P1,P2);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessFunctionResultCallback_2_0(FunctionSignature function, P1 p1, P2 p2)
    :
      function_(function),      p1_(p1),      p2_(p2) { }

  virtual void Run() {
    if (!del) {
      (*function_)(p1_,p2_);
    } else {
      (*function_)(p1_,p2_);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_2_0::base*
NewTessCallback(R (*function)(P1,P2), typename Identity::type p1, typename Identity::type p2) {
  return new _TessFunctionResultCallback_2_0(function, p1, p2);
}

template 
inline typename _TessFunctionResultCallback_2_0::base*
NewPermanentTessCallback(R (*function)(P1,P2), typename Identity::type p1, typename Identity::type p2) {
  return new _TessFunctionResultCallback_2_0(function, p1, p2);
}

template 
class _ConstTessMemberResultCallback_3_0 : public TessResultCallback {
 public:
  typedef TessResultCallback base;
  typedef R (T::*MemberSignature)(P1,P2,P3) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _ConstTessMemberResultCallback_3_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    :
      object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual R Run() {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_3_0 : public TessClosure {
 public:
  typedef TessClosure base;
  typedef void (T::*MemberSignature)(P1,P2,P3) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _ConstTessMemberResultCallback_3_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual void Run() {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_);
    } else {
      (object_->*member_)(p1_,p2_,p3_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_3_0::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _ConstTessMemberResultCallback_3_0(obj, member, p1, p2, p3);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_3_0::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _ConstTessMemberResultCallback_3_0(obj, member, p1, p2, p3);
}
#endif

template 
class _TessMemberResultCallback_3_0 : public TessResultCallback {
 public:
  typedef TessResultCallback base;
  typedef R (T::*MemberSignature)(P1,P2,P3) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessMemberResultCallback_3_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual R Run() {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_3_0 : public TessClosure {
 public:
  typedef TessClosure base;
  typedef void (T::*MemberSignature)(P1,P2,P3) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessMemberResultCallback_3_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual void Run() {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_);
    } else {
      (object_->*member_)(p1_,p2_,p3_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_3_0::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessMemberResultCallback_3_0(obj, member, p1, p2, p3);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_3_0::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessMemberResultCallback_3_0(obj, member, p1, p2, p3);
}
#endif

template 
class _TessFunctionResultCallback_3_0 : public TessResultCallback {
 public:
  typedef TessResultCallback base;
  typedef R (*FunctionSignature)(P1,P2,P3);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessFunctionResultCallback_3_0(FunctionSignature function, P1 p1, P2 p2, P3 p3)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual R Run() {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_3_0 : public TessClosure {
 public:
  typedef TessClosure base;
  typedef void (*FunctionSignature)(P1,P2,P3);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessFunctionResultCallback_3_0(FunctionSignature function, P1 p1, P2 p2, P3 p3)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual void Run() {
    if (!del) {
      (*function_)(p1_,p2_,p3_);
    } else {
      (*function_)(p1_,p2_,p3_);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_3_0::base*
NewTessCallback(R (*function)(P1,P2,P3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessFunctionResultCallback_3_0(function, p1, p2, p3);
}

template 
inline typename _TessFunctionResultCallback_3_0::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessFunctionResultCallback_3_0(function, p1, p2, p3);
}

template 
class _ConstTessMemberResultCallback_4_0 : public TessResultCallback {
 public:
  typedef TessResultCallback base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _ConstTessMemberResultCallback_4_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual R Run() {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_4_0 : public TessClosure {
 public:
  typedef TessClosure base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _ConstTessMemberResultCallback_4_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual void Run() {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_4_0::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _ConstTessMemberResultCallback_4_0(obj, member, p1, p2, p3, p4);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_4_0::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _ConstTessMemberResultCallback_4_0(obj, member, p1, p2, p3, p4);
}
#endif

template 
class _TessMemberResultCallback_4_0 : public TessResultCallback {
 public:
  typedef TessResultCallback base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessMemberResultCallback_4_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual R Run() {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_4_0 : public TessClosure {
 public:
  typedef TessClosure base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessMemberResultCallback_4_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual void Run() {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_4_0::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessMemberResultCallback_4_0(obj, member, p1, p2, p3, p4);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_4_0::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessMemberResultCallback_4_0(obj, member, p1, p2, p3, p4);
}
#endif

template 
class _TessFunctionResultCallback_4_0 : public TessResultCallback {
 public:
  typedef TessResultCallback base;
  typedef R (*FunctionSignature)(P1,P2,P3,P4);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessFunctionResultCallback_4_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual R Run() {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,p4_);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,p4_);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_4_0 : public TessClosure {
 public:
  typedef TessClosure base;
  typedef void (*FunctionSignature)(P1,P2,P3,P4);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessFunctionResultCallback_4_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual void Run() {
    if (!del) {
      (*function_)(p1_,p2_,p3_,p4_);
    } else {
      (*function_)(p1_,p2_,p3_,p4_);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_4_0::base*
NewTessCallback(R (*function)(P1,P2,P3,P4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessFunctionResultCallback_4_0(function, p1, p2, p3, p4);
}

template 
inline typename _TessFunctionResultCallback_4_0::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,P4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessFunctionResultCallback_4_0(function, p1, p2, p3, p4);
}

template 
class _ConstTessMemberResultCallback_5_0 : public TessResultCallback {
 public:
  typedef TessResultCallback base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _ConstTessMemberResultCallback_5_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual R Run() {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_5_0 : public TessClosure {
 public:
  typedef TessClosure base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _ConstTessMemberResultCallback_5_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual void Run() {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_5_0::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _ConstTessMemberResultCallback_5_0(obj, member, p1, p2, p3, p4, p5);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_5_0::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _ConstTessMemberResultCallback_5_0(obj, member, p1, p2, p3, p4, p5);
}
#endif

template 
class _TessMemberResultCallback_5_0 : public TessResultCallback {
 public:
  typedef TessResultCallback base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessMemberResultCallback_5_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual R Run() {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_5_0 : public TessClosure {
 public:
  typedef TessClosure base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessMemberResultCallback_5_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual void Run() {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_5_0::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessMemberResultCallback_5_0(obj, member, p1, p2, p3, p4, p5);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_5_0::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessMemberResultCallback_5_0(obj, member, p1, p2, p3, p4, p5);
}
#endif

template 
class _TessFunctionResultCallback_5_0 : public TessResultCallback {
 public:
  typedef TessResultCallback base;
  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessFunctionResultCallback_5_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual R Run() {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_5_0 : public TessClosure {
 public:
  typedef TessClosure base;
  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessFunctionResultCallback_5_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual void Run() {
    if (!del) {
      (*function_)(p1_,p2_,p3_,p4_,p5_);
    } else {
      (*function_)(p1_,p2_,p3_,p4_,p5_);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_5_0::base*
NewTessCallback(R (*function)(P1,P2,P3,P4,P5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessFunctionResultCallback_5_0(function, p1, p2, p3, p4, p5);
}

template 
inline typename _TessFunctionResultCallback_5_0::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessFunctionResultCallback_5_0(function, p1, p2, p3, p4, p5);
}

template 
class _ConstTessMemberResultCallback_6_0 : public TessResultCallback {
 public:
  typedef TessResultCallback base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _ConstTessMemberResultCallback_6_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual R Run() {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_6_0 : public TessClosure {
 public:
  typedef TessClosure base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _ConstTessMemberResultCallback_6_0(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual void Run() {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_6_0::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _ConstTessMemberResultCallback_6_0(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_6_0::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _ConstTessMemberResultCallback_6_0(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

template 
class _TessMemberResultCallback_6_0 : public TessResultCallback {
 public:
  typedef TessResultCallback base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessMemberResultCallback_6_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual R Run() {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_6_0 : public TessClosure {
 public:
  typedef TessClosure base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessMemberResultCallback_6_0( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual void Run() {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_6_0::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessMemberResultCallback_6_0(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_6_0::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessMemberResultCallback_6_0(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

template 
class _TessFunctionResultCallback_6_0 : public TessResultCallback {
 public:
  typedef TessResultCallback base;
  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessFunctionResultCallback_6_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual R Run() {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_6_0 : public TessClosure {
 public:
  typedef TessClosure base;
  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessFunctionResultCallback_6_0(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual void Run() {
    if (!del) {
      (*function_)(p1_,p2_,p3_,p4_,p5_,p6_);
    } else {
      (*function_)(p1_,p2_,p3_,p4_,p5_,p6_);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_6_0::base*
NewTessCallback(R (*function)(P1,P2,P3,P4,P5,P6), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessFunctionResultCallback_6_0(function, p1, p2, p3, p4, p5, p6);
}

template 
inline typename _TessFunctionResultCallback_6_0::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,P6), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessFunctionResultCallback_6_0(function, p1, p2, p3, p4, p5, p6);
}

template 
class TessCallback1 {
 public:
  virtual ~TessCallback1() { }
  virtual void Run(A1) = 0;
};

template 
class TessResultCallback1 {
 public:
  virtual ~TessResultCallback1() { }
  virtual R Run(A1) = 0;
};


template 
class TessCallback2 {
 public:
  virtual ~TessCallback2() { }
  virtual void Run(A1,A2) = 0;
};

template 
class TessResultCallback2 {
 public:
  virtual ~TessResultCallback2() { }
  virtual R Run(A1,A2) = 0;
};

template 
class TessCallback3 {
 public:
  virtual ~TessCallback3() { }
  virtual void Run(A1,A2,A3) = 0;
};

template 
class TessResultCallback3 {
 public:
  virtual ~TessResultCallback3() { }
  virtual R Run(A1,A2,A3) = 0;
};

template 
class TessCallback4 {
 public:
  virtual ~TessCallback4() { }
  virtual void Run(A1,A2,A3,A4) = 0;
};

template 
class TessResultCallback4 {
 public:
  virtual ~TessResultCallback4() { }
  virtual R Run(A1,A2,A3,A4) = 0;
};

template 
class _ConstTessMemberResultCallback_0_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (T::*MemberSignature)(A1) const;

 private:
  const T* object_;
  MemberSignature member_;

 public:
  inline _ConstTessMemberResultCallback_0_1(
     const T* object, MemberSignature member)
    : object_(object),
      member_(member) {
  }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (object_->*member_)(a1);
      return result;
    } else {
      R result = (object_->*member_)(a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_0_1
  : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (T::*MemberSignature)(A1) const;

 private:
  const T* object_;
  MemberSignature member_;

 public:
  inline _ConstTessMemberResultCallback_0_1(
      const T* object, MemberSignature member)
    : object_(object),
      member_(member) {
  }

  virtual void Run(A1 a1) {
    if (!del) {
      (object_->*member_)(a1);
    } else {
      (object_->*member_)(a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_0_1::base*
NewTessCallback(
    const T1* obj, R (T2::*member)(A1) const) {
  return new _ConstTessMemberResultCallback_0_1(
      obj, member);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_0_1::base*
NewPermanentTessCallback(
    const T1* obj, R (T2::*member)(A1) const) {
  return new _ConstTessMemberResultCallback_0_1(
      obj, member);
}
#endif

template 
class _TessMemberResultCallback_0_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (T::*MemberSignature)(A1) ;

 private:
   T* object_;
  MemberSignature member_;

 public:
  inline _TessMemberResultCallback_0_1(
      T* object, MemberSignature member)
    : object_(object),
      member_(member) {
  }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (object_->*member_)(a1);
      return result;
    } else {
      R result = (object_->*member_)(a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_0_1
  : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (T::*MemberSignature)(A1) ;

 private:
   T* object_;
  MemberSignature member_;

 public:
  inline _TessMemberResultCallback_0_1(
       T* object, MemberSignature member)
    : object_(object),
      member_(member) {
  }

  virtual void Run(A1 a1) {
    if (!del) {
      (object_->*member_)(a1);
    } else {
      (object_->*member_)(a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_0_1::base*
NewTessCallback(
     T1* obj, R (T2::*member)(A1) ) {
  return new _TessMemberResultCallback_0_1(
      obj, member);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_0_1::base*
NewPermanentTessCallback(
     T1* obj, R (T2::*member)(A1) ) {
  return new _TessMemberResultCallback_0_1(
      obj, member);
}
#endif

template 
class _TessFunctionResultCallback_0_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (*FunctionSignature)(A1);

 private:
  FunctionSignature function_;

 public:
  inline _TessFunctionResultCallback_0_1(
      FunctionSignature function)
    : function_(function) {
  }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (*function_)(a1);
      return result;
    } else {
      R result = (*function_)(a1);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_0_1
  : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (*FunctionSignature)(A1);

 private:
  FunctionSignature function_;

 public:
  inline _TessFunctionResultCallback_0_1(
      FunctionSignature function)
    : function_(function) {
  }

  virtual void Run(A1 a1) {
    if (!del) {
      (*function_)(a1);
    } else {
      (*function_)(a1);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_0_1::base*
NewTessCallback(R (*function)(A1)) {
  return new _TessFunctionResultCallback_0_1(function);
}

template 
inline typename _TessFunctionResultCallback_0_1::base*
NewPermanentTessCallback(R (*function)(A1)) {
  return new _TessFunctionResultCallback_0_1(function);
}

template 
class _ConstTessMemberResultCallback_1_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (T::*MemberSignature)(P1,A1) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _ConstTessMemberResultCallback_1_1(const T* object, MemberSignature member, P1 p1)
    : object_(object),
      member_(member),      p1_(p1) { }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (object_->*member_)(p1_,a1);
      return result;
    } else {
      R result = (object_->*member_)(p1_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_1_1 : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (T::*MemberSignature)(P1,A1) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _ConstTessMemberResultCallback_1_1(const T* object, MemberSignature member, P1 p1)
    : object_(object),
      member_(member),      p1_(p1) { }

  virtual void Run(A1 a1) {
    if (!del) {
      (object_->*member_)(p1_,a1);
    } else {
      (object_->*member_)(p1_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_1_1::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,A1) const, typename Identity::type p1) {
  return new _ConstTessMemberResultCallback_1_1(obj, member, p1);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_1_1::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,A1) const, typename Identity::type p1) {
  return new _ConstTessMemberResultCallback_1_1(obj, member, p1);
}
#endif

template 
class _TessMemberResultCallback_1_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (T::*MemberSignature)(P1,A1) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _TessMemberResultCallback_1_1( T* object, MemberSignature member, P1 p1)
    : object_(object),
      member_(member),      p1_(p1) { }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (object_->*member_)(p1_,a1);
      return result;
    } else {
      R result = (object_->*member_)(p1_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_1_1 : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (T::*MemberSignature)(P1,A1) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _TessMemberResultCallback_1_1( T* object, MemberSignature member, P1 p1)
    : object_(object),
      member_(member),      p1_(p1) { }

  virtual void Run(A1 a1) {
    if (!del) {
      (object_->*member_)(p1_,a1);
    } else {
      (object_->*member_)(p1_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_1_1::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,A1) , typename Identity::type p1) {
  return new _TessMemberResultCallback_1_1(obj, member, p1);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_1_1::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1) , typename Identity::type p1) {
  return new _TessMemberResultCallback_1_1(obj, member, p1);
}
#endif

template 
class _TessFunctionResultCallback_1_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (*FunctionSignature)(P1,A1);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;

 public:
  inline _TessFunctionResultCallback_1_1(FunctionSignature function, P1 p1)
    : function_(function),      p1_(p1) { }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (*function_)(p1_,a1);
      return result;
    } else {
      R result = (*function_)(p1_,a1);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_1_1 : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (*FunctionSignature)(P1,A1);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;

 public:
  inline _TessFunctionResultCallback_1_1(FunctionSignature function, P1 p1)
    : function_(function),      p1_(p1) { }

  virtual void Run(A1 a1) {
    if (!del) {
      (*function_)(p1_,a1);
    } else {
      (*function_)(p1_,a1);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_1_1::base*
NewTessCallback(R (*function)(P1,A1), typename Identity::type p1) {
  return new _TessFunctionResultCallback_1_1(function, p1);
}

template 
inline typename _TessFunctionResultCallback_1_1::base*
NewPermanentTessCallback(R (*function)(P1,A1), typename Identity::type p1) {
  return new _TessFunctionResultCallback_1_1(function, p1);
}

template 
class _ConstTessMemberResultCallback_2_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (T::*MemberSignature)(P1,P2,A1) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _ConstTessMemberResultCallback_2_1(const T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,a1);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_2_1 : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (T::*MemberSignature)(P1,P2,A1) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _ConstTessMemberResultCallback_2_1(const T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual void Run(A1 a1) {
    if (!del) {
      (object_->*member_)(p1_,p2_,a1);
    } else {
      (object_->*member_)(p1_,p2_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_2_1::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1) const, typename Identity::type p1, typename Identity::type p2) {
  return new _ConstTessMemberResultCallback_2_1(obj, member, p1, p2);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_2_1::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1) const, typename Identity::type p1, typename Identity::type p2) {
  return new _ConstTessMemberResultCallback_2_1(obj, member, p1, p2);
}
#endif

template 
class _TessMemberResultCallback_2_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (T::*MemberSignature)(P1,P2,A1) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessMemberResultCallback_2_1( T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,a1);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_2_1 : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (T::*MemberSignature)(P1,P2,A1) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessMemberResultCallback_2_1( T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual void Run(A1 a1) {
    if (!del) {
      (object_->*member_)(p1_,p2_,a1);
    } else {
      (object_->*member_)(p1_,p2_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_2_1::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,A1) , typename Identity::type p1, typename Identity::type p2) {
  return new _TessMemberResultCallback_2_1(obj, member, p1, p2);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_2_1::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,A1) , typename Identity::type p1, typename Identity::type p2) {
  return new _TessMemberResultCallback_2_1(obj, member, p1, p2);
}
#endif

template 
class _TessFunctionResultCallback_2_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (*FunctionSignature)(P1,P2,A1);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessFunctionResultCallback_2_1(FunctionSignature function, P1 p1, P2 p2)
    : function_(function),      p1_(p1),      p2_(p2) { }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (*function_)(p1_,p2_,a1);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,a1);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_2_1 : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (*FunctionSignature)(P1,P2,A1);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessFunctionResultCallback_2_1(FunctionSignature function, P1 p1, P2 p2)
    : function_(function),      p1_(p1),      p2_(p2) { }

  virtual void Run(A1 a1) {
    if (!del) {
      (*function_)(p1_,p2_,a1);
    } else {
      (*function_)(p1_,p2_,a1);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_2_1::base*
NewTessCallback(R (*function)(P1,P2,A1), typename Identity::type p1, typename Identity::type p2) {
  return new _TessFunctionResultCallback_2_1(function, p1, p2);
}

template 
inline typename _TessFunctionResultCallback_2_1::base*
NewPermanentTessCallback(R (*function)(P1,P2,A1), typename Identity::type p1, typename Identity::type p2) {
  return new _TessFunctionResultCallback_2_1(function, p1, p2);
}

template 
class _ConstTessMemberResultCallback_3_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,A1) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _ConstTessMemberResultCallback_3_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,a1);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_3_1 : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,A1) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _ConstTessMemberResultCallback_3_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual void Run(A1 a1) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,a1);
    } else {
      (object_->*member_)(p1_,p2_,p3_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_3_1::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _ConstTessMemberResultCallback_3_1(obj, member, p1, p2, p3);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_3_1::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _ConstTessMemberResultCallback_3_1(obj, member, p1, p2, p3);
}
#endif

template 
class _TessMemberResultCallback_3_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,A1) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessMemberResultCallback_3_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,a1);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_3_1 : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,A1) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessMemberResultCallback_3_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual void Run(A1 a1) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,a1);
    } else {
      (object_->*member_)(p1_,p2_,p3_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_3_1::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessMemberResultCallback_3_1(obj, member, p1, p2, p3);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_3_1::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessMemberResultCallback_3_1(obj, member, p1, p2, p3);
}
#endif

template 
class _TessFunctionResultCallback_3_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (*FunctionSignature)(P1,P2,P3,A1);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessFunctionResultCallback_3_1(FunctionSignature function, P1 p1, P2 p2, P3 p3)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,a1);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,a1);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_3_1 : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (*FunctionSignature)(P1,P2,P3,A1);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessFunctionResultCallback_3_1(FunctionSignature function, P1 p1, P2 p2, P3 p3)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual void Run(A1 a1) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,a1);
    } else {
      (*function_)(p1_,p2_,p3_,a1);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_3_1::base*
NewTessCallback(R (*function)(P1,P2,P3,A1), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessFunctionResultCallback_3_1(function, p1, p2, p3);
}

template 
inline typename _TessFunctionResultCallback_3_1::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,A1), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessFunctionResultCallback_3_1(function, p1, p2, p3);
}

template 
class _ConstTessMemberResultCallback_4_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _ConstTessMemberResultCallback_4_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_4_1 : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _ConstTessMemberResultCallback_4_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual void Run(A1 a1) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_4_1::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _ConstTessMemberResultCallback_4_1(obj, member, p1, p2, p3, p4);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_4_1::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _ConstTessMemberResultCallback_4_1(obj, member, p1, p2, p3, p4);
}
#endif

template 
class _TessMemberResultCallback_4_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessMemberResultCallback_4_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_4_1 : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessMemberResultCallback_4_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual void Run(A1 a1) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_4_1::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessMemberResultCallback_4_1(obj, member, p1, p2, p3, p4);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_4_1::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessMemberResultCallback_4_1(obj, member, p1, p2, p3, p4);
}
#endif

template 
class _TessFunctionResultCallback_4_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (*FunctionSignature)(P1,P2,P3,P4,A1);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessFunctionResultCallback_4_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,p4_,a1);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,p4_,a1);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_4_1 : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (*FunctionSignature)(P1,P2,P3,P4,A1);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessFunctionResultCallback_4_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual void Run(A1 a1) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,p4_,a1);
    } else {
      (*function_)(p1_,p2_,p3_,p4_,a1);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_4_1::base*
NewTessCallback(R (*function)(P1,P2,P3,P4,A1), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessFunctionResultCallback_4_1(function, p1, p2, p3, p4);
}

template 
inline typename _TessFunctionResultCallback_4_1::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,A1), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessFunctionResultCallback_4_1(function, p1, p2, p3, p4);
}

template 
class _ConstTessMemberResultCallback_5_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _ConstTessMemberResultCallback_5_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_5_1 : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _ConstTessMemberResultCallback_5_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual void Run(A1 a1) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_5_1::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _ConstTessMemberResultCallback_5_1(obj, member, p1, p2, p3, p4, p5);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_5_1::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _ConstTessMemberResultCallback_5_1(obj, member, p1, p2, p3, p4, p5);
}
#endif

template 
class _TessMemberResultCallback_5_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessMemberResultCallback_5_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_5_1 : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessMemberResultCallback_5_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual void Run(A1 a1) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_5_1::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessMemberResultCallback_5_1(obj, member, p1, p2, p3, p4, p5);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_5_1::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessMemberResultCallback_5_1(obj, member, p1, p2, p3, p4, p5);
}
#endif

template 
class _TessFunctionResultCallback_5_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessFunctionResultCallback_5_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_5_1 : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessFunctionResultCallback_5_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual void Run(A1 a1) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,p4_,p5_,a1);
    } else {
      (*function_)(p1_,p2_,p3_,p4_,p5_,a1);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_5_1::base*
NewTessCallback(R (*function)(P1,P2,P3,P4,P5,A1), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessFunctionResultCallback_5_1(function, p1, p2, p3, p4, p5);
}

template 
inline typename _TessFunctionResultCallback_5_1::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,A1), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessFunctionResultCallback_5_1(function, p1, p2, p3, p4, p5);
}

template 
class _ConstTessMemberResultCallback_6_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _ConstTessMemberResultCallback_6_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_6_1 : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _ConstTessMemberResultCallback_6_1(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual void Run(A1 a1) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_6_1::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _ConstTessMemberResultCallback_6_1(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_6_1::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _ConstTessMemberResultCallback_6_1(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

template 
class _TessMemberResultCallback_6_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessMemberResultCallback_6_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_6_1 : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessMemberResultCallback_6_1( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual void Run(A1 a1) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_6_1::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessMemberResultCallback_6_1(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_6_1::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessMemberResultCallback_6_1(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

template 
class _TessFunctionResultCallback_6_1 : public TessResultCallback1 {
 public:
  typedef TessResultCallback1 base;
  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessFunctionResultCallback_6_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual R Run(A1 a1) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_6_1 : public TessCallback1 {
 public:
  typedef TessCallback1 base;
  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessFunctionResultCallback_6_1(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual void Run(A1 a1) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
    } else {
      (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_6_1::base*
NewTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessFunctionResultCallback_6_1(function, p1, p2, p3, p4, p5, p6);
}

template 
inline typename _TessFunctionResultCallback_6_1::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessFunctionResultCallback_6_1(function, p1, p2, p3, p4, p5, p6);
}

template 
class _ConstTessMemberResultCallback_0_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (T::*MemberSignature)(A1,A2) const;

 private:
  const T* object_;
  MemberSignature member_;

 public:
  inline _ConstTessMemberResultCallback_0_2(
     const T* object, MemberSignature member)
    : object_(object),
      member_(member) {
  }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (object_->*member_)(a1,a2);
      return result;
    } else {
      R result = (object_->*member_)(a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_0_2
  : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (T::*MemberSignature)(A1,A2) const;

 private:
  const T* object_;
  MemberSignature member_;

 public:
  inline _ConstTessMemberResultCallback_0_2(
      const T* object, MemberSignature member)
    : object_(object),
      member_(member) {
  }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (object_->*member_)(a1,a2);
    } else {
      (object_->*member_)(a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_0_2::base*
NewTessCallback(
    const T1* obj, R (T2::*member)(A1,A2) const) {
  return new _ConstTessMemberResultCallback_0_2(
      obj, member);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_0_2::base*
NewPermanentTessCallback(
    const T1* obj, R (T2::*member)(A1,A2) const) {
  return new _ConstTessMemberResultCallback_0_2(
      obj, member);
}
#endif

template 
class _TessMemberResultCallback_0_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (T::*MemberSignature)(A1,A2) ;

 private:
   T* object_;
  MemberSignature member_;

 public:
  inline _TessMemberResultCallback_0_2(
      T* object, MemberSignature member)
    : object_(object),
      member_(member) {
  }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (object_->*member_)(a1,a2);
      return result;
    } else {
      R result = (object_->*member_)(a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_0_2
  : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (T::*MemberSignature)(A1,A2) ;

 private:
   T* object_;
  MemberSignature member_;

 public:
  inline _TessMemberResultCallback_0_2(
       T* object, MemberSignature member)
    : object_(object),
      member_(member) {
  }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (object_->*member_)(a1,a2);
    } else {
      (object_->*member_)(a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_0_2::base*
NewTessCallback(
     T1* obj, R (T2::*member)(A1,A2) ) {
  return new _TessMemberResultCallback_0_2(
      obj, member);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_0_2::base*
NewPermanentTessCallback(
     T1* obj, R (T2::*member)(A1,A2) ) {
  return new _TessMemberResultCallback_0_2(
      obj, member);
}
#endif

template 
class _TessFunctionResultCallback_0_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (*FunctionSignature)(A1,A2);

 private:
  FunctionSignature function_;

 public:
  inline _TessFunctionResultCallback_0_2(
      FunctionSignature function)
    : function_(function) {
  }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (*function_)(a1,a2);
      return result;
    } else {
      R result = (*function_)(a1,a2);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_0_2
  : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (*FunctionSignature)(A1,A2);

 private:
  FunctionSignature function_;

 public:
  inline _TessFunctionResultCallback_0_2(
      FunctionSignature function)
    : function_(function) {
  }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (*function_)(a1,a2);
    } else {
      (*function_)(a1,a2);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_0_2::base*
NewTessCallback(R (*function)(A1,A2)) {
  return new _TessFunctionResultCallback_0_2(function);
}

template 
inline typename _TessFunctionResultCallback_0_2::base*
NewPermanentTessCallback(R (*function)(A1,A2)) {
  return new _TessFunctionResultCallback_0_2(function);
}

template 
class _ConstTessMemberResultCallback_1_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (T::*MemberSignature)(P1,A1,A2) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _ConstTessMemberResultCallback_1_2(const T* object, MemberSignature member, P1 p1)
    : object_(object),
      member_(member),      p1_(p1) { }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (object_->*member_)(p1_,a1,a2);
      return result;
    } else {
      R result = (object_->*member_)(p1_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_1_2 : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (T::*MemberSignature)(P1,A1,A2) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _ConstTessMemberResultCallback_1_2(const T* object, MemberSignature member, P1 p1)
    : object_(object),
      member_(member),      p1_(p1) { }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (object_->*member_)(p1_,a1,a2);
    } else {
      (object_->*member_)(p1_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_1_2::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2) const, typename Identity::type p1) {
  return new _ConstTessMemberResultCallback_1_2(obj, member, p1);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_1_2::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2) const, typename Identity::type p1) {
  return new _ConstTessMemberResultCallback_1_2(obj, member, p1);
}
#endif

template 
class _TessMemberResultCallback_1_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (T::*MemberSignature)(P1,A1,A2) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _TessMemberResultCallback_1_2( T* object, MemberSignature member, P1 p1)
    : object_(object),
      member_(member),      p1_(p1) { }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (object_->*member_)(p1_,a1,a2);
      return result;
    } else {
      R result = (object_->*member_)(p1_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_1_2 : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (T::*MemberSignature)(P1,A1,A2) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _TessMemberResultCallback_1_2( T* object, MemberSignature member, P1 p1)
    : object_(object),
      member_(member),      p1_(p1) { }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (object_->*member_)(p1_,a1,a2);
    } else {
      (object_->*member_)(p1_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_1_2::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,A1,A2) , typename Identity::type p1) {
  return new _TessMemberResultCallback_1_2(obj, member, p1);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_1_2::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1,A2) , typename Identity::type p1) {
  return new _TessMemberResultCallback_1_2(obj, member, p1);
}
#endif

template 
class _TessFunctionResultCallback_1_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (*FunctionSignature)(P1,A1,A2);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;

 public:
  inline _TessFunctionResultCallback_1_2(FunctionSignature function, P1 p1)
    : function_(function),      p1_(p1) { }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (*function_)(p1_,a1,a2);
      return result;
    } else {
      R result = (*function_)(p1_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_1_2 : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (*FunctionSignature)(P1,A1,A2);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;

 public:
  inline _TessFunctionResultCallback_1_2(FunctionSignature function, P1 p1)
    : function_(function),      p1_(p1) { }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (*function_)(p1_,a1,a2);
    } else {
      (*function_)(p1_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_1_2::base*
NewTessCallback(R (*function)(P1,A1,A2), typename Identity::type p1) {
  return new _TessFunctionResultCallback_1_2(function, p1);
}

template 
inline typename _TessFunctionResultCallback_1_2::base*
NewPermanentTessCallback(R (*function)(P1,A1,A2), typename Identity::type p1) {
  return new _TessFunctionResultCallback_1_2(function, p1);
}

template 
class _ConstTessMemberResultCallback_2_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (T::*MemberSignature)(P1,P2,A1,A2) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _ConstTessMemberResultCallback_2_2(const T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,a1,a2);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_2_2 : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (T::*MemberSignature)(P1,P2,A1,A2) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _ConstTessMemberResultCallback_2_2(const T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (object_->*member_)(p1_,p2_,a1,a2);
    } else {
      (object_->*member_)(p1_,p2_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_2_2::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2) const, typename Identity::type p1, typename Identity::type p2) {
  return new _ConstTessMemberResultCallback_2_2(obj, member, p1, p2);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_2_2::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2) const, typename Identity::type p1, typename Identity::type p2) {
  return new _ConstTessMemberResultCallback_2_2(obj, member, p1, p2);
}
#endif

template 
class _TessMemberResultCallback_2_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (T::*MemberSignature)(P1,P2,A1,A2) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessMemberResultCallback_2_2( T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,a1,a2);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_2_2 : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (T::*MemberSignature)(P1,P2,A1,A2) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessMemberResultCallback_2_2( T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (object_->*member_)(p1_,p2_,a1,a2);
    } else {
      (object_->*member_)(p1_,p2_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_2_2::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2) , typename Identity::type p1, typename Identity::type p2) {
  return new _TessMemberResultCallback_2_2(obj, member, p1, p2);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_2_2::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2) , typename Identity::type p1, typename Identity::type p2) {
  return new _TessMemberResultCallback_2_2(obj, member, p1, p2);
}
#endif

template 
class _TessFunctionResultCallback_2_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (*FunctionSignature)(P1,P2,A1,A2);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessFunctionResultCallback_2_2(FunctionSignature function, P1 p1, P2 p2)
    : function_(function),      p1_(p1),      p2_(p2) { }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (*function_)(p1_,p2_,a1,a2);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_2_2 : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (*FunctionSignature)(P1,P2,A1,A2);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessFunctionResultCallback_2_2(FunctionSignature function, P1 p1, P2 p2)
    : function_(function),      p1_(p1),      p2_(p2) { }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (*function_)(p1_,p2_,a1,a2);
    } else {
      (*function_)(p1_,p2_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_2_2::base*
NewTessCallback(R (*function)(P1,P2,A1,A2), typename Identity::type p1, typename Identity::type p2) {
  return new _TessFunctionResultCallback_2_2(function, p1, p2);
}

template 
inline typename _TessFunctionResultCallback_2_2::base*
NewPermanentTessCallback(R (*function)(P1,P2,A1,A2), typename Identity::type p1, typename Identity::type p2) {
  return new _TessFunctionResultCallback_2_2(function, p1, p2);
}

template 
class _ConstTessMemberResultCallback_3_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _ConstTessMemberResultCallback_3_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,a1,a2);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_3_2 : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _ConstTessMemberResultCallback_3_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,a1,a2);
    } else {
      (object_->*member_)(p1_,p2_,p3_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_3_2::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _ConstTessMemberResultCallback_3_2(obj, member, p1, p2, p3);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_3_2::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _ConstTessMemberResultCallback_3_2(obj, member, p1, p2, p3);
}
#endif

template 
class _TessMemberResultCallback_3_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessMemberResultCallback_3_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,a1,a2);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_3_2 : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessMemberResultCallback_3_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,a1,a2);
    } else {
      (object_->*member_)(p1_,p2_,p3_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_3_2::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1,A2) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessMemberResultCallback_3_2(obj, member, p1, p2, p3);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_3_2::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1,A2) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessMemberResultCallback_3_2(obj, member, p1, p2, p3);
}
#endif

template 
class _TessFunctionResultCallback_3_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (*FunctionSignature)(P1,P2,P3,A1,A2);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessFunctionResultCallback_3_2(FunctionSignature function, P1 p1, P2 p2, P3 p3)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,a1,a2);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_3_2 : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (*FunctionSignature)(P1,P2,P3,A1,A2);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessFunctionResultCallback_3_2(FunctionSignature function, P1 p1, P2 p2, P3 p3)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,a1,a2);
    } else {
      (*function_)(p1_,p2_,p3_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_3_2::base*
NewTessCallback(R (*function)(P1,P2,P3,A1,A2), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessFunctionResultCallback_3_2(function, p1, p2, p3);
}

template 
inline typename _TessFunctionResultCallback_3_2::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,A1,A2), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessFunctionResultCallback_3_2(function, p1, p2, p3);
}

template 
class _ConstTessMemberResultCallback_4_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _ConstTessMemberResultCallback_4_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_4_2 : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _ConstTessMemberResultCallback_4_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_4_2::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _ConstTessMemberResultCallback_4_2(obj, member, p1, p2, p3, p4);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_4_2::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _ConstTessMemberResultCallback_4_2(obj, member, p1, p2, p3, p4);
}
#endif

template 
class _TessMemberResultCallback_4_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessMemberResultCallback_4_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_4_2 : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessMemberResultCallback_4_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_4_2::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessMemberResultCallback_4_2(obj, member, p1, p2, p3, p4);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_4_2::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessMemberResultCallback_4_2(obj, member, p1, p2, p3, p4);
}
#endif

template 
class _TessFunctionResultCallback_4_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (*FunctionSignature)(P1,P2,P3,P4,A1,A2);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessFunctionResultCallback_4_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_4_2 : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (*FunctionSignature)(P1,P2,P3,P4,A1,A2);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessFunctionResultCallback_4_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,p4_,a1,a2);
    } else {
      (*function_)(p1_,p2_,p3_,p4_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_4_2::base*
NewTessCallback(R (*function)(P1,P2,P3,P4,A1,A2), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessFunctionResultCallback_4_2(function, p1, p2, p3, p4);
}

template 
inline typename _TessFunctionResultCallback_4_2::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,A1,A2), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessFunctionResultCallback_4_2(function, p1, p2, p3, p4);
}

template 
class _ConstTessMemberResultCallback_5_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _ConstTessMemberResultCallback_5_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_5_2 : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _ConstTessMemberResultCallback_5_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_5_2::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _ConstTessMemberResultCallback_5_2(obj, member, p1, p2, p3, p4, p5);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_5_2::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _ConstTessMemberResultCallback_5_2(obj, member, p1, p2, p3, p4, p5);
}
#endif

template 
class _TessMemberResultCallback_5_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessMemberResultCallback_5_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_5_2 : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessMemberResultCallback_5_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_5_2::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessMemberResultCallback_5_2(obj, member, p1, p2, p3, p4, p5);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_5_2::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessMemberResultCallback_5_2(obj, member, p1, p2, p3, p4, p5);
}
#endif

template 
class _TessFunctionResultCallback_5_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessFunctionResultCallback_5_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_5_2 : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessFunctionResultCallback_5_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
    } else {
      (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_5_2::base*
NewTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessFunctionResultCallback_5_2(function, p1, p2, p3, p4, p5);
}

template 
inline typename _TessFunctionResultCallback_5_2::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessFunctionResultCallback_5_2(function, p1, p2, p3, p4, p5);
}

template 
class _ConstTessMemberResultCallback_6_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _ConstTessMemberResultCallback_6_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_6_2 : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _ConstTessMemberResultCallback_6_2(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_6_2::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _ConstTessMemberResultCallback_6_2(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_6_2::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _ConstTessMemberResultCallback_6_2(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

template 
class _TessMemberResultCallback_6_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessMemberResultCallback_6_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_6_2 : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessMemberResultCallback_6_2( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_6_2::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessMemberResultCallback_6_2(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_6_2::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessMemberResultCallback_6_2(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

template 
class _TessFunctionResultCallback_6_2 : public TessResultCallback2 {
 public:
  typedef TessResultCallback2 base;
  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessFunctionResultCallback_6_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual R Run(A1 a1,A2 a2) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_6_2 : public TessCallback2 {
 public:
  typedef TessCallback2 base;
  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessFunctionResultCallback_6_2(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual void Run(A1 a1,A2 a2) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
    } else {
      (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_6_2::base*
NewTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessFunctionResultCallback_6_2(function, p1, p2, p3, p4, p5, p6);
}

template 
inline typename _TessFunctionResultCallback_6_2::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessFunctionResultCallback_6_2(function, p1, p2, p3, p4, p5, p6);
}

template 
class _ConstTessMemberResultCallback_0_3 : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (T::*MemberSignature)(A1,A2,A3) const;

 private:
  const T* object_;
  MemberSignature member_;

 public:
  inline _ConstTessMemberResultCallback_0_3(
     const T* object, MemberSignature member)
    : object_(object),
      member_(member) {
  }

  virtual R Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      R result = (object_->*member_)(a1,a2,a3);
      return result;
    } else {
      R result = (object_->*member_)(a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_0_3
  : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (T::*MemberSignature)(A1,A2,A3) const;

 private:
  const T* object_;
  MemberSignature member_;

 public:
  inline _ConstTessMemberResultCallback_0_3(
      const T* object, MemberSignature member)
    : object_(object),
      member_(member) {
  }

  virtual void Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      (object_->*member_)(a1,a2,a3);
    } else {
      (object_->*member_)(a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_0_3::base*
NewTessCallback(
    const T1* obj, R (T2::*member)(A1,A2,A3) const) {
  return new _ConstTessMemberResultCallback_0_3(
      obj, member);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_0_3::base*
NewPermanentTessCallback(
    const T1* obj, R (T2::*member)(A1,A2,A3) const) {
  return new _ConstTessMemberResultCallback_0_3(
      obj, member);
}
#endif

template 
class _TessMemberResultCallback_0_3 : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (T::*MemberSignature)(A1,A2,A3) ;

 private:
   T* object_;
  MemberSignature member_;

 public:
  inline _TessMemberResultCallback_0_3(
      T* object, MemberSignature member)
    : object_(object),
      member_(member) {
  }

  virtual R Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      R result = (object_->*member_)(a1,a2,a3);
      return result;
    } else {
      R result = (object_->*member_)(a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_0_3
  : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (T::*MemberSignature)(A1,A2,A3) ;

 private:
   T* object_;
  MemberSignature member_;

 public:
  inline _TessMemberResultCallback_0_3(
       T* object, MemberSignature member)
    : object_(object),
      member_(member) {
  }

  virtual void Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      (object_->*member_)(a1,a2,a3);
    } else {
      (object_->*member_)(a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_0_3::base*
NewTessCallback(
     T1* obj, R (T2::*member)(A1,A2,A3) ) {
  return new _TessMemberResultCallback_0_3(
      obj, member);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_0_3::base*
NewPermanentTessCallback(
     T1* obj, R (T2::*member)(A1,A2,A3) ) {
  return new _TessMemberResultCallback_0_3(
      obj, member);
}
#endif

template 
class _TessFunctionResultCallback_0_3 : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (*FunctionSignature)(A1,A2,A3);

 private:
  FunctionSignature function_;

 public:
  inline _TessFunctionResultCallback_0_3(
      FunctionSignature function)
    : function_(function) {
  }

  virtual R Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      R result = (*function_)(a1,a2,a3);
      return result;
    } else {
      R result = (*function_)(a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_0_3
  : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (*FunctionSignature)(A1,A2,A3);

 private:
  FunctionSignature function_;

 public:
  inline _TessFunctionResultCallback_0_3(
      FunctionSignature function)
    : function_(function) {
  }

  virtual void Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      (*function_)(a1,a2,a3);
    } else {
      (*function_)(a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_0_3::base*
NewTessCallback(R (*function)(A1,A2,A3)) {
  return new _TessFunctionResultCallback_0_3(function);
}

template 
inline typename _TessFunctionResultCallback_0_3::base*
NewPermanentTessCallback(R (*function)(A1,A2,A3)) {
  return new _TessFunctionResultCallback_0_3(function);
}

template 
class _ConstTessMemberResultCallback_1_3
  : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (T::*MemberSignature)(P1,A1,A2,A3) const;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _ConstTessMemberResultCallback_1_3(T* object,
                                            MemberSignature member, P1 p1)
    : object_(object), member_(member), p1_(p1) { }

  virtual R Run(A1 a1, A2 a2, A3 a3) {
    if (!del) {
      R result = (object_->*member_)(p1_,a1,a2,a3);
      return result;
    } else {
      R result = (object_->*member_)(p1_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_1_3
  : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (T::*MemberSignature)(P1,A1,A2,A3) const;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _ConstTessMemberResultCallback_1_3(T* object,
                                            MemberSignature member, P1 p1)
    : object_(object), member_(member), p1_(p1) { }

  virtual void Run(A1 a1, A2 a2, A3 a3) {
    if (!del) {
      (object_->*member_)(p1_,a1,a2,a3);
    } else {
      (object_->*member_)(p1_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_1_3::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3) , typename Identity::type p1) {
  return new _ConstTessMemberResultCallback_1_3(obj, member, p1);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_1_3::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3) , typename Identity::type p1) {
  return new _ConstTessMemberResultCallback_1_3(obj, member, p1);
}
#endif

template 
class _TessMemberResultCallback_1_3 : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (T::*MemberSignature)(P1,A1,A2,A3) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _TessMemberResultCallback_1_3(T* object,
                                        MemberSignature member, P1 p1)
    : object_(object), member_(member), p1_(p1) { }

  virtual R Run(A1 a1, A2 a2, A3 a3) {
    if (!del) {
      R result = (object_->*member_)(p1_,a1,a2,a3);
      return result;
    } else {
      R result = (object_->*member_)(p1_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_1_3
  : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (T::*MemberSignature)(P1,A1,A2,A3) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _TessMemberResultCallback_1_3(T* object,
                                        MemberSignature member, P1 p1)
    : object_(object), member_(member), p1_(p1) { }

  virtual void Run(A1 a1, A2 a2, A3 a3) {
    if (!del) {
      (object_->*member_)(p1_,a1,a2,a3);
    } else {
      (object_->*member_)(p1_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_1_3::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3) , typename Identity::type p1) {
  return new _TessMemberResultCallback_1_3(obj, member, p1);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_1_3::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3) , typename Identity::type p1) {
  return new _TessMemberResultCallback_1_3(obj, member, p1);
}
#endif

template 
class _TessFunctionResultCallback_1_3 : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef R (*FunctionSignature)(P1,A1,A2,A3);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;

 public:
  inline _TessFunctionResultCallback_1_3(FunctionSignature function, P1 p1)
    : function_(function), p1_(p1) { }

  virtual R Run(A1 a1, A2 a2, A3 a3) {
    if (!del) {
      R result = (*function_)(p1_,a1,a2,a3);
      return result;
    } else {
      R result = (*function_)(p1_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_1_3
  : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (*FunctionSignature)(P1,A1,A2,A3);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;

 public:
  inline _TessFunctionResultCallback_1_3(FunctionSignature function, P1 p1)
    : function_(function), p1_(p1) { }

  virtual void Run(A1 a1, A2 a2, A3 a3) {
    if (!del) {
      (*function_)(p1_,a1,a2,a3);
    } else {
      (*function_)(p1_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_1_3::base*
NewTessCallback(R (*function)(P1,A1,A2,A3), typename Identity::type p1) {
  return new _TessFunctionResultCallback_1_3(function, p1);
}

template 
inline typename _TessFunctionResultCallback_1_3::base*
NewPermanentTessCallback(R (*function)(P1,A1,A2,A3), typename Identity::type p1) {
  return new _TessFunctionResultCallback_1_3(function, p1);
}

template 
class _ConstTessMemberResultCallback_2_3 : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _ConstTessMemberResultCallback_2_3(const T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual R Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,a1,a2,a3);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_2_3 : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _ConstTessMemberResultCallback_2_3(const T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual void Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      (object_->*member_)(p1_,p2_,a1,a2,a3);
    } else {
      (object_->*member_)(p1_,p2_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_2_3::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2) {
  return new _ConstTessMemberResultCallback_2_3(obj, member, p1, p2);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_2_3::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2) {
  return new _ConstTessMemberResultCallback_2_3(obj, member, p1, p2);
}
#endif

template 
class _TessMemberResultCallback_2_3 : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessMemberResultCallback_2_3( T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }


  virtual R Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,a1,a2,a3);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_2_3 : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessMemberResultCallback_2_3( T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual void Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      (object_->*member_)(p1_,p2_,a1,a2,a3);
    } else {
      (object_->*member_)(p1_,p2_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_2_3::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2) {
  return new _TessMemberResultCallback_2_3(obj, member, p1, p2);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_2_3::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2) {
  return new _TessMemberResultCallback_2_3(obj, member, p1, p2);
}
#endif

template 
class _TessFunctionResultCallback_2_3 : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (*FunctionSignature)(P1,P2,A1,A2,A3);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessFunctionResultCallback_2_3(FunctionSignature function, P1 p1, P2 p2)
    : function_(function),      p1_(p1),      p2_(p2) { }

  virtual R Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      R result = (*function_)(p1_,p2_,a1,a2,a3);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_2_3 : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (*FunctionSignature)(P1,P2,A1,A2,A3);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessFunctionResultCallback_2_3(FunctionSignature function, P1 p1, P2 p2)
    : function_(function),      p1_(p1),      p2_(p2) { }

  virtual void Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      (*function_)(p1_,p2_,a1,a2,a3);
    } else {
      (*function_)(p1_,p2_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_2_3::base*
NewTessCallback(R (*function)(P1,P2,A1,A2,A3), typename Identity::type p1, typename Identity::type p2) {
  return new _TessFunctionResultCallback_2_3(function, p1, p2);
}

template 
inline typename _TessFunctionResultCallback_2_3::base*
NewPermanentTessCallback(R (*function)(P1,P2,A1,A2,A3), typename Identity::type p1, typename Identity::type p2) {
  return new _TessFunctionResultCallback_2_3(function, p1, p2);
}

template 
class _ConstTessMemberResultCallback_3_3 : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _ConstTessMemberResultCallback_3_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual R Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_3_3 : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _ConstTessMemberResultCallback_3_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual void Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
    } else {
      (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_3_3::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _ConstTessMemberResultCallback_3_3(obj, member, p1, p2, p3);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_3_3::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _ConstTessMemberResultCallback_3_3(obj, member, p1, p2, p3);
}
#endif

template 
class _TessMemberResultCallback_3_3 : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessMemberResultCallback_3_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual R Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_3_3 : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessMemberResultCallback_3_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual void Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
    } else {
      (object_->*member_)(p1_,p2_,p3_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_3_3::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessMemberResultCallback_3_3(obj, member, p1, p2, p3);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_3_3::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessMemberResultCallback_3_3(obj, member, p1, p2, p3);
}
#endif

template 
class _TessFunctionResultCallback_3_3 : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (*FunctionSignature)(P1,P2,P3,A1,A2,A3);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessFunctionResultCallback_3_3(FunctionSignature function, P1 p1, P2 p2, P3 p3)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual R Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,a1,a2,a3);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_3_3 : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (*FunctionSignature)(P1,P2,P3,A1,A2,A3);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessFunctionResultCallback_3_3(FunctionSignature function, P1 p1, P2 p2, P3 p3)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual void Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,a1,a2,a3);
    } else {
      (*function_)(p1_,p2_,p3_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_3_3::base*
NewTessCallback(R (*function)(P1,P2,P3,A1,A2,A3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessFunctionResultCallback_3_3(function, p1, p2, p3);
}

template 
inline typename _TessFunctionResultCallback_3_3::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,A1,A2,A3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessFunctionResultCallback_3_3(function, p1, p2, p3);
}

template 
class _ConstTessMemberResultCallback_4_3 : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _ConstTessMemberResultCallback_4_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual R Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_4_3 : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _ConstTessMemberResultCallback_4_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual void Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_4_3::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _ConstTessMemberResultCallback_4_3(obj, member, p1, p2, p3, p4);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_4_3::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _ConstTessMemberResultCallback_4_3(obj, member, p1, p2, p3, p4);
}
#endif

template 
class _TessMemberResultCallback_4_3 : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessMemberResultCallback_4_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual R Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_4_3 : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessMemberResultCallback_4_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual void Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_4_3::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessMemberResultCallback_4_3(obj, member, p1, p2, p3, p4);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_4_3::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessMemberResultCallback_4_3(obj, member, p1, p2, p3, p4);
}
#endif

template 
class _TessFunctionResultCallback_4_3 : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessFunctionResultCallback_4_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual R Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_4_3 : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessFunctionResultCallback_4_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual void Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3);
    } else {
      (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_4_3::base*
NewTessCallback(R (*function)(P1,P2,P3,P4,A1,A2,A3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessFunctionResultCallback_4_3(function, p1, p2, p3, p4);
}

template 
inline typename _TessFunctionResultCallback_4_3::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,A1,A2,A3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessFunctionResultCallback_4_3(function, p1, p2, p3, p4);
}

template 
class _ConstTessMemberResultCallback_5_3 : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _ConstTessMemberResultCallback_5_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual R Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_5_3 : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _ConstTessMemberResultCallback_5_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual void Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_5_3::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _ConstTessMemberResultCallback_5_3(obj, member, p1, p2, p3, p4, p5);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_5_3::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _ConstTessMemberResultCallback_5_3(obj, member, p1, p2, p3, p4, p5);
}
#endif

template 
class _TessMemberResultCallback_5_3 : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessMemberResultCallback_5_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual R Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_5_3 : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessMemberResultCallback_5_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual void Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_5_3::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessMemberResultCallback_5_3(obj, member, p1, p2, p3, p4, p5);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_5_3::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessMemberResultCallback_5_3(obj, member, p1, p2, p3, p4, p5);
}
#endif

template 
class _TessFunctionResultCallback_5_3 : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessFunctionResultCallback_5_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual R Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_5_3 : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessFunctionResultCallback_5_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual void Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
    } else {
      (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_5_3::base*
NewTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2,A3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessFunctionResultCallback_5_3(function, p1, p2, p3, p4, p5);
}

template 
inline typename _TessFunctionResultCallback_5_3::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2,A3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessFunctionResultCallback_5_3(function, p1, p2, p3, p4, p5);
}

template 
class _ConstTessMemberResultCallback_6_3 : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _ConstTessMemberResultCallback_6_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual R Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_6_3 : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _ConstTessMemberResultCallback_6_3(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual void Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_6_3::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _ConstTessMemberResultCallback_6_3(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_6_3::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _ConstTessMemberResultCallback_6_3(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

template 
class _TessMemberResultCallback_6_3 : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessMemberResultCallback_6_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual R Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_6_3 : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessMemberResultCallback_6_3( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual void Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_6_3::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessMemberResultCallback_6_3(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_6_3::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessMemberResultCallback_6_3(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

template 
class _TessFunctionResultCallback_6_3 : public TessResultCallback3 {
 public:
  typedef TessResultCallback3 base;
  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessFunctionResultCallback_6_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual R Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_6_3 : public TessCallback3 {
 public:
  typedef TessCallback3 base;
  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessFunctionResultCallback_6_3(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual void Run(A1 a1,A2 a2,A3 a3) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
    } else {
      (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_6_3::base*
NewTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2,A3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessFunctionResultCallback_6_3(function, p1, p2, p3, p4, p5, p6);
}

template 
inline typename _TessFunctionResultCallback_6_3::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2,A3), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessFunctionResultCallback_6_3(function, p1, p2, p3, p4, p5, p6);
}

template 
class _ConstTessMemberResultCallback_0_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (T::*MemberSignature)(A1,A2,A3,A4) const;

 private:
  const T* object_;
  MemberSignature member_;

 public:
  inline _ConstTessMemberResultCallback_0_4(const T* object, MemberSignature member)
    : object_(object),
      member_(member) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (object_->*member_)(a1,a2,a3,a4);
      return result;
    } else {
      R result = (object_->*member_)(a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_0_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (T::*MemberSignature)(A1,A2,A3,A4) const;

 private:
  const T* object_;
  MemberSignature member_;

 public:
  inline _ConstTessMemberResultCallback_0_4(const T* object, MemberSignature member)
    : object_(object),
      member_(member) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (object_->*member_)(a1,a2,a3,a4);
    } else {
      (object_->*member_)(a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_0_4::base*
NewTessCallback(const T1* obj, R (T2::*member)(A1,A2,A3,A4) const) {
  return new _ConstTessMemberResultCallback_0_4(obj, member);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_0_4::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(A1,A2,A3,A4) const) {
  return new _ConstTessMemberResultCallback_0_4(obj, member);
}
#endif

template 
class _TessMemberResultCallback_0_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (T::*MemberSignature)(A1,A2,A3,A4) ;

 private:
   T* object_;
  MemberSignature member_;

 public:
  inline _TessMemberResultCallback_0_4( T* object, MemberSignature member)
    : object_(object),
      member_(member) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (object_->*member_)(a1,a2,a3,a4);
      return result;
    } else {
      R result = (object_->*member_)(a1,a2,a3,a4);
     //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_0_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (T::*MemberSignature)(A1,A2,A3,A4) ;

 private:
   T* object_;
  MemberSignature member_;

 public:
  inline _TessMemberResultCallback_0_4( T* object, MemberSignature member)
    : object_(object),
      member_(member) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (object_->*member_)(a1,a2,a3,a4);
    } else {
      (object_->*member_)(a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_0_4::base*
NewTessCallback( T1* obj, R (T2::*member)(A1,A2,A3,A4) ) {
  return new _TessMemberResultCallback_0_4(obj, member);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_0_4::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(A1,A2,A3,A4) ) {
  return new _TessMemberResultCallback_0_4(obj, member);
}
#endif

template 
class _TessFunctionResultCallback_0_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (*FunctionSignature)(A1,A2,A3,A4);

 private:
  FunctionSignature function_;

 public:
  inline _TessFunctionResultCallback_0_4(FunctionSignature function)
    : function_(function) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (*function_)(a1,a2,a3,a4);
      return result;
    } else {
      R result = (*function_)(a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_0_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (*FunctionSignature)(A1,A2,A3,A4);

 private:
  FunctionSignature function_;

 public:
  inline _TessFunctionResultCallback_0_4(FunctionSignature function)
    : function_(function) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (*function_)(a1,a2,a3,a4);
    } else {
      (*function_)(a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_0_4::base*
NewTessCallback(R (*function)(A1,A2,A3,A4)) {
  return new _TessFunctionResultCallback_0_4(function);
}

template 
inline typename _TessFunctionResultCallback_0_4::base*
NewPermanentTessCallback(R (*function)(A1,A2,A3,A4)) {
  return new _TessFunctionResultCallback_0_4(function);
}

template 
class _ConstTessMemberResultCallback_1_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (T::*MemberSignature)(P1,A1,A2,A3,A4) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _ConstTessMemberResultCallback_1_4(const T* object, MemberSignature member, P1 p1)
    : object_(object),
      member_(member),      p1_(p1) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (object_->*member_)(p1_,a1,a2,a3,a4);
      return result;
    } else {
      R result = (object_->*member_)(p1_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_1_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (T::*MemberSignature)(P1,A1,A2,A3,A4) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _ConstTessMemberResultCallback_1_4(const T* object, MemberSignature member, P1 p1)
    : object_(object),
      member_(member),      p1_(p1) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (object_->*member_)(p1_,a1,a2,a3,a4);
    } else {
      (object_->*member_)(p1_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_1_4::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2,A3,A4) const, typename Identity::type p1) {
  return new _ConstTessMemberResultCallback_1_4(obj, member, p1);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_1_4::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2,A3,A4) const, typename Identity::type p1) {
  return new _ConstTessMemberResultCallback_1_4(obj, member, p1);
}
#endif

template 
class _TessMemberResultCallback_1_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (T::*MemberSignature)(P1,A1,A2,A3,A4) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _TessMemberResultCallback_1_4( T* object, MemberSignature member, P1 p1)
    : object_(object),
      member_(member),      p1_(p1) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (object_->*member_)(p1_,a1,a2,a3,a4);
      return result;
    } else {
      R result = (object_->*member_)(p1_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_1_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (T::*MemberSignature)(P1,A1,A2,A3,A4) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _TessMemberResultCallback_1_4( T* object, MemberSignature member, P1 p1)
    : object_(object),
      member_(member),      p1_(p1) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (object_->*member_)(p1_,a1,a2,a3,a4);
    } else {
      (object_->*member_)(p1_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_1_4::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3,A4) , typename Identity::type p1) {
  return new _TessMemberResultCallback_1_4(obj, member, p1);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_1_4::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3,A4) , typename Identity::type p1) {
  return new _TessMemberResultCallback_1_4(obj, member, p1);
}
#endif

template 
class _TessFunctionResultCallback_1_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (*FunctionSignature)(P1,A1,A2,A3,A4);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;

 public:
  inline _TessFunctionResultCallback_1_4(FunctionSignature function, P1 p1)
    : function_(function),      p1_(p1) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (*function_)(p1_,a1,a2,a3,a4);
      return result;
    } else {
      R result = (*function_)(p1_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_1_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (*FunctionSignature)(P1,A1,A2,A3,A4);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;

 public:
  inline _TessFunctionResultCallback_1_4(FunctionSignature function, P1 p1)
    : function_(function),      p1_(p1) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (*function_)(p1_,a1,a2,a3,a4);
    } else {
      (*function_)(p1_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_1_4::base*
NewTessCallback(R (*function)(P1,A1,A2,A3,A4), typename Identity::type p1) {
  return new _TessFunctionResultCallback_1_4(function, p1);
}

template 
inline typename _TessFunctionResultCallback_1_4::base*
NewPermanentTessCallback(R (*function)(P1,A1,A2,A3,A4), typename Identity::type p1) {
  return new _TessFunctionResultCallback_1_4(function, p1);
}

template 
class _ConstTessMemberResultCallback_2_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3,A4) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _ConstTessMemberResultCallback_2_4(const T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_2_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3,A4) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _ConstTessMemberResultCallback_2_4(const T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
    } else {
      (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_2_4::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2) {
  return new _ConstTessMemberResultCallback_2_4(obj, member, p1, p2);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_2_4::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2) {
  return new _ConstTessMemberResultCallback_2_4(obj, member, p1, p2);
}
#endif

template 
class _TessMemberResultCallback_2_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3,A4) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessMemberResultCallback_2_4( T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_2_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3,A4) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessMemberResultCallback_2_4( T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
    } else {
      (object_->*member_)(p1_,p2_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_2_4::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2) {
  return new _TessMemberResultCallback_2_4(obj, member, p1, p2);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_2_4::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2) {
  return new _TessMemberResultCallback_2_4(obj, member, p1, p2);
}
#endif

template 
class _TessFunctionResultCallback_2_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (*FunctionSignature)(P1,P2,A1,A2,A3,A4);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessFunctionResultCallback_2_4(FunctionSignature function, P1 p1, P2 p2)
    : function_(function),      p1_(p1),      p2_(p2) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (*function_)(p1_,p2_,a1,a2,a3,a4);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_2_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (*FunctionSignature)(P1,P2,A1,A2,A3,A4);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessFunctionResultCallback_2_4(FunctionSignature function, P1 p1, P2 p2)
    : function_(function),      p1_(p1),      p2_(p2) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (*function_)(p1_,p2_,a1,a2,a3,a4);
    } else {
      (*function_)(p1_,p2_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_2_4::base*
NewTessCallback(R (*function)(P1,P2,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2) {
  return new _TessFunctionResultCallback_2_4(function, p1, p2);
}

template 
inline typename _TessFunctionResultCallback_2_4::base*
NewPermanentTessCallback(R (*function)(P1,P2,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2) {
  return new _TessFunctionResultCallback_2_4(function, p1, p2);
}

template 
class _ConstTessMemberResultCallback_3_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _ConstTessMemberResultCallback_3_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_3_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _ConstTessMemberResultCallback_3_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
    } else {
      (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_3_4::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _ConstTessMemberResultCallback_3_4(obj, member, p1, p2, p3);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_3_4::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _ConstTessMemberResultCallback_3_4(obj, member, p1, p2, p3);
}
#endif

template 
class _TessMemberResultCallback_3_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessMemberResultCallback_3_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_3_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessMemberResultCallback_3_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
    } else {
      (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_3_4::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessMemberResultCallback_3_4(obj, member, p1, p2, p3);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_3_4::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessMemberResultCallback_3_4(obj, member, p1, p2, p3);
}
#endif

template 
class _TessFunctionResultCallback_3_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (*FunctionSignature)(P1,P2,P3,A1,A2,A3,A4);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessFunctionResultCallback_3_4(FunctionSignature function, P1 p1, P2 p2, P3 p3)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,a1,a2,a3,a4);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_3_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (*FunctionSignature)(P1,P2,P3,A1,A2,A3,A4);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessFunctionResultCallback_3_4(FunctionSignature function, P1 p1, P2 p2, P3 p3)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,a1,a2,a3,a4);
    } else {
      (*function_)(p1_,p2_,p3_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_3_4::base*
NewTessCallback(R (*function)(P1,P2,P3,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessFunctionResultCallback_3_4(function, p1, p2, p3);
}

template 
inline typename _TessFunctionResultCallback_3_4::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessFunctionResultCallback_3_4(function, p1, p2, p3);
}

template 
class _ConstTessMemberResultCallback_4_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _ConstTessMemberResultCallback_4_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_4_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _ConstTessMemberResultCallback_4_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_4_4::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _ConstTessMemberResultCallback_4_4(obj, member, p1, p2, p3, p4);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_4_4::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _ConstTessMemberResultCallback_4_4(obj, member, p1, p2, p3, p4);
}
#endif

template 
class _TessMemberResultCallback_4_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessMemberResultCallback_4_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_4_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessMemberResultCallback_4_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_4_4::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessMemberResultCallback_4_4(obj, member, p1, p2, p3, p4);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_4_4::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessMemberResultCallback_4_4(obj, member, p1, p2, p3, p4);
}
#endif

template 
class _TessFunctionResultCallback_4_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3,A4);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessFunctionResultCallback_4_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_4_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3,A4);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessFunctionResultCallback_4_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
    } else {
      (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_4_4::base*
NewTessCallback(R (*function)(P1,P2,P3,P4,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessFunctionResultCallback_4_4(function, p1, p2, p3, p4);
}

template 
inline typename _TessFunctionResultCallback_4_4::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessFunctionResultCallback_4_4(function, p1, p2, p3, p4);
}

template 
class _ConstTessMemberResultCallback_5_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _ConstTessMemberResultCallback_5_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_5_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _ConstTessMemberResultCallback_5_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_5_4::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _ConstTessMemberResultCallback_5_4(obj, member, p1, p2, p3, p4, p5);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_5_4::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _ConstTessMemberResultCallback_5_4(obj, member, p1, p2, p3, p4, p5);
}
#endif

template 
class _TessMemberResultCallback_5_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessMemberResultCallback_5_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_5_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessMemberResultCallback_5_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_5_4::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessMemberResultCallback_5_4(obj, member, p1, p2, p3, p4, p5);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_5_4::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessMemberResultCallback_5_4(obj, member, p1, p2, p3, p4, p5);
}
#endif

template 
class _TessFunctionResultCallback_5_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessFunctionResultCallback_5_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_5_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessFunctionResultCallback_5_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
    } else {
      (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_5_4::base*
NewTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessFunctionResultCallback_5_4(function, p1, p2, p3, p4, p5);
}

template 
inline typename _TessFunctionResultCallback_5_4::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessFunctionResultCallback_5_4(function, p1, p2, p3, p4, p5);
}

template 
class _ConstTessMemberResultCallback_6_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _ConstTessMemberResultCallback_6_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_6_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _ConstTessMemberResultCallback_6_4(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_6_4::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _ConstTessMemberResultCallback_6_4(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_6_4::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _ConstTessMemberResultCallback_6_4(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

template 
class _TessMemberResultCallback_6_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessMemberResultCallback_6_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_6_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessMemberResultCallback_6_4( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_6_4::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessMemberResultCallback_6_4(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_6_4::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessMemberResultCallback_6_4(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

template 
class _TessFunctionResultCallback_6_4 : public TessResultCallback4 {
 public:
  typedef TessResultCallback4 base;
  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessFunctionResultCallback_6_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_6_4 : public TessCallback4 {
 public:
  typedef TessCallback4 base;
  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessFunctionResultCallback_6_4(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
    } else {
      (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_6_4::base*
NewTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessFunctionResultCallback_6_4(function, p1, p2, p3, p4, p5, p6);
}

template 
inline typename _TessFunctionResultCallback_6_4::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessFunctionResultCallback_6_4(function, p1, p2, p3, p4, p5, p6);
}

template 
class TessCallback5 {
 public:
  virtual ~TessCallback5() { }
  virtual void Run(A1,A2,A3,A4,A5) = 0;
};

template 
class TessResultCallback5 {
 public:
  virtual ~TessResultCallback5() { }
  virtual R Run(A1,A2,A3,A4,A5) = 0;
};

template 
class _ConstTessMemberResultCallback_0_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (T::*MemberSignature)(A1,A2,A3,A4,A5) const;

 private:
  const T* object_;
  MemberSignature member_;

 public:
  inline _ConstTessMemberResultCallback_0_5(const T* object, MemberSignature member)
    : object_(object),
      member_(member) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (object_->*member_)(a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (object_->*member_)(a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_0_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (T::*MemberSignature)(A1,A2,A3,A4,A5) const;

 private:
  const T* object_;
  MemberSignature member_;

 public:
  inline _ConstTessMemberResultCallback_0_5(const T* object, MemberSignature member)
    : object_(object),
      member_(member) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (object_->*member_)(a1,a2,a3,a4,a5);
    } else {
      (object_->*member_)(a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_0_5::base*
NewTessCallback(const T1* obj, R (T2::*member)(A1,A2,A3,A4,A5) const) {
  return new _ConstTessMemberResultCallback_0_5(obj, member);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_0_5::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(A1,A2,A3,A4,A5) const) {
  return new _ConstTessMemberResultCallback_0_5(obj, member);
}
#endif

template 
class _TessMemberResultCallback_0_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (T::*MemberSignature)(A1,A2,A3,A4,A5) ;

 private:
   T* object_;
  MemberSignature member_;

 public:
  inline _TessMemberResultCallback_0_5( T* object, MemberSignature member)
    : object_(object),
      member_(member) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (object_->*member_)(a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (object_->*member_)(a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_0_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (T::*MemberSignature)(A1,A2,A3,A4,A5) ;

 private:
   T* object_;
  MemberSignature member_;

 public:
  inline _TessMemberResultCallback_0_5( T* object, MemberSignature member)
    : object_(object),
      member_(member) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (object_->*member_)(a1,a2,a3,a4,a5);
    } else {
      (object_->*member_)(a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_0_5::base*
NewTessCallback( T1* obj, R (T2::*member)(A1,A2,A3,A4,A5) ) {
  return new _TessMemberResultCallback_0_5(obj, member);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_0_5::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(A1,A2,A3,A4,A5) ) {
  return new _TessMemberResultCallback_0_5(obj, member);
}
#endif

template 
class _TessFunctionResultCallback_0_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (*FunctionSignature)(A1,A2,A3,A4,A5);

 private:
  FunctionSignature function_;

 public:
  inline _TessFunctionResultCallback_0_5(FunctionSignature function)
    : function_(function) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (*function_)(a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (*function_)(a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_0_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (*FunctionSignature)(A1,A2,A3,A4,A5);

 private:
  FunctionSignature function_;

 public:
  inline _TessFunctionResultCallback_0_5(FunctionSignature function)
    : function_(function) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (*function_)(a1,a2,a3,a4,a5);
    } else {
      (*function_)(a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_0_5::base*
NewTessCallback(R (*function)(A1,A2,A3,A4,A5)) {
  return new _TessFunctionResultCallback_0_5(function);
}

template 
inline typename _TessFunctionResultCallback_0_5::base*
NewPermanentTessCallback(R (*function)(A1,A2,A3,A4,A5)) {
  return new _TessFunctionResultCallback_0_5(function);
}

template 
class _ConstTessMemberResultCallback_1_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (T::*MemberSignature)(P1,A1,A2,A3,A4,A5) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _ConstTessMemberResultCallback_1_5(const T* object, MemberSignature member, P1 p1)
    : object_(object),
      member_(member),      p1_(p1) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (object_->*member_)(p1_,a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (object_->*member_)(p1_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_1_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (T::*MemberSignature)(P1,A1,A2,A3,A4,A5) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _ConstTessMemberResultCallback_1_5(const T* object, MemberSignature member, P1 p1)
    : object_(object),
      member_(member),      p1_(p1) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (object_->*member_)(p1_,a1,a2,a3,a4,a5);
    } else {
      (object_->*member_)(p1_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_1_5::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2,A3,A4,A5) const, typename Identity::type p1) {
  return new _ConstTessMemberResultCallback_1_5(obj, member, p1);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_1_5::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,A1,A2,A3,A4,A5) const, typename Identity::type p1) {
  return new _ConstTessMemberResultCallback_1_5(obj, member, p1);
}
#endif

template 
class _TessMemberResultCallback_1_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (T::*MemberSignature)(P1,A1,A2,A3,A4,A5) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _TessMemberResultCallback_1_5( T* object, MemberSignature member, P1 p1)
    : object_(object),
      member_(member),      p1_(p1) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (object_->*member_)(p1_,a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (object_->*member_)(p1_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_1_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (T::*MemberSignature)(P1,A1,A2,A3,A4,A5) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;

 public:
  inline _TessMemberResultCallback_1_5( T* object, MemberSignature member, P1 p1)
    : object_(object),
      member_(member),      p1_(p1) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (object_->*member_)(p1_,a1,a2,a3,a4,a5);
    } else {
      (object_->*member_)(p1_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_1_5::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3,A4,A5) , typename Identity::type p1) {
  return new _TessMemberResultCallback_1_5(obj, member, p1);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_1_5::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,A1,A2,A3,A4,A5) , typename Identity::type p1) {
  return new _TessMemberResultCallback_1_5(obj, member, p1);
}
#endif

template 
class _TessFunctionResultCallback_1_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (*FunctionSignature)(P1,A1,A2,A3,A4,A5);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;

 public:
  inline _TessFunctionResultCallback_1_5(FunctionSignature function, P1 p1)
    : function_(function),      p1_(p1) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (*function_)(p1_,a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (*function_)(p1_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_1_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (*FunctionSignature)(P1,A1,A2,A3,A4,A5);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;

 public:
  inline _TessFunctionResultCallback_1_5(FunctionSignature function, P1 p1)
    : function_(function),      p1_(p1) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (*function_)(p1_,a1,a2,a3,a4,a5);
    } else {
      (*function_)(p1_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_1_5::base*
NewTessCallback(R (*function)(P1,A1,A2,A3,A4,A5), typename Identity::type p1) {
  return new _TessFunctionResultCallback_1_5(function, p1);
}

template 
inline typename _TessFunctionResultCallback_1_5::base*
NewPermanentTessCallback(R (*function)(P1,A1,A2,A3,A4,A5), typename Identity::type p1) {
  return new _TessFunctionResultCallback_1_5(function, p1);
}

template 
class _ConstTessMemberResultCallback_2_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3,A4,A5) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _ConstTessMemberResultCallback_2_5(const T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_2_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3,A4,A5) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _ConstTessMemberResultCallback_2_5(const T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
    } else {
      (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_2_5::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2) {
  return new _ConstTessMemberResultCallback_2_5(obj, member, p1, p2);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_2_5::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2) {
  return new _ConstTessMemberResultCallback_2_5(obj, member, p1, p2);
}
#endif

template 
class _TessMemberResultCallback_2_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (T::*MemberSignature)(P1,P2,A1,A2,A3,A4,A5) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessMemberResultCallback_2_5( T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_2_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (T::*MemberSignature)(P1,P2,A1,A2,A3,A4,A5) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessMemberResultCallback_2_5( T* object, MemberSignature member, P1 p1, P2 p2)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
    } else {
      (object_->*member_)(p1_,p2_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_2_5::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2) {
  return new _TessMemberResultCallback_2_5(obj, member, p1, p2);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_2_5::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2) {
  return new _TessMemberResultCallback_2_5(obj, member, p1, p2);
}
#endif

template 
class _TessFunctionResultCallback_2_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (*FunctionSignature)(P1,P2,A1,A2,A3,A4,A5);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessFunctionResultCallback_2_5(FunctionSignature function, P1 p1, P2 p2)
    : function_(function),      p1_(p1),      p2_(p2) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (*function_)(p1_,p2_,a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_2_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (*FunctionSignature)(P1,P2,A1,A2,A3,A4,A5);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;

 public:
  inline _TessFunctionResultCallback_2_5(FunctionSignature function, P1 p1, P2 p2)
    : function_(function),      p1_(p1),      p2_(p2) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (*function_)(p1_,p2_,a1,a2,a3,a4,a5);
    } else {
      (*function_)(p1_,p2_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_2_5::base*
NewTessCallback(R (*function)(P1,P2,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2) {
  return new _TessFunctionResultCallback_2_5(function, p1, p2);
}

template 
inline typename _TessFunctionResultCallback_2_5::base*
NewPermanentTessCallback(R (*function)(P1,P2,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2) {
  return new _TessFunctionResultCallback_2_5(function, p1, p2);
}

template 
class _ConstTessMemberResultCallback_3_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4,A5) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _ConstTessMemberResultCallback_3_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_3_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4,A5) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _ConstTessMemberResultCallback_3_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
    } else {
      (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_3_5::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _ConstTessMemberResultCallback_3_5(obj, member, p1, p2, p3);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_3_5::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _ConstTessMemberResultCallback_3_5(obj, member, p1, p2, p3);
}
#endif

template 
class _TessMemberResultCallback_3_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4,A5) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessMemberResultCallback_3_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_3_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,A1,A2,A3,A4,A5) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessMemberResultCallback_3_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
    } else {
      (object_->*member_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_3_5::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessMemberResultCallback_3_5(obj, member, p1, p2, p3);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_3_5::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessMemberResultCallback_3_5(obj, member, p1, p2, p3);
}
#endif

template 
class _TessFunctionResultCallback_3_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (*FunctionSignature)(P1,P2,P3,A1,A2,A3,A4,A5);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessFunctionResultCallback_3_5(FunctionSignature function, P1 p1, P2 p2, P3 p3)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_3_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (*FunctionSignature)(P1,P2,P3,A1,A2,A3,A4,A5);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;

 public:
  inline _TessFunctionResultCallback_3_5(FunctionSignature function, P1 p1, P2 p2, P3 p3)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
    } else {
      (*function_)(p1_,p2_,p3_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_3_5::base*
NewTessCallback(R (*function)(P1,P2,P3,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessFunctionResultCallback_3_5(function, p1, p2, p3);
}

template 
inline typename _TessFunctionResultCallback_3_5::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3) {
  return new _TessFunctionResultCallback_3_5(function, p1, p2, p3);
}

template 
class _ConstTessMemberResultCallback_4_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _ConstTessMemberResultCallback_4_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_4_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _ConstTessMemberResultCallback_4_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_4_5::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _ConstTessMemberResultCallback_4_5(obj, member, p1, p2, p3, p4);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_4_5::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _ConstTessMemberResultCallback_4_5(obj, member, p1, p2, p3, p4);
}
#endif

template 
class _TessMemberResultCallback_4_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessMemberResultCallback_4_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_4_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessMemberResultCallback_4_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_4_5::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessMemberResultCallback_4_5(obj, member, p1, p2, p3, p4);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_4_5::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessMemberResultCallback_4_5(obj, member, p1, p2, p3, p4);
}
#endif

template 
class _TessFunctionResultCallback_4_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessFunctionResultCallback_4_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_4_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (*FunctionSignature)(P1,P2,P3,P4,A1,A2,A3,A4,A5);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;

 public:
  inline _TessFunctionResultCallback_4_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
    } else {
      (*function_)(p1_,p2_,p3_,p4_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_4_5::base*
NewTessCallback(R (*function)(P1,P2,P3,P4,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessFunctionResultCallback_4_5(function, p1, p2, p3, p4);
}

template 
inline typename _TessFunctionResultCallback_4_5::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4) {
  return new _TessFunctionResultCallback_4_5(function, p1, p2, p3, p4);
}

template 
class _ConstTessMemberResultCallback_5_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _ConstTessMemberResultCallback_5_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }


  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_5_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _ConstTessMemberResultCallback_5_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_5_5::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _ConstTessMemberResultCallback_5_5(obj, member, p1, p2, p3, p4, p5);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_5_5::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _ConstTessMemberResultCallback_5_5(obj, member, p1, p2, p3, p4, p5);
}
#endif

template 
class _TessMemberResultCallback_5_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessMemberResultCallback_5_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_5_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessMemberResultCallback_5_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_5_5::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessMemberResultCallback_5_5(obj, member, p1, p2, p3, p4, p5);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_5_5::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessMemberResultCallback_5_5(obj, member, p1, p2, p3, p4, p5);
}
#endif

template 
class _TessFunctionResultCallback_5_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessFunctionResultCallback_5_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_5_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;

 public:
  inline _TessFunctionResultCallback_5_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
    } else {
      (*function_)(p1_,p2_,p3_,p4_,p5_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_5_5::base*
NewTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessFunctionResultCallback_5_5(function, p1, p2, p3, p4, p5);
}

template 
inline typename _TessFunctionResultCallback_5_5::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5) {
  return new _TessFunctionResultCallback_5_5(function, p1, p2, p3, p4, p5);
}

template 
class _ConstTessMemberResultCallback_6_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _ConstTessMemberResultCallback_6_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _ConstTessMemberResultCallback_6_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) const;

 private:
  const T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _ConstTessMemberResultCallback_6_5(const T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_6_5::base*
NewTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _ConstTessMemberResultCallback_6_5(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

#ifndef SWIG
template 
inline typename _ConstTessMemberResultCallback_6_5::base*
NewPermanentTessCallback(const T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) const, typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _ConstTessMemberResultCallback_6_5(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

template 
class _TessMemberResultCallback_6_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessMemberResultCallback_6_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessMemberResultCallback_6_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (T::*MemberSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) ;

 private:
   T* object_;
  MemberSignature member_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessMemberResultCallback_6_5( T* object, MemberSignature member, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : object_(object),
      member_(member),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
    } else {
      (object_->*member_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      member_ = NULL;
      delete this;
    }
  }
};

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_6_5::base*
NewTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessMemberResultCallback_6_5(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

#ifndef SWIG
template 
inline typename _TessMemberResultCallback_6_5::base*
NewPermanentTessCallback( T1* obj, R (T2::*member)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5) , typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessMemberResultCallback_6_5(obj, member, p1, p2, p3, p4, p5, p6);
}
#endif

template 
class _TessFunctionResultCallback_6_5 : public TessResultCallback5 {
 public:
  typedef TessResultCallback5 base;
  typedef R (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessFunctionResultCallback_6_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual R Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
      return result;
    } else {
      R result = (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
      return result;
    }
  }
};

template 
class _TessFunctionResultCallback_6_5 : public TessCallback5 {
 public:
  typedef TessCallback5 base;
  typedef void (*FunctionSignature)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5);

 private:
  FunctionSignature function_;
  typename remove_reference::type p1_;
  typename remove_reference::type p2_;
  typename remove_reference::type p3_;
  typename remove_reference::type p4_;
  typename remove_reference::type p5_;
  typename remove_reference::type p6_;

 public:
  inline _TessFunctionResultCallback_6_5(FunctionSignature function, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
    : function_(function),      p1_(p1),      p2_(p2),      p3_(p3),      p4_(p4),      p5_(p5),      p6_(p6) { }

  virtual void Run(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) {
    if (!del) {
      (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
    } else {
      (*function_)(p1_,p2_,p3_,p4_,p5_,p6_,a1,a2,a3,a4,a5);
      //  zero out the pointer to ensure segfault if used again
      function_ = NULL;
      delete this;
    }
  }
};

template 
inline typename _TessFunctionResultCallback_6_5::base*
NewTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessFunctionResultCallback_6_5(function, p1, p2, p3, p4, p5, p6);
}

template 
inline typename _TessFunctionResultCallback_6_5::base*
NewPermanentTessCallback(R (*function)(P1,P2,P3,P4,P5,P6,A1,A2,A3,A4,A5), typename Identity::type p1, typename Identity::type p2, typename Identity::type p3, typename Identity::type p4, typename Identity::type p5, typename Identity::type p6) {
  return new _TessFunctionResultCallback_6_5(function, p1, p2, p3, p4, p5, p6);
}

#endif /* _TESS_CALLBACK_SPECIALIZATIONS_H */




    © 2015 - 2025 Weber Informatics LLC | Privacy Policy