#if !defined (__CALLBACK__)
#define       __CALLBACK__

#include "include.hpp"
#include "failure.hpp"


namespace xgx_support {


  class gx_countedBody {
  public:
    gx_countedBody() : counter(0) {}
    virtual ~gx_countedBody() {}
    void inc() throw() { counter++;}
    void dec() throw() { counter--;}
    unsigned int count() const throw() {return counter;}
  private:
    unsigned int counter;
  };



  class gx_callbackBaseBody : public gx_countedBody {
  public:
    gx_callbackBaseBody() {}
    virtual ~gx_callbackBaseBody() {}
    virtual void operator ()() const = 0;
  };



  class gx_callback {
  public:

    gx_callback(gx_callbackBaseBody *ptr) : entity(ptr) {incEntityCount();}
    gx_callback(gx_callback const & arg) : entity(arg.entity) {incEntityCount();}
    ~gx_callback() { decEntityCount();entity = 0;return;}
    void operator ()() { (*entity)();}
    void incEntityCount() throw() {entity->inc();return;}
    void decEntityCount() throw() {entity->dec();if(!entity->count()) delete entity;return;}

    template <class CLIENT,class CLIENTMEMBER>
    static gx_callback make_M2(CLIENT &,CLIENTMEMBER &);

    template <class CLIENT,class CLIENTMEMBER,class PARAMETER>
    static gx_callback make_M3P(CLIENT &,CLIENTMEMBER &,PARAMETER &);

    template <class CLIENT,class CLIENTMEMBER,class RESULT>
    static gx_callback make_M3R(CLIENT &,CLIENTMEMBER &,RESULT &);

    template <class CLIENT,class CLIENTMEMBER,class PARAMETER,class RESULT>
    static gx_callback make_M4(CLIENT &,CLIENTMEMBER &,PARAMETER &,RESULT &);

    template <class FUNCTION>
    static gx_callback make_F(FUNCTION &);

    template <class FUNCTION,class PARAMETER>
    static gx_callback make_F2P(FUNCTION &,PARAMETER &);

    template <class FUNCTION,class RESULT>
    static gx_callback make_F2R(FUNCTION &,RESULT &);

    template <class FUNCTION,class PARAMETER,class RESULT>
    static gx_callback make_F3(FUNCTION &,PARAMETER &,RESULT &);

  private:
    gx_callbackBaseBody *entity;
  };



  template <class CLIENT,class MEMBER>
  class gx_memberCB : public gx_callbackBaseBody {
  public:
    gx_memberCB(CLIENT &clnt,MEMBER &clntmem) : client(clnt),clientmember(clntmem) {}
    virtual void operator () () { ((&client) ->*member)();}

  private:
    CLIENT &client;
    MEMBER &clientmember;
  };



  template <class CLIENT,class MEMBER,class PARAMETER>
  class gx_memberCBP : public gx_callbackBaseBody {
  public:
    gx_memberCBP(CLIENT &clnt,MEMBER &clntmem,PARAMETER &parm) : client(clnt),clientmember(clntmem),parameter(parm) {}
    virtual void operator () () { ((&client) ->*member)(parameter);}

  private:
    CLIENT &client;
    MEMBER &clientmember;
    PARAMETER &parameter;
  };



  template <class CLIENT,class MEMBER,class RESULT>
  class gx_memberCBR : public gx_callbackBaseBody {
  public:
    gx_memberCBR(CLIENT &clnt,MEMBER &clntmem,RESULT &res) : client(clnt),clientmember(clntmem),result(res) {}
    virtual void operator () () { ((&client) ->*member)(res);}

  private:
    CLIENT &client;
    MEMBER &clientmember;
    RESULT &result;
  };



  template <class CLIENT,class MEMBER,class PARAMETER,class RESULT>
  class gx_memberCBPR : public gx_callbackBaseBody {
  public:
    gx_memberCBPR(CLIENT &clnt,MEMBER &clntmem,PARAMETER &parm,RESULT &res) : client(clnt),clientmember(clntmem),parameter(parm),result(res) {}
    virtual void operator () () { (result = (&client) ->*member)(parameter);}

  private:
    CLIENT &client;
    MEMBER &clientmember;
    PARAMETER &parameter;
    RESULT &result;
  };



  template <class FUNCTION>
  class gx_functionCB : public gx_callbackBaseBody {
  public:
    gx_functionCB(FUNCTION &func) : function(func) {}
    virtual void operator() () { function();}

  private:
    FUNCTION &function;
  };



  template <class FUNCTION,class PARAMETER>
  class gx_functionCBP : public gx_callbackBaseBody {
  public:
    gx_functionCBP(FUNCTION &func,PARAMETER &parm) : function(func),parameter(parm) {}
    virtual void operator() () { function(parameter);}

  private:
    FUNCTION &function;
    PARAMETER &parameter;
  };



  template <class FUNCTION,class RESULT>
  class gx_functionCBR : public gx_callbackBaseBody {
  public:
    gx_functionCBR(FUNCTION &func) : function(func) {}
    virtual void operator() () { result = function();}

  private:
    FUNCTION &function;
    RESULT &result;
  };



  template <class FUNCTION,class PARAMETER,class RESULT>
  class gx_functionCBPR : public gx_callbackBaseBody {
  public:
    gx_functionCBPR(FUNCTION &func,PARAMETER &para,RESULT &res) : function(func),parameter(para),result(res) {}
    virtual void operator() () { result = function(parameter);}

  private:
    FUNCTION &function;
    PARAMETER &parameter;
    RESULT &result;
  };



  template <class CLIENT,class CLIENTMEMBER>
  gx_callback gx_callback::make_M2(CLIENT &c,CLIENTMEMBER &cm) {
    return gx_callback(new gx_memberCB<CLIENT,CLIENTMEMBER>(c,cm));
  }

  template <class CLIENT,class CLIENTMEMBER,class PARAMETER>
  gx_callback gx_callback::make_M3P(CLIENT &c,CLIENTMEMBER &cm,PARAMETER &p) {
    return gx_callback(new gx_memberCBP<CLIENT,CLIENTMEMBER,PARAMETER>(c,cm,p));
  }

  template <class CLIENT,class CLIENTMEMBER,class RESULT>
  gx_callback gx_callback::make_M3R(CLIENT &c,CLIENTMEMBER &cm,RESULT &r) {
    return gx_callback(new gx_memberCBR<CLIENT,CLIENTMEMBER,RESULT>(c,cm,r));
  }

  template <class CLIENT,class CLIENTMEMBER,class PARAMETER,class RESULT>
  gx_callback gx_callback::make_M4(CLIENT &c,CLIENTMEMBER &cm,PARAMETER &p,RESULT &r) {
    return gx_callback(new gx_memberCBPR<CLIENT,CLIENTMEMBER,PARAMETER,RESULT>(c,cm,p,r));
  }

  template <class FUNCTION>
  gx_callback gx_callback::make_F(FUNCTION &f) {
    return gx_callback(new gx_functionCB<FUNCTION>(f));
  }

  template <class FUNCTION,class PARAMETER>
  gx_callback gx_callback::make_F2P(FUNCTION &f,PARAMETER &p) {
    return gx_callback(new gx_functionCBP<FUNCTION,PARAMETER>(f,p));
  }

  template <class FUNCTION,class RESULT>
  gx_callback gx_callback::make_F2R(FUNCTION &f,RESULT &r) {
    return gx_callback(new gx_functionCBR<FUNCTION,RESULT>(f,r));
  }

  template <class FUNCTION,class PARAMETER,class RESULT>
  gx_callback gx_callback::make_F3(FUNCTION &f,PARAMETER &r,RESULT &p) {
    return gx_callback(new gx_functionCBPR<FUNCTION,PARAMETER,RESULT>(f,p,r));
  }


} //namespace xgx_support

#endif