WebServiceModule.h

Go to the documentation of this file.

/*
 * Copyright 2006-2009 Savarese Software Research Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.savarese.com/software/ApacheLicense-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __SSRC_WSPR_WS_WEB_SERVICE_MODULE_H
#define __SSRC_WSPR_WS_WEB_SERVICE_MODULE_H

#include <ssrc/wispers/service/service.h>
#include <ssrc/wispers/ws/types.h>
#include <ssrc/wispers/utility/Properties.h>

__BEGIN_NS_SSRC_WSPR_WS

using NS_SSRC_WISP_PROTOCOL::CallException;
using NS_SSRC_WSPR_SERVICE::timeout_handler;
using NS_SSRC_WSPR_SERVICE::timeout_ptr;
using NS_SSRC_WSPR_SERVICE::message_handler_type;
using NS_SSRC_WSPR_SERVICE::message_handler_entry;
using NS_SSRC_WSPR_SERVICE::message_handler_map;
using NS_SSRC_WSPR_SERVICE::EventLoop;
using NS_SSRC_WSPR_UTILITY::Properties;

// Forward declaration
class WebServiceRunner;

struct WebServiceModuleContext {
  typedef WebServiceProtocol protocol_traits;
  WISP_IMPORT(protocol_traits, packing_traits);
  typedef NS_SSRC_WISP_PROTOCOL::ContinuationCaller<packing_traits> caller_type;

  caller_type & caller;
  const string ws_type;
  const Properties & properties;

  timeout_ptr schedule_timeout(const timeout_handler & handler,
                               const TimeValue & timeout,
                               const bool once = EventLoop::Persist);

  void cancel_timeout(const timeout_ptr & timeout);

private:
  friend class WebServiceRunner;

  WebServiceModuleContext(WebServiceRunner & runner,
                          caller_type & caller,
                          const string & ws_type,
                          const Properties & properties) :
    caller(caller), ws_type(ws_type), properties(properties),
    _runner(runner)
  { }

  WebServiceRunner & _runner;
};

typedef boost::shared_ptr<WebServiceModuleContext> ws_module_context_ptr;

struct WebServiceModule {
  virtual ~WebServiceModule() { }

  virtual string ws_type() const = 0;

  virtual call_handler_map::iterator call_begin() = 0;

  virtual call_handler_map::iterator call_end() = 0;

  virtual call_handler_map::iterator call_find(const string & call) = 0;

  virtual message_handler_map::iterator request_begin() = 0;
  virtual message_handler_map::iterator request_end() = 0;
  virtual message_handler_map::iterator response_begin() = 0;
  virtual message_handler_map::iterator response_end() = 0;
};

#define WS_MODULE_CALL(call, function_ptr) \
  DefaultWebServiceModule::call_insert(call, boost::bind(function_ptr, this, _1, _2))

#define WS_MODULE_CALL_WITH_PARAM(call, module_type, param_type, function_ptr) \
  DefaultWebServiceModule::call_insert(call, boost::bind(NS_SSRC_WSPR_WS::ws_call<module_type, param_type>, this, function_ptr, _1, _2))

class DefaultWebServiceModule : public WebServiceModule {
  call_handler_map _call_handlers;
  message_handler_map _request_handlers;
  message_handler_map _response_handlers;

protected:
  typedef WebServiceProtocol protocol_traits;

  WISP_IMPORT(protocol_traits, packing_traits);
  WISP_IMPORT(protocol_traits, parameter_map);
  WISP_IMPORT(protocol_traits, MessageResponse);
  WISP_IMPORT(protocol_traits, MessageDeliverEvent);
  WISP_IMPORT(protocol_traits, CallResponse);
  WISP_IMPORT(protocol_traits, CallDeliverEvent);

public:

  typedef NS_SSRC_WISP_PROTOCOL::ContinuationCaller<packing_traits> caller_type;

  DefaultWebServiceModule(const ws_module_context_ptr & context) :
    _call_handlers(), _request_handlers(), _response_handlers(),
    _caller(context->caller), _context(context)
  { }

  virtual ~DefaultWebServiceModule() { }

  virtual string ws_type() const {
    return _context->ws_type;
  }

  virtual call_handler_map::iterator call_begin() {
    return _call_handlers.begin();
  }

  virtual call_handler_map::iterator call_end() {
    return _call_handlers.end();
  }

  virtual call_handler_map::iterator call_find(const string & call) {
    return _call_handlers.find(call);
  }

  virtual message_handler_map::iterator request_begin() {
    return _request_handlers.begin();
  }

  virtual message_handler_map::iterator request_end() {
    return _request_handlers.end();
  }

  virtual message_handler_map::iterator response_begin() {
    return _response_handlers.begin();
  }

  virtual message_handler_map::iterator response_end() {
    return _response_handlers.end();
  }

protected:

  bool
  call_insert(const string & call, const call_handler_type & call_handler) {
    return
      _call_handlers.insert(call_handler_map::value_type(call, call_handler)).second;
  }

  // So you can reuse message types that are expensive to create on each call.
  template<typename MessageType, typename Impl>
  void request(Impl & impl, MessageType & msg, MessageInfo & msginfo)
    SSRC_DECL_THROW(boost::archive::archive_exception, std::ios_base::failure,
                    CallException)
  {
    _caller.unpack(msg, msginfo);
    // Cast forces msginfo to be const arg in process_request
    impl.process_request(msg, static_cast<const MessageInfo &>(msginfo));
  }

  template<typename MessageType, typename Impl>
  void request(Impl & impl, MessageInfo & msginfo)
    SSRC_DECL_THROW(boost::archive::archive_exception, std::ios_base::failure)
  {
    MessageType msg;
    request(impl, msg, msginfo);
  }

  template<typename MessageType, typename Impl>
  void respond(Impl & impl, MessageType & msg, MessageInfo & msginfo)
    SSRC_DECL_THROW(boost::archive::archive_exception, std::ios_base::failure,
                    CallException)
  {
    _caller.unpack(msg, msginfo);
    // Cast forces msginfo to be const arg in process_response
    impl.process_response(msg, static_cast<const MessageInfo &>(msginfo));
  }

  template<typename MessageType, typename Impl>
  void respond(Impl & impl, MessageInfo & msginfo)
    SSRC_DECL_THROW(boost::archive::archive_exception, std::ios_base::failure)
  {
    MessageType msg;
    respond(impl, msg, msginfo);
  }

  bool set_request_handler(const message_handler_entry & handler) {
    return _request_handlers.insert(handler).second;
  }

  template<typename MessageType, typename Impl>
  bool set_request_handler(Impl & impl) {
    return set_request_handler(message_handler_entry(MessageType::protocol,
                                                     MessageType::id,
                                                     boost::bind(&DefaultWebServiceModule::template request<MessageType, Impl>, this, std::ref(impl), _1)));
  }

  template<typename MessageType, typename Impl>
  bool set_request_handler(Impl & impl, MessageType & buffer)  {
    return set_request_handler(message_handler_entry(MessageType::protocol,
                                                     MessageType::id,
                                                     boost::bind(&DefaultWebServiceModule::template request<MessageType, Impl>, this, std::ref(impl), std::ref(buffer), _1)));
  }

  bool set_response_handler(const message_handler_entry & handler) {
    return _response_handlers.insert(handler).second;
  }

  template<typename MessageType, typename Impl>
  bool set_response_handler(Impl & impl) {
    return set_response_handler(message_handler_entry(MessageType::protocol,
                                                      MessageType::id,
                                                      boost::bind(&DefaultWebServiceModule::template respond<MessageType, Impl>, this, std::ref(impl), _1)));  }

  template<typename MessageType, typename Impl>
  bool set_response_handler(Impl & impl, MessageType & buffer) {
    return set_response_handler(message_handler_entry(MessageType::protocol,
                                                      MessageType::id,
                                                      boost::bind(&DefaultWebServiceModule::template respond<MessageType, Impl>, this, std::ref(impl), std::ref(buffer), _1)));
  }

  caller_type & _caller;
  ws_module_context_ptr _context;
};

__END_NS_SSRC_WSPR_WS

#endif