Issue 5137 - [emscripten] Added basic filter storage implementation

compiled/bindings/generator.h

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
- * Copyright (C) 2006-2017 eyeo GmbH
+ * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
@@ skipping 98 matching lines @@
   char TypeInfo<T>::s_typeIDHelper;
 
   struct FunctionInfo
   {
     TypeCategory returnType;
     TYPEID pointerType;
     std::vector<TypeCategory> args;
     bool instance_function;
     int effectiveArgs;
     TypeCategory effectiveReturnType;
-    char name[1024];
+    std::string name;
 
     FunctionInfo();
 
     FunctionInfo(TypeCategory returnType, TYPEID pointerType,
         std::initializer_list<TypeCategory> argTypes, bool instance_function,
         void* function);
 
     template<typename ReturnType, typename... Args>
     FunctionInfo(ReturnType (*function)(Args...))
         : FunctionInfo(TypeInfo<ReturnType>(),
@@ skipping 40 matching lines @@
     std::string name;
     FunctionInfo call;
   };
 
   struct DifferentiatorInfo
   {
     size_t offset;
     std::vector<std::pair<int, std::string>> mapping;
   };
 
-  typedef std::vector<PropertyInfo> PropertyList;

[sergei, 2017/05/08 10:54:39]

It's usually a bad practice to call something like List, Set, Map, etc when it's
not important to emphasize the underlying data structure. Properties and Methods
would be better, though for me it's fine here.

[Wladimir Palant, 2017/05/08 12:55:41]

Done.

-  typedef std::vector<MethodInfo> MethodList;
+  typedef std::vector<PropertyInfo> Properties;
+  typedef std::vector<MethodInfo> Methods;
 
   struct ClassInfo
   {
     TYPEID id;
     TYPEID baseClass;
     std::string name;
-    PropertyList properties;
-    MethodList methods;
+    Properties properties;
+    Methods methods;
     DifferentiatorInfo subclass_differentiator;
     ptrdiff_t ref_counted_offset;
-  };
-
-  struct NamespaceInfo
-  {
-    std::string name;
-    PropertyList properties;
-    MethodList methods;
+    FunctionInfo instanceGetter;
   };
 
   void register_class(const char* name, TYPEID classID, TYPEID baseClassID,
-                      ptrdiff_t ref_counted_offset);
+                      ptrdiff_t ref_counted_offset,
+                      const FunctionInfo& instanceGetter = FunctionInfo());
 
   void register_property(TYPEID classID, const char* name,
       const FunctionInfo& getter, const FunctionInfo& setter,
       const char* jsValue = "");
 
   void register_method(TYPEID classID, const char* name,
       const FunctionInfo& call);
 
   void register_differentiator(TYPEID classID, size_t offset,
       std::vector<std::pair<int, std::string>>& mapping);
 
-  void register_namespace(const char* name);
-
-  void register_namespace_property(const char* namespaceName, const char* name,
-      const FunctionInfo& getter, const FunctionInfo& setter);
-
-  void register_namespace_method(const char* namespaceName, const char* name,
-      const FunctionInfo& call);
-
-  std::string generateCall(const FunctionInfo& call,
-      std::vector<std::string>& params);
-
-  std::string wrapCall(const FunctionInfo& call, bool isFunction = true);
-
-  void printHelpers();
-
-  void printClass(const ClassInfo& cls);
+  std::string wrapCall(const FunctionInfo& call, bool isFunction = true,
+      const FunctionInfo& instanceGetter = FunctionInfo());
 }
 
 template<typename ClassType,
     typename BaseClass = bindings_internal::NoBaseClass,
     typename std::enable_if<std::is_base_of<ref_counted, ClassType>::value>::type* = nullptr>
 class class_
 {
 public:
   class_(const char* name)
   {
@@ skipping 63 matching lines @@
     std::vector<std::pair<int, std::string>> mapping;
     for (const auto& item : list)
       mapping.emplace_back(item.first, item.second);
 
     bindings_internal::register_differentiator(
         bindings_internal::TypeInfo<ClassType>(), offset, mapping);
     return *this;
   }
 };
 
-class namespace_
+template<typename ClassType>
+class singleton
 {
-private:
-  const char* mName;
-
 public:
-  namespace_(const char* name)
-    : mName(name)
-  {
-    bindings_internal::register_namespace(name);
+  singleton(const char* name, ClassType* (*instanceGetter)())
+  {
+    bindings_internal::register_class(name,
+        bindings_internal::TypeInfo<ClassType>(),
+        bindings_internal::TypeInfo<bindings_internal::NoBaseClass>(),
+        0,
+        instanceGetter
+      );
   }
 
   template<typename FieldType>
-  namespace_& property(const char* name,
-      FieldType (*getter)(),
-      void (*setter)(FieldType) = nullptr)
-  {
-    bindings_internal::register_namespace_property(mName, name, getter,
-        setter);
-    return *this;
-  }
-
-  template<typename ReturnType, typename... Args>
-  namespace_& function(const char* name, ReturnType (*method)(Args...))
-  {
-    bindings_internal::register_namespace_method(mName, name, method);
+  const singleton& property(const char* name,
+      FieldType (ClassType::*getter)() const,
+      void (ClassType::*setter)(FieldType) = nullptr) const
+  {
+    bindings_internal::register_property(
+        bindings_internal::TypeInfo<ClassType>(), name, getter, setter);
+    return *this;
+  }
+
+  template<typename ReturnType, typename... Args>
+  const singleton& function(const char* name, ReturnType (ClassType::*method)(Args...)) const
+  {
+    bindings_internal::register_method(
+        bindings_internal::TypeInfo<ClassType>(), name, method);
+    return *this;
+  }
+
+  template<typename ReturnType, typename... Args>
+  const singleton& function(const char* name, ReturnType (ClassType::*method)(Args...) const) const
+  {
+    bindings_internal::register_method(
+        bindings_internal::TypeInfo<ClassType>(), name, method);
     return *this;
   }
 };
 
 void printBindings();