libzeep

PrevUpHomeNext

Class soap_controller

zeep::http::soap_controller — class that helps with handling SOAP requests

Synopsis

// In header: <zeep/http/soap-controller.hpp>


class soap_controller : public zeep::http::controller {
public:
  // member classes/structs/unions
  template<typename Callback, typename... > 
  struct mount_point {
  };
  template<typename ControllerType, typename Result, typename... Args> 
  struct mount_point<Result(ControllerType::*)(Args...)> : public zeep::http::soap_controller::mount_point_base {
    // types
    typedef Result(ControllerType::*)(Args...)                                                        Sig;      
    typedef std::tuple< typename std::remove_const_t< typename std::remove_reference_t< Args > >... > ArgsTuple;
    typedef std::function< Result(Args...)>                                                           Callback; 

    // construct/copy/destruct
    mount_point(const char *, soap_controller *, Sig);
    template<typename... Names> 
      mount_point(const char *, soap_controller *, Sig, Names...);

    // public member functions
    virtual void 
    collect_types(std::map< std::string, xml::element > &, 
                  const std::string &);
    template<std::size_t... I> 
      void collect_types(std::map< std::string, xml::element > &, 
                         const std::string &, std::index_sequence< I... >);
    template<std::size_t I> 
      xml::element 
      collect_type(std::map< std::string, xml::element > &, 
                   const std::string &);
    virtual void call(const xml::element &, reply &, const std::string &);
    template<typename ResultType, typename ArgsTuple, 
             std::enable_if_t< std::is_void_v< ResultType >, int >  = 0> 
      void invoke(ArgsTuple &&, reply &, const std::string &);
    template<typename ResultType, typename ArgsTuple, 
             std::enable_if_t< not std::is_void_v< ResultType >, int >  = 0> 
      void invoke(ArgsTuple &&, reply &, const std::string &);
    template<std::size_t... I> 
      ArgsTuple collect_arguments(const xml::element &, 
                                  std::index_sequence< I... >);
    template<typename T> T get_parameter(xml::deserializer &, const char *);
    virtual void 
    describe(type_map &, message_map &, xml::element &, xml::element *);

    // public data members
    static constexpr size_t N;
    Callback m_callback;
    std::array< const char *, N > m_names;
    xml::element m_responseType;
    std::array< xml::element, N > m_parameterTypes;
  };

  struct mount_point_base {
    // construct/copy/destruct
    mount_point_base(const char *);
    ~mount_point_base();

    // public member functions
    virtual void call(const xml::element &, reply &, const std::string &) = 0;
    virtual void 
    collect_types(std::map< std::string, xml::element > &, 
                  const std::string &) = 0;

    // public data members
    std::string m_action;
  };
  // construct/copy/destruct
  soap_controller(const std::string &, const std::string &);
  ~soap_controller();

  // public member functions
  void set_location(const std::string &);
  void set_service(const std::string &);
  template<typename Callback, typename... ArgNames> 
    void map_action(const char *, Callback, ArgNames...);
  xml::element make_wsdl();
  virtual bool handle_request(request &, reply &);
};

Description

This controller will handle SOAP requests automatically handing the packing and unpacking of XML envelopes.

To use this, create a subclass and add some methods that should be exposed. Then map these methods on a path that optionally contains parameter values.

See the chapter on SOAP controllers in the documention for more information.

soap_controller public construct/copy/destruct

  1. soap_controller(const std::string & prefix_path, const std::string & ns);
    constructor

    Parameters:

    ns

    This is the XML Namespace for our SOAP calls

    prefix_path

    This is the leading part of the request URI for each mount point

  2. ~soap_controller();

soap_controller public member functions

  1. void set_location(const std::string & location);
    Set the external address at which this service is visible.
  2. void set_service(const std::string & service);
    Set the service name.
  3. template<typename Callback, typename... ArgNames> 
      void map_action(const char * actionName, Callback callback, 
                      ArgNames... names);
    map a SOAP action to callback using names for mapping the arguments

    The method in callback should be a method of the derived class having as many arguments as the number of specified names.

  4. xml::element make_wsdl();
    Create a WSDL based on the registered actions.
  5. virtual bool handle_request(request & req, reply & reply);
    Handle the SOAP request.

PrevUpHomeNext