Implement two-phase session insertion

On the first step an uninitialized object is inserted into the cache
as before (this is necessary to handle recursive loading). The second
step is to notify the session that the object has been initialized.
On this second step the session can perform change tracking preparations,
such as make a copy of the object or reset the modification flag.

New test: common/session/custom (implements a custom session that uses
copies to track changes).

1 files changed, 119 insertions, 0 deletions

diff --git a/common/session/custom/test.hxx b/common/session/custom/test.hxx
new file mode 100644
index 0000000..1c4a713
--- /dev/null
+++ b/common/session/custom/test.hxx
@@ -0,0 +1,119 @@
+// file      : common/session/custom/test.hxx
+// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef TEST_HXX
+#define TEST_HXX
+
+#include <string>
+#include <memory>
+#include <vector>
+
+#include <odb/core.hxx>
+#include <odb/lazy-ptr.hxx>
+
+class employee;
+
+#pragma db object pointer(std::shared_ptr) session
+class employer
+{
+public:
+  employer (const std::string& name, const std::string& symbol)
+      : name_ (name), symbol_ (symbol) {}
+
+  const std::string&
+  name () const {return name_;}
+
+  const std::string&
+  symbol () const {return symbol_;}
+
+  void
+  symbol (const std::string& symbol) {symbol_ = symbol;}
+
+  // Employees of this employer.
+  //
+  typedef std::vector<odb::lazy_weak_ptr<employee>> employees_type;
+
+  const employees_type&
+  employees () const {return employees_;}
+
+  employees_type&
+  employees () {return employees_;}
+
+  // Change tracking.
+  //
+public:
+  bool
+  changed (const employer& orig) const
+  {
+    // Note that we don't need to track object ids, inverse pointers, nor
+    // readonly/const data members.
+    //
+    return symbol_ != orig.symbol_;
+  }
+
+private:
+  friend class odb::access;
+  employer () {}
+
+  #pragma db id
+  std::string name_;
+
+  std::string symbol_;
+
+  #pragma db value_not_null inverse(employer_)
+  employees_type employees_;
+};
+
+#pragma db object pointer(std::shared_ptr) session
+class employee
+{
+public:
+  typedef ::employer employer_type;
+
+  employee (const std::string& first,
+            const std::string& last,
+            std::shared_ptr<employer_type> employer)
+      : first_ (first), last_ (last), employer_ (employer) {}
+
+  // Name.
+  //
+  const std::string&
+  first () const {return first_;}
+
+  const std::string&
+  last () const {return last_;}
+
+  // Employer.
+  //
+  std::shared_ptr<employer_type>
+  employer () const {return employer_;}
+
+  void
+  employer (std::shared_ptr<employer_type> e) {employer_ = e;}
+
+  // Change tracking.
+  //
+public:
+  bool
+  changed (const employee& orig) const
+  {
+    return first_ != orig.first_ || last_ != orig.last_ ||
+      employer_ != orig.employer_;
+  }
+
+private:
+  friend class odb::access;
+  employee () {}
+
+  #pragma db id auto
+  unsigned long id_;
+
+  std::string first_;
+  std::string last_;
+
+  #pragma db not_null
+  std::shared_ptr<employer_type> employer_;
+};
+
+#endif // TEST_HXX