comet-cpp 0.9.0

data/vendor/src/object.hpp

@@ -0,0 +1,298 @@
+#ifndef  CRAILS_FRONT_OBJECT_HPP
+# define CRAILS_FRONT_OBJECT_HPP
+
+# include <cheerp/client.h>
+# include <cheerp/clientlib.h>
+# include <map>
+# include <vector>
+# include <string>
+# include <sstream>
+
+#define js_object(...) \
+  Comet::Object(std::map<std::string, Comet::Object>({__VA_ARGS__}))
+#define js_array(...) \
+  Comet::Object(std::vector<Comet::Object>({__VA_ARGS__}))
+
+namespace Comet
+{
+  template<typename CLIENT_TYPE>
+  class ObjectImpl;
+
+  template<typename ARG>
+  struct ApplyParamsToString;
+
+  std::wstring to_wstring(client::String*);
+
+  class Object
+  {
+  protected:
+    client::Object* ptr;
+  public:
+    Object() { ptr = new client::Object; }
+    Object(client::Object* ptr) : ptr(ptr) {}
+    Object(client::String* ptr) : ptr((client::Object*)ptr) {}
+    Object(const char* str)         { ptr = new client::String(str); }
+    Object(const wchar_t* str)      { ptr = new client::String(str); }
+    Object(const std::string& str)  { ptr = new client::String(str.c_str()); }
+    Object(const std::wstring& str) { ptr = new client::String(str.c_str()); }
+    Object(unsigned long number)    { ptr = new client::String(number); }
+    Object(unsigned int number)     { ptr = new client::String(number); }
+    Object(long number)             { ptr = new client::String(number); }
+    Object(int number)              { ptr = new client::String(number); }
+    Object(double number)           { ptr = new client::String(number); }
+    Object(bool boolean)            { ptr = new client::String((int)boolean); }
+    Object(const std::map<std::string, Object>& items) { ptr = new client::Object; set(items); }
+
+    Object(const std::vector<Object>& items)
+    {
+      auto* array = new client::Array;
+
+      for (auto item : items)
+        array->push(*item);
+      ptr = array;
+    }
+
+    template<typename FUNCTYPE>
+    Object(std::function<FUNCTYPE> func) { ptr = cheerp::Callback(func); }
+
+    static Object from_json(client::String* str)
+    {
+      return client::JSON.parse(str);
+    }
+
+    static Object from_json(const std::string& str)
+    {
+      return from_json(new client::String(str.c_str()));
+    }
+
+    static Object from_json(const std::wstring& str)
+    {
+      return from_json(new client::String(str.c_str()));
+    }
+
+    template<typename RETURN_TYPE = std::string>
+    RETURN_TYPE to_json() const
+    {
+      return (RETURN_TYPE)(*static_cast<client::String*>(client::JSON.stringify(ptr)));
+    }
+
+    template<>
+    std::wstring to_json<std::wstring>() const
+    {
+      return to_wstring(static_cast<client::String*>(client::JSON.stringify(ptr)));
+    }
+
+    Object operator[](const char* key)
+    {
+      return Object(ptr->operator[](key));
+    }
+
+    template<typename CLIENT_TYPE>
+    ObjectImpl<CLIENT_TYPE> get(const char* key)
+    {
+      return ObjectImpl<CLIENT_TYPE>(*(this->operator[](key)));
+    }
+
+    client::Object* operator*() const { return ptr; }
+    client::Object* operator->() const { return ptr; }
+
+    operator std::string() const
+    {
+      if (!is_of_type("String"))
+        __asm__("throw 'Comet::Object cast to std::string, but type is not String'");
+      return (std::string)(*static_cast<client::String*>(ptr));
+    }
+
+    operator std::wstring() const
+    {
+      if (!is_of_type("String"))
+        __asm__("throw 'Comet::Object cast to std::wstring, but type is not String'");
+      return to_wstring(static_cast<client::String*>(ptr));
+    }
+
+    operator double()      const { return (double)(*ptr); }
+
+    template<typename T>
+    operator std::vector<T>() const
+    {
+      return to_vector<T>();
+    }
+
+    template<typename T>
+    std::vector<T> to_vector() const
+    {
+      std::vector<T> result;
+
+      if (is_of_type("Array"))
+{
+        const client::Array& array = *(static_cast<client::Array*>(ptr));
+        result.resize(array.get_length());
+        for (int i = 0 ; i < array.get_length() ; ++i)
+          result[i] = (T)(Object(array[i]));
+      }
+      return result;
+    }
+
+    bool is_of_type(const std::string& type) const { return is_of_type(type.c_str()); }
+    bool is_of_type(const char* type) const;
+
+    void set(const std::string& str, Object object)
+    {
+      ptr->set_(str.c_str(), object.ptr);
+    }
+
+    void set(const std::map<std::string, Object>& items)
+    {
+      for (auto item : items)
+        set(item.first, item.second);
+    }
+
+    void unset(const std::string& str)
+    {
+      ptr->set_(str.c_str(), nullptr);
+    }
+
+    template<typename ...ARGS>
+    Object apply(const std::string& name, ARGS... args)
+    {
+      std::string str      = "_comet_." + name + '(';
+      std::string str_args = _apply_params('a', args...);
+
+      str = str + str_args;
+      str = str + ')';
+      set_global("_comet_", *this);
+      return client::eval(str.c_str());
+    }
+
+    bool is_undefined() const;
+    
+    static void set_global(const std::string&, Comet::Object);
+
+  private:
+    std::string _apply_params(char) { return ""; }
+
+    template<typename ARG>
+    std::string _apply_params(char i, ARG arg)
+    {
+      return ApplyParamsToString<ARG>::func(arg, i);
+    }
+
+    template<typename ARG, typename ...ARGS>
+    std::string _apply_params(char i, ARG arg, ARGS... args)
+    {
+      return ApplyParamsToString<ARG>::func(arg, i)
+        + ',' + _apply_params<ARGS...>(i + 1, args...);
+    }
+  };
+  template<>
+  std::vector<std::wstring> Object::to_vector() const;
+
+  template<typename ARG>
+  struct ApplyParamsToString
+  {
+    static std::string func(ARG arg, char)
+    {
+      std::stringstream stream;
+
+      stream << arg;
+      return stream.str();
+    }
+  };
+
+  template<>
+  struct ApplyParamsToString<Object>
+  {
+    static std::string func(Object object, char i)
+    {
+      std::string varname = "_comet_arg_0_";
+
+      varname[11] = i;
+      Object::set_global(varname.c_str(), object);
+      return varname;
+    }
+  };
+
+  template<typename ARG>
+  struct ApplyParamsToString<ObjectImpl<ARG> >
+  {
+    static std::string func(ObjectImpl<ARG> arg, char i)
+    {
+      return ApplyParamsToString<Object>::func(Object((client::Object*)(*arg)), i);
+    }
+  };
+
+  template<>
+  struct ApplyParamsToString<client::Object*>
+  {
+    static std::string func(client::Object* arg, char i)
+    {
+      return ApplyParamsToString<Object>::func(Object(arg), i);
+    }
+  };
+
+  template<>
+  struct ApplyParamsToString<client::String*>
+  {
+    static std::string func(client::String* arg, char i)
+    {
+      return ApplyParamsToString<Object>::func(Object((client::Object*)arg), i);
+    }
+  };
+
+  template<>
+  struct ApplyParamsToString<const char*>
+  {
+    static std::string func(const char* arg, char i)
+    {
+      std::string varval("\"");
+
+      varval = varval + arg;
+      varval = varval + "\"";
+      return varval;
+    }
+  };
+
+  template<>
+  struct ApplyParamsToString<std::string>
+  {
+    static std::string func(std::string arg, char i)
+    {
+      return '"' + arg + '"';
+    }
+  };
+
+  template<typename CLIENT_TYPE>
+  class ObjectImpl : public Object
+  {
+  public:
+    ObjectImpl() { ptr = new CLIENT_TYPE; }
+    ObjectImpl(CLIENT_TYPE* ptr) { this->ptr = ptr; }
+    ObjectImpl(client::Object* ptr) { this->ptr = ptr; }
+
+    CLIENT_TYPE* operator*() const { return static_cast<CLIENT_TYPE*>(ptr); }
+    CLIENT_TYPE* operator->() const { return static_cast<CLIENT_TYPE*>(ptr); }
+  };
+
+  class String : public ObjectImpl<client::String>
+  {
+  public:
+    String() { ptr = new client::String; }
+    String(client::String* ptr) { this->ptr = ptr; }
+    String(client::Object* ptr) { this->ptr = ptr; }
+    String(const char* str)         { ptr = new client::String(str); }
+    String(const wchar_t* str)      { ptr = new client::String(str); }
+    String(const std::string& str)  { ptr = new client::String(str.c_str()); }
+    String(const std::wstring& str) { ptr = new client::String(str.c_str()); }
+  };
+
+  template<>
+  struct ApplyParamsToString<String>
+  {
+    static std::string func(String arg, char i)
+    {
+      return ApplyParamsToString<Object>::func(Object((client::Object*)(*arg)), i);
+    }
+  };
+}
+
+#endif

data/vendor/src/parse_cookie_values.hpp

@@ -0,0 +1,12 @@
+#ifndef  PARSE_COOKIE_VALUES_HPP
+# define PARSE_COOKIE_VALUES_HPP
+
+# include <string>
+# include <functional>
+
+namespace Comet
+{
+  void parse_cookie_values(const std::string&, std::function<bool (const std::string&, const std::string&)> callback);
+}
+
+#endif

data/vendor/src/promise.cpp

@@ -0,0 +1,50 @@
+#include "promise.hpp"
+#include "globals.hpp"
+
+using namespace std;
+using namespace Comet;
+
+Promise::Promise(std::function<void (std::function<void ()>, std::function<void ()>)> resolver)
+{
+  client::Object* func = cheerp::Callback([resolver](client::Object* callbacks_ptr)
+  {
+    Comet::Object callbacks(callbacks_ptr);
+
+    resolver(
+      [callbacks]() mutable { callbacks.apply("resolve"); },
+      [callbacks]() mutable { callbacks.apply("reject");  }
+    );
+  });
+  new_promise(func);
+}
+
+void Promise::new_promise(client::Object* resolver)
+{
+  prepare_promise_constructor();
+  ptr = *(window.apply("_comet_new_promise", resolver));
+}
+
+void Promise::prepare_promise_constructor()
+{
+  static bool is_prepared = false;
+
+  if (!is_prepared)
+  {
+    client::eval("window._comet_new_promise = function(r) { return new Promise(function(resolve, reject) { return r({ resolve: resolve, reject: reject }); }); }");
+    is_prepared = true;
+  }
+}
+
+Promise Promise::all(const std::vector<Promise>& promises)
+{
+  Comet::ObjectImpl<client::Array> array;
+
+  for (auto promise : promises)
+    array->push(*promise);
+  return *(window["Promise"].apply("all", array));
+}
+
+Promise Promise::solved_promise()
+{
+  return Promise([](function<void()> resolve, function<void()>) { resolve(); });
+}

data/vendor/src/promise.hpp

@@ -0,0 +1,43 @@
+#ifndef  CRAILS_FRONT_PROMISE_HPP
+# define CRAILS_FRONT_PROMISE_HPP
+
+# include "object.hpp"
+# include <vector>
+
+namespace Comet
+{
+  class Promise : public ObjectImpl<client::Promise>
+  {
+  public:
+    static Promise solved_promise();
+    static Promise all(const std::vector<Promise>& promises);
+
+    Promise(std::function<void (std::function<void ()>, std::function<void ()>)> resolver);
+    Promise(client::Promise* ptr) : ObjectImpl(ptr) {}
+    Promise(client::Object* ptr) : ObjectImpl(ptr) {}
+
+    template<typename T>
+    Promise then(T callback)
+    {
+      client::EventListener* func = cheerp::Callback(callback);
+      (*this)->then(func);
+      return *this;
+    }
+
+    template<typename T>
+    Promise _catch(T callback)
+    {
+      client::EventListener* func = cheerp::Callback(callback);
+
+      this->apply("catch", Comet::Object(func));
+      return *this;
+    }
+
+  protected:
+    void new_promise(client::Object* resolver);
+
+    static void prepare_promise_constructor();
+  };
+}
+
+#endif

data/vendor/src/repeater.hpp

@@ -0,0 +1,116 @@
+#ifndef  CRAILS_FRONT_REPEATER_HPP
+# define CRAILS_FRONT_REPEATER_HPP
+
+# include "anchorable_element.hpp"
+
+namespace Comet
+{
+  template<typename ARRAY, typename ELEMENT>
+  struct Repeater : public AnchorableElement
+  {
+    typedef typename ARRAY::const_iterator                 Iterator;
+    typedef std::pair<Iterator, std::shared_ptr<ELEMENT> > ElementPair;
+    typedef std::vector<ElementPair>                       Elements;
+    Elements elements;
+    bool use_element_cache = false;
+
+    template<typename PARENT>
+    void refresh(PARENT* parent, const ARRAY& array)
+    {
+      if (use_element_cache)
+        purge_removed_elements(array);
+      else
+        clear();
+      update_elements(parent, array);
+      attach_elements();
+      trigger_binding_updates();
+    }
+
+    void bind_attributes()
+    {
+      for (const auto pair : elements)
+        pair.second->bind_attributes();
+    }
+
+    void trigger_binding_updates()
+    {
+      for (const auto pair : elements)
+        pair.second->trigger_binding_updates();
+    }
+
+    void clear()
+    {
+      for (auto element : elements)
+        element.second->destroy();
+      elements.clear();
+    }
+
+  private:
+    void attach_elements()
+    {
+      std::vector< std::shared_ptr<ELEMENT> > element_vector;
+
+      element_vector.reserve(elements.size());
+      for (const auto& pair : elements)
+        element_vector.push_back(pair.second);
+      AnchorableElement::attach_elements(element_vector);
+    }
+
+    void purge_removed_elements(const ARRAY& array)
+    {
+      auto it = elements.begin();
+
+      while (it != elements.end())
+      {
+        bool exists = false;
+        for (auto subit = array.begin() ; subit != array.end() ; ++subit)
+        {
+          if (subit == it->first)
+          {
+            exists = true;
+            break ;
+          }
+        }
+        if (!exists)
+        {
+          it->second->destroy();
+          it = elements.erase(it);
+        }
+        else
+          ++it;
+      }
+    }
+
+    template<typename PARENT>
+    void update_elements(PARENT* parent, const ARRAY& array)
+    {
+      Elements new_elements;
+
+      new_elements.reserve(array.size());
+      for (Iterator it = array.begin() ; it != array.end() ; ++it)
+      {
+        bool exists = false;
+
+        for (auto subit = elements.begin() ; subit != elements.end() ; ++subit)
+        {
+          if (subit->first == it)
+          {
+            new_elements.push_back(ElementPair(it, subit->second));
+            exists = true;
+            break ;
+          }
+        }
+        if (!exists)
+        {
+          auto ptr = std::make_shared<ELEMENT>(parent, *it);
+
+          ptr->bind_attributes();
+          new_elements.push_back(ElementPair(it, ptr));
+        }
+      }
+      elements = new_elements;
+    }
+  };
+}
+
+#endif

data/vendor/src/router.cpp

@@ -0,0 +1,62 @@
+#include "router.hpp"
+#include "object.hpp"
+#include "globals.hpp"
+
+using namespace Comet;
+using namespace std;
+
+Router::Router()
+{
+  window->addEventListener("hashchange", cheerp::Callback([this](client::Event* e) {
+    on_hash_changed();
+  }));
+  initialize();
+}
+
+void Router::start()
+{
+  document.on_ready([this]() { navigate(get_current_path(), true); });
+}
+
+void Router::on_hash_changed()
+{
+  string hash = (string)(*window->get_location()->get_hash());
+
+  if (hash != last_hash)
+  {
+    last_hash = hash;
+    if (hash[0] == '#')
+      hash = hash.substr(1, hash.size() - 1);
+    navigate(hash);
+  }
+}
+
+bool Router::navigate(const string& path, bool trigger)
+{
+  if ((string)(*window->get_location()->get_hash()) != path)
+    window->get_location()->set_hash(path.c_str());
+  if (trigger)
+  {
+    Params params;
+    const Action* action = get_action("", path, params);
+
+    if (action)
+    {
+      (*action)(params);
+      on_route_executed.trigger(path);
+      return true;
+    }
+    else
+      on_route_not_found.trigger(path);
+  }
+  return false;
+}
+
+string Router::get_current_path() const
+{
+  Comet::Object location_hash = window->get_location()->get_hash();
+  string result = location_hash;
+
+  result.erase(result.begin()); // remove the sharp character
+  return result;
+}

data/vendor/src/router.hpp

@@ -0,0 +1,34 @@
+#ifndef  CRAILS_FRONT_ROUTER_HPP
+# define CRAILS_FRONT_ROUTER_HPP
+
+# include "router_base.hpp"
+# include "signal.hpp"
+# include <cheerp/client.h>
+# include <map>
+
+namespace Comet
+{
+  typedef std::map<std::string, std::string> Params;
+
+  class Router : public RouterBase<Params, std::function<void (const Params&)> >
+  {
+  public:
+    Router();
+
+    Signal<const std::string&> on_route_executed;
+    Signal<const std::string&> on_route_not_found;
+
+    bool navigate(const std::string& path, bool trigger = true);
+
+    void initialize();
+    void start();
+    std::string get_current_path() const;
+
+  private:
+    void on_hash_changed();
+
+    std::string last_hash;
+  };
+}
+
+#endif