comet-cpp 0.9.0

data/vendor/src/element.hpp

@@ -0,0 +1,138 @@
+#ifndef  COMET_ELEMENT_HPP
+# define COMET_ELEMENT_HPP
+
+# include <cheerp/client.h>
+# include <cheerp/clientlib.h>
+# include <map>
+# include "object.hpp"
+# include "events.hpp"
+# include "append_semantics.hpp"
+
+namespace Comet
+{
+  class Element : public ObjectImpl<client::HTMLElement>
+  {
+  public:
+    std::shared_ptr<JavascriptEvents> events;
+
+    Element();
+    Element(const client::String& str, const std::map<std::string, std::string>& attrs = {});
+    Element(client::HTMLElement*);
+
+    Element& attr(const std::map<std::string, std::string>& attrs);
+    Element& attr(const std::map<std::string, std::wstring>& attrs);
+    Element& attr(const std::map<std::string, client::String*>& attrs);
+    Element& attr(const std::string& name, const std::string& value);
+    std::string attr(const std::string& name) const;
+
+    Element& css(const std::string& name, const std::string& value);
+    Element& css(const std::map<std::string, std::string>& attrs);
+    std::map<std::string, std::string> css() const;
+
+    Element& html(client::String* content)      { (*this)->set_innerHTML(content); return *this; }
+    Element& html(const std::string& content)   { _html<std::string>(content); return *this; }
+    Element& html(const std::wstring& content)  { _html<std::wstring>(content); return *this; }
+    Element& text(client::String* content)      { (*this)->set_textContent(content); return *this; }
+    Element& text(const std::string& content)   { _text<std::string>(content); return *this; }
+    Element& text(const std::wstring& content)  { _text<std::wstring>(content); return *this; }
+    Element& value(client::String* val)         { static_cast<client::HTMLInputElement*>(**this)->set_value(val); return *this; }
+    Element& value(const std::string& val)      { _value<std::string>(val); return *this; }
+    Element& value(const std::wstring& val)     { _value<std::wstring>(val); return *this; }
+    template<typename T>
+    Element& value(const T val) { std::stringstream stream; stream << val; _value<std::string>(stream.str()); return *this; }
+    Element& checked(bool val)                  { static_cast<client::HTMLInputElement*>(**this)->set_checked(val); return *this; }
+
+    std::string html()    const { return Comet::Object((*this)->get_innerHTML()); }
+    std::string tagName() const { return Comet::Object((*this)->get_tagName()); }
+
+    template<typename T>
+    T value()
+    {
+      T var;
+      std::stringstream stream;
+      stream << get_value();
+      stream >> var;
+      return var;
+    }
+
+    template<>
+    std::wstring value<std::wstring>()
+    {
+      auto* input_el = static_cast<client::HTMLInputElement*>(**this);
+      auto* client_string = input_el->get_value();
+
+      return to_wstring(client_string);
+    }
+
+    inline Element& inner(const std::vector<Element>& els)                  { return operator>(els); }
+    inline Element& inner(const std::vector<Element*>& els)                 { return operator>(els); }
+    inline Element& inner(const std::vector<std::shared_ptr<Element> > els) { return operator>(els); }
+
+    template<typename LIST>
+    Element& operator>(const LIST& list)
+    {
+      ElementListAppender<LIST, is_array_container<LIST>::value>::append_list(list, **this);
+      return *this;
+    }
+
+    Element& empty();
+
+    void append_to(client::HTMLElement* el);
+    void append_to(Element& el);
+    void insert_before(client::HTMLElement* el);
+    void insert_before(Element& el);
+    void insert_after(client::HTMLElement* el);
+    void insert_after(Element& el);
+    void destroy();
+
+    bool    is_attached() const;
+    bool    has_parent() const;
+    Element get_parent();
+    Element get_next();
+
+    std::vector<Element> find(const std::string& selector);
+    Element              find_one(const std::string& selector);
+    bool                 contains(const client::HTMLElement*);
+    void                 each(std::function<bool (Element&)>);
+
+    void                 toggle_class(const std::string& str, bool set);
+    void                 add_class(const std::string& str);
+    void                 remove_class(const std::string& str);
+    bool                 has_class(const std::string& str) const;
+
+    bool                 has_attribute(const std::string& key) const;
+    std::string          get_attribute(const std::string& key) const;
+    void                 remove_attribute(const std::string& key);
+
+    bool                 is_visible() const;
+    Element&             visible(bool, const std::string& display = "");
+    void                 set_visible(bool val) { visible(val); }
+
+    std::string          get_inner_html() const;
+    std::string          get_text() const;
+    std::string          get_value() const;
+    bool                 get_checked() const { return static_cast<client::HTMLInputElement*>(**this)->get_checked(); }
+
+  private:
+    template<typename TYPE>
+    void _html(const TYPE& content)
+    {
+      (*this)->set_innerHTML(content.c_str());
+    }
+
+    template<typename TYPE>
+    void _text(const TYPE& content)
+    {
+      (*this)->set_textContent(content.c_str());
+    }
+
+    template<typename TYPE>
+    void _value(const TYPE& val)
+    {
+      static_cast<client::HTMLInputElement*>(**this)->set_value(val.c_str());
+    }
+  };
+}
+
+#endif
+

data/vendor/src/events.hpp

@@ -0,0 +1,76 @@
+#ifndef  COMET_EVENTS_HPP
+# define COMET_EVENTS_HPP
+
+# include <cheerp/clientlib.h>
+# include <map>
+
+namespace Comet
+{
+  class JavascriptEvents
+  {
+    client::EventTarget*                          target;
+    std::map<std::string, client::EventListener*> listeners;
+  public:
+    JavascriptEvents(client::EventTarget* value) : target(value)
+    {
+    }
+
+    JavascriptEvents(const JavascriptEvents& copy)
+    {
+      target = copy.target;
+    }
+
+    ~JavascriptEvents()
+    {
+      clear();
+    }
+    
+    JavascriptEvents& operator=(const JavascriptEvents& copy)
+    {
+      target = copy.target;
+      return *this;
+    }
+
+    template<typename CALLBACK>
+    void on(const std::string& event, CALLBACK callback)
+    {
+      auto listener = cheerp::Callback(callback);
+
+      if (listeners.count(event)) off(event);
+      target->addEventListener(event.c_str(), listener);
+      listeners.emplace(event, listener);
+    }
+
+    void off(const std::string& event)
+    {
+      auto it = listeners.find(event);
+
+      if (it != listeners.end())
+      {
+        target->removeEventListener(it->first.c_str(), it->second);
+        listeners.erase(it);
+      }
+    }
+
+    void clear()
+    {
+      disconnect();
+      listeners.clear();
+    }
+
+    void connect()
+    {
+      disconnect();
+      for (auto listener : listeners)
+        target->addEventListener(listener.first.c_str(), listener.second);
+    }
+
+    void disconnect()
+    {
+      for (auto listener : listeners)
+        target->removeEventListener(listener.first.c_str(), listener.second);
+    } 
+  };
+}
+
+#endif

data/vendor/src/exception.cpp

@@ -0,0 +1,13 @@
+#include "exception.hpp"
+#include "globals.hpp"
+
+namespace Comet
+{
+  void raise(const std::exception& e)
+  {
+    String what(e.what());
+
+    window.set("_comet_exception", what);
+    __asm__("throw window._comet_exception");
+  }
+}

data/vendor/src/exception.hpp

@@ -0,0 +1,11 @@
+#ifndef  COMET_EXCEPTION_HPP
+# define COMET_EXCEPTION_HPP
+
+# include <exception>
+
+namespace Comet
+{
+  void raise(const std::exception& e);
+}
+
+#endif

data/vendor/src/from_string.cpp

@@ -0,0 +1,99 @@
+#include "from_string.hpp"
+#include "exception.hpp"
+#include <map>
+#include <climits>
+#include <algorithm>
+
+#define declare_std_converter(type, func) \
+  template<> type from_string<type>(const std::string& str) \
+  { \
+    return std::func(str); \
+  }
+
+namespace Comet
+{
+  declare_std_converter(int,                stoi)
+  declare_std_converter(double,             stod)
+  declare_std_converter(long double,        stold)
+  declare_std_converter(long,               stol)
+  declare_std_converter(unsigned long,      stoul)
+  declare_std_converter(long long,          stoll)
+  declare_std_converter(unsigned long long, stoull)
+  declare_std_converter(float,              stof)
+
+  template<> unsigned int from_string<unsigned int>(const std::string& str)
+  {
+    unsigned long value = std::stoul(str);
+
+    if (value > UINT_MAX)
+      raise(std::out_of_range(str));
+    return value;
+  }
+
+  template<> short from_string<short>(const std::string& str)
+  {
+    int value = std::stoi(str);
+
+    if (value > SHRT_MAX || value < SHRT_MIN)
+      raise(std::out_of_range(str));
+    return value;
+  }
+
+  template<> unsigned short from_string<unsigned short>(const std::string& str)
+  {
+    unsigned long value = std::stoul(str);
+
+    if (value > USHRT_MAX)
+      raise(std::out_of_range(str));
+    return value;
+  }
+
+  template<> char from_string<char>(const std::string& str)
+  {
+    if (str.length() > 1)
+      raise(std::out_of_range(str));
+    return *str.begin();
+  }
+
+  template<> unsigned char from_string<unsigned char>(const std::string& str)
+  {
+    if (str.length() > 1)
+      raise(std::out_of_range(str));
+    return *str.begin();
+  }
+
+  template<> bool from_string<bool>(const std::string& str)
+  {
+    static const std::map<std::string, bool> translation_table {
+      {"true", true}, {"TRUE", true}, {"True", true}, {"t", true},
+      {"false", false}, {"FALSE", false}, {"False", false}, {"f", false}
+    };
+    auto it = translation_table.find(str);
+
+    if (it == translation_table.end())
+    {
+      bool is_number = false;
+
+      if (!str.empty())
+      {
+        auto it = str.begin();
+
+        if (*it == '-')
+          ++it;
+        is_number = std::find_if(it, str.end(), [](unsigned char c) { return !std::isdigit(c); }) == str.end();
+      }
+      if (!is_number)
+      {
+        std::string what = "cannot cast '" + str + "' to boolean";
+        raise(std::runtime_error(what.c_str()));
+      }
+      return std::stold(str) > 0;
+    }
+    return it->second;
+  }
+
+  template<> std::string from_string<std::string>(const std::string& str)
+  {
+    return str;
+  }
+}

data/vendor/src/from_string.hpp

@@ -0,0 +1,37 @@
+#ifndef  COMET_FROM_STRING_HPP
+# define COMET_FROM_STRING_HPP
+
+# include <string>
+# include <sstream>
+
+namespace Comet
+{
+  template<typename TYPE>
+  TYPE from_string(const std::string& str)
+  {
+    std::stringstream stream;
+    TYPE value;
+
+    stream << str;
+    stream >> value;
+    return value;
+  }
+
+  template<> int                from_string<int>(const std::string& str);
+  template<> unsigned int       from_string<unsigned int>(const std::string& str);
+  template<> double             from_string<double>(const std::string& str);
+  template<> long double        from_string<long double>(const std::string& str);
+  template<> long               from_string<long>(const std::string& str);
+  template<> unsigned long      from_string<unsigned long>(const std::string& str);
+  template<> long long          from_string<long long>(const std::string& str);
+  template<> unsigned long long from_string<unsigned long long>(const std::string& str);
+  template<> float              from_string<float>(const std::string& str);
+  template<> short              from_string<short>(const std::string& str);
+  template<> unsigned short     from_string<unsigned short>(const std::string& str);
+  template<> char               from_string<char>(const std::string& str);
+  template<> unsigned char      from_string<unsigned char>(const std::string& str);
+  template<> bool               from_string<bool>(const std::string& str);
+  template<> std::string        from_string<std::string>(const std::string& str);
+}
+
+#endif

data/vendor/src/globals.cpp

@@ -0,0 +1,6 @@
+#include "globals.hpp"
+
+namespace Comet
+{
+  Comet::Element body;
+}

data/vendor/src/globals.hpp

@@ -0,0 +1,15 @@
+#ifndef  COMET_GLOBALS_HPP
+# define COMET_GLOBALS_HPP
+
+# include "element.hpp"
+# include "document.hpp"
+# include "window.hpp"
+
+namespace Comet
+{
+  extern Element  body;
+  extern Window   window;
+  extern Document document;
+}
+
+#endif

data/vendor/src/http.cpp

@@ -0,0 +1,93 @@
+#include "http.hpp"
+
+using namespace std;
+using namespace Comet;
+using namespace Comet::Http;
+
+/*
+ * Response
+ */
+Response::Response()
+{
+}
+
+void Response::initialize(client::XMLHttpRequest* xhr)
+{
+  status = xhr->get_status();
+  if (xhr->get_responseText())
+  {
+    _has_body = true;
+    body      = xhr->get_responseText();
+  }
+}
+
+DataTree Response::get_response_data() const
+{
+  return DataTree(get_response_object());
+}
+
+Comet::Object Response::get_response_object() const
+{
+  if (_has_body)
+    return Comet::Object::from_json(body);
+  return Comet::Object();
+}
+
+/*
+ * Request
+ */
+Request::Request(const string& m, const string& p) : method(m), path(p)
+{
+  response = make_shared<Response>();
+  xhr      = new client::XMLHttpRequest;
+  xhr->open(method.c_str(), path.c_str());
+}
+
+void Request::set_headers(const map<string, string> headers)
+{
+  for (const auto header : headers)
+    xhr->setRequestHeader(header.first.c_str(), header.second.c_str());
+}
+
+void Request::set_body(const std::string& value)
+{
+  set_body(Comet::String(value));
+}
+
+void Request::set_body(const std::wstring& value)
+{
+  set_body(Comet::String(value));
+}
+
+void Request::set_body(Comet::String value)
+{
+  body = value;
+}
+
+static client::EventListener* request_on_load(
+  client::XMLHttpRequest* xhr,
+  shared_ptr<Response>    response,
+  function<void()>        resolve,
+  function<void()>        reject)
+{
+  return cheerp::Callback([xhr, response, resolve, reject]()
+  {
+    if ((int)xhr->get_readyState() == 4)
+    {
+      response->initialize(xhr);
+      resolve();
+    }
+  });
+}
+
+Promise Request::send()
+{
+  return Promise([this](function<void()> resolve, function<void()> reject)
+  {
+    xhr->set_onload(request_on_load(xhr, response, resolve, reject));
+    if (body->get_length() > 0)
+      xhr->send(*body);
+    else
+      xhr->send();
+  });
+}

data/vendor/src/http.hpp

@@ -0,0 +1,72 @@
+#ifndef  CRAILS_FRONT_HTTP_HPP
+# define CRAILS_FRONT_HTTP_HPP
+
+#include "promise.hpp"
+#include "datatree.hpp"
+
+namespace Comet
+{
+  namespace Http
+  {
+    class Request;
+    
+    class Response
+    {
+      friend class Request;
+
+      bool            _has_body = false;
+      client::String* body;
+      double          status = 0;
+    public:
+      Response();
+      
+      void initialize(client::XMLHttpRequest* xhr);
+
+      bool   has_body()   const { return _has_body; }          
+      bool   ok()         const { return status >= 200 && status < 300; }
+      double get_status() const { return status; }
+
+      Comet::Object get_response_object() const;
+      DataTree      get_response_data() const;
+      std::string   get_response_text() const { return std::string(*body); }
+      std::wstring  get_response_wide_text() const { return to_wstring(body); }
+    };
+
+    class Request
+    {
+      const std::string          method,  path;
+      Comet::String              body;
+      std::shared_ptr<Response>  response;
+      client::XMLHttpRequest*    xhr;
+
+    public:
+      Request(const std::string& m, const std::string& p);
+
+      typedef Comet::Promise       PromiseType;
+      typedef std::shared_ptr<PromiseType> PromisePtr;
+      typedef std::shared_ptr<Request>     Ptr;
+
+      static Ptr get    (const std::string& path) { return make("get", path); }
+      static Ptr post   (const std::string& path) { return make("post", path); }
+      static Ptr put    (const std::string& path) { return make("put", path); }
+      static Ptr patch  (const std::string& path) { return make("patch", path); }
+      static Ptr _delete(const std::string& path) { return make("delete", path); }
+
+      static Ptr make(const std::string& method, const std::string& path)
+      {
+        return std::make_shared<Request>(method, path);
+      }
+
+      std::shared_ptr<Response> get_response() const { return response; }
+
+      void set_headers(const std::map<std::string, std::string> value);
+      void set_body(const std::string& value);
+      void set_body(const std::wstring& value);
+      void set_body(Comet::String value);
+
+      Comet::Promise send();
+    };
+  }
+}
+
+#endif

data/vendor/src/lexical_cast.hpp

@@ -0,0 +1,51 @@
+#ifndef  COMET_LEXICAL_CAST_HPP
+# define COMET_LEXICAL_CAST_HPP
+
+# include <string>
+# include <sstream>
+# include "from_string.hpp"
+
+#include <iostream>
+
+namespace Comet
+{
+  template<typename OUTPUT, typename INPUT, bool SAME = std::is_same<OUTPUT, INPUT>::value >
+  struct lexical_caster
+  {
+    static inline OUTPUT _(INPUT input)
+    {
+      std::stringstream stream;
+      OUTPUT output;
+
+      stream << input;
+      stream >> output;
+      return output;
+    }
+  };
+
+  template<typename OUTPUT, typename INPUT>
+  struct lexical_caster<OUTPUT, INPUT, true>
+  {
+    static inline OUTPUT _(INPUT input) { return input; }
+  };
+
+  template<typename OUTPUT>
+  struct lexical_caster<OUTPUT, std::string, false>
+  {
+    static inline OUTPUT _(const std::string& input) { return Comet::from_string<OUTPUT>(input); }
+  };
+
+  template<typename INPUT>
+  struct lexical_caster<std::string, INPUT, false>
+  {
+    static inline std::string _(INPUT input) { return std::to_string(input); }
+  };
+
+  template<typename OUTPUT, typename INPUT>
+  OUTPUT lexical_cast(INPUT input)
+  {
+    return lexical_caster<OUTPUT, INPUT, std::is_same<OUTPUT, INPUT>::value >::_(input);
+  }
+}
+
+#endif

data/vendor/src/local_storage.cpp

@@ -0,0 +1,75 @@
+#include "local_storage.hpp"
+#include <cheerp/client.h>
+
+using namespace std;
+using namespace Comet;
+
+LocalStorage::LocalStorage(client::Storage* storage) :
+  storage(storage)
+{
+  initialize();
+}
+
+LocalStorage::LocalStorage()
+{
+  storage = client::window.get_localStorage();
+  initialize();
+}
+
+LocalStorage::~LocalStorage()
+{
+  client::window.removeEventListener("storage", event_listener);
+}
+
+void LocalStorage::initialize()
+{
+  event_listener = cheerp::Callback([this](client::Event* _event)
+  {
+    auto* event = static_cast<client::StorageEvent*>(_event);
+
+    if (event->get_storageArea() == storage)
+      on_change.trigger(Change(event));
+  });
+  client::window.addEventListener("storage", event_listener);
+}
+
+LocalStorage::Change::Change(client::StorageEvent* event)
+{
+  key = (string)(*event->get_key());
+  if (event->get_oldValue())
+    old_value = (string)(*static_cast<client::String*>(event->get_oldValue()));
+  if (event->get_newValue())
+    new_value = (string)(*static_cast<client::String*>(event->get_newValue()));
+}
+
+template<>
+void LocalStorage::set_item<const string&>(const string& key, const string& value)
+{
+  storage->setItem(key.c_str(), value.c_str());
+}
+
+template<>
+void LocalStorage::set_item<string>(const string& key, string value)
+{
+  set_item<const string&>(key, value);
+}
+
+template<>
+string LocalStorage::get_item<string>(const string& key) const
+{
+  client::Object* object = storage->getItem(key.c_str());
+
+  if (object)
+    return (string)(*static_cast<client::String*>(object));
+  return "";
+}
+
+void LocalStorage::remove_item(const string& key)
+{
+  storage->removeItem(key.c_str());
+}
+
+void LocalStorage::clear()
+{
+  storage->clear();
+}