base.hxx   base.hxx 
skipping to change at line 83 skipping to change at line 83
void void
operator delete (void*, share) throw (); operator delete (void*, share) throw ();
void void
operator delete (void*) throw (); operator delete (void*) throw ();
struct refcount_callback struct refcount_callback
{ {
void* arg; void* arg;
void (*zero_counter) (void*);
// Return true if the object should be deleted, false otherwise.
//
bool (*zero_counter) (void*);
}; };
private: private:
bool bool
_dec_ref_callback (); _dec_ref_callback ();
protected: protected:
std::size_t counter_; std::size_t counter_;
refcount_callback* callback_; refcount_callback* callback_;
}; };
 End of changes. 1 change blocks. 
1 lines changed or deleted 4 lines changed or added


 exception.hxx   exception.hxx 
skipping to change at line 22 skipping to change at line 22
#include <odb/details/export.hxx> #include <odb/details/export.hxx>
namespace odb namespace odb
{ {
struct LIBODB_EXPORT exception: std::exception struct LIBODB_EXPORT exception: std::exception
{ {
virtual const char* virtual const char*
what () const throw () = 0; what () const throw () = 0;
}; };
namespace core
{
using odb::exception;
}
} }
#include <odb/post.hxx> #include <odb/post.hxx>
#endif // ODB_EXCEPTION_HXX #endif // ODB_EXCEPTION_HXX
 End of changes. 1 change blocks. 
0 lines changed or deleted 5 lines changed or added


 exceptions.hxx   exceptions.hxx 
// file : odb/exceptions.hxx // file : odb/exceptions.hxx
// author : Boris Kolpackov <boris@codesynthesis.com> // author : Boris Kolpackov <boris@codesynthesis.com>
// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC // copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC
// license : GNU GPL v2; see accompanying LICENSE file // license : GNU GPL v2; see accompanying LICENSE file
#ifndef ODB_EXCEPTIONS_HXX #ifndef ODB_EXCEPTIONS_HXX
#define ODB_EXCEPTIONS_HXX #define ODB_EXCEPTIONS_HXX
#include <odb/pre.hxx> #include <odb/pre.hxx>
#include <string>
#include <odb/exception.hxx> #include <odb/exception.hxx>
#include <odb/details/export.hxx> #include <odb/details/export.hxx>
namespace odb namespace odb
{ {
struct LIBODB_EXPORT null_pointer: odb::exception struct LIBODB_EXPORT null_pointer: exception
{ {
virtual const char* virtual const char*
what () const throw (); what () const throw ();
}; };
// Transaction exceptions. // Transaction exceptions.
// //
struct LIBODB_EXPORT already_in_transaction: odb::exception struct LIBODB_EXPORT already_in_transaction: exception
{ {
virtual const char* virtual const char*
what () const throw (); what () const throw ();
}; };
struct LIBODB_EXPORT not_in_transaction: odb::exception struct LIBODB_EXPORT not_in_transaction: exception
{ {
virtual const char* virtual const char*
what () const throw (); what () const throw ();
}; };
struct LIBODB_EXPORT transaction_already_finalized: odb::exception struct LIBODB_EXPORT transaction_already_finalized: exception
{ {
virtual const char* virtual const char*
what () const throw (); what () const throw ();
}; };
// Session exceptions. // Session exceptions.
// //
struct LIBODB_EXPORT already_in_session: odb::exception struct LIBODB_EXPORT already_in_session: exception
{ {
virtual const char* virtual const char*
what () const throw (); what () const throw ();
}; };
struct LIBODB_EXPORT not_in_session: odb::exception struct LIBODB_EXPORT not_in_session: exception
{ {
virtual const char* virtual const char*
what () const throw (); what () const throw ();
}; };
struct LIBODB_EXPORT const_object: odb::exception struct LIBODB_EXPORT const_object: exception
{ {
virtual const char* virtual const char*
what () const throw (); what () const throw ();
}; };
// Database operations exceptions. // Database operations exceptions.
// //
struct LIBODB_EXPORT deadlock: odb::exception struct LIBODB_EXPORT recoverable: exception
{
};
struct LIBODB_EXPORT connection_lost: recoverable
{ {
virtual const char* virtual const char*
what () const throw (); what () const throw ();
}; };
struct LIBODB_EXPORT object_not_persistent: odb::exception struct LIBODB_EXPORT timeout: recoverable
{ {
virtual const char* virtual const char*
what () const throw (); what () const throw ();
}; };
struct LIBODB_EXPORT object_already_persistent: odb::exception struct LIBODB_EXPORT deadlock: recoverable
{ {
virtual const char* virtual const char*
what () const throw (); what () const throw ();
}; };
struct LIBODB_EXPORT result_not_cached: odb::exception struct LIBODB_EXPORT object_not_persistent: exception
{ {
virtual const char* virtual const char*
what () const throw (); what () const throw ();
}; };
struct LIBODB_EXPORT database_exception: odb::exception struct LIBODB_EXPORT object_already_persistent: exception
{ {
virtual const char*
what () const throw ();
}; };
struct LIBODB_EXPORT result_not_cached: exception
{
virtual const char*
what () const throw ();
};
struct LIBODB_EXPORT database_exception: exception
{
};
// Schema catalog exceptions.
//
struct LIBODB_EXPORT unknown_schema: exception
{
unknown_schema (const std::string& name);
~unknown_schema () throw ();
const std::string&
name () const
{
return name_;
}
virtual const char*
what () const throw ();
private:
std::string name_;
std::string what_;
};
namespace core
{
using odb::null_pointer;
using odb::already_in_transaction;
using odb::not_in_transaction;
using odb::transaction_already_finalized;
using odb::already_in_session;
using odb::not_in_session;
using odb::const_object;
using odb::recoverable;
using odb::deadlock;
using odb::connection_lost;
using odb::timeout;
using odb::object_not_persistent;
using odb::object_already_persistent;
using odb::result_not_cached;
using odb::database_exception;
using odb::unknown_schema;
}
} }
#include <odb/post.hxx> #include <odb/post.hxx>
#endif // ODB_EXCEPTIONS_HXX #endif // ODB_EXCEPTIONS_HXX
 End of changes. 15 change blocks. 
12 lines changed or deleted 75 lines changed or added


 forward.hxx   forward.hxx 
skipping to change at line 15 skipping to change at line 15
#ifndef ODB_FORWARD_HXX #ifndef ODB_FORWARD_HXX
#define ODB_FORWARD_HXX #define ODB_FORWARD_HXX
#include <odb/pre.hxx> #include <odb/pre.hxx>
namespace odb namespace odb
{ {
class database; class database;
class transaction; class transaction;
class session;
namespace core
{
using odb::database;
using odb::transaction;
using odb::session;
}
// Implementation details. // Implementation details.
// //
class access class access
{ {
public: public:
template <typename T> template <typename T>
class object_traits; class object_traits;
 End of changes. 1 change blocks. 
0 lines changed or deleted 8 lines changed or added


 lazy-ptr.hxx   lazy-ptr.hxx 
skipping to change at line 189 skipping to change at line 189
template <class Y> friend class lazy_auto_ptr; template <class Y> friend class lazy_auto_ptr;
// Note that it is possible to have a situation where p_ is NULL, // Note that it is possible to have a situation where p_ is NULL,
// i_.id is NULL and i_.db is not NULL. This will happen if the // i_.id is NULL and i_.db is not NULL. This will happen if the
// auto_ptr reference returned by load() is transferred to another // auto_ptr reference returned by load() is transferred to another
// pointer or reset. // pointer or reset.
// //
mutable std::auto_ptr<T> p_; mutable std::auto_ptr<T> p_;
mutable lazy_ptr_impl<T> i_; mutable lazy_ptr_impl<T> i_;
}; };
namespace core
{
using odb::lazy_ptr;
using odb::lazy_auto_ptr;
}
} }
#include <odb/lazy-ptr.ixx> #include <odb/lazy-ptr.ixx>
#include <odb/lazy-ptr.txx> #include <odb/lazy-ptr.txx>
#include <odb/lazy-pointer-traits.hxx> #include <odb/lazy-pointer-traits.hxx>
#include <odb/post.hxx> #include <odb/post.hxx>
#endif // ODB_LAZY_PTR_HXX #endif // ODB_LAZY_PTR_HXX
 End of changes. 1 change blocks. 
0 lines changed or deleted 6 lines changed or added


 query.hxx   query.hxx 
skipping to change at line 18 skipping to change at line 18
#include <odb/pre.hxx> #include <odb/pre.hxx>
#include <odb/traits.hxx> #include <odb/traits.hxx>
namespace odb namespace odb
{ {
template <typename T, template <typename T,
typename Q = typename object_traits<T>::query_base_type> typename Q = typename object_traits<T>::query_base_type>
class query; class query;
namespace core
{
using odb::query;
}
} }
#include <odb/post.hxx> #include <odb/post.hxx>
#endif // ODB_QUERY_HXX #endif // ODB_QUERY_HXX
 End of changes. 1 change blocks. 
0 lines changed or deleted 5 lines changed or added


 result.hxx   result.hxx 
skipping to change at line 329 skipping to change at line 329
// //
size_type size_type
size () const size () const
{ {
return impl_ ? impl_->size () : 0; return impl_ ? impl_->size () : 0;
} }
private: private:
details::shared_ptr<result_impl<T> > impl_; details::shared_ptr<result_impl<T> > impl_;
}; };
namespace core
{
using odb::result;
}
} }
#include <odb/result.txx> #include <odb/result.txx>
#include <odb/post.hxx> #include <odb/post.hxx>
#endif // ODB_RESULT_HXX #endif // ODB_RESULT_HXX
 End of changes. 1 change blocks. 
0 lines changed or deleted 5 lines changed or added


 version.hxx   version.hxx 
skipping to change at line 30 skipping to change at line 30
// Version AABBCCDD // Version AABBCCDD
// 2.0.0 02000000 // 2.0.0 02000000
// 2.1.0 02010000 // 2.1.0 02010000
// 2.1.1 02010100 // 2.1.1 02010100
// 2.2.0.a1 02019901 // 2.2.0.a1 02019901
// 3.0.0.b2 02999952 // 3.0.0.b2 02999952
// //
// ODB interface version: minor, major, and alpha/beta versions. // ODB interface version: minor, major, and alpha/beta versions.
// //
#define ODB_VERSION 10100 #define ODB_VERSION 10200
#define ODB_VERSION_STR "1.1" #define ODB_VERSION_STR "1.2"
// libodb version: interface version plus the bugfix version. // libodb version: interface version plus the bugfix version.
// //
#define LIBODB_VERSION 1010000 #define LIBODB_VERSION 1020000
#define LIBODB_VERSION_STR "1.1.0" #define LIBODB_VERSION_STR "1.2.0"
#include <odb/post.hxx> #include <odb/post.hxx>
#endif // ODB_VERSION_HXX #endif // ODB_VERSION_HXX
 End of changes. 2 change blocks. 
4 lines changed or deleted 4 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/