FilterEngine API improvements

include/AdblockPlus/FilterEngine.h

 #ifndef ADBLOCKPLUS_FILTER_ENGINE_H
 #define ADBLOCKPLUS_FILTER_ENGINE_H
 
 #include <vector>
 #include <map>
 #include <string>
+#include <tr1/memory>
 
 namespace AdblockPlus
 {
   class JsEngine;
   class FilterEngine;
 
-  class Subscription
+  class JsObject
+  {
+  public:
+    std::string GetProperty(const std::string& name, const std::string& defaultValue) const;
+    int GetProperty(const std::string& name, int defaultValue) const;
+    bool GetProperty(const std::string& name, bool defaultValue) const;
+    inline std::string GetProperty(const std::string& name, const char* defaultValue) const
+    {
+      return GetProperty(name, std::string(defaultValue));
+    }
+
+    void SetProperty(const std::string& name, const std::string& value);
+    void SetProperty(const std::string& name, int value);
+    void SetProperty(const std::string& name, bool value);
+    inline void SetProperty(const std::string& name, const char* value)
+    {
+      SetProperty(name, std::string(value));
+    }
+
+  protected:
+#if FILTER_ENGINE_STUBS
+    JsObject(FilterEngine& filterEngine);
+
+    FilterEngine& filterEngine;
+    std::map<std::string, std::string> stringProperties;
+    std::map<std::string, int> intProperties;
+    std::map<std::string, bool> boolProperties;
+#else
+    JsObject();
+#endif
+  };
+
+  class Filter : public JsObject,
+                 public std::tr1::enable_shared_from_this<Filter>
   {
     friend class FilterEngine;
+
   public:
-    const std::string GetProperty(const std::string& name) const;

[Felix Dahlke, 2013/04/05 08:50:20]

Why return a const value here? It's copied on return anyway, const will only
dictate that the caller has to store his copy in a const, which may not always
make sense.

[Wladimir Palant, 2013/04/05 12:15:16]

True of course, originally I tried to return a reference.

-    int GetIntProperty(const std::string& name) const;
-    void SetProperty(const std::string& name, const std::string& value);
-    void SetIntProperty(const std::string& name, int value);
+    enum Type {TYPE_BLOCKING, TYPE_EXCEPTION,
+               TYPE_ELEMHIDE, TYPE_ELEMHIDE_EXCEPTION,
+               TYPE_COMMENT, TYPE_INVALID};
 
+    bool IsListed() const;
+    void AddToList();
+    void RemoveFromList();
+
+  private:
+#if FILTER_ENGINE_STUBS
+    Filter(FilterEngine& filterEngine, const std::string& text);
+#else
+    Filter();
+#endif
+  };
+
+  class Subscription : public JsObject,
+                       public std::tr1::enable_shared_from_this<Subscription>
+  {
+    friend class FilterEngine;
+
+  public:
     bool IsListed() const;
     void AddToList();
     void RemoveFromList();
     void UpdateFilters();
 
   private:
 #if FILTER_ENGINE_STUBS
     Subscription(FilterEngine& filterEngine, const std::string& url);
-
-    FilterEngine& filterEngine;
-    std::map<std::string,std::string> properties;

[Felix Dahlke, 2013/04/05 08:50:20]

We generally put a space after a comma in template parameters (although it's not
fully consistent in ABP for IE).

-    std::map<std::string,int> intProperties;

[Felix Dahlke, 2013/04/05 08:50:20]

Will we need more types than string and int? We'll need a value type that
supports several types for return values from JS anyway, so we should keep this
in mind.

[Wladimir Palant, 2013/04/05 12:15:16]

Yes, we need booleans as well. Other than that subscriptions and filters only
have a few structured fields that will need special treatment later if we want
to use them.

 #else
     Subscription();
 #endif
   };
 
-  typedef void (*SubscriptionsCallback)(const std::vector<Subscription*>&);
+  typedef std::tr1::shared_ptr<Filter> FilterPtr;
+  typedef std::tr1::shared_ptr<Subscription> SubscriptionPtr;
+  typedef void (*SubscriptionsCallback)(const std::vector<SubscriptionPtr>&);
 
   class FilterEngine
   {
+    friend class Filter;
     friend class Subscription;
   public:
     explicit FilterEngine(JsEngine& jsEngine);
+    Filter& GetFilter(const std::string& text);
     Subscription& GetSubscription(const std::string& url);
-    const std::vector<Subscription*>& GetListedSubscriptions() const;
+    const std::vector<FilterPtr>& GetListedFilters() const;
+    const std::vector<SubscriptionPtr>& GetListedSubscriptions() const;
     void FetchAvailableSubscriptions(SubscriptionsCallback callback);
-    bool Matches(const std::string& url,
-                 const std::string& contentType,
-                 const std::string& documentUrl) const;
-    std::vector<std::string> GetElementHidingRules() const;
+    FilterPtr Matches(const std::string& url,
+        const std::string& contentType,
+        const std::string& documentUrl);
+    std::vector<std::string> GetElementHidingSelectors(const std::string& domain) const;
 
   private:
     JsEngine& jsEngine;
 #if FILTER_ENGINE_STUBS
-    std::map<std::string,Subscription*> knownSubscriptions;
-    std::vector<Subscription*> listedSubscriptions;
+    std::map<std::string, FilterPtr> knownFilters;
+    std::vector<FilterPtr> listedFilters;
+    std::map<std::string, SubscriptionPtr> knownSubscriptions;
+    std::vector<SubscriptionPtr> listedSubscriptions;
 #endif
   };
 }
 
 #endif