Issue 4128, 5138 - Add Parser and Serializer implemented in C++

compiled/bindings/main.cpp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * 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
@@ skipping 16 matching lines @@
 #include "../filter/BlockingFilter.h"
 #include "../filter/WhitelistFilter.h"
 #include "../filter/ElemHideBase.h"
 #include "../filter/ElemHideFilter.h"
 #include "../filter/ElemHideException.h"
 #include "../filter/ElemHideEmulationFilter.h"
 #include "../subscription/Subscription.h"
 #include "../subscription/DownloadableSubscription.h"
 #include "../subscription/UserDefinedSubscription.h"
 #include "../storage/FilterStorage.h"
+#include "../ElemHide.h"
+#include "../ElemHideEmulation.h"
 #include "../FilterNotifier.h"
 #include "../storage/Parser.h"
 #include "../storage/Serializer.h"
+
+ABP_NS_USING
 
 int main()
 {
   try
   {
     class_<Filter>("Filter")
         .property("text", &Filter::GetText)
         .function("serialize", &Filter::Serialize)
         .class_function("fromText", &Filter::FromText)
         .subclass_differentiator(&Filter::mType, {
@@ skipping 19 matching lines @@
         .property("lastHit", &ActiveFilter::GetLastHit, &ActiveFilter::SetLastHit)
         .function("isActiveOnDomain", &ActiveFilter::IsActiveOnDomain)
         .function("isActiveOnlyOnDomain", &ActiveFilter::IsActiveOnlyOnDomain)
         .function("isGeneric", &ActiveFilter::IsGeneric)
         .function("serialize", &ActiveFilter::Serialize);
 
     class_<RegExpFilter,ActiveFilter>("RegExpFilter")
         .function("matches", &RegExpFilter::Matches);
 
     class_<BlockingFilter,RegExpFilter>("BlockingFilter")
-        .class_property("type", "'blocking'");
+        .class_property("type", "'blocking'")
+        .property("collapse", &BlockingFilter::GetCollapse);
+
 
     class_<WhitelistFilter,RegExpFilter>("WhitelistFilter")
         .class_property("type", "'whitelist'");
 
     class_<ElemHideBase,ActiveFilter>("ElemHideBase")
         .property("selector", &ElemHideBase::GetSelector)
         .property("selectorDomain", &ElemHideBase::GetSelectorDomain);
 
     class_<ElemHideFilter,ElemHideBase>("ElemHideFilter")
         .class_property("type", "'elemhide'");
 
     class_<ElemHideException,ElemHideBase>("ElemHideException")
         .class_property("type", "'elemhideexception'");
 
     class_<ElemHideEmulationFilter,ElemHideBase>("ElemHideEmulationFilter")
         .class_property("type", "'elemhideemulation'");
 
     class_<Subscription>("Subscription")
         .property("url", &Subscription::GetID)
         .property("title", &Subscription::GetTitle, &Subscription::SetTitle)
         .property("disabled", &Subscription::GetDisabled, &Subscription::SetDisabled)
         .property("listed", &Subscription::GetListed)
         .property("filterCount", &Subscription::GetFilterCount)
         .function("filterAt", &Subscription::FilterAt)
         .function("indexOfFilter", &Subscription::IndexOfFilter)
         .class_function("fromURL", &Subscription::FromID)
         .subclass_differentiator(&Subscription::mType, {
-          {Subscription::Type::USERDEFINED, "SpecialSubscription"},
+          {Subscription::Type::USERDEFINED, "UserDefinedSubscription"},
           {Subscription::Type::DOWNLOADABLE, "DownloadableSubscription"},
         });
 
-    class_<UserDefinedSubscription,Subscription>("SpecialSubscription")
+    class_<UserDefinedSubscription,Subscription>("UserDefinedSubscription")
         .function("isDefaultFor", &UserDefinedSubscription::IsDefaultFor)
         .function("makeDefaultFor", &UserDefinedSubscription::MakeDefaultFor)
         .function("isGeneric", &UserDefinedSubscription::IsGeneric)
         .function("insertFilterAt", &UserDefinedSubscription::InsertFilterAt)
         .function("removeFilterAt", &UserDefinedSubscription::RemoveFilterAt);
 
     class_<DownloadableSubscription,Subscription>("DownloadableSubscription")
         .property("fixedTitle", &DownloadableSubscription::GetFixedTitle, &DownloadableSubscription::SetFixedTitle)
         .property("homepage", &DownloadableSubscription::GetHomepage, &DownloadableSubscription::SetHomepage)
         .property("lastCheck", &DownloadableSubscription::GetLastCheck, &DownloadableSubscription::SetLastCheck)
-        .property("expires", &DownloadableSubscription::GetHardExpiration, &DownloadableSubscription::SetHardExpiration)
+        .property("hardExpiration", &DownloadableSubscription::GetHardExpiration, &DownloadableSubscription::SetHardExpiration)
         .property("softExpiration", &DownloadableSubscription::GetSoftExpiration, &DownloadableSubscription::SetSoftExpiration)
         .property("lastDownload", &DownloadableSubscription::GetLastDownload, &DownloadableSubscription::SetLastDownload)
         .property("downloadStatus", &DownloadableSubscription::GetDownloadStatus, &DownloadableSubscription::SetDownloadStatus)
         .property("lastSuccess", &DownloadableSubscription::GetLastSuccess, &DownloadableSubscription::SetLastSuccess)
-        .property("errors", &DownloadableSubscription::GetErrorCount, &DownloadableSubscription::SetErrorCount)
-        .property("version", &DownloadableSubscription::GetDataRevision, &DownloadableSubscription::SetDataRevision)
+        .property("errorCount", &DownloadableSubscription::GetErrorCount, &DownloadableSubscription::SetErrorCount)
+        .property("dataRevision", &DownloadableSubscription::GetDataRevision, &DownloadableSubscription::SetDataRevision)
         .property("requiredVersion", &DownloadableSubscription::GetRequiredVersion, &DownloadableSubscription::SetRequiredVersion)
         .property("downloadCount", &DownloadableSubscription::GetDownloadCount, &DownloadableSubscription::SetDownloadCount);
 
     singleton<FilterStorage>("FilterStorage", &FilterStorage::GetInstance)
         .property("subscriptionCount", &FilterStorage::GetSubscriptionCount)
         .function("subscriptionAt", &FilterStorage::SubscriptionAt)
         .function("indexOfSubscription", &FilterStorage::IndexOfSubscription)
         .function("getSubscriptionForFilter", &FilterStorage::GetSubscriptionForFilter)
         .function("addSubscription", &FilterStorage::AddSubscription)
         .function("removeSubscription", &FilterStorage::RemoveSubscription)
         .function("moveSubscription", &FilterStorage::MoveSubscription);
+
+    class_<ElemHide_SelectorList>("ElemHide_SelectorList")
+        .property("selectorCount", &ElemHide_SelectorList::GetSelectorCount)
+        .function("selectorAt", &ElemHide_SelectorList::SelectorAt)
+        .function("filterKeyAt", &ElemHide_SelectorList::FilterKeyAt);
+
+    class_<ElemHide>("ElemHide")
+        .class_function("create", &ElemHide::Create)
+        .function("add", &ElemHide::Add)
+        .function("remove", &ElemHide::Remove)
+        .function("clear", &ElemHide::Clear)
+        .function("getSelectorsForDomain", &ElemHide::GetSelectorsForDomain)
+        .function("getUnconditionalSelectors", &ElemHide::GetUnconditionalSelectors);
+
+    class_<ElemHideEmulation_FilterList>("ElemHideEmulation_FilterList")
+        .property("filterCount", &ElemHideEmulation_FilterList::GetFilterCount)
+        .function("filterAt", &ElemHideEmulation_FilterList::FilterAt);
+
+    class_<ElemHideEmulation>("ElemHideEmulation")
+        .class_function("create", &ElemHideEmulation::Create)
+        .function("add", &ElemHideEmulation::Add)
+        .function("remove", &ElemHideEmulation::Remove)
+        .function("clear", &ElemHideEmulation::Clear)
+        .function("getRulesForDomain", &ElemHideEmulation::GetRulesForDomain);
 
     class_<Parser>("_FilterStorage_Parser")
         .property("subscriptionCount", &Parser::GetSubscriptionCount)
         .function("process", &Parser::Process)
         .function("finalize", &Parser::Finalize)
         .function("subscriptionAt", &Parser::SubscriptionAt)
         .class_function("create", &Parser::Create);
 
     class_<Serializer>("_FilterStorage_Serializer")
         .property("data", &Serializer::GetData)
         .function("serialize", &Serializer::Serialize)
         .class_function("create", &Serializer::Create);
 
     printBindings();
     RegExpFilter::GenerateCustomBindings();
-    FilterNotifier::GenerateCustomBindings();
+    FilterNotifier::GenerateCustomBindings::Generate();
 
     return 0;
   }
   catch (const std::exception& e)
   {
     EM_ASM_ARGS(
       console.error("Error occurred generating JavaScript bindings: " +
           Module.AsciiToString($0)), e.what()
     );
     return 1;
   }
 }