## Struct template mount_point<Result(ControllerType::*)(Args...)>

zeep::http::soap_controller::mount_point<Result(ControllerType::*)(Args...)>

## Synopsis

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

    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;
    };

## Description

### `mount_point` public construct/copy/destruct

1.     mount_point(const char * action, soap_controller * owner, Sig sig);

2.     template<typename... Names>
         mount_point(const char * action, soap_controller * owner, Sig sig,
                     Names... names);

### `mount_point` public member functions

1.     virtual void
       collect_types(std::map< std::string, xml::element > & types,
                     const std::string & ns);

2.     template<std::size_t... I>
         void collect_types(std::map< std::string, xml::element > & types,
                            const std::string & ns, std::index_sequence< I... > ix);

3.     template<std::size_t I>
         xml::element
         collect_type(std::map< std::string, xml::element > & types,
                      const std::string & ns);

4.     virtual void
       call(const xml::element & request, reply & reply, const std::string & ns);

5.     template<typename ResultType, typename ArgsTuple,
                std::enable_if_t< std::is_void_v< ResultType >, int >  = 0>
         void invoke(ArgsTuple && args, reply & reply, const std::string & ns);

6.     template<typename ResultType, typename ArgsTuple,
                std::enable_if_t< not std::is_void_v< ResultType >, int >  = 0>
         void invoke(ArgsTuple && args, reply & reply, const std::string & ns);

7.     template<std::size_t... I>
         ArgsTuple collect_arguments(const xml::element & request,
                                     std::index_sequence< I... >);

8.     template<typename T>
         T get_parameter(xml::deserializer & ds, const char * name);

9.     virtual void
       describe(type_map & types, message_map & messages, xml::element & portType,
                xml::element * binding);