/usr/include/odb/cache-traits.hxx is in libodb-dev 2.4.0-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 | // file : odb/cache-traits.hxx
// copyright : Copyright (c) 2009-2015 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/forward.hxx>
#include <odb/session.hxx>
#include <odb/pointer-traits.hxx>
#include <odb/no-op-cache-traits.hxx>
namespace odb
{
// pointer_cache_traits
//
// Caching traits for objects passed by pointer. P should be the canonical
// pointer (non-const).
//
template <typename P, typename S, pointer_kind pk>
struct pointer_cache_traits_impl
{
typedef P pointer_type;
typedef S session_type;
typedef odb::pointer_traits<pointer_type> pointer_traits;
typedef typename pointer_traits::element_type object_type;
typedef typename object_traits<object_type>::id_type id_type;
typedef typename session_type::template cache_position<object_type>
position_type;
struct insert_guard
{
insert_guard () {}
insert_guard (const position_type& pos): pos_ (pos) {}
~insert_guard () {session_type::_cache_erase (pos_);}
const position_type&
position () const {return pos_;}
void
release () {pos_ = position_type ();}
// Note: doesn't call erase() on the old position (assumes empty).
//
void
reset (const position_type& pos) {pos_ = pos;}
private:
position_type pos_;
};
// Cache management.
//
// We need the insert() overload with explicit id to handle self-
// references. In such cases the object is not yet loaded and the
// id member does not contain the correct id.
//
// Qualify the database type to resolve a phony ambiguity in VC 10.
//
static position_type
insert (odb::database& db, const id_type& id, const pointer_type& p)
{
return session_type::template _cache_insert<object_type> (db, id, p);
}
static position_type
insert (odb::database& db, const pointer_type& p)
{
const id_type& id (
object_traits<object_type>::id (
pointer_traits::get_ref (p)));
return session_type::template _cache_insert<object_type> (db, id, p);
}
static pointer_type
find (odb::database& db, const id_type& id)
{
return session_type::template _cache_find<object_type> (db, id);
}
static void
erase (const position_type& p)
{
session_type::template _cache_erase<object_type> (p);
}
// Notifications.
//
static void
persist (const position_type& p)
{
session_type::template _cache_persist<object_type> (p);
}
static void
load (const position_type& p)
{
session_type::template _cache_load<object_type> (p);
}
static void
update (odb::database& db, const object_type& obj)
{
session_type::template _cache_update<object_type> (db, obj);
}
static void
erase (odb::database& db, const id_type& id)
{
session_type::template _cache_erase<object_type> (db, id);
}
};
// Unique pointers don't work with the object cache.
//
template <typename P, typename S>
struct pointer_cache_traits_impl<P, S, pk_unique>:
no_op_pointer_cache_traits<P> {};
template <typename P, typename S>
struct pointer_cache_traits:
pointer_cache_traits_impl<P, S, pointer_traits<P>::kind> {};
// reference_cache_traits
//
// Caching traits for objects passed by reference. T should be the
// canonical object type (non-const). Only if the object pointer
// kind is raw do we add the object to the session.
//
template <typename T, typename S, pointer_kind pk>
struct reference_cache_traits_impl: no_op_reference_cache_traits<T> {};
template <typename T, typename S>
struct reference_cache_traits_impl<T, S, pk_raw>
{
typedef T object_type;
typedef typename object_traits<object_type>::pointer_type pointer_type;
typedef typename object_traits<object_type>::id_type id_type;
typedef pointer_cache_traits<pointer_type, S> pointer_traits;
typedef typename pointer_traits::position_type position_type;
typedef typename pointer_traits::insert_guard insert_guard;
static position_type
insert (odb::database& db, const id_type& id, object_type& obj)
{
pointer_type p (&obj);
return pointer_traits::insert (db, id, p);
}
static position_type
insert (odb::database& db, object_type& obj)
{
pointer_type p (&obj);
return pointer_traits::insert (db, p);
}
static void
persist (const position_type& p)
{
pointer_traits::persist (p);
}
static void
load (const position_type& p)
{
pointer_traits::load (p);
}
};
template <typename T, typename S>
struct reference_cache_traits:
reference_cache_traits_impl<
T, S, pointer_traits<typename object_traits<T>::pointer_type>::kind> {};
}
#include <odb/post.hxx>
#endif // ODB_CACHE_TRAITS_HXX
|