Renamed map_serializert to virtual_mapt

Author: NathanJPhillips

src/util/cached_map.h

@@ -5,15 +5,15 @@ Module: cached_map
 Author: [email protected]
 
 Purpose:
-  A map-like data structure that unloads elements using a map_serializert when
+  A map-like data structure that unloads elements using a virtual_mapt when
   there are more than a specified number of elements in memory.
 
 \*******************************************************************/
 
 #ifndef CPROVER_UTIL_CACHED_MAP_H
 #define CPROVER_UTIL_CACHED_MAP_H
 
-#include "map_serializer.h"
+#include "virtual_map.h"
 #include "range_union.h"
 #include <memory>
 #include <functional>
@@ -36,13 +36,13 @@ Template parameters:
 Purpose:
   A map that caches the most recently used max_size entries in memory and
   virtualizes the rest to a backing store.
-  Neither the map_serializert passed at construction, nor any other
-  map_serializert pointing at the same backing store should be used to update
+  Neither the virtual_mapt passed at construction, nor any other
+  virtual_mapt pointing at the same backing store should be used to update
   values in the backing store used by the cached_mapt while the latter has
   cached objects. The cached objects can be cleared with unload_all.
 
 Remarks:
-  The map_serializert must be kept in scope for the life of the cached_mapt.
+  The virtual_mapt must be kept in scope for the life of the cached_mapt.
   This class could be improved in a couple of ways:
   1) Keep track of the size of objects rather than the count of objects using a
       user-provided get_element_size function and limit the cache to a memory
@@ -74,10 +74,10 @@ class cached_mapt final
   // NOLINTNEXTLINE(readability/identifiers)  - name matches those used in STL
   typedef const value_type * const_pointer;
   // NOLINTNEXTLINE(readability/identifiers)  - name matches those used in STL
-  typedef typename map_serializert<keyt, valuet>::size_type size_type;
+  typedef typename virtual_mapt<keyt, valuet>::size_type size_type;
 
 private:
-  map_serializert<keyt, valuet> &serializer;
+  virtual_mapt<keyt, valuet> &base_map;
   mutable std::map<keyt, valuet> cache;
   mutable std::map<valuet *, keyt> key_from_ptr;
   mutable std::map<keyt, std::weak_ptr<valuet>> locked;
@@ -94,8 +94,8 @@ class cached_mapt final
   Function: cached_mapt::cached_mapt
 
   Inputs:
-    serializer:
-      The map_serializert that provides access to the backing store for the
+    base_map:
+      The virtual_mapt that provides access to the backing store for the
       cached_mapt. This must be kept in scope for the life of the cached_mapt.
 
   Outputs:
@@ -104,8 +104,8 @@ class cached_mapt final
     Creates a cached_mapt with unlimited size.
 
   \*******************************************************************/
-  explicit cached_mapt(map_serializert<keyt, valuet> &serializer)
-    : serializer(serializer)
+  explicit cached_mapt(virtual_mapt<keyt, valuet> &base_map)
+    : base_map(base_map)
   {
   }
 
@@ -114,8 +114,8 @@ class cached_mapt final
   Function: cached_mapt::cached_mapt
 
   Inputs:
-    serializer:
-      The map_serializert that provides access to the backing store for the
+    base_map:
+      The virtual_mapt that provides access to the backing store for the
       cached_mapt. This must be kept in scope for the life of the cached_mapt.
     max_size:
       The maximum size limit of the cache, EXCEPT when more items than this are
@@ -127,10 +127,10 @@ class cached_mapt final
     Creates a cached_mapt.
 
   \*******************************************************************/
-  explicit cached_mapt(
-      map_serializert<keyt, valuet> &serializer,
+  cached_mapt(
+      virtual_mapt<keyt, valuet> &base_map,
       size_t max_size)
-    : serializer(serializer), max_size(max_size)
+    : base_map(base_map), max_size(max_size)
   {
   }
 
@@ -214,11 +214,11 @@ class cached_mapt final
     This function checks the existence on disc of each item in the map.
 
   \*******************************************************************/
-  typename map_serializert<keyt, valuet>::keys_ranget keys() const
+  typename virtual_mapt<keyt, valuet>::keys_ranget keys() const
   {
     // Need to remove duplicates
     return range_union(
-      serializer.keys(),
+      base_map.keys(),
       cache | boost::adaptors::map_keys);
   }
 
@@ -253,7 +253,7 @@ class cached_mapt final
 
   private:
     typedef constify<cached_mapt> &cached_map_reft;
-    typedef typename map_serializert<keyt, valuet>::keys_ranget::iterator
+    typedef typename virtual_mapt<keyt, valuet>::keys_ranget::iterator
       key_iteratort;
 
   private:
@@ -363,7 +363,7 @@ class cached_mapt final
   \*******************************************************************/
   bool contains(const keyt &key) const
   {
-    return cache.count(key) != 0 || serializer.contains(key);
+    return cache.count(key) != 0 || base_map.contains(key);
   }
 
   /*******************************************************************\
@@ -416,7 +416,7 @@ class cached_mapt final
     return get(
       key,
       [this, &key]
-      { return serializer.contains(key) ? serializer.at(key) : valuet(); });
+      { return base_map.contains(key) ? base_map.at(key) : valuet(); });
   }
 
   /*******************************************************************\
@@ -437,7 +437,7 @@ class cached_mapt final
   {
     return get(
       key,
-      [this, &key] { return serializer.at(key); });
+      [this, &key] { return base_map.at(key); });
   }
 
   /*******************************************************************\
@@ -464,7 +464,7 @@ class cached_mapt final
       return false;
     if(cache.count(key) != 0)
       remove_cache(key);
-    serializer.remove(key);
+    base_map.remove(key);
     return true;
   }
 
@@ -493,7 +493,7 @@ class cached_mapt final
     key_from_ptr.clear();
     unloadable.clear();
     // Clear the backing store
-    serializer.clear();
+    base_map.clear();
     return true;
   }
 
@@ -538,8 +538,8 @@ class cached_mapt final
   void flush()
   {
     for(std::pair<const keyt, valuet> &elt : cache)
-      serializer.set(elt.first, elt.second);
-    serializer.flush();
+      base_map.set(elt.first, elt.second);
+    base_map.flush();
   }
 
 private:
@@ -595,7 +595,7 @@ class cached_mapt final
     // Save any changes made while it was locked
     // This may double save if flush was called
     // This may save unnecessarily if the element wasn't changed while locked
-    serializer.set(key, cache.at(key));
+    base_map.set(key, cache.at(key));
     remove_cache(key);
   }
 

src/util/json_map_serializer.h

@@ -11,7 +11,7 @@ Purpose: Generic serialization of maps of object hierarchies to JSON.
 #ifndef CPROVER_UTIL_JSON_MAP_SERIALIZER_H
 #define CPROVER_UTIL_JSON_MAP_SERIALIZER_H
 
-#include "map_serializer.h"
+#include "virtual_map.h"
 #include "json_serializer.h"
 #include <util/file_util.h>
 #include <cstdio>
@@ -37,7 +37,7 @@ Template parameters:
 
 \*******************************************************************/
 template<typename keyt, typename valuet>
-class json_map_serializert:public map_serializert<keyt, valuet>
+class json_map_serializert:public virtual_mapt<keyt, valuet>
 {
 private:
   // This extension is added to all saved JSON files

src/util/map_serializer.h renamed to src/util/virtual_map.h

@@ -1,34 +1,34 @@
 /*******************************************************************\
 
-Module: map_serializer
+Module: virtual_map
 
 Author: [email protected]
 
-Purpose: Generic serialization of maps of object hierarchies.
+Purpose: Generic virtual maps.
 
 \*******************************************************************/
 
-#ifndef CPROVER_UTIL_MAP_SERIALIZER_H
-#define CPROVER_UTIL_MAP_SERIALIZER_H
+#ifndef CPROVER_UTIL_VIRTUAL_MAP_H
+#define CPROVER_UTIL_VIRTUAL_MAP_H
 
 #include <boost/range/any_range.hpp>
 
 
 /*******************************************************************\
 
-Class: map_serializert
+Class: virtual_mapt
 
 Template parameters:
   keyt: The type of keys of the map.
-  valuet: The type of values of the map. Must be serializable.
+  valuet: The type of values of the map.
 
 Purpose:
   Provides a map-like interface to a backing store such as JSON files or a
   database.
 
 \*******************************************************************/
 template<typename keyt, typename valuet>
-class map_serializert
+class virtual_mapt
 {
 public:
   // NOLINTNEXTLINE(readability/identifiers)  - name matches those used in STL
@@ -58,11 +58,11 @@ class map_serializert
     keys_ranget;
 
   // The virtual destructor ensures sub-classes are disposed correctly.
-  virtual ~map_serializert()=default;
+  virtual ~virtual_mapt()=default;
 
   /*******************************************************************\
 
-  Function: map_serializert::size
+  Function: virtual_mapt::size
 
   Inputs:
 
@@ -77,7 +77,7 @@ class map_serializert
 
   /*******************************************************************\
 
-  Function: map_serializert::keys
+  Function: virtual_mapt::keys
 
   Inputs:
 
@@ -92,7 +92,7 @@ class map_serializert
 
   /*******************************************************************\
 
-  Function: map_serializert::contains
+  Function: virtual_mapt::contains
 
   Inputs:
     key: The key to search for.
@@ -108,7 +108,7 @@ class map_serializert
 
   /*******************************************************************\
 
-  Function: map_serializert::at
+  Function: virtual_mapt::at
 
   Inputs:
     key: The key to search for.
@@ -124,7 +124,7 @@ class map_serializert
 
   /*******************************************************************\
 
-  Function: map_serializert::set
+  Function: virtual_mapt::set
 
   Inputs:
     key: The key of the key-value pair to add.
@@ -140,7 +140,7 @@ class map_serializert
 
   /*******************************************************************\
 
-  Function: map_serializert::erase
+  Function: virtual_mapt::erase
 
   Inputs:
     key: The key of the key-value pair to remove.
@@ -155,7 +155,7 @@ class map_serializert
 
   /*******************************************************************\
 
-  Function: map_serializert::clear
+  Function: virtual_mapt::clear
 
   Inputs:
 
@@ -169,14 +169,14 @@ class map_serializert
 
   /*******************************************************************\
 
-  Function: map_serializert::flush
+  Function: virtual_mapt::flush
 
   Inputs:
 
   Outputs:
 
   Purpose:
-    Flushes cached data from the serializer to the backing store, if any.
+    Flushes changes, if any.
 
   \*******************************************************************/
   virtual void flush()=0;