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

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

## Synopsis

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

    template<typename ControllerType, typename Result, typename... Args>
    struct mount_point<Result(ControllerType::*)(Args...)> : public zeep::http::rest_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 typename std::remove_const_t< typename std::remove_reference_t< Result > >                ResultType;
      typedef std::function< ResultType(Args...)>                                                       Callback;

      // construct/copy/destruct
      template<typename... Names>
        mount_point(const char *, const std::string &, rest_controller *, Sig,
                    Names...);

      // public member functions
      virtual void call(const parameter_pack &, reply &);
      template<typename ResultType, typename ArgsTuple,
               std::enable_if_t< std::is_void_v< ResultType >, int >  = 0>
        void invoke(ArgsTuple &&, reply &);
      template<typename ResultType, typename ArgsTuple,
               std::enable_if_t< not(std::is_void_v< ResultType > or std::is_same_v< ResultType, reply >), int >  = 0>
        void invoke(ArgsTuple &&, reply &);
      template<typename ResultType, typename ArgsTuple,
               std::enable_if_t< std::is_same_v< ResultType, reply >, int >  = 0>
        void invoke(ArgsTuple &&, reply &);
      void set_reply(reply &, std::filesystem::path);
      void set_reply(reply &, zeep::json::element &&);
      template<typename T> void set_reply(reply &, T &&);
      template<std::size_t... I>
        ArgsTuple collect_arguments(const parameter_pack &,
                                    std::index_sequence< I... >);
      bool get_parameter(const parameter_pack &, const char *, bool);
      std::string get_parameter(const parameter_pack &, const char *, std::string);
      file_param get_parameter(const parameter_pack &, const char *, file_param);
      std::vector< file_param >
      get_parameter(const parameter_pack &, const char *,
                    std::vector< file_param >);
      json::element
      get_parameter(const parameter_pack &, const char *, json::element);
      template<typename T>
        std::optional< T >
        get_parameter(const parameter_pack &, const char *, std::optional< T >);
      std::optional< std::string >
      get_parameter(const parameter_pack &, const char *,
                    std::optional< std::string >);
      template<typename T, std::enable_if_t< not(zeep::has_serialize_v< T, zeep::json::deserializer< json::element >> or std::is_enum_v< T > or zeep::is_serializable_array_type_v< T, zeep::json::deserializer< json::element >>), int >  = 0>
        T get_parameter(const parameter_pack &, const char *, T);
      template<typename T, unspecified  = 0>
        T get_parameter(const parameter_pack &, const char *, T);
      template<typename T, std::enable_if_t< zeep::has_serialize_v< T, zeep::json::deserializer< json::element >> or zeep::is_serializable_array_type_v< T, zeep::json::deserializer< json::element >>, int >  = 0>
        T get_parameter(const parameter_pack &, const char *, T);

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

## Description

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

1.     template<typename... Names>
         mount_point(const char * path, const std::string & method,
                     rest_controller * owner, Sig sig, Names... names);

### `mount_point` public member functions

1.     virtual void call(const parameter_pack & params, reply & reply);

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

3.     template<typename ResultType, typename ArgsTuple,
                std::enable_if_t< not(std::is_void_v< ResultType > or std::is_same_v< ResultType, reply >), int >  = 0>
         void invoke(ArgsTuple && args, reply & reply);

4.     template<typename ResultType, typename ArgsTuple,
                std::enable_if_t< std::is_same_v< ResultType, reply >, int >  = 0>
         void invoke(ArgsTuple && args, reply & reply);

5.     void set_reply(reply & rep, std::filesystem::path v);

6.     void set_reply(reply & rep, zeep::json::element && v);

7.     template<typename T> void set_reply(reply & rep, T && v);

8.     template<std::size_t... I>
         ArgsTuple collect_arguments(const parameter_pack & params,
                                     std::index_sequence< I... >);

9.     bool get_parameter(const parameter_pack & params, const char * name,
                          bool result);

10.     std::string get_parameter(const parameter_pack & params, const char * name,
                                  std::string result);

11.     file_param get_parameter(const parameter_pack & params, const char * name,
                                 file_param result);

12.     std::vector< file_param >
        get_parameter(const parameter_pack & params, const char * name,
                      std::vector< file_param > result);

13.     json::element
        get_parameter(const parameter_pack & params, const char * name,
                      json::element result);

14.     template<typename T>
          std::optional< T >
          get_parameter(const parameter_pack & params, const char * name,
                        std::optional< T > result);

15.     std::optional< std::string >
        get_parameter(const parameter_pack & params, const char * name,
                      std::optional< std::string > result);

16.     template<typename T, std::enable_if_t< not(zeep::has_serialize_v< T, zeep::json::deserializer< json::element >> or std::is_enum_v< T > or zeep::is_serializable_array_type_v< T, zeep::json::deserializer< json::element >>), int >  = 0>
          T get_parameter(const parameter_pack & params, const char * name, T result);

17.     template<typename T, unspecified  = 0>
          T get_parameter(const parameter_pack & params, const char * name, T result);

18.     template<typename T, std::enable_if_t< zeep::has_serialize_v< T, zeep::json::deserializer< json::element >> or zeep::is_serializable_array_type_v< T, zeep::json::deserializer< json::element >>, int >  = 0>
          T get_parameter(const parameter_pack & params, const char * name, T result);