Replace map to pair with a more specialized type

Requested in code review

Author: NathanJPhillips

src/java_bytecode/ci_lazy_methods.cpp

@@ -140,17 +140,16 @@ bool ci_lazy_methodst::operator()(
       {
         if(!methods_already_populated.insert(mname).second)
           continue;
-        auto findit = method_bytecode.find(mname);
-        if(findit == method_bytecode.end())
+        method_bytecodet::opt_reft cmb = method_bytecode.get(mname);
+        if(!cmb)
         {
           debug() << "Skip " << mname << eom;
           continue;
         }
         debug() << "CI lazy methods: elaborate " << mname << eom;
-        const auto &parsed_method=findit->second;
         method_converter(
-          symbol_table.lookup_ref(parsed_method.first),
-          *parsed_method.second,
+          symbol_table.lookup_ref(cmb->get().class_id),
+          cmb->get().method,
           // Note this wraps *references* to method_worklist2 & needed_classes
           ci_lazy_methods_neededt(
             method_worklist2, needed_classes, symbol_table));
@@ -190,7 +189,7 @@ bool ci_lazy_methodst::operator()(
     if(sym.second.is_static_lifetime)
       continue;
     if(
-      method_bytecode.count(sym.first) &&
+      method_bytecode.contains_method(sym.first) &&
       !methods_already_populated.count(sym.first))
     {
       continue;

src/java_bytecode/ci_lazy_methods.h

@@ -26,11 +26,63 @@
 
 class java_string_library_preprocesst;
 
-// Pair of class id and methodt
-typedef std::pair<irep_idt, const java_bytecode_parse_treet::methodt *>
-  class_and_bytecodet;
-// Map from method id to class_and_bytecodet
-typedef std::map<irep_idt, class_and_bytecodet> method_bytecodet;
+// Map from method id to class_method_and_bytecodet
+class method_bytecodet
+{
+public:
+  /// Pair of class id and methodt
+  struct class_method_and_bytecodet
+  {
+    irep_idt class_id;
+    irep_idt method_id;
+    const java_bytecode_parse_treet::methodt &method;
+  };
+
+  typedef optionalt<std::reference_wrapper<const class_method_and_bytecodet>>
+    opt_reft;
+
+private:
+  typedef std::map<irep_idt, class_method_and_bytecodet> mapt;
+  mapt map;
+
+public:
+  bool contains_method(const irep_idt &method_id) const
+  {
+    return map.count(method_id) != 0;
+  }
+
+  void add(const class_method_and_bytecodet &method_class_and_bytecode)
+  {
+    map.emplace(
+      std::make_pair(
+        method_class_and_bytecode.method_id, method_class_and_bytecode));
+  }
+
+  void add(
+    const irep_idt &class_id,
+    const irep_idt &method_id,
+    const java_bytecode_parse_treet::methodt &method)
+  {
+    add(class_method_and_bytecodet{class_id, method_id, method});
+  }
+
+  mapt::const_iterator begin() const
+  {
+    return map.begin();
+  }
+  mapt::const_iterator end() const
+  {
+    return map.end();
+  }
+
+  opt_reft get(const irep_idt &method_id)
+  {
+    const auto it = map.find(method_id);
+    if(it == map.end())
+      return opt_reft();
+    return std::cref(it->second);
+  }
+};
 
 typedef std::function<void(
   const symbolt &,

src/java_bytecode/java_bytecode_convert_class.cpp

@@ -205,8 +205,7 @@ void java_bytecode_convert_classt::convert(const classt &c)
       method,
       symbol_table,
       get_message_handler());
-    method_bytecode[method_identifier] =
-      std::make_pair(qualified_classname, &method);
+    method_bytecode.add(qualified_classname, method_identifier, method);
   }
 
   // is this a root class?

src/java_bytecode/java_bytecode_language.cpp

@@ -251,8 +251,8 @@ bool java_bytecode_languaget::typecheck(
     for(const auto &method_sig : method_bytecode)
     {
       java_bytecode_convert_method(
-        symbol_table.lookup_ref(method_sig.second.first),
-        *method_sig.second.second,
+        symbol_table.lookup_ref(method_sig.second.class_id),
+        method_sig.second.method,
         symbol_table,
         get_message_handler(),
         max_user_array_length,
@@ -368,10 +368,11 @@ void java_bytecode_languaget::convert_lazy_method(
   const irep_idt &function_id,
   symbol_tablet &symbol_table)
 {
-  const auto &lazy_method_entry = method_bytecode.at(function_id);
+  const method_bytecodet::class_method_and_bytecodet &cmb =
+    *method_bytecode.get(function_id);
   java_bytecode_convert_method(
-    symbol_table.lookup_ref(lazy_method_entry.first),
-    *lazy_method_entry.second,
+    symbol_table.lookup_ref(cmb.class_id),
+    cmb.method,
     symbol_table,
     get_message_handler(),
     max_user_array_length,

src/java_bytecode/java_bytecode_language.h

@@ -16,6 +16,7 @@ Author: Daniel Kroening, [email protected]
 #include <util/cmdline.h>
 #include <util/make_unique.h>
 
+#include "ci_lazy_methods.h"
 #include "java_class_loader.h"
 #include "java_string_library_preprocess.h"
 
@@ -81,12 +82,6 @@ struct object_factory_parameterst final
   bool string_printable = false;
 };
 
-// Pair of class id and methodt
-typedef std::pair<irep_idt, const java_bytecode_parse_treet::methodt *>
-  class_and_bytecodet;
-// Map from method id to class_and_bytecodet
-typedef std::map<irep_idt, class_and_bytecodet> method_bytecodet;
-
 class java_bytecode_languaget:public languaget
 {
 public: