jbridge.h

Go to the documentation of this file.

/*
  Copyright (c) Mircea Neacsu (2014-2025) Licensed under MIT License.
  This is part of MLIB project. See LICENSE file for full license terms.
*/

#pragma once
 
#include "httpd.h"
#include "json.h"
 
#include <list>
#include <typeindex>
 
namespace mlib::http {
 
// Errors
#define HTTP_JSON_NOTFOUND -10 
#define HTTP_JSON_DICSTRUC -11 
 
class JSONBridge;

typedef std::function<int (JSONBridge& bridge, void* var)> var_handler;

class JSONBridge
{
public:
  enum jb_type
  {
    JT_UNKNOWN,
    JT_SHORT,   
    JT_USHORT,  
    JT_INT,     
    JT_UINT,    
    JT_LONG,    
    JT_ULONG,   
    JT_FLT,     
    JT_DBL,     
    JT_PSTR,    
    JT_CSTR,    
    JT_STR,     
    JT_BOOL,    
    JT_OBJECT,  
    JT_POSTFUN, 
  };

  class entry;
  typedef std::list<entry> dictionary;
  typedef dictionary::iterator dict_ptr;
  typedef dictionary::const_iterator dict_cptr;
 
  class entry
  {
  public:
    entry (const std::string& n, void* a, jb_type t, size_t s, size_t c)
      : name (n)
      , addr (a)
      , type (t)
      , cnt (c)
      , sz (s)
    {}
 
    template <typename T, size_t C>
    void add_var (T (&var)[C], const std::string& name)
    {
      using U = typename std::remove_extent<T>::type;
      constexpr size_t sz = sizeof (U) * (std::extent_v<T> ? std::extent_v<T> : 1);
      constexpr jb_type t = std::is_same_v<U, short>            ? JT_SHORT
                            : std::is_same_v<U, unsigned short> ? JT_USHORT
                            : std::is_same_v<U, int>            ? JT_INT
                            : std::is_same_v<U, unsigned int>   ? JT_UINT
                            : std::is_same_v<U, long>           ? JT_LONG
                            : std::is_same_v<U, unsigned long>  ? JT_ULONG
                            : std::is_same_v<U, float>          ? JT_FLT
                            : std::is_same_v<U, double>         ? JT_DBL
                            : std::is_same_v<U, bool>           ? JT_BOOL
                            : std::is_same_v<U, char>           ? JT_CSTR
                            : std::is_same_v<U, std::string>    ? JT_STR
                            : std::is_same_v<U, char*>          ? JT_PSTR
                            : std::is_same_v<U, const char*>    ? JT_PSTR
                                                                : JT_UNKNOWN;
      static_assert (t != JT_UNKNOWN, "Invalid array type");
      if (t == JT_CSTR && sz == 1)
        children.emplace_back (name, var, t, C, 1); // char var[C]
      else
        children.emplace_back (name, var, t, sz, C);
    }
 
    template <typename T>
    std::enable_if_t<std::is_same_v<T, std::string> || std::is_same_v<T, short>
                     || std::is_same_v<T, unsigned short> || std::is_same_v<T, int>
                     || std::is_same_v<T, unsigned int> || std::is_same_v<T, long>
                     || std::is_same_v<T, unsigned long> || std::is_same_v<T, float>
                     || std::is_same_v<T, double> || std::is_same_v<T, bool>>
    add_var (T& var, const std::string& name)
    {
      constexpr jb_type t = std::is_same_v<T, short>            ? JT_SHORT
                            : std::is_same_v<T, unsigned short> ? JT_USHORT
                            : std::is_same_v<T, int>            ? JT_INT
                            : std::is_same_v<T, unsigned int>   ? JT_UINT
                            : std::is_same_v<T, long>           ? JT_LONG
                            : std::is_same_v<T, unsigned long>  ? JT_ULONG
                            : std::is_same_v<T, float>          ? JT_FLT
                            : std::is_same_v<T, double>         ? JT_DBL
                            : std::is_same_v<T, bool>           ? JT_BOOL
                            : std::is_same_v<T, char>           ? JT_CSTR
                            : std::is_same_v<T, std::string>    ? JT_STR
                            : std::is_same_v<T, char*>          ? JT_PSTR
                            : std::is_same_v<T, const char*>    ? JT_PSTR
                                                                : JT_UNKNOWN;
      static_assert (t != JT_UNKNOWN, "Invalid variable type");
      children.emplace_back (name, &var, t, sizeof (T), 1);
    }
 
    entry& add_object (const std::string& name)
    {
      children.emplace_back (name, nullptr, JT_OBJECT, 0, 1);
      return *(--children.end ());
    }
 
  private:
    std::string name; 
    void* addr;       
    jb_type type;     
    size_t sz;
    size_t cnt; 
    dictionary children;
    friend class JSONBridge;
  };
 
  JSONBridge (const char* path);
  ~JSONBridge ();
 
  void attach_to (server& server);
  void lock ();
  void unlock ();
  const std::string& path () const;
  void redirect_to (const std::string& uri);
  void set_post_action (uri_handler pfn);
  connection& client ();
 
  bool parse_urlencoded () const;
  bool parse_jsonencoded () const;

  template <typename T, size_t C>
  void add_var (T (&var)[C], const std::string& name)
  {
    using U = typename std::remove_extent<T>::type;
    constexpr size_t sz = sizeof (U) * (std::extent_v<T> ? std::extent_v<T> : 1);
    constexpr jb_type t = std::is_same_v<U, short>            ? JT_SHORT
                          : std::is_same_v<U, unsigned short> ? JT_USHORT
                          : std::is_same_v<U, int>            ? JT_INT
                          : std::is_same_v<U, unsigned int>   ? JT_UINT
                          : std::is_same_v<U, long>           ? JT_LONG
                          : std::is_same_v<U, unsigned long>  ? JT_ULONG
                          : std::is_same_v<U, float>          ? JT_FLT
                          : std::is_same_v<U, double>         ? JT_DBL
                          : std::is_same_v<U, bool>           ? JT_BOOL
                          : std::is_same_v<U, char>           ? JT_CSTR
                          : std::is_same_v<U, char*>          ? JT_PSTR
                          : std::is_same_v<U, const char*>    ? JT_PSTR
                                                              : JT_UNKNOWN;
    static_assert (t != JT_UNKNOWN, "Invalid array type");
    if (t == JT_CSTR && sz == 1)
      dict_.emplace_back (name, var, t, C, 1); // char var[C]
    else
      dict_.emplace_back (name, var, t, sz, C);
  }

  template <typename T>
  std::enable_if_t<std::is_same_v<T, std::string> || std::is_same_v<T, short>
                    || std::is_same_v<T, unsigned short> || std::is_same_v<T, int>
                    || std::is_same_v<T, unsigned int> || std::is_same_v<T, long>
                    || std::is_same_v<T, unsigned long> || std::is_same_v<T, float>
                    || std::is_same_v<T, double> || std::is_same_v<T, bool>>
  add_var (T& var, const std::string& name)
  {
    constexpr jb_type t = std::is_same_v<T, short>            ? JT_SHORT
                          : std::is_same_v<T, unsigned short> ? JT_USHORT
                          : std::is_same_v<T, int>            ? JT_INT
                          : std::is_same_v<T, unsigned int>   ? JT_UINT
                          : std::is_same_v<T, long>           ? JT_LONG
                          : std::is_same_v<T, unsigned long>  ? JT_ULONG
                          : std::is_same_v<T, float>          ? JT_FLT
                          : std::is_same_v<T, double>         ? JT_DBL
                          : std::is_same_v<T, bool>           ? JT_BOOL
                          : std::is_same_v<T, char>           ? JT_CSTR
                          : std::is_same_v<T, std::string>    ? JT_STR
                          : std::is_same_v<T, char*>          ? JT_PSTR
                          : std::is_same_v<T, const char*>    ? JT_PSTR
                                                              : JT_UNKNOWN;
    static_assert (t != JT_UNKNOWN, "Invalid variable type");
    dict_.emplace_back (name, &var, t, sizeof (T), 1);
  }
 
  entry& add_object (const std::string& name);
  void add_postfun (const std::string& name, uri_handler pfn);
 
protected:
 
  erc jsonify (json::node& n, dict_cptr entry);
  void not_found (const char* varname);
  bool find (const std::string& name, dict_cptr& found, size_t* idx = 0) const;
  bool deep_find (const std::string& name, dict_cptr& found, size_t* idx = 0) const;
 
private:
  void process_request ();
  erc json_begin (json::node& obj);
  erc json_end (json::node& obj);
  erc serialize_node (json::node& n, dict_cptr v, size_t index = 0);
  erc deserialize_node (const json::node& n, dict_cptr v, size_t index = 0) const;
  std::string path_;
  dictionary dict_;
  connection* client_;
  criticalsection in_use;
  uri_handler post_action;
  std::string redirect_uri;
  std::map<std::string, uri_handler> post_handlers;
 
  static int callback (connection& client, void* ctx);
  static bool deep_search (const std::string& var, const dictionary& dict, dict_cptr& found);
};
 
/*==================== INLINE FUNCTIONS ===========================*/

inline void JSONBridge::lock ()
{
  in_use.enter ();
}

inline void JSONBridge::unlock ()
{
  in_use.leave ();
}

inline const std::string& JSONBridge::path () const
{
  return path_;
}

inline void JSONBridge::redirect_to (const std::string& uri)
{
  redirect_uri = uri;
}

inline connection& JSONBridge::client ()
{
  if (client_)
    return *client_;
  else
    throw std::logic_error ("Missing client connection");
};

inline void JSONBridge::set_post_action (uri_handler pfn)
{
  post_action = pfn;
}
 
inline JSONBridge::entry& JSONBridge::add_object (const std::string& name)
{
  dict_.emplace_back (name, nullptr, JT_OBJECT, 0, 1);
  return *(--dict_.end ());
}

inline void JSONBridge::add_postfun (const std::string& qparam, uri_handler pfn)
{
  post_handlers[qparam] = pfn;
}
 
} // end namespace mlib::http