#ifndef HEPUSEMETHOD_H
#define HEPUSEMETHOD_H

// ----------------------------------------------------------------------
//
// useMethod.h - definition of interface to access arbitraty method
//               in arbitrary classes.
//
// A ZMuseMethod is used to wrappe around a 'get' method while
// a ZMsetMethod is used to wrappe around a 'set' method
//
// newUseMethod and newSetMethod are prone to memory leak if the user
// change the method in the middle.
// This is because the addresse of one ZMuse/setMethod is share among
// several ColumnAttribs (each time you copy it, etc...).
// Since newUseMethod NEED to return a new instance of ZMuseMethod
// that can have polymorphism, newUseMethod have to call new.
// However it is not trivial do not when to delete it.


ZM_BEGIN_NAMESPACE( zmht )	/*  namespace zmht  {  */

template <class T>
class ZMuseMethod {
public:
  virtual T evaluate() = 0;
};

template <class T>
class ZMsetMethod {
public:
  virtual void set(T) = 0;
};


template <class T,class Obj>
class ZMuseMethodImpl : public ZMuseMethod<T> {
public:

  typedef  T (Obj::*methodPointer)();

  ZMuseMethodImpl<T,Obj>(Obj* object, methodPointer method);

  virtual T evaluate();

protected:
  Obj* _object;
  methodPointer _method;
};

template <class T,class Obj,class Y>
class ZMsetMethodImpl : public ZMsetMethod<T> {
public:

  typedef Y (Obj::*methodPointer)(T);

  ZMsetMethodImpl<T,Obj,Y>(Obj* object, methodPointer method);

  virtual void set(T);

protected:
  Obj* _object;
  methodPointer _method;
};

#ifdef FUNCTION_TEMPLATE_PROTOTYPE_NEEDED
// this two function are actually defined in useMethod.icc
// the two definition perturbe gcc.
template <class T,class Obj>
ZMuseMethod<T>* newUseMethod(Obj* object, ZMuseMethodImpl<T,Obj>::methodPointer method );

template <class T,class Obj,class Y>
ZMsetMethod<T>* newSetMethod(Obj* object, ZMsetMethodImpl<T,Obj,Y>::methodPointer method );
#endif


ZM_END_NAMESPACE( zmht )	/*  }  // namespace zmht  */

#include "HepTuple/useMethod.icc"

#endif // HEPUSEMETHOD_H