Add cache_ suffix to session cache functions

This way they won't conflict with other functions (e.g., delayed
database operations) that may have the same names.

2 files changed, 26 insertions, 24 deletions

diff --git a/common/session/custom/session.hxx b/common/session/custom/session.hxx
index ce7e43c..b0a6694 100644
--- a/common/session/custom/session.hxx
+++ b/common/session/custom/session.hxx
@@ -96,13 +96,13 @@ private:
   //
 public:
   template <typename T>
-  struct position
+  struct cache_position
   {
     typedef object_map<T> map;
     typedef typename map::iterator iterator;
 
-    position (): map_ (0) {}
-    position (map& m, const iterator& p): map_ (&m), pos_ (p) {}
+    cache_position (): map_ (0) {}
+    cache_position (map& m, const iterator& p): map_ (&m), pos_ (p) {}
 
     map* map_;
     iterator pos_;
@@ -111,18 +111,18 @@ public:
   // Cache management.
   //
   template <typename T>
-  static position<T>
-  insert (odb::database&,
-          const typename odb::object_traits<T>::id_type&,
-          const typename odb::object_traits<T>::pointer_type&);
+  static cache_position<T>
+  _cache_insert (odb::database&,
+                 const typename odb::object_traits<T>::id_type&,
+                 const typename odb::object_traits<T>::pointer_type&);
 
   template <typename T>
   static typename odb::object_traits<T>::pointer_type
-  find (odb::database&, const typename odb::object_traits<T>::id_type&);
+  _cache_find (odb::database&, const typename odb::object_traits<T>::id_type&);
 
   template <typename T>
   static void
-  erase (const position<T>& p)
+  _cache_erase (const cache_position<T>& p)
   {
     if (p.map_ != 0)
       p.map_->erase (p.pos_);
@@ -132,22 +132,23 @@ public:
   //
   template <typename T>
   static void
-  persist (const position<T>& p)
+  _cache_persist (const cache_position<T>& p)
   {
-    load (p);
+    _cache_load (p);
   }
 
   template <typename T>
   static void
-  load (const position<T>&);
+  _cache_load (const cache_position<T>&);
 
   template <typename T>
   static void
-  update (odb::database&, const T&);
+  _cache_update (odb::database&, const T&);
 
   template <typename T>
   static void
-  erase (odb::database&, const typename odb::object_traits<T>::id_type&);
+  _cache_erase (odb::database&,
+                const typename odb::object_traits<T>::id_type&);
 
 private:
   // Post-commit/rollback callback.
diff --git a/common/session/custom/session.txx b/common/session/custom/session.txx
index 31c08c7..de1f3f0 100644
--- a/common/session/custom/session.txx
+++ b/common/session/custom/session.txx
@@ -5,15 +5,15 @@
 #include <cassert>
 
 template <typename T>
-typename session::position<T> session::
-insert (odb::database&,
-        const typename odb::object_traits<T>::id_type& id,
-        const typename odb::object_traits<T>::pointer_type& obj)
+typename session::cache_position<T> session::
+_cache_insert (odb::database&,
+               const typename odb::object_traits<T>::id_type& id,
+               const typename odb::object_traits<T>::pointer_type& obj)
 {
   typedef odb::object_traits<T> object_traits;
 
   if (current == 0)
-    return position<T> (); // No session, return empty position.
+    return cache_position<T> (); // No session, return empty position.
 
   std::shared_ptr<object_map_base>& pm (current->map_[&typeid (T)]);
 
@@ -29,12 +29,12 @@ insert (odb::database&,
   //
   assert (r.second);
 
-  return position<T> (m, r.first);
+  return cache_position<T> (m, r.first);
 }
 
 template <typename T>
 typename odb::object_traits<T>::pointer_type session::
-find (odb::database&, const typename odb::object_traits<T>::id_type& id)
+_cache_find (odb::database&, const typename odb::object_traits<T>::id_type& id)
 {
   typedef typename odb::object_traits<T>::pointer_type pointer_type;
 
@@ -57,7 +57,7 @@ find (odb::database&, const typename odb::object_traits<T>::id_type& id)
 
 template <typename T>
 void session::
-load (const position<T>& p)
+_cache_load (const cache_position<T>& p)
 {
   typedef typename odb::object_traits<T>::pointer_type pointer_type;
 
@@ -75,7 +75,7 @@ load (const position<T>& p)
 
 template <typename T>
 void session::
-update (odb::database&, const T& obj)
+_cache_update (odb::database&, const T& obj)
 {
   typedef odb::object_traits<T> object_traits;
   typedef typename object_traits::pointer_type pointer_type;
@@ -105,7 +105,8 @@ update (odb::database&, const T& obj)
 
 template <typename T>
 void session::
-erase (odb::database&, const typename odb::object_traits<T>::id_type& id)
+_cache_erase (odb::database&,
+              const typename odb::object_traits<T>::id_type& id)
 {
   if (current == 0)
     return; // No session.