aboutsummaryrefslogtreecommitdiff
path: root/odb/cache-traits.hxx
diff options
context:
space:
mode:
Diffstat (limited to 'odb/cache-traits.hxx')
-rw-r--r--odb/cache-traits.hxx152
1 files changed, 152 insertions, 0 deletions
diff --git a/odb/cache-traits.hxx b/odb/cache-traits.hxx
new file mode 100644
index 0000000..5d32624
--- /dev/null
+++ b/odb/cache-traits.hxx
@@ -0,0 +1,152 @@
+// file : odb/cache-traits.hxx
+// author : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2009-2010 Code Synthesis Tools CC
+// license : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_CACHE_TRAITS_HXX
+#define ODB_CACHE_TRAITS_HXX
+
+#include <odb/pre.hxx>
+
+#include <odb/traits.hxx>
+#include <odb/session.hxx>
+#include <odb/pointer-traits.hxx>
+
+namespace odb
+{
+ // Caching traits for objects passed by pointer.
+ //
+ template <typename P, pointer_kind = pointer_traits<P>::kind>
+ struct pointer_cache_traits
+ {
+ typedef P pointer_type;
+ typedef typename pointer_traits<pointer_type>::element_type element_type;
+ typedef typename object_traits<element_type>::id_type id_type;
+ typedef session::object_position<element_type> position_type;
+
+ struct insert_guard
+ {
+ insert_guard (const position_type& pos): pos_ (pos) {}
+
+ ~insert_guard ()
+ {
+ if (pos_.map_ != 0)
+ session::current ().erase<element_type> (pos_);
+ }
+
+ void
+ release () {pos_.map_ = 0;}
+
+ private:
+ position_type pos_;
+ };
+
+ static position_type
+ insert (database& db, const id_type& id, const pointer_type& p)
+ {
+ if (session::has_current ())
+ return session::current ().insert<element_type> (db, id, p);
+ else
+ return position_type ();
+ }
+
+ static pointer_type
+ find (database& db, const id_type& id)
+ {
+ if (session::has_current ())
+ return session::current ().find<element_type> (db, id);
+ else
+ return pointer_type ();
+ }
+
+ static void
+ erase (database& db, const id_type& id)
+ {
+ if (session::has_current ())
+ session::current ().erase<element_type> (db, id);
+ }
+ };
+
+ // Unique pointers don't work with the object cache.
+ //
+ template <typename P>
+ struct pointer_cache_traits<P, pk_unique>
+ {
+ typedef P pointer_type;
+ typedef typename pointer_traits<pointer_type>::element_type element_type;
+ typedef typename object_traits<element_type>::id_type id_type;
+ struct position_type {};
+
+ struct insert_guard
+ {
+ insert_guard (const position_type&) {}
+ void release () {}
+ };
+
+ static position_type
+ insert (database&, const id_type&, const pointer_type&)
+ {
+ return position_type ();
+ }
+
+ static pointer_type
+ find (database&, const id_type&) { return pointer_type (); }
+
+ static void
+ erase (database&, const id_type&) {}
+ };
+
+ // Caching traits for objects passed by reference. Only if the object
+ // pointer kind is naked do we add the object to the session.
+ //
+ template <typename T,
+ pointer_kind =
+ pointer_traits<typename object_traits<T>::pointer_type>::kind>
+ struct reference_cache_traits
+ {
+ typedef T element_type;
+ typedef typename object_traits<element_type>::pointer_type pointer_type;
+ typedef typename object_traits<element_type>::id_type id_type;
+
+ struct position_type {};
+
+ struct insert_guard
+ {
+ insert_guard (const position_type&) {}
+ void release () {}
+ };
+
+ static position_type
+ insert (database&, const id_type&, element_type&)
+ {
+ return position_type ();
+ }
+ };
+
+ template <typename T>
+ struct reference_cache_traits<T, pk_naked>
+ {
+ typedef T element_type;
+ typedef typename object_traits<element_type>::pointer_type pointer_type;
+ typedef typename object_traits<element_type>::id_type id_type;
+
+ typedef
+ typename pointer_cache_traits<pointer_type>::position_type
+ position_type;
+
+ typedef
+ typename pointer_cache_traits<pointer_type>::insert_guard
+ insert_guard;
+
+ static position_type
+ insert (database& db, const id_type& id, element_type& obj)
+ {
+ pointer_type p (&obj);
+ return pointer_cache_traits<pointer_type>::insert (db, id, p);
+ }
+ };
+}
+
+#include <odb/post.hxx>
+
+#endif // ODB_CACHE_TRAITS_HXX