ulxr_method_adder.h

Go to the documentation of this file.

/***************************************************************************
           ulxr-method_adder.h  -  interface for adding methods
                             -------------------
    begin                : Thu Jul 12 2007
    copyright            : (C) 2002-2007 by Ewald Arnold
    email                : ulxmlrpcpp@ewald-arnold.de

    $Id: ulxr_mtrpc_server.h 940 2006-12-30 18:22:05Z ewald-arnold $

 ***************************************************************************/

/**************************************************************************
 *
 * This program 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 of the License,
 * or (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 ***************************************************************************/

#ifndef ULXR_METHOD_ADDER_H
#define ULXR_METHOD_ADDER_H

#include <ulxmlrpcpp/ulxmlrpcpp.h>  // always first header

namespace ulxr {


class MethodResponse;
class MethodCall;
class Dispatcher;
class Signature;


namespace hidden {


class ULXR_API_DECL0 MethodWrapperBase
{
  public:

    virtual ~MethodWrapperBase();

    virtual MethodResponse call(const MethodCall &calldata) const = 0;
};


template <class T>
class MethodWrapper : public MethodWrapperBase
{
  public:

   typedef MethodResponse (T::*PMF)(const MethodCall &calldata);

   virtual ~MethodWrapper()
   {
   }

   virtual MethodResponse call (const MethodCall &calldata) const
   {
      return (obj->*adr) (calldata);
   }

   MethodWrapper(T *o, PMF a)
    : obj(o), adr(a)
     {}

  private:
   T    *obj;
   PMF   adr ;

 private:
    // forbid them all due to internal pointers
    const MethodWrapper& operator= (const MethodWrapper&);
    MethodWrapper (const MethodWrapper&);
};


}  // namespace hidden


class ULXR_API_DECL0 MethodAdder
{
  public:

    typedef MethodResponse (*StaticMethodCall_t)(const MethodCall &);

    typedef MethodResponse (*SystemMethodCall_t)(const MethodCall &,
                                                 const Dispatcher* disp);

    typedef hidden::MethodWrapperBase*  DynamicMethodCall_t;    // call Wrappers call();

    enum   CallType { CallNone,
                      CallSystem,
                      CallStatic,
                      CallDynamic
                    };

  protected:

    friend StaticMethodCall_t make_method(const StaticMethodCall_t);

    typedef union
    {
       StaticMethodCall_t    static_function;
       SystemMethodCall_t    system_function;
       DynamicMethodCall_t   dynamic_function;
    } MethodCall_t;

  public:

    virtual ~MethodAdder()
    {}

   virtual void addMethod (StaticMethodCall_t adr,
                   const CppString &ret_signature,
                   const CppString &name,
                   const CppString &signature,
                   const CppString &help) = 0;

   virtual void addMethod (DynamicMethodCall_t wrapper,
                   const CppString &ret_signature,
                   const CppString &name,
                   const CppString &signature,
                   const CppString &help) = 0;

   virtual void addMethod (SystemMethodCall_t adr,
                   const CppString &ret_signature,
                   const CppString &name,
                   const CppString &signature,
                   const CppString &help) = 0;

   virtual void addMethod (StaticMethodCall_t adr,
                   const Signature &ret_signature,
                   const CppString &name,
                   const Signature &signature,
                   const CppString &help) = 0;

   virtual void addMethod (DynamicMethodCall_t wrapper,
                   const Signature &ret_signature,
                   const CppString &name,
                   const Signature &signature,
                   const CppString &help) = 0;

   virtual void addMethod (SystemMethodCall_t adr,
                   const Signature &ret_signature,
                   const CppString &name,
                   const Signature &signature,
                   const CppString &help) = 0;

   virtual void removeMethod(const CppString &name) = 0;
};


#ifndef _MSC_VER

template <class T>
inline hidden::MethodWrapperBase*
make_method(T &w, typename hidden::MethodWrapper<T>::PMF pmf)
{
  return new hidden::MethodWrapper<T> (&w, pmf);
}

#else // work around m$vc bug

template <class T, class U>
inline hidden::MethodWrapper<T>*
make_method(T &w, U pmf)
{
  return new hidden::MethodWrapper<T> (&w, pmf);
}

#endif

typedef MethodAdder::StaticMethodCall_t MethodAdder_StaticMethodCall_t;

inline MethodAdder_StaticMethodCall_t
make_method(MethodAdder_StaticMethodCall_t ptr)
{
  return ptr;
}


} // namespace

#endif // ULXR_METHOD_ADDER_H

---