S3FC project page

S3FC home page

---

               

---

s3_rpc.h

Go to the documentation of this file.

/*
 * Stone Three Foundation Class (s3fc) provides a number of utility classes.
 * Copyright (C) 2001 by Stone Three Signal Processing (Pty) Ltd.
 *
 * Authored by Stone Three Signal Processing (Pty) Ltd.
 *
 * 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 Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 * Please see the file 'COPYING' in the source root directory.
 */

#ifndef S3_RPC_H
#define S3_RPC_H

#include <s3fc/s3_exception.h>
#include <s3fc/s3_thread_base.h>
#include <s3fc/s3_message.h>

#include <string>
#include <vector>
#include <map>


struct s3_rpc_common
{
   //
   static const std::string cmd_tag_call;
   //
   static std::string rpc_server_name(const std::string& name);
   //
   static std::string rpc_random_client_name(const std::string& name);
};

// forward decl
template<typename T_obj> class s3_rpc_caller_m;

template <typename T_obj>
struct s3_rpc_type_common
{
   //
   typedef std::map<std::string, s3_rpc_caller_m<T_obj>*> callmap_t;
   // clear callmap and deallocate memory of callers
   static void clear_callmap(callmap_t& cmap);
};

class s3_rpc_exception : public s3_exception
{
  public:
   s3_rpc_exception(const std::string& where,
          const std::string& what);
};

template<typename T_obj>
class s3_rpc_caller_m
{
  public:
   virtual void call(T_obj* obj,
           const std::vector<std::string>& args) = 0;
   virtual unsigned int get_num_params() = 0;
  protected:
   static s3_rpc_exception err_invalid_args(
      const std::string& where,
      const std::vector<std::string>& args);
};

template<typename T_obj>
struct s3_rpc_caller_m_v_v : public s3_rpc_caller_m<T_obj>
{
  public:
   // type of method that this caller invokes
   typedef void (T_obj::* methodptr_t)(void);
  protected:
   //
   methodptr_t method;
  public:
   //
   s3_rpc_caller_m_v_v(methodptr_t n_method);
   //
   virtual void call(T_obj* obj,
           const std::vector<std::string>& args);
   //
   virtual unsigned int get_num_params();
};

template<typename T_obj, typename T_arg1>
struct s3_rpc_caller_m_v_t1 : public s3_rpc_caller_m<T_obj>
{
  public:
   // type of method that this caller invokes
   typedef void (T_obj::* methodptr_t)(const T_arg1&);
  protected:
   //
   methodptr_t method;
  public:
   //
   s3_rpc_caller_m_v_t1(methodptr_t n_method);
   //
   virtual void call(T_obj* obj,
           const std::vector<std::string>& args);
   //
   virtual unsigned int get_num_params();
};

template<typename T_obj, typename T_arg1, typename T_arg2>
struct s3_rpc_caller_m_v_t2 : public s3_rpc_caller_m<T_obj>
{
  public:
   // type of method that this caller invokes
   typedef void (T_obj::* methodptr_t)(const T_arg1&, const T_arg2&);
  protected:
   //
   methodptr_t method;
  public:
   //
   s3_rpc_caller_m_v_t2(methodptr_t n_method);
   //
   virtual void call(T_obj* obj,
           const std::vector<std::string>& args);
   //
   virtual unsigned int get_num_params();
};

template<typename T_obj>
struct s3_rpc_callmap;


template<typename T_obj>
class s3_rpc_server : public s3_thread_base
{
  protected:
   s3_message_box mb;
   T_obj* obj;
   typename s3_rpc_type_common<T_obj>::callmap_t cmap;
   // this gets posted once when we enter the main loop
   s3_semaphore started;
  public:
   s3_rpc_server(const std::string& n_name,
       T_obj& n_obj);
   virtual ~s3_rpc_server();
  protected:
   //
   virtual void main_loop();
   //
   void handle_message(const s3_message& msg);
   //
   void exec_cmd_call(const s3_message& msg,
            std::string body_str);
   //
   std::string remove_first(std::string& str);
   //
   static void reply_client(s3_message_box& mb,
             const s3_message& msg,
             const std::string& err,
             bool err);
};

template<typename T_obj>
class s3_rpc_client
{
  protected:
   s3_message_box mb;
   std::string server_name;
   typename s3_rpc_type_common<T_obj>::callmap_t cmap;
  public:
   s3_rpc_client(const std::string& n_server_name);
   ~s3_rpc_client();
   std::string call(const std::string& method);
   template<typename T_arg1>
   std::string call(const std::string& method,
          const T_arg1& arg1);
   template<typename T_arg1, typename T_arg2>
   std::string call(const std::string& method,
          const T_arg1& arg1,
          const T_arg2& arg2);
  protected:
   std::string call_common(const std::string& method,
            const std::string& args);
   void assert_method_args(const std::string& where,
            const std::string& method,
            unsigned int num_args);
};


#include <s3fc/s3_rpc.tcc>

#endif

---

Send comments to: s3fc@stonethree.com