libzeep

PrevUpHomeNext

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 >, 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 >), 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 >>, 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 & reply);
  3. template<typename ResultType, typename ArgsTuple, 
             std::enable_if_t< not std::is_void_v< ResultType >, int >  = 0> 
      void invoke(ArgsTuple && args, reply & reply);
  4. void set_reply(reply & rep, std::filesystem::path v);
  5. void set_reply(reply & rep, zeep::json::element && v);
  6. template<typename T> void set_reply(reply & rep, T && v);
  7. template<std::size_t... I> 
      ArgsTuple collect_arguments(const parameter_pack & params, 
                                  std::index_sequence< I... >);
  8. bool get_parameter(const parameter_pack & params, const char * name, 
                       bool result);
  9. std::string get_parameter(const parameter_pack & params, const char * name, 
                              std::string result);
  10. file_param get_parameter(const parameter_pack & params, const char * name, 
                             file_param result);
  11. std::vector< file_param > 
    get_parameter(const parameter_pack & params, const char * name, 
                  std::vector< file_param > result);
  12. json::element 
    get_parameter(const parameter_pack & params, const char * name, 
                  json::element result);
  13. template<typename T> 
      std::optional< T > 
      get_parameter(const parameter_pack & params, const char * name, 
                    std::optional< T > result);
  14. std::optional< std::string > 
    get_parameter(const parameter_pack & params, const char * name, 
                  std::optional< std::string > result);
  15. template<typename T, std::enable_if_t< not(zeep::has_serialize_v< T, zeep::json::deserializer< json::element >> or std::is_enum_v< T >), int >  = 0> 
      T get_parameter(const parameter_pack & params, const char * name, T result);
  16. template<typename T, unspecified  = 0> 
      T get_parameter(const parameter_pack & params, const char * name, T result);
  17. template<typename T, std::enable_if_t< zeep::has_serialize_v< T, zeep::json::deserializer< json::element >>, int >  = 0> 
      T get_parameter(const parameter_pack & params, const char * name, T result);

PrevUpHomeNext