odb/transaction.hxx


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

// file      : odb/transaction.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_TRANSACTION_HXX
#define ODB_TRANSACTION_HXX

#include <new> // placement new

#include <odb/forward.hxx>

namespace odb
{
  class transaction_impl;

  class transaction
  {
  public:
    typedef odb::session session_type;
    typedef odb::database database_type;

    explicit
    transaction (transaction_impl*);

    // Unless the transaction has been already been finilized (explicitly
    // committed or rolled back), the destructor will roll it back.
    //
    ~transaction ();

    void
    commit ();

    void
    rollback ();

    // Return the database this transaction is on.
    //
    database_type&
    database ();

    // Return the session this transaction is part of.
    //
    session_type&
    session ();

    // Return current transaction or throw if there is no transaction
    // in effect.
    //
    static transaction&
    current ();

    // Return true if there is a transaction in effect.
    //
    static bool
    has_current ();

  public:
    transaction_impl&
    implementation ();

  private:
    // Copying or assignment of transactions is not supported.
    //
    transaction (const transaction&);
    transaction& operator= (const transaction&);

  protected:
    bool finilized_;
    transaction_impl* impl_;
  };
}

#include <odb/session.hxx>

namespace odb
{
  class transaction_impl
  {
  protected:
    friend class transaction;

    typedef odb::session session_type;
    typedef odb::database database_type;

    transaction_impl (database_type& db, session_type& s)
        : database_ (db), session_ (s)
    {
    }

    transaction_impl (database_type& db)
        : database_ (db),
          session_ (*reinterpret_cast<session_type*> (&session_mem_))
    {
      new (&session_mem_) session_type ();
    }

    virtual
    ~transaction_impl ();

    virtual void
    commit () = 0;

    virtual void
    rollback () = 0;

    session_type&
    session ()
    {
      return session_;
    }

    database_type&
    database ()
    {
      return database_;
    }

    bool
    own_session () const
    {
      return &session_ == reinterpret_cast<const session_type*> (&session_mem_);
    }

  protected:
    database_type& database_;
    session_type& session_;

    union
    {
      void* align_;
      char data_[sizeof (session_type)];
    } session_mem_;
  };
}

#include <odb/transaction.ixx>

#endif // ODB_TRANSACTION_HXX