VRS - The Virtual Rendering System

version 3.3

methodcallback.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2003 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * This  library  is  free  software; you can redistribute it and/or  modify it
 * under the terms of the GNU Lesser General Public  License  as  published  by
 * the  Free  Software  Foundation;  either  version 2.1 of the License, or (at
 * your option) any later version. This library  is  distributed  in  the  hope
 * that  it will be useful, but  WITHOUT ANY WARRANTY; without even the implied
 * warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE.  See  the
 * GNU Lesser General Public License for more details. You should have received
 * a copy of the GNU Lesser+ General Public License along with this library; if
 * not, write to the FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/

// $Id: methodcallback.h 6696 2009-08-25 13:47:52Z Jan_Klimke $
// $Date: 2009-08-25 15:47:52 +0200 (Tue, 25 Aug 2009) $
// $Revision: 6696 $
// $State$
// $Author: Jan_Klimke $
//
// $Log$
// Revision 1.14  2005/01/03 01:43:08  klimetschek
// - modified win32 project layout, splitted vrs.vcproj into vrs_container, vrs_core, vrs_sg, vrs_image, vrs_opengl and vrs_io
// - removed vrs.vcproj
// minor things:
// - added all glutexamples to vrs4glut.sln
// - fixed some problems in glutexamples
// - removed all project references from all VS projects (using solution wide project dependencies instead)
//
// Revision 1.13  2004/11/05 13:58:09  basch
// Class comment changed (Doxygen style)
//
// Revision 1.12  2004/03/12 16:28:38  baumann
// macros VRS_NAMESPACE_BEGIN/_END expanded and removed
//
// Revision 1.11  2003/02/18 09:53:23  baumann
// bug fix for MS Visual C++ compiler 6.0
//
// Revision 1.10  2002/08/06 16:24:01  baumann
// VRS_CORE_API removed for template classes
//
// Revision 1.9  2002/03/03 21:44:25  kosta
// VRS_TYPEINFO-macro rewritten
//
// Revision 1.8  2002/02/19 10:34:09  kosta
// undone all changes since 2002-02-15
//
// Revision 1.5  2002/01/26 23:42:02  kosta
// changed macro TEMPLATE_ARGS_* to VRS_TEMPLATE_ARGS_*
//
// Revision 1.4  2002/01/15 16:25:54  kosta
// macros rewritten for a better namespace support
//
// Revision 1.3  2002/01/11 12:51:20  kosta
// callback specification simplified by functions makeCallback() and makeCallbackWithReturn()
//
// Revision 1.2  2001/11/13 16:36:30  kirsch
// changed line feed to unix style (removed control-M)
//
// Revision 1.1.1.1  2001/06/08 08:09:20  kirsch
// imported alpha-version by olli 
//

#ifndef VRS_METHODCALLBACK_H
#define VRS_METHODCALLBACK_H

#include <vrs/callback.h>

namespace VRS {

template<class CLASS>
class MethodCallback : public Callback {

public: 
    typedef void (CLASS::*ConstMethod)() const;

    MethodCallback(CLASS* obj, void (CLASS::*meth)())
        : obj_(obj), meth_((ConstMethod) meth) {
         VRS_Assertion(obj != NULL, "no object");
         VRS_Assertion(meth != NULL, "no method");
    }
    MethodCallback(const CLASS* obj, void (CLASS::*meth)() const)
        : obj_(obj), meth_(meth) {
         VRS_Assertion(obj != NULL, "no object");
         VRS_Assertion(meth != NULL, "no method");
    }
    virtual void callback() { (obj_->*meth_)(); }
    
    VRS_TYPEINFO(MethodCallback, Callback);

private:
    const CLASS* obj_;
    void (CLASS::*meth_)() const;
};

template<class CLASS, class RETURN>
class MethodCallbackR : public CallbackR<RETURN> {

public:
    typedef RETURN (CLASS::*ConstMethod)() const;

    MethodCallbackR(CLASS* obj, RETURN (CLASS::*meth)())
        : obj_(obj), meth_((ConstMethod) meth) {
         VRS_Assertion(obj != NULL, "no object");
         VRS_Assertion(meth != NULL, "no method");
    }
    MethodCallbackR(const CLASS* obj, RETURN (CLASS::*meth)() const)
        : obj_(obj), meth_(meth) {
         VRS_Assertion(obj != NULL, "no object");
         VRS_Assertion(meth != NULL, "no method");
    }
    virtual RETURN callback() { return (obj_->*meth_)(); }
    
    VRS_TYPEINFO(MethodCallbackR, CallbackR<RETURN>);

private:
    const CLASS* obj_;
    RETURN (CLASS::*meth_)() const;
};

template<class CLASS, class ARG1>
class MethodCallback1 : public Callback1<ARG1> {

public:
    typedef void (CLASS::*ConstMethod)(ARG1) const;

    MethodCallback1(CLASS* obj, void (CLASS::*meth)(ARG1))
        : obj_(obj), meth_((ConstMethod) meth) {
         VRS_Assertion(obj != NULL, "no object");
         VRS_Assertion(meth != NULL, "no method");
    }
    MethodCallback1(const CLASS* obj, void (CLASS::*meth)(ARG1) const)
        : obj_(obj), meth_(meth) {
         VRS_Assertion(obj != NULL, "no object");
         VRS_Assertion(meth != NULL, "no method");
    }
    virtual void callback(ARG1 arg1) { (obj_->*meth_)(arg1); }
    
    VRS_TYPEINFO(MethodCallback1, Callback1<ARG1>);

private:
    const CLASS* obj_;
    void (CLASS::*meth_)(ARG1) const;
};

template<class CLASS, class RETURN, class ARG1>
class MethodCallbackR1 : public CallbackR1<RETURN, ARG1> {

public:
    typedef RETURN (CLASS::*ConstMethod)(ARG1) const;

    MethodCallbackR1(CLASS* obj, RETURN (CLASS::*meth)(ARG1))
        : obj_(obj), meth_((ConstMethod) meth) {
         VRS_Assertion(obj != NULL, "no object");
         VRS_Assertion(meth != NULL, "no method");
    }
    MethodCallbackR1(const CLASS* obj, RETURN (CLASS::*meth)(ARG1) const)
        : obj_(obj), meth_(meth) {
         VRS_Assertion(obj != NULL, "no object");
         VRS_Assertion(meth != NULL, "no method");
    }
    virtual RETURN callback(ARG1 arg1) { return (obj_->*meth_)(arg1); }
    
    VRS_TYPEINFO(MethodCallbackR1, VRS_TEMPLATE_ARGS_2(RETURN, ARG1, CallbackR1));

private:
    const CLASS* obj_;
    RETURN (CLASS::*meth_)(ARG1) const;
};

template<class CLASS, class ARG1, class ARG2>
class MethodCallback2 : public Callback2<ARG1, ARG2> {

public:
    typedef void (CLASS::*ConstMethod)(ARG1, ARG2) const;

    MethodCallback2(CLASS* obj, void (CLASS::*meth)(ARG1, ARG2))
        : obj_(obj), meth_((ConstMethod) meth) {
         VRS_Assertion(obj != NULL, "no object");
         VRS_Assertion(meth != NULL, "no method");
    }
    MethodCallback2(const CLASS* obj, void (CLASS::*meth)(ARG1, ARG2) const)
        : obj_(obj), meth_(meth) {
         VRS_Assertion(obj != NULL, "no object");
         VRS_Assertion(meth != NULL, "no method");
    }
    virtual void callback(ARG1 arg1, ARG2 arg2) { (obj_->*meth_)(arg1, arg2); }
    
    VRS_TYPEINFO(MethodCallback2, VRS_TEMPLATE_ARGS_2(ARG1, ARG2, Callback2));

private:
    const CLASS* obj_;
    void (CLASS::*meth_)(ARG1, ARG2) const;
};

template<class CLASS, class RETURN, class ARG1, class ARG2>
class MethodCallbackR2 : public CallbackR2<RETURN, ARG1, ARG2> {

public:
    typedef RETURN (CLASS::*ConstMethod)(ARG1, ARG2) const;

    MethodCallbackR2(CLASS* obj, RETURN (CLASS::*meth)(ARG1, ARG2))
        : obj_(obj), meth_((ConstMethod) meth) {
         VRS_Assertion(obj != NULL, "no object");
         VRS_Assertion(meth != NULL, "no method");
    }
    MethodCallbackR2(const CLASS* obj, RETURN (CLASS::*meth)(ARG1, ARG2) const)
        : obj_(obj), meth_(meth) {
         VRS_Assertion(obj != NULL, "no object");
         VRS_Assertion(meth != NULL, "no method");
    }
    virtual RETURN callback(ARG1 arg1, ARG2 arg2) { return (obj_->*meth_)(arg1, arg2); }
    
    VRS_TYPEINFO(MethodCallbackR2, VRS_TEMPLATE_ARGS_3(RETURN, ARG1, ARG2, CallbackR2));

private:
    const CLASS* obj_;
    RETURN (CLASS::*meth_)(ARG1, ARG2) const;
};

template<class CLASS, class ARG1, class ARG2, class ARG3>
class MethodCallback3 : public Callback3<ARG1, ARG2, ARG3> {

public:
    typedef void (CLASS::*ConstMethod)(ARG1, ARG2, ARG3) const;

    MethodCallback3(CLASS* obj, void (CLASS::*meth)(ARG1, ARG2, ARG3))
        : obj_(obj), meth_((ConstMethod) meth) {
         VRS_Assertion(obj != NULL, "no object");
         VRS_Assertion(meth != NULL, "no method");
    }
    MethodCallback3(const CLASS* obj, void (CLASS::*meth)(ARG1, ARG2, ARG3) const)
        : obj_(obj), meth_(meth) {
         VRS_Assertion(obj != NULL, "no object");
         VRS_Assertion(meth != NULL, "no method");
    }
    virtual void callback(ARG1 arg1, ARG2 arg2, ARG3 arg3) { (obj_->*meth_)(arg1, arg2, arg3); }
    
    VRS_TYPEINFO(MethodCallback3, VRS_TEMPLATE_ARGS_3(ARG1, ARG2, ARG3, Callback3));

private:
    const CLASS* obj_;
    void (CLASS::*meth_)(ARG1, ARG2, ARG3) const;
};

template<class CLASS, class RETURN, class ARG1, class ARG2, class ARG3>
class MethodCallbackR3 : public CallbackR3<RETURN, ARG1, ARG2, ARG3> {

public:
    typedef RETURN (CLASS::*ConstMethod)(ARG1, ARG2, ARG3) const;

    MethodCallbackR3(CLASS* obj, RETURN (CLASS::*meth)(ARG1, ARG2, ARG3))
        : obj_(obj), meth_((ConstMethod) meth) {
         VRS_Assertion(obj != NULL, "no object");
         VRS_Assertion(meth != NULL, "no method");
    }
    MethodCallbackR3(const CLASS* obj, RETURN (CLASS::*meth)(ARG1, ARG2, ARG3) const)
        : obj_(obj), meth_(meth) {
         VRS_Assertion(obj != NULL, "no object");
         VRS_Assertion(meth != NULL, "no method");
    }
    virtual RETURN callback(ARG1 arg1, ARG2 arg2, ARG3 arg3) { return (obj_->*meth_)(arg1, arg2, arg3); }
    
    VRS_TYPEINFO(MethodCallbackR3, VRS_TEMPLATE_ARGS_4(RETURN, ARG1, ARG2, ARG3, CallbackR3));

private:
    const CLASS* obj_;
    RETURN (CLASS::*meth_)(ARG1, ARG2, ARG3) const;
};

template<class CLASS, class ARG1, class ARG2, class ARG3,class ARG4>
class MethodCallback4 : public Callback4<ARG1, ARG2, ARG3,ARG4> {

public:
  typedef void (CLASS::*ConstMethod)(ARG1, ARG2, ARG3,ARG4) const;

  MethodCallback4(CLASS* obj, void (CLASS::*meth)(ARG1, ARG2, ARG3,ARG4))
    : obj_(obj), meth_((ConstMethod) meth) {
      VRS_Assertion(obj != NULL, "no object");
      VRS_Assertion(meth != NULL, "no method");
  }
  MethodCallback4(const CLASS* obj, void (CLASS::*meth)(ARG1, ARG2, ARG3,ARG4) const)
    : obj_(obj), meth_(meth) {
      VRS_Assertion(obj != NULL, "no object");
      VRS_Assertion(meth != NULL, "no method");
  }
  virtual void callback(ARG1 arg1, ARG2 arg2, ARG3 arg3,ARG4 arg4) { (obj_->*meth_)(arg1, arg2, arg3,arg4); }

  VRS_TYPEINFO(MethodCallback4, VRS_TEMPLATE_ARGS_4(ARG1, ARG2, ARG3 ,ARG4, Callback4));

private:
  const CLASS* obj_;
  void (CLASS::*meth_)(ARG1, ARG2, ARG3,ARG4) const;
};


template<class CLASS, class RETURN, class ARG1, class ARG2, class ARG3,class ARG4>
class MethodCallbackR4 : public CallbackR4<RETURN, ARG1, ARG2, ARG3,ARG4> {

public:
  typedef RETURN (CLASS::*ConstMethod)(ARG1, ARG2, ARG3,ARG4) const;

  MethodCallbackR4(CLASS* obj, RETURN (CLASS::*meth)(ARG1, ARG2, ARG3,ARG4))
    : obj_(obj), meth_((ConstMethod) meth) {
      VRS_Assertion(obj != NULL, "no object");
      VRS_Assertion(meth != NULL, "no method");
  }
  MethodCallbackR4(const CLASS* obj, RETURN (CLASS::*meth)(ARG1, ARG2, ARG3,ARG4) const)
    : obj_(obj), meth_(meth) {
      VRS_Assertion(obj != NULL, "no object");
      VRS_Assertion(meth != NULL, "no method");
  }
  virtual RETURN callback(ARG1 arg1, ARG2 arg2, ARG3 arg3,ARG4 arg4) { return (obj_->*meth_)(arg1, arg2, arg3,arg4); }

  VRS_TYPEINFO(MethodCallbackR4, VRS_TEMPLATE_ARGS_5(RETURN, ARG1, ARG2, ARG3, ARG4, CallbackR4));

private:
  const CLASS* obj_;
  RETURN (CLASS::*meth_)(ARG1, ARG2, ARG3, ARG4) const;
};


template<class CLASS>
inline Callback* makeCallback(CLASS* obj, void (CLASS::*meth)()) {
    return new MethodCallback<CLASS>(obj, meth);
}

template<class CLASS>
inline Callback* makeCallback(CLASS* obj, void (CLASS::*meth)() const) {
    return new MethodCallback<CLASS>(obj, meth);
}

template<class CLASS, class RETURN>
inline CallbackR<RETURN>* makeCallbackWithReturn(CLASS* obj, RETURN (CLASS::*meth)()) {
    return new MethodCallbackR<CLASS, RETURN>(obj, meth);
}

template<class CLASS, class RETURN>
inline CallbackR<RETURN>* makeCallbackWithReturn(CLASS* obj, RETURN (CLASS::*meth)() const) {
    return new MethodCallbackR<CLASS, RETURN>(obj, meth);
}


template<class CLASS, class ARG1>
inline Callback1<ARG1>* makeCallback(CLASS* obj, void (CLASS::*meth)(ARG1)) {
    return new MethodCallback1<CLASS, ARG1>(obj, meth);
}

template<class CLASS, class ARG1>
inline Callback1<ARG1>* makeCallback(CLASS* obj, void (CLASS::*meth)(ARG1) const) {
    return new MethodCallback1<CLASS, ARG1>(obj, meth);
}

template<class CLASS, class RETURN, class ARG1>
inline CallbackR1<RETURN, ARG1>* makeCallbackWithReturn(CLASS* obj, RETURN (CLASS::*meth)(ARG1)) {
    return new MethodCallbackR1<CLASS, RETURN, ARG1>(obj, meth);
}

template<class CLASS, class RETURN, class ARG1>
inline CallbackR1<RETURN, ARG1>* makeCallbackWithReturn(CLASS* obj, RETURN (CLASS::*meth)(ARG1) const) {
    return new MethodCallbackR1<CLASS, RETURN, ARG1>(obj, meth);
}



template<class CLASS, class ARG1, class ARG2>
inline Callback2<ARG1, ARG2>* makeCallback(CLASS* obj, void (CLASS::*meth)(ARG1, ARG2)) {
    return new MethodCallback2<CLASS, ARG1, ARG2>(obj, meth);
}

template<class CLASS, class ARG1, class ARG2>
inline Callback2<ARG1, ARG2>* makeCallback(CLASS* obj, void (CLASS::*meth)(ARG1, ARG2) const) {
    return new MethodCallback2<CLASS, ARG1, ARG2>(obj, meth);
}

template<class CLASS, class RETURN, class ARG1, class ARG2>
inline CallbackR2<RETURN, ARG1, ARG2>* makeCallbackWithReturn(CLASS* obj, RETURN (CLASS::*meth)(ARG1, ARG2)) {
    return new MethodCallbackR2<CLASS, RETURN, ARG1, ARG2>(obj, meth);
}

template<class CLASS, class RETURN, class ARG1, class ARG2>
inline CallbackR2<RETURN, ARG1, ARG2>* makeCallbackWithReturn(CLASS* obj, RETURN (CLASS::*meth)(ARG1, ARG2) const) {
    return new MethodCallbackR2<CLASS, RETURN, ARG1, ARG2>(obj, meth);
}


template<class CLASS, class ARG1, class ARG2, class ARG3>
inline Callback3<ARG1, ARG2, ARG3>* makeCallback(CLASS* obj, void (CLASS::*meth)(ARG1, ARG2, ARG3)) {
    return new MethodCallback3<CLASS, ARG1, ARG2, ARG3>(obj, meth);
}

template<class CLASS, class ARG1, class ARG2, class ARG3>
inline Callback3<ARG1, ARG2, ARG3>* makeCallback(CLASS* obj, void (CLASS::*meth)(ARG1, ARG2, ARG3) const) {
    return new MethodCallback3<CLASS, ARG1, ARG2, ARG3>(obj, meth);
}

template<class CLASS, class RETURN, class ARG1, class ARG2, class ARG3>
inline CallbackR3<RETURN, ARG1, ARG2, ARG3>* makeCallbackWithReturn(CLASS* obj, RETURN (CLASS::*meth)(ARG1, ARG2, ARG3)) {
    return new MethodCallbackR3<CLASS, RETURN, ARG1, ARG2, ARG3>(obj, meth);
}

template<class CLASS, class RETURN, class ARG1, class ARG2, class ARG3>
inline CallbackR3<RETURN, ARG1, ARG2, ARG3>* makeCallbackWithReturn(CLASS* obj, RETURN (CLASS::*meth)(ARG1, ARG2, ARG3) const) {
    return new MethodCallbackR3<CLASS, RETURN, ARG1, ARG2, ARG3>(obj, meth);
}


template<class CLASS, class ARG1, class ARG2, class ARG3,class ARG4>
inline Callback4<ARG1, ARG2, ARG3, ARG4>* makeCallback(CLASS* obj, void (CLASS::*meth)(ARG1, ARG2, ARG3, ARG4)) {
  return new MethodCallback4<CLASS, ARG1, ARG2, ARG3,ARG4>(obj, meth);
}

template<class CLASS, class ARG1, class ARG2, class ARG3,class ARG4>
inline Callback4<ARG1, ARG2, ARG3, ARG4>* makeCallback(CLASS* obj, void (CLASS::*meth)(ARG1, ARG2, ARG3, ARG4) const) {
  return new MethodCallback4<CLASS, ARG1, ARG2, ARG3, ARG4>(obj, meth);
}

template<class CLASS, class RETURN, class ARG1, class ARG2, class ARG3, class ARG4>
inline CallbackR4<RETURN, ARG1, ARG2, ARG3, ARG4>* makeCallbackWithReturn(CLASS* obj, RETURN (CLASS::*meth)(ARG1, ARG2, ARG3, ARG4)) {
  return new MethodCallbackR4<CLASS, RETURN, ARG1, ARG2, ARG3, ARG4>(obj, meth);
}

template<class CLASS, class RETURN, class ARG1, class ARG2, class ARG3, class ARG4>
inline CallbackR4<RETURN, ARG1, ARG2, ARG3, ARG4>* makeCallbackWithReturn(CLASS* obj, RETURN (CLASS::*meth)(ARG1, ARG2, ARG3, ARG4) const) {
  return new MethodCallbackR4<CLASS, RETURN, ARG1, ARG2, ARG3, ARG4>(obj, meth);
}


} // namespace VRS

#endif // VRS_METHODCALLBACK_H

---

Generated on Sun May 19 06:00:28 2013 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact