aboutsummaryrefslogtreecommitdiff
path: root/odb/no-op-cache-traits.hxx
diff options
context:
space:
mode:
Diffstat (limited to 'odb/no-op-cache-traits.hxx')
-rw-r--r--odb/no-op-cache-traits.hxx208
1 files changed, 208 insertions, 0 deletions
diff --git a/odb/no-op-cache-traits.hxx b/odb/no-op-cache-traits.hxx
new file mode 100644
index 0000000..84d1c7a
--- /dev/null
+++ b/odb/no-op-cache-traits.hxx
@@ -0,0 +1,208 @@
+// file : odb/no-op-cache-traits.hxx
+// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC
+// license : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_NO_OP_CACHE_TRAITS_HXX
+#define ODB_NO_OP_CACHE_TRAITS_HXX
+
+#include <odb/pre.hxx>
+
+#include <odb/traits.hxx>
+#include <odb/forward.hxx>
+#include <odb/pointer-traits.hxx>
+
+namespace odb
+{
+ // pointer_cache_type
+ //
+ // Used to convert an object pointer to the canonical form (non-const),
+ // suitable for insertion into the cache.
+ //
+ template <typename P,
+ typename E = typename pointer_traits<P>::element_type,
+ typename O = typename object_traits<E>::object_type,
+ pointer_kind pk = pointer_traits<P>::kind>
+ struct pointer_cache_type
+ {
+ typedef typename object_traits<O>::pointer_type pointer_type;
+
+ static pointer_type
+ convert (const P& p)
+ {
+ return pointer_traits<P>::const_pointer_cast (p);
+ }
+ };
+
+ template <typename P, typename T, pointer_kind pk>
+ struct pointer_cache_type<P, T, T, pk>
+ {
+ // If element_type and object_type are the same, then it is already
+ // the canonical pointer.
+ //
+ static const P&
+ convert (const P& p) {return p;}
+ };
+
+ template <typename P, typename E, typename O>
+ struct pointer_cache_type<P, E, O, pk_unique>
+ {
+ // If the pointer is unique, then casting it can transfer ownership.
+ // So return null pointer, which will be ignored down the chain.
+ //
+ typedef typename object_traits<O>::pointer_type pointer_type;
+
+ static pointer_type
+ convert (const P&) {return pointer_type ();}
+ };
+
+ template <typename P, typename T>
+ struct pointer_cache_type<P, T, T, pk_unique>
+ {
+ typedef typename object_traits<T>::pointer_type pointer_type;
+
+ static pointer_type
+ convert (const P&) {return pointer_type ();}
+ };
+
+ // reference_cache_type
+ //
+ // Used to convert an object reference to the canonical form (non-const),
+ // suitable for insertion into the cache.
+ //
+ template <typename T,
+ typename O = typename object_traits<T>::object_type>
+ struct reference_cache_type
+ {
+ static O&
+ convert (T& r)
+ {
+ return const_cast<O&> (r);
+ }
+ };
+
+ template <typename T>
+ struct reference_cache_type<T, T>
+ {
+ // If the types are the same, then it is already the canonical form.
+ //
+ static T&
+ convert (T& r) {return r;}
+ };
+
+ // pointer_cache_traits
+ //
+ // Caching traits for objects passed by pointer. P should be the canonical
+ // pointer (non-const).
+ //
+ template <typename P>
+ struct no_op_pointer_cache_traits
+ {
+ typedef P pointer_type;
+ typedef typename pointer_traits<pointer_type>::element_type object_type;
+ typedef typename object_traits<object_type>::id_type id_type;
+ struct position_type {};
+
+ struct insert_guard
+ {
+ insert_guard () {}
+ insert_guard (const position_type&) {}
+
+ position_type
+ position () const {return position_type ();}
+
+ void
+ release () {}
+
+ void
+ reset (const position_type&) {}
+ };
+
+ static position_type
+ insert (odb::database&, const id_type&, const pointer_type&)
+ {
+ return position_type ();
+ }
+
+ static position_type
+ insert (odb::database&, const pointer_type&) {return position_type ();}
+
+ static pointer_type
+ find (odb::database&, const id_type&) {return pointer_type ();}
+
+ static void
+ erase (odb::database&, const id_type&) {}
+
+ static void
+ erase (const position_type&) {}
+ };
+
+ template <typename P>
+ struct no_id_pointer_cache_traits
+ {
+ typedef P pointer_type;
+ struct position_type {};
+
+ static position_type
+ insert (odb::database&, const pointer_type&)
+ {
+ return position_type ();
+ }
+ };
+
+ // reference_cache_traits
+ //
+ // Caching traits for objects passed by reference. T should be the
+ // canonical object type (non-const).
+ //
+ template <typename T>
+ struct no_op_reference_cache_traits
+ {
+ typedef T object_type;
+ typedef typename object_traits<object_type>::id_type id_type;
+ struct position_type {};
+
+ struct insert_guard
+ {
+ insert_guard () {}
+ insert_guard (const position_type&) {}
+
+ position_type
+ position () const {return position_type ();}
+
+ void
+ release () {}
+
+ void
+ reset () {}
+ };
+
+ static position_type
+ insert (odb::database&, const id_type&, object_type&)
+ {
+ return position_type ();
+ }
+
+ static position_type
+ insert (odb::database&, object_type&)
+ {
+ return position_type ();
+ }
+ };
+
+ template <typename T>
+ struct no_id_reference_cache_traits
+ {
+ typedef T object_type;
+ struct position_type {};
+
+ static position_type
+ insert (odb::database&, object_type&)
+ {
+ return position_type ();
+ }
+ };
+}
+
+#include <odb/post.hxx>
+
+#endif // ODB_NO_OP_CACHE_TRAITS_HXX