Chang the structure to use a lambda rather than a class

thk123 · thk123 · commit 60305de8a747 · 2018-06-19T13:43:43.000+01:00
This reduces overall boilerplate.
diff --git a/jbmc/src/java_bytecode/ci_lazy_methods.cpp b/jbmc/src/java_bytecode/ci_lazy_methods.cpp
@@ -34,8 +34,7 @@ ci_lazy_methodst::ci_lazy_methodst(
   const symbol_tablet &symbol_table,
   const irep_idt &main_class,
   const std::vector<irep_idt> &main_jar_classes,
-  const std::vector<std::unique_ptr<load_extra_methodst>>
-    &lazy_methods_extra_entry_points,
+  const std::vector<load_extra_methodst> &lazy_methods_extra_entry_points,
   java_class_loadert &java_class_loader,
   const std::vector<irep_idt> &extra_instantiated_classes,
   const select_pointer_typet &pointer_type_selector,
@@ -107,8 +106,7 @@ bool ci_lazy_methodst::operator()(
   std::vector<irep_idt> extra_entry_points;
   for(const auto &extra_function_generator : lazy_methods_extra_entry_points)
   {
-    const auto &extra_methods =
-      extra_function_generator->extra_methods(symbol_table);
+    const auto &extra_methods = extra_function_generator(symbol_table);
     extra_entry_points.insert(
       extra_entry_points.end(), extra_methods.begin(), extra_methods.end());
   }
diff --git a/jbmc/src/java_bytecode/ci_lazy_methods.h b/jbmc/src/java_bytecode/ci_lazy_methods.h
@@ -91,12 +91,8 @@ typedef std::function<
   bool(const irep_idt &function_id, ci_lazy_methods_neededt)>
   method_convertert;
 
-class load_extra_methodst
-{
-public:
-  virtual std::vector<irep_idt>
-  extra_methods(const symbol_tablet &symbol_table) const = 0;
-};
+typedef std::function<std::vector<irep_idt>(const symbol_tablet &)>
+  load_extra_methodst;
 
 class ci_lazy_methodst:public messaget
 {
@@ -105,8 +101,7 @@ class ci_lazy_methodst:public messaget
     const symbol_tablet &symbol_table,
     const irep_idt &main_class,
     const std::vector<irep_idt> &main_jar_classes,
-    const std::vector<std::unique_ptr<load_extra_methodst>>
-      &lazy_methods_extra_entry_points,
+    const std::vector<load_extra_methodst> &lazy_methods_extra_entry_points,
     java_class_loadert &java_class_loader,
     const std::vector<irep_idt> &extra_instantiated_classes,
     const select_pointer_typet &pointer_type_selector,
@@ -153,8 +148,7 @@ class ci_lazy_methodst:public messaget
   class_hierarchyt class_hierarchy;
   irep_idt main_class;
   std::vector<irep_idt> main_jar_classes;
-  const std::vector<std::unique_ptr<load_extra_methodst>>
-    &lazy_methods_extra_entry_points;
+  const std::vector<load_extra_methodst> &lazy_methods_extra_entry_points;
   java_class_loadert &java_class_loader;
   const std::vector<irep_idt> &extra_instantiated_classes;
   const select_pointer_typet &pointer_type_selector;
diff --git a/jbmc/src/java_bytecode/java_bytecode_language.cpp b/jbmc/src/java_bytecode/java_bytecode_language.cpp
@@ -100,7 +100,7 @@ void java_bytecode_languaget::get_language_options(const cmdlinet &cmd)
     extra_entry_points.end(),
     std::back_inserter(extra_methods),
     [](const std::string &pattern) {
-      return util_make_unique<load_method_by_regext>(pattern);
+      return build_load_method_by_regex(pattern);
     });
 
   if(cmd.isset("java-cp-include-files"))
diff --git a/jbmc/src/java_bytecode/java_bytecode_language.h b/jbmc/src/java_bytecode/java_bytecode_language.h
@@ -198,7 +198,7 @@ class java_bytecode_languaget:public languaget
   // List of classes to never load
   std::unordered_set<std::string> no_load_classes;
 
-  std::vector<std::unique_ptr<load_extra_methodst>> extra_methods;
+  std::vector<load_extra_methodst> extra_methods;
 };
 
 std::unique_ptr<languaget> new_java_bytecode_language();
diff --git a/jbmc/src/java_bytecode/load_method_by_regex.cpp b/jbmc/src/java_bytecode/load_method_by_regex.cpp
@@ -13,13 +13,12 @@ Author: Diffblue Ltd.
 
 #include <util/symbol_table.h>
 
-/// Create a load_method_by_regext matching the pattern. If the pattern doesn't
-/// include a colon for matching the descriptor, append a `:\(.*\).*` to the
-/// regex. Note this will mean all overloaded methods will be marked as extra
-/// entry points for CI lazy loading.
-/// If the pattern doesn't include the java:: prefix, prefix that
+/// For a given user provided pattern, return a regex, having dealt with the
+/// cases where the user has not prefixed with java:: or suffixed with the
+/// descriptor
 /// \param pattern: The user provided pattern
-load_method_by_regext::load_method_by_regext(const std::string &pattern)
+/// \return The regex to match with
+static std::regex build_regex_from_pattern(const std::string &pattern)
 {
   std::string modified_pattern = pattern;
   if(does_pattern_miss_descriptor(pattern))
@@ -28,43 +27,50 @@ load_method_by_regext::load_method_by_regext(const std::string &pattern)
   if(!has_prefix(pattern, "java::"))
     modified_pattern = "java::" + modified_pattern;
 
-  regex = std::regex{modified_pattern};
-}
-
-/// Get the methods that match the regex
-/// \param symbol_table: The symbol table to look through
-/// \return: The method identifiers that should be loaded
-std::vector<irep_idt>
-load_method_by_regext::extra_methods(const symbol_tablet &symbol_table) const
-{
-  std::vector<irep_idt> matched_methods;
-  for(const auto &symbol : symbol_table.symbols)
-  {
-    if(symbol.second.is_function())
-    {
-      const std::string symbol_name = id2string(symbol.first);
-      if(std::regex_match(symbol_name, regex))
-      {
-        matched_methods.push_back(symbol_name);
-      }
-    }
-  }
-  return matched_methods;
+  return std::regex{modified_pattern};
 }
 
 /// Identify if a parameter includes a part that will match a descriptor. That
 /// is, does it have a colon separtor.
 /// \param pattern: The user provided pattern
 /// \return True if no descriptor is found (that is, the only : relates to the
 /// java:: prefix.
-bool load_method_by_regext::does_pattern_miss_descriptor(
-  const std::string &pattern)
+bool does_pattern_miss_descriptor(const std::string &pattern)
 {
   const size_t descriptor_index = pattern.rfind(':');
   if(descriptor_index == std::string::npos)
     return true;
 
   static const std::string java_prefix = "java::";
   return descriptor_index == java_prefix.length() - 1 &&
-         has_prefix(pattern, "java::");
+         has_prefix(pattern, java_prefix);
+}
+
+/// Create a lambda that returns the symbols that the given pattern should be
+/// loaded.If the pattern doesn't include a colon for matching the descriptor,
+/// append a `:\(.*\).*` to the regex. Note this will mean all overloaded
+/// methods will be marked as extra entry points for CI lazy loading.
+/// If the pattern doesn't include the java:: prefix, prefix that
+/// \param pattern: The user provided pattern
+/// \return The lambda to execute.
+std::function<std::vector<irep_idt>(const symbol_tablet &symbol_table)>
+build_load_method_by_regex(const std::string &pattern)
+{
+  std::regex regex = build_regex_from_pattern(pattern);
+
+  return [=](const symbol_tablet &symbol_table) {
+    std::vector<irep_idt> matched_methods;
+    for(const auto &symbol : symbol_table.symbols)
+    {
+      if(symbol.second.is_function())
+      {
+        const std::string symbol_name = id2string(symbol.first);
+        if(std::regex_match(symbol_name, regex))
+        {
+          matched_methods.push_back(symbol_name);
+        }
+      }
+    }
+    return matched_methods;
+  };
 }
diff --git a/jbmc/src/java_bytecode/load_method_by_regex.h b/jbmc/src/java_bytecode/load_method_by_regex.h
@@ -17,20 +17,9 @@ Author: Diffblue Ltd.
 
 class symbol_tablet;
 
-class load_method_by_regext : public load_extra_methodst
-{
-public:
-  explicit load_method_by_regext(const std::string &pattern);
+std::function<std::vector<irep_idt>(const symbol_tablet &symbol_table)>
+build_load_method_by_regex(const std::string &pattern);
 
-  std::vector<irep_idt>
-  extra_methods(const symbol_tablet &symbol_table) const override;
-
-private:
-  std::regex regex;
-
-  static bool does_pattern_miss_descriptor(const std::string &pattern);
-
-  friend class load_method_by_regex_testt;
-};
+bool does_pattern_miss_descriptor(const std::string &pattern);
 
 #endif // CPROVER_JAVA_BYTECODE_LOAD_METHOD_BY_REGEX_H
diff --git a/jbmc/unit/java_bytecode/load_method_by_regex.cpp b/jbmc/unit/java_bytecode/load_method_by_regex.cpp
@@ -10,15 +10,6 @@
 #include <testing-utils/catch.hpp>
 #include <testing-utils/require_vectors_equal_unordered.h>
 
-class load_method_by_regex_testt
-{
-public:
-  static bool does_pattern_miss_descriptor(const std::string &pattern)
-  {
-    return load_method_by_regext::does_pattern_miss_descriptor(pattern);
-  }
-};
-
 SCENARIO(
   "load_method_by_regex::does_pattern_miss_descriptor",
   "[core][java_bytecode][load_method_by_regex]")
@@ -28,8 +19,7 @@ SCENARIO(
     const std::string pattern = "java::com.diffblue.ClassName.methodName";
     WHEN("When calling does_pattern_miss_descriptor")
     {
-      bool result =
-        load_method_by_regex_testt::does_pattern_miss_descriptor(pattern);
+      bool result = does_pattern_miss_descriptor(pattern);
       THEN("It should miss discriptor")
       {
         REQUIRE(result);
@@ -41,8 +31,7 @@ SCENARIO(
     const std::string pattern = "java::com.diffblue.ClassName.methodName:()V";
     WHEN("When calling does_pattern_miss_descriptor")
     {
-      bool result =
-        load_method_by_regex_testt::does_pattern_miss_descriptor(pattern);
+      bool result = does_pattern_miss_descriptor(pattern);
       THEN("It should have the discriptor")
       {
         REQUIRE_FALSE(result);
@@ -54,8 +43,7 @@ SCENARIO(
     const std::string pattern = "com.diffblue.ClassName.methodName";
     WHEN("When calling does_pattern_miss_descriptor")
     {
-      bool result =
-        load_method_by_regex_testt::does_pattern_miss_descriptor(pattern);
+      bool result = does_pattern_miss_descriptor(pattern);
       THEN("It should miss discriptor")
       {
         REQUIRE(result);
@@ -67,8 +55,7 @@ SCENARIO(
     const std::string pattern = "com.diffblue.ClassName.methodName:()V";
     WHEN("When calling does_pattern_miss_descriptor")
     {
-      bool result =
-        load_method_by_regex_testt::does_pattern_miss_descriptor(pattern);
+      bool result = does_pattern_miss_descriptor(pattern);
       THEN("It should have the discriptor")
       {
         REQUIRE_FALSE(result);
@@ -80,8 +67,7 @@ SCENARIO(
     const std::string pattern = "java:com.diffblue.ClassName.methodName";
     WHEN("When calling does_pattern_miss_descriptor")
     {
-      bool result =
-        load_method_by_regex_testt::does_pattern_miss_descriptor(pattern);
+      bool result = does_pattern_miss_descriptor(pattern);
       THEN("It should classify the last : as a descriptor")
       {
         REQUIRE_FALSE(result);
@@ -93,8 +79,7 @@ SCENARIO(
     const std::string pattern = "java:com.diffblue.ClassName.methodName:()V";
     WHEN("When calling does_pattern_miss_descriptor")
     {
-      bool result =
-        load_method_by_regex_testt::does_pattern_miss_descriptor(pattern);
+      bool result = does_pattern_miss_descriptor(pattern);
       THEN("It should have the discriptor")
       {
         REQUIRE_FALSE(result);
@@ -118,8 +103,8 @@ static void require_result_for_pattern(
 {
   WHEN("Constructing a load_method_by_regex")
   {
-    load_method_by_regext matcher{pattern};
-    const auto &results = matcher.extra_methods(symbol_table);
+    const auto matcher = build_load_method_by_regex(pattern);
+    const auto &results = matcher(symbol_table);
     if(expected.size() == 1)
     {
       THEN("Expect " + id2string(expected[0]))

Original file line number	Diff line number	Diff line change
`@@ -10,15 +10,6 @@`
`10`	`10`	`#include <testing-utils/catch.hpp>`
`11`	`11`	`#include <testing-utils/require_vectors_equal_unordered.h>`
`12`	`12`
`13`		`-class load_method_by_regex_testt`
`14`		`-{`
`15`		`-public:`
`16`		`- static bool does_pattern_miss_descriptor(const std::string &pattern)`
`17`		`- {`
`18`		`- return load_method_by_regext::does_pattern_miss_descriptor(pattern);`
`19`		`- }`
`20`		`-};`
`21`		`-`
`22`	`13`	`SCENARIO(`
`23`	`14`	`"load_method_by_regex::does_pattern_miss_descriptor",`
`24`	`15`	`"[core][java_bytecode][load_method_by_regex]")`
`@@ -28,8 +19,7 @@ SCENARIO(`
`28`	`19`	`const std::string pattern = "java::com.diffblue.ClassName.methodName";`
`29`	`20`	`WHEN("When calling does_pattern_miss_descriptor")`
`30`	`21`	`{`
`31`		`- bool result =`
`32`		`- load_method_by_regex_testt::does_pattern_miss_descriptor(pattern);`
	`22`	`+ bool result = does_pattern_miss_descriptor(pattern);`
`33`	`23`	`THEN("It should miss discriptor")`
`34`	`24`	`{`
`35`	`25`	`REQUIRE(result);`
`@@ -41,8 +31,7 @@ SCENARIO(`
`41`	`31`	`const std::string pattern = "java::com.diffblue.ClassName.methodName:()V";`
`42`	`32`	`WHEN("When calling does_pattern_miss_descriptor")`
`43`	`33`	`{`
`44`		`- bool result =`
`45`		`- load_method_by_regex_testt::does_pattern_miss_descriptor(pattern);`
	`34`	`+ bool result = does_pattern_miss_descriptor(pattern);`
`46`	`35`	`THEN("It should have the discriptor")`
`47`	`36`	`{`
`48`	`37`	`REQUIRE_FALSE(result);`
`@@ -54,8 +43,7 @@ SCENARIO(`
`54`	`43`	`const std::string pattern = "com.diffblue.ClassName.methodName";`
`55`	`44`	`WHEN("When calling does_pattern_miss_descriptor")`
`56`	`45`	`{`
`57`		`- bool result =`
`58`		`- load_method_by_regex_testt::does_pattern_miss_descriptor(pattern);`
	`46`	`+ bool result = does_pattern_miss_descriptor(pattern);`
`59`	`47`	`THEN("It should miss discriptor")`
`60`	`48`	`{`
`61`	`49`	`REQUIRE(result);`
`@@ -67,8 +55,7 @@ SCENARIO(`
`67`	`55`	`const std::string pattern = "com.diffblue.ClassName.methodName:()V";`
`68`	`56`	`WHEN("When calling does_pattern_miss_descriptor")`
`69`	`57`	`{`
`70`		`- bool result =`
`71`		`- load_method_by_regex_testt::does_pattern_miss_descriptor(pattern);`
	`58`	`+ bool result = does_pattern_miss_descriptor(pattern);`
`72`	`59`	`THEN("It should have the discriptor")`
`73`	`60`	`{`
`74`	`61`	`REQUIRE_FALSE(result);`
`@@ -80,8 +67,7 @@ SCENARIO(`
`80`	`67`	`const std::string pattern = "java:com.diffblue.ClassName.methodName";`
`81`	`68`	`WHEN("When calling does_pattern_miss_descriptor")`
`82`	`69`	`{`
`83`		`- bool result =`
`84`		`- load_method_by_regex_testt::does_pattern_miss_descriptor(pattern);`
	`70`	`+ bool result = does_pattern_miss_descriptor(pattern);`
`85`	`71`	`THEN("It should classify the last : as a descriptor")`
`86`	`72`	`{`
`87`	`73`	`REQUIRE_FALSE(result);`
`@@ -93,8 +79,7 @@ SCENARIO(`
`93`	`79`	`const std::string pattern = "java:com.diffblue.ClassName.methodName:()V";`
`94`	`80`	`WHEN("When calling does_pattern_miss_descriptor")`
`95`	`81`	`{`
`96`		`- bool result =`
`97`		`- load_method_by_regex_testt::does_pattern_miss_descriptor(pattern);`
	`82`	`+ bool result = does_pattern_miss_descriptor(pattern);`
`98`	`83`	`THEN("It should have the discriptor")`
`99`	`84`	`{`
`100`	`85`	`REQUIRE_FALSE(result);`
`@@ -118,8 +103,8 @@ static void require_result_for_pattern(`
`118`	`103`	`{`
`119`	`104`	`WHEN("Constructing a load_method_by_regex")`
`120`	`105`	`{`
`121`		`- load_method_by_regext matcher{pattern};`
`122`		`- const auto &results = matcher.extra_methods(symbol_table);`
	`106`	`+ const auto matcher = build_load_method_by_regex(pattern);`
	`107`	`+ const auto &results = matcher(symbol_table);`
`123`	`108`	`if(expected.size() == 1)`
`124`	`109`	`{`
`125`	`110`	`THEN("Expect " + id2string(expected[0]))`