Add support for change-tracking containers

ODB now supports "smart" ordered containers. Such containers get extra
functions for updating and deleting individual elements. Based on this
functionality implement two change-tracking containers: odb::vector
(equivalent to std::vector) and QOdbList (equivalent to QList). New
tests: common/container/change-tracking and qt/common/container/change-
tracking.

19 files changed, 1909 insertions, 136 deletions

diff --git a/odb/container-traits.hxx b/odb/container-traits.hxx
index 85cf512..18645e6 100644
--- a/odb/container-traits.hxx
+++ b/odb/container-traits.hxx
@@ -46,50 +46,82 @@ namespace odb
     }
 
     void
-    insert_one (I index, const V& value) const
+    insert (I index, const V& value) const
     {
-      insert_one_ (index, value, data_);
+      insert_ (index, value, data_);
     }
 
     bool
-    load_all (I& next_index, V& next_value) const
+    select (I& next_index, V& next_value) const
     {
-      return load_all_ (next_index, next_value, data_);
+      return select_ (next_index, next_value, data_);
     }
 
     void
-    delete_all () const
+    delete_ () const
     {
-      delete_all_ (data_);
+      delete__ (data_);
     }
 
     // Implementation details.
     //
   public:
-    typedef void (*insert_one_type) (I, const V&, void*);
-    typedef bool (*load_all_type) (I&, V&, void*);
-    typedef void (*delete_all_type) (void*);
-
-    ordered_functions (void* data,
-                       insert_one_type io,
-                       load_all_type la,
-                       delete_all_type da)
-        : data_ (data), insert_one_ (io), load_all_ (la), delete_all_ (da)
+    ordered_functions (void* data): data_ (data) {}
+
+  public:
+    void* data_;
+    bool ordered_;
+
+    void (*insert_) (I, const V&, void*);
+    bool (*select_) (I&, V&, void*);
+    void (*delete__) (void*);
+  };
+
+  template <typename I, typename V>
+  struct smart_ordered_functions
+  {
+    typedef I index_type;
+    typedef V value_type;
+
+    void
+    insert (I index, const V& value) const
     {
+      insert_ (index, value, data_);
+    }
+
+    bool
+    select (I& next_index, V& next_value) const
+    {
+      return select_ (next_index, next_value, data_);
     }
 
     void
-    ordered (bool v)
+    update (I index, const V& value) const
     {
-      ordered_ = v;
+      update_ (index, value, data_);
     }
 
-  private:
+    // Delete all the elements starting with the specified index. To
+    // delete everything, pass 0.
+    //
+    void
+    delete_ (I start_index) const
+    {
+      delete__ (start_index, data_);
+    }
+
+    // Implementation details.
+    //
+  public:
+    smart_ordered_functions (void* data) : data_ (data) {}
+
+  public:
     void* data_;
-    bool ordered_;
-    insert_one_type insert_one_;
-    load_all_type load_all_;
-    delete_all_type delete_all_;
+
+    void (*insert_) (I, const V&, void*);
+    bool (*select_) (I&, V&, void*);
+    void (*update_) (I, const V&, void*);
+    void (*delete__) (I, void*);
   };
 
   // Set/multiset containers.
@@ -100,43 +132,34 @@ namespace odb
     typedef V value_type;
 
     void
-    insert_one (const V& value) const
+    insert (const V& value) const
     {
-      insert_one_ (value, data_);
+      insert_ (value, data_);
     }
 
     bool
-    load_all (V& next_value) const
+    select (V& next_value) const
     {
-      return load_all_ (next_value, data_);
+      return select_ (next_value, data_);
     }
 
     void
-    delete_all () const
+    delete_ () const
     {
-      delete_all_ (data_);
+      delete__ (data_);
     }
 
     // Implementation details.
     //
   public:
-    typedef void (*insert_one_type) (const V&, void*);
-    typedef bool (*load_all_type) (V&, void*);
-    typedef void (*delete_all_type) (void*);
-
-    set_functions (void* data,
-                   insert_one_type io,
-                   load_all_type la,
-                   delete_all_type da)
-        : data_ (data), insert_one_ (io), load_all_ (la), delete_all_ (da)
-    {
-    }
+    set_functions (void* data): data_ (data) {}
 
-  private:
+  public:
     void* data_;
-    insert_one_type insert_one_;
-    load_all_type load_all_;
-    delete_all_type delete_all_;
+
+    void (*insert_) (const V&, void*);
+    bool (*select_) (V&, void*);
+    void (*delete__) (void*);
   };
 
   // Map/multimap containers.
@@ -148,43 +171,34 @@ namespace odb
     typedef V value_type;
 
     void
-    insert_one (const K& key, const V& value) const
+    insert (const K& key, const V& value) const
     {
-      insert_one_ (key, value, data_);
+      insert_ (key, value, data_);
     }
 
     bool
-    load_all (K& next_key, V& next_value) const
+    select (K& next_key, V& next_value) const
     {
-      return load_all_ (next_key, next_value, data_);
+      return select_ (next_key, next_value, data_);
     }
 
     void
-    delete_all () const
+    delete_ () const
     {
-      delete_all_ (data_);
+      delete__ (data_);
     }
 
     // Implementation details.
     //
   public:
-    typedef void (*insert_one_type) (const K&, const V&, void*);
-    typedef bool (*load_all_type) (K&, V&, void*);
-    typedef void (*delete_all_type) (void*);
-
-    map_functions (void* data,
-                   insert_one_type io,
-                   load_all_type la,
-                   delete_all_type da)
-        : data_ (data), insert_one_ (io), load_all_ (la), delete_all_ (da)
-    {
-    }
+    map_functions (void* data): data_ (data) {}
 
-  private:
+  public:
     void* data_;
-    insert_one_type insert_one_;
-    load_all_type load_all_;
-    delete_all_type delete_all_;
+
+    void (*insert_) (const K&, const V&, void*);
+    bool (*select_) (K&, V&, void*);
+    void (*delete__) (void*);
   };
 }
 
diff --git a/odb/details/config-vc.h b/odb/details/config-vc.h
index 2c2990a..6c7ed6d 100644
--- a/odb/details/config-vc.h
+++ b/odb/details/config-vc.h
@@ -19,6 +19,8 @@
 //#  define ODB_CXX11_DELETED_FUNCTION
 //#  define ODB_CXX11_EXPLICIT_CONVERSION_OPERATOR
 //#  define ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT
+//#  define ODB_CXX11_VARIADIC_TEMPLATES
+//#  define ODB_CXX11_INITIALIZER_LIST
 #endif
 
 #endif /* ODB_DETAILS_CONFIG_VC_H */
diff --git a/odb/details/config.hxx b/odb/details/config.hxx
index 36a8e3a..ddba5b7 100644
--- a/odb/details/config.hxx
+++ b/odb/details/config.hxx
@@ -20,6 +20,8 @@
 #    define ODB_CXX11_DELETED_FUNCTION
 #    define ODB_CXX11_EXPLICIT_CONVERSION_OPERATOR
 #    define ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT
+#    define ODB_CXX11_VARIADIC_TEMPLATE
+#    define ODB_CXX11_INITIALIZER_LIST
 #  endif
 #else
 #  include <odb/details/config.h>
@@ -35,6 +37,8 @@
 #    define ODB_CXX11_DELETED_FUNCTION
 #    define ODB_CXX11_EXPLICIT_CONVERSION_OPERATOR
 #    define ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT
+#    define ODB_CXX11_VARIADIC_TEMPLATE
+#    define ODB_CXX11_INITIALIZER_LIST
 #  endif
 #endif
 
diff --git a/odb/makefile b/odb/makefile
index c630e7c..ac7355a 100644
--- a/odb/makefile
+++ b/odb/makefile
@@ -8,6 +8,7 @@ cxx :=             \
 callback.cxx       \
 exceptions.cxx     \
 database.cxx       \
+vector-impl.cxx    \
 connection.cxx     \
 lazy-ptr-impl.cxx  \
 prepared-query.cxx \
diff --git a/odb/std-array-traits.hxx b/odb/std-array-traits.hxx
index a6cb5e3..438665a 100644
--- a/odb/std-array-traits.hxx
+++ b/odb/std-array-traits.hxx
@@ -19,7 +19,8 @@ namespace odb
   class access::container_traits<std::array<V, N>>
   {
   public:
-    static container_kind const kind = ck_ordered;
+    static const container_kind kind = ck_ordered;
+    static const bool smart = false;
 
     typedef std::array<V, N> container_type;
 
@@ -33,7 +34,7 @@ namespace odb
     persist (const container_type& c, const functions& f)
     {
       for (index_type i (0); i < N; ++i)
-        f.insert_one (i, c[i]);
+        f.insert (i, c[i]);
     }
 
     static void
@@ -44,7 +45,7 @@ namespace odb
       for (; more && i < N; ++i)
       {
         index_type dummy;
-        more = f.load_all (dummy, c[i]);
+        more = f.select (dummy, c[i]);
       }
 
       assert (!more && i == N);
@@ -53,16 +54,16 @@ namespace odb
     static void
     update (const container_type& c, const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
 
       for (index_type i (0); i < N; ++i)
-        f.insert_one (i, c[i]);
+        f.insert (i, c[i]);
     }
 
     static void
     erase (const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
     }
   };
 }
diff --git a/odb/std-forward-list-traits.hxx b/odb/std-forward-list-traits.hxx
index a86524b..1e88abc 100644
--- a/odb/std-forward-list-traits.hxx
+++ b/odb/std-forward-list-traits.hxx
@@ -17,7 +17,8 @@ namespace odb
   class access::container_traits<std::forward_list<V, A>>
   {
   public:
-    static container_kind const kind = ck_ordered;
+    static const container_kind kind = ck_ordered;
+    static const bool smart = false;
 
     typedef std::forward_list<V, A> container_type;
 
@@ -33,7 +34,7 @@ namespace odb
       index_type i (0);
       for (typename container_type::const_iterator j (c.begin ()),
              e (c.end ()); j != e; ++j)
-        f.insert_one (i++, *j);
+        f.insert (i++, *j);
     }
 
     static void
@@ -45,25 +46,25 @@ namespace odb
       {
         index_type dummy;
         i = c.insert_after (i, value_type ());
-        more = f.load_all (dummy, *i);
+        more = f.select (dummy, *i);
       }
     }
 
     static void
     update (const container_type& c, const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
 
       index_type i (0);
       for (typename container_type::const_iterator j (c.begin ()),
              e (c.end ()); j != e; ++j)
-        f.insert_one (i++, *j);
+        f.insert (i++, *j);
     }
 
     static void
     erase (const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
     }
   };
 }
diff --git a/odb/std-list-traits.hxx b/odb/std-list-traits.hxx
index 9289c67..ec570e2 100644
--- a/odb/std-list-traits.hxx
+++ b/odb/std-list-traits.hxx
@@ -17,7 +17,8 @@ namespace odb
   class access::container_traits<std::list<V, A> >
   {
   public:
-    static container_kind const kind = ck_ordered;
+    static const container_kind kind = ck_ordered;
+    static const bool smart = false;
 
     typedef std::list<V, A> container_type;
 
@@ -33,7 +34,7 @@ namespace odb
       index_type i (0);
       for (typename container_type::const_iterator j (c.begin ()),
              e (c.end ()); j != e; ++j)
-        f.insert_one (i++, *j);
+        f.insert (i++, *j);
     }
 
     static void
@@ -45,25 +46,25 @@ namespace odb
       {
         index_type dummy;
         c.push_back (value_type ());
-        more = f.load_all (dummy, c.back ());
+        more = f.select (dummy, c.back ());
       }
     }
 
     static void
     update (const container_type& c, const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
 
       index_type i (0);
       for (typename container_type::const_iterator j (c.begin ()),
              e (c.end ()); j != e; ++j)
-        f.insert_one (i++, *j);
+        f.insert (i++, *j);
     }
 
     static void
     erase (const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
     }
   };
 }
diff --git a/odb/std-map-traits.hxx b/odb/std-map-traits.hxx
index a30b13e..7347172 100644
--- a/odb/std-map-traits.hxx
+++ b/odb/std-map-traits.hxx
@@ -19,7 +19,8 @@ namespace odb
   class access::container_traits<std::map<K, V, C, A> >
   {
   public:
-    static container_kind const kind = ck_map;
+    static const container_kind kind = ck_map;
+    static const bool smart = false;
 
     typedef std::map<K, V, C, A> container_type;
 
@@ -35,7 +36,7 @@ namespace odb
     {
       for (typename container_type::const_iterator i (c.begin ()),
              e (c.end ()); i != e; ++i)
-        f.insert_one (i->first, i->second);
+        f.insert (i->first, i->second);
     }
 
     static void
@@ -47,7 +48,7 @@ namespace odb
       {
         key_type k;
         value_type v;
-        more = f.load_all (k, v);
+        more = f.select (k, v);
 #ifdef ODB_CXX11
         c.insert (pair_type (std::move (k), std::move (v)));
 #else
@@ -59,17 +60,17 @@ namespace odb
     static void
     update (const container_type& c, const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
 
       for (typename container_type::const_iterator i (c.begin ()),
              e (c.end ()); i != e; ++i)
-        f.insert_one (i->first, i->second);
+        f.insert (i->first, i->second);
     }
 
     static void
     erase (const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
     }
   };
 
@@ -81,7 +82,8 @@ namespace odb
   class access::container_traits<std::multimap<K, V, C, A> >
   {
   public:
-    static container_kind const kind = ck_multimap;
+    static const container_kind kind = ck_multimap;
+    static const bool smart = false;
 
     typedef std::multimap<K, V, C, A> container_type;
 
@@ -97,7 +99,7 @@ namespace odb
     {
       for (typename container_type::const_iterator i (c.begin ()),
              e (c.end ()); i != e; ++i)
-        f.insert_one (i->first, i->second);
+        f.insert (i->first, i->second);
     }
 
     static void
@@ -109,7 +111,7 @@ namespace odb
       {
         key_type k;
         value_type v;
-        more = f.load_all (k, v);
+        more = f.select (k, v);
 #ifdef ODB_CXX11
         c.insert (pair_type (std::move (k), std::move (v)));
 #else
@@ -121,17 +123,17 @@ namespace odb
     static void
     update (const container_type& c, const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
 
       for (typename container_type::const_iterator i (c.begin ()),
              e (c.end ()); i != e; ++i)
-        f.insert_one (i->first, i->second);
+        f.insert (i->first, i->second);
     }
 
     static void
     erase (const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
     }
   };
 }
diff --git a/odb/std-set-traits.hxx b/odb/std-set-traits.hxx
index e6b4853..6df5c61 100644
--- a/odb/std-set-traits.hxx
+++ b/odb/std-set-traits.hxx
@@ -19,7 +19,8 @@ namespace odb
   class access::container_traits<std::set<V, C, A> >
   {
   public:
-    static container_kind const kind = ck_set;
+    static const container_kind kind = ck_set;
+    static const bool smart = false;
 
     typedef std::set<V, C, A> container_type;
     typedef V value_type;
@@ -32,7 +33,7 @@ namespace odb
     {
       for (typename container_type::const_iterator i (c.begin ()),
              e (c.end ()); i != e; ++i)
-        f.insert_one (*i);
+        f.insert (*i);
     }
 
     static void
@@ -43,7 +44,7 @@ namespace odb
       while (more)
       {
         value_type v;
-        more = f.load_all (v);
+        more = f.select (v);
 #ifdef ODB_CXX11
         c.insert (std::move (v));
 #else
@@ -55,17 +56,17 @@ namespace odb
     static void
     update (const container_type& c, const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
 
       for (typename container_type::const_iterator i (c.begin ()),
              e (c.end ()); i != e; ++i)
-        f.insert_one (*i);
+        f.insert (*i);
     }
 
     static void
     erase (const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
     }
   };
 
@@ -77,7 +78,8 @@ namespace odb
   class access::container_traits<std::multiset<V, C, A> >
   {
   public:
-    static container_kind const kind = ck_multiset;
+    static const container_kind kind = ck_multiset;
+    static const bool smart = false;
 
     typedef std::multiset<V, C, A> container_type;
     typedef V value_type;
@@ -90,7 +92,7 @@ namespace odb
     {
       for (typename container_type::const_iterator i (c.begin ()),
              e (c.end ()); i != e; ++i)
-        f.insert_one (*i);
+        f.insert (*i);
     }
 
     static void
@@ -101,7 +103,7 @@ namespace odb
       while (more)
       {
         value_type v;
-        more = f.load_all (v);
+        more = f.select (v);
 #ifdef ODB_CXX11
         c.insert (std::move (v));
 #else
@@ -113,17 +115,17 @@ namespace odb
     static void
     update (const container_type& c, const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
 
       for (typename container_type::const_iterator i (c.begin ()),
              e (c.end ()); i != e; ++i)
-        f.insert_one (*i);
+        f.insert (*i);
     }
 
     static void
     erase (const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
     }
   };
 }
diff --git a/odb/std-unordered-map-traits.hxx b/odb/std-unordered-map-traits.hxx
index 072d345..6045d4c 100644
--- a/odb/std-unordered-map-traits.hxx
+++ b/odb/std-unordered-map-traits.hxx
@@ -18,7 +18,8 @@ namespace odb
   class access::container_traits<std::unordered_map<K, V, H, P, A>>
   {
   public:
-    static container_kind const kind = ck_map;
+    static const container_kind kind = ck_map;
+    static const bool smart = false;
 
     typedef std::unordered_map<K, V, H, P, A> container_type;
 
@@ -34,7 +35,7 @@ namespace odb
     {
       for (typename container_type::const_iterator i (c.begin ()),
              e (c.end ()); i != e; ++i)
-        f.insert_one (i->first, i->second);
+        f.insert (i->first, i->second);
     }
 
     static void
@@ -46,7 +47,7 @@ namespace odb
       {
         key_type k;
         value_type v;
-        more = f.load_all (k, v);
+        more = f.select (k, v);
         c.insert (pair_type (std::move (k), std::move (v)));
       }
     }
@@ -54,17 +55,17 @@ namespace odb
     static void
     update (const container_type& c, const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
 
       for (typename container_type::const_iterator i (c.begin ()),
              e (c.end ()); i != e; ++i)
-        f.insert_one (i->first, i->second);
+        f.insert (i->first, i->second);
     }
 
     static void
     erase (const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
     }
   };
 
@@ -76,7 +77,8 @@ namespace odb
   class access::container_traits<std::unordered_multimap<K, V, H, P, A>>
   {
   public:
-    static container_kind const kind = ck_multimap;
+    static const container_kind kind = ck_multimap;
+    static const bool smart = false;
 
     typedef std::unordered_multimap<K, V, H, P, A> container_type;
 
@@ -92,7 +94,7 @@ namespace odb
     {
       for (typename container_type::const_iterator i (c.begin ()),
              e (c.end ()); i != e; ++i)
-        f.insert_one (i->first, i->second);
+        f.insert (i->first, i->second);
     }
 
     static void
@@ -104,7 +106,7 @@ namespace odb
       {
         key_type k;
         value_type v;
-        more = f.load_all (k, v);
+        more = f.select (k, v);
         c.insert (pair_type (std::move (k), std::move (v)));
       }
     }
@@ -112,17 +114,17 @@ namespace odb
     static void
     update (const container_type& c, const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
 
       for (typename container_type::const_iterator i (c.begin ()),
              e (c.end ()); i != e; ++i)
-        f.insert_one (i->first, i->second);
+        f.insert (i->first, i->second);
     }
 
     static void
     erase (const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
     }
   };
 }
diff --git a/odb/std-unordered-set-traits.hxx b/odb/std-unordered-set-traits.hxx
index 6f8e6a8..3033519 100644
--- a/odb/std-unordered-set-traits.hxx
+++ b/odb/std-unordered-set-traits.hxx
@@ -18,7 +18,8 @@ namespace odb
   class access::container_traits<std::unordered_set<V, H, P, A>>
   {
   public:
-    static container_kind const kind = ck_set;
+    static const container_kind kind = ck_set;
+    static const bool smart = false;
 
     typedef std::unordered_set<V, H, P, A> container_type;
     typedef V value_type;
@@ -31,7 +32,7 @@ namespace odb
     {
       for (typename container_type::const_iterator i (c.begin ()),
              e (c.end ()); i != e; ++i)
-        f.insert_one (*i);
+        f.insert (*i);
     }
 
     static void
@@ -42,7 +43,7 @@ namespace odb
       while (more)
       {
         value_type v;
-        more = f.load_all (v);
+        more = f.select (v);
         c.insert (std::move (v));
       }
     }
@@ -50,17 +51,17 @@ namespace odb
     static void
     update (const container_type& c, const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
 
       for (typename container_type::const_iterator i (c.begin ()),
              e (c.end ()); i != e; ++i)
-        f.insert_one (*i);
+        f.insert (*i);
     }
 
     static void
     erase (const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
     }
   };
 
@@ -72,7 +73,8 @@ namespace odb
   class access::container_traits<std::unordered_multiset<V, H, P, A>>
   {
   public:
-    static container_kind const kind = ck_multiset;
+    static const container_kind kind = ck_multiset;
+    static const bool smart = false;
 
     typedef std::unordered_multiset<V, H, P, A> container_type;
     typedef V value_type;
@@ -85,7 +87,7 @@ namespace odb
     {
       for (typename container_type::const_iterator i (c.begin ()),
              e (c.end ()); i != e; ++i)
-        f.insert_one (*i);
+        f.insert (*i);
     }
 
     static void
@@ -96,7 +98,7 @@ namespace odb
       while (more)
       {
         value_type v;
-        more = f.load_all (v);
+        more = f.select (v);
         c.insert (std::move (v));
       }
     }
@@ -104,17 +106,17 @@ namespace odb
     static void
     update (const container_type& c, const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
 
       for (typename container_type::const_iterator i (c.begin ()),
              e (c.end ()); i != e; ++i)
-        f.insert_one (*i);
+        f.insert (*i);
     }
 
     static void
     erase (const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
     }
   };
 }
diff --git a/odb/std-vector-traits.hxx b/odb/std-vector-traits.hxx
index b0a2992..381db36 100644
--- a/odb/std-vector-traits.hxx
+++ b/odb/std-vector-traits.hxx
@@ -17,7 +17,8 @@ namespace odb
   class access::container_traits<std::vector<V, A> >
   {
   public:
-    static container_kind const kind = ck_ordered;
+    static const container_kind kind = ck_ordered;
+    static const bool smart = false;
 
     typedef std::vector<V, A> container_type;
 
@@ -31,7 +32,7 @@ namespace odb
     persist (const container_type& c, const functions& f)
     {
       for (index_type i (0), n (c.size ()); i < n; ++i)
-        f.insert_one (i, c[i]);
+        f.insert (i, c[i]);
     }
 
     static void
@@ -43,23 +44,23 @@ namespace odb
       {
         index_type dummy;
         c.push_back (value_type ());
-        more = f.load_all (dummy, c.back ());
+        more = f.select (dummy, c.back ());
       }
     }
 
     static void
     update (const container_type& c, const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
 
       for (index_type i (0), n (c.size ()); i < n; ++i)
-        f.insert_one (i, c[i]);
+        f.insert (i, c[i]);
     }
 
     static void
     erase (const functions& f)
     {
-      f.delete_all ();
+      f.delete_ ();
     }
   };
 }
diff --git a/odb/vector-impl.cxx b/odb/vector-impl.cxx
new file mode 100644
index 0000000..9fd38f3
--- /dev/null
+++ b/odb/vector-impl.cxx
@@ -0,0 +1,229 @@
+// file      : odb/vector-impl.cxx
+// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+#include <odb/vector-impl.hxx>
+
+#include <cstring> // std::memcpy, std::memset
+
+#ifdef ODB_CXX11
+#  include <utility> // std::swap, std::move
+#else
+#  include <algorithm> // std::swap
+#endif
+
+#include <iostream> // @@ tmp
+
+using namespace std;
+
+namespace odb
+{
+  // vector_impl
+  //
+  const unsigned char vector_impl::mask_[4] = {0x3, 0xC, 0x30, 0xC0};
+  const unsigned char vector_impl::shift_[4] = {0, 2, 4, 6};
+
+  vector_impl::
+  vector_impl (const vector_impl& x)
+      : state_ (x.state_), size_ (0), tail_ (0), capacity_ (0), data_ (0)
+  {
+    // Copy the data over if we are tracking.
+    //
+    if (state_ == state_tracking && size_ != 0)
+    {
+      realloc (x.size_ < 1024 ? 1024 : x.size_);
+      memcpy (data_, x.data_, x.size_ / 4 + (x.size_ % 4 == 0 ? 0 : 1));
+      size_ = x.size_;
+      tail_ = x.tail_;
+    }
+  }
+
+  void vector_impl::
+  realloc (size_t n)
+  {
+    // The new capacity can be less or greater than the old one, but
+    // it cannot be less than size.
+    //
+    size_t b (n / 4 + (n % 4 == 0 ? 0 : 1));
+
+    if (b != capacity_ * 4)
+    {
+      unsigned char* d (static_cast<unsigned char*> (operator new (b)));
+
+      if (size_ != 0)
+        memcpy (d, data_, size_ / 4 + (size_ % 4 == 0 ? 0 : 1));
+
+      if (data_ != 0)
+        operator delete (data_);
+
+      data_ = d;
+      capacity_ = b * 4;
+    }
+  }
+
+  void vector_impl::
+  shrink_to_fit ()
+  {
+    if (size_ != capacity_)
+    {
+      if (size_ != 0)
+        realloc (size_);
+      else
+      {
+        operator delete (data_);
+        data_ = 0;
+        capacity_ = 0;
+      }
+    }
+  }
+
+  void vector_impl::
+  start (size_t n)
+  {
+    if (n != 0)
+    {
+      if (capacity_ < n)
+      {
+        size_ = 0;
+        realloc (n < 1024 ? 1024 : n);
+      }
+
+      memset (data_, 0, n / 4 + (n % 4 == 0 ? 0 : 1));
+    }
+
+    state_ = state_tracking;
+    size_ = tail_ = n;
+  }
+
+  void vector_impl::
+  push_back (size_t n)
+  {
+    for (; n != 0; --n)
+    {
+      size_t i (tail_);
+
+      element_state_type s;
+      if (i != size_)
+        // We have an erased element we can reuse.
+        //
+        s = state_updated;
+      else
+      {
+        if (size_ == capacity_)
+        {
+          size_t c (capacity_ == 0 ? 1024 : capacity_ * 2);
+          if (c < size_ + n)
+            c = size_ + n;
+          realloc (c);
+        }
+
+        s = state_inserted;
+        size_++;
+      }
+
+      set (i, s);
+      tail_++;
+    }
+  }
+
+  void vector_impl::
+  pop_back (size_t n)
+  {
+    for (; n != 0; --n)
+    {
+      size_t i (tail_ - 1);
+
+      if (state (i) != state_inserted)
+        set (i, state_erased);
+      else
+        size_--; // tail_ == size_
+
+      tail_--;
+    }
+  }
+
+  void vector_impl::
+  insert (size_t i, size_t n)
+  {
+    for (; i != tail_; ++i)
+      if (state (i) != state_inserted)
+        set (i, state_updated);
+
+    push_back (n);
+  }
+
+  void vector_impl::
+  erase (size_t i, size_t n)
+  {
+    pop_back (n);
+
+    for (; i != tail_; ++i)
+      if (state (i) != state_inserted)
+        set (i, state_updated);
+  }
+
+  void vector_impl::
+  clear ()
+  {
+    // The idea is to drop any inserted elements from the back and
+    // set everything else to erased.
+    //
+    if (tail_ == size_)
+    {
+      while (size_ != 0 && state (size_ - 1) == state_inserted)
+        size_--;
+
+      tail_ = size_;
+    }
+
+    if (tail_ != 0)
+      memset (data_, 0xFF, tail_ / 4 + (tail_ % 4 == 0 ? 0 : 1));
+
+    tail_ = 0;
+  }
+
+  // vector_base
+  //
+#ifdef ODB_CXX11
+  vector_base::
+  vector_base (vector_base&& x)
+      : impl_ (std::move (x.impl_)), tran_ (0)
+  {
+    if (x.tran_ != 0)
+    {
+      x.tran_->unregister (&x);
+      _arm (*x.tran_);
+    }
+  }
+#endif
+
+  void vector_base::
+  rollback (unsigned short, void* key, unsigned long long)
+  {
+    // Mark as changed.
+    //
+    static_cast<vector_base*> (key)->impl_.change ();
+  }
+
+  void vector_base::
+  swap_tran (vector_base& x)
+  {
+    // If either instance is armed, then we need to update the
+    // callback registration.
+    //
+    transaction* t (x.tran_);
+    if (tran_ != 0)
+    {
+      tran_->unregister (this);
+      x._arm (*tran_);
+    }
+
+    if (t != 0)
+    {
+      t->unregister (&x);
+      _arm (*t);
+    }
+
+    std::swap (tran_, x.tran_);
+  }
+}
diff --git a/odb/vector-impl.hxx b/odb/vector-impl.hxx
new file mode 100644
index 0000000..a6be505
--- /dev/null
+++ b/odb/vector-impl.hxx
@@ -0,0 +1,222 @@
+// file      : odb/vector-impl.hxx
+// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_VECTOR_IMPL_HXX
+#define ODB_VECTOR_IMPL_HXX
+
+#include <odb/pre.hxx>
+#include <odb/details/config.hxx> // ODB_CXX11
+
+#include <new>
+#include <cstddef> // std::size_t
+
+#include <odb/transaction.hxx>
+#include <odb/details/export.hxx>
+
+namespace odb
+{
+  // Change tracking vector implementation details.
+  //
+  class LIBODB_EXPORT vector_impl
+  {
+  public:
+    enum element_state_type
+    {
+      state_unchanged,
+      state_inserted,
+      state_updated,
+      state_erased
+    };
+
+    enum container_state_type
+    {
+      state_tracking,
+      state_not_tracking,
+      state_changed       // Container has changed but individual changes
+                          // were not tracked.
+    };
+
+    vector_impl ();
+    ~vector_impl ();
+
+    // The copy constructor will copy the state. The idea is that the
+    // copy keeps tracking changes, just like the original.
+    //
+    vector_impl (const vector_impl&);
+
+#ifdef ODB_CXX11
+    vector_impl (vector_impl&&);
+#endif
+
+    void
+    swap (vector_impl& x);
+
+    // Allocate enough memory to store the specified number of
+    // elements.
+    //
+    void
+    reserve (std::size_t);
+
+    // Reduce capacity to size.
+    //
+    void
+    shrink_to_fit ();
+
+    // Capacity (each entry takes 2 bits).
+    //
+    std::size_t
+    capacity () const;
+
+    // (Re)start tracking changes for a vector with n elements.
+    //
+    void
+    start (std::size_t);
+
+    // Stop tracking changes.
+    //
+    void
+    stop ();
+
+    // Mark the container as changed without tracking the changes.
+    // This state is useful as a fallback mechnism for situations
+    // where the change information has been discarded (e.g., after
+    // its state has been updated in the database) but the container
+    // should remain changed (e.g., after the transaction is rolled
+    // back).
+    //
+    void
+    change ();
+
+    // Get the state of the container.
+    //
+    container_state_type
+    state () const;
+
+    // Shortcut for state() == state_tracking.
+    //
+    bool
+    tracking () const;
+
+    // Note that the returned size can be greater than the actual,
+    // parallel vector size. In this case the difference is the
+    // erased elements at the back.
+    //
+    std::size_t
+    size () const;
+
+    // Get the change state of the specified element.
+    //
+    element_state_type
+    state (std::size_t) const;
+
+    // Change notifications.
+    //
+    void
+    push_back (std::size_t n = 1);
+
+    void
+    pop_back (std::size_t n = 1);
+
+    void
+    insert (std::size_t, std::size_t n = 1);
+
+    void
+    erase (std::size_t, std::size_t n = 1);
+
+    void
+    modify (std::size_t, std::size_t n = 1);
+
+    void
+    clear ();
+
+    void
+    assign (std::size_t n);
+
+    void
+    resize (std::size_t n);
+
+  private:
+    // Assignment does not make sense (it is changing of the content).
+    //
+    vector_impl& operator= (const vector_impl&);
+
+  private:
+    void
+    realloc (std::size_t);
+
+    void
+    set (std::size_t, element_state_type);
+
+    static const unsigned char mask_[4];
+    static const unsigned char shift_[4];
+
+    container_state_type state_;
+
+    // Size, tail, and capacity are in 2-bit blocks. Size is the number
+    // of elements we have in data. Tail is the position of the first
+    // erased element at the back. If there are no erased elements, then
+    // tail is equal size. Capacity is the number of elements we can
+    // store in data.
+    //
+    std::size_t size_;
+    std::size_t tail_;
+    std::size_t capacity_;
+    unsigned char* data_;
+  };
+
+  // Base class that provides a change tracking interface and
+  // handles the rollback callback. The only function that's
+  // missing is _start() which needs to know the number of
+  // elements currently in the vector.
+  //
+  class LIBODB_EXPORT vector_base
+  {
+  public:
+    void
+    _stop () const {impl_.stop ();}
+
+    bool
+    _tracking () const {return impl_.tracking ();}
+
+    void
+    _arm (transaction& t) const;
+
+    vector_impl&
+    _impl () const {return impl_;}
+
+  private:
+    // Assignment is changing of the content.
+    //
+    vector_base& operator= (const vector_base&);
+
+  protected:
+    vector_base (): tran_ (0) {}
+    ~vector_base () {if (tran_ != 0) tran_->unregister (this);}
+    vector_base (const vector_base&);
+
+#ifdef ODB_CXX11
+    vector_base (vector_base&&);
+#endif
+
+    void
+    swap (vector_base&);
+
+    static void
+    rollback (unsigned short, void* key, unsigned long long);
+
+  private:
+    void
+    swap_tran (vector_base&);
+
+  protected:
+    mutable vector_impl impl_;
+    mutable transaction* tran_;
+  };
+}
+
+#include <odb/vector-impl.ixx>
+
+#include <odb/post.hxx>
+
+#endif // ODB_VECTOR_IMPL_HXX
diff --git a/odb/vector-impl.ixx b/odb/vector-impl.ixx
new file mode 100644
index 0000000..5a859c4
--- /dev/null
+++ b/odb/vector-impl.ixx
@@ -0,0 +1,169 @@
+// file      : odb/vector-impl.ixx
+// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+#ifdef ODB_CXX11
+#  include <utility> // std::swap
+#else
+#  include <algorithm> // std::swap
+#endif
+
+namespace odb
+{
+  // vector_impl
+  //
+  inline vector_impl::
+  vector_impl ()
+      : state_ (state_not_tracking),
+        size_ (0), tail_ (0), capacity_ (0), data_ (0)
+  {
+  }
+
+#ifdef ODB_CXX11
+  inline vector_impl::
+  vector_impl (vector_impl&& x)
+      : state_ (state_not_tracking),
+        size_ (0), tail_ (0), capacity_ (0), data_ (0)
+  {
+    swap (x);
+  }
+#endif
+
+  inline vector_impl::
+  ~vector_impl ()
+  {
+    if (data_ != 0)
+      operator delete (data_);
+  }
+
+  inline void vector_impl::
+  swap (vector_impl& x)
+  {
+    std::swap (state_, x.state_);
+    std::swap (size_, x.size_);
+    std::swap (tail_, x.tail_);
+    std::swap (capacity_, x.capacity_);
+    std::swap (data_, x.data_);
+  }
+
+  inline void vector_impl::
+  reserve (std::size_t n)
+  {
+    if (n > capacity_)
+      realloc (n);
+  }
+
+  inline void vector_impl::
+  stop ()
+  {
+    state_ = state_not_tracking;
+    size_ = tail_ = 0;
+  }
+
+  inline void vector_impl::
+  change ()
+  {
+    state_ = state_changed;
+    size_ = tail_ = 0;
+  }
+
+  inline vector_impl::container_state_type vector_impl::
+  state () const
+  {
+    return state_;
+  }
+
+  inline bool vector_impl::
+  tracking () const
+  {
+    return state_ == state_tracking;
+  }
+
+  inline std::size_t vector_impl::
+  size () const
+  {
+    return size_;
+  }
+
+  inline std::size_t vector_impl::
+  capacity () const
+  {
+    return capacity_;
+  }
+
+  inline vector_impl::element_state_type vector_impl::
+  state (std::size_t i) const
+  {
+    std::size_t r (i % 4);
+    unsigned char v (data_[i / 4]);
+    return static_cast<element_state_type> ((v & mask_[r]) >> shift_[r]);
+  }
+
+  inline void vector_impl::
+  modify (std::size_t i, std::size_t n)
+  {
+    for (; n != 0; --n, ++i)
+      if (state (i) != state_inserted)
+        set (i, state_updated);
+  }
+
+  inline void vector_impl::
+  assign (std::size_t n)
+  {
+    if (tail_ != 0)
+      clear ();
+
+    push_back (n);
+  }
+
+  inline void vector_impl::
+  resize (size_t n)
+  {
+    if (n < tail_)
+      pop_back (tail_ - n);
+    else if (n > tail_)
+      push_back (n - tail_);
+  }
+
+  inline void vector_impl::
+  set (std::size_t i, element_state_type s)
+  {
+    std::size_t r (i % 4);
+    i /= 4;
+    unsigned char v (static_cast<unsigned char> (s));
+    v <<= shift_[r];
+    data_[i] = (data_[i] & ~mask_[r]) | v;
+  }
+
+  // vector_base
+  //
+  inline void vector_base::
+  _arm (transaction& t) const
+  {
+    tran_ = &t;
+    t.register_ (&rollback,
+                 const_cast<vector_base*> (this),
+                 transaction::event_rollback,
+                 0,
+                 &tran_);
+  }
+
+  inline vector_base::
+  vector_base (const vector_base& x)
+      : impl_ (x.impl_), tran_ (0)
+  {
+    // If the original is armed, then arm ourselves as well.
+    //
+    if (x.tran_ != 0)
+      _arm (*x.tran_);
+  }
+
+  inline void vector_base::
+  swap (vector_base& x)
+  {
+    impl_.swap (x.impl_);
+
+    if (tran_ != 0 || x.tran_ != 0)
+      swap_tran (x);
+  }
+}
diff --git a/odb/vector-traits.hxx b/odb/vector-traits.hxx
new file mode 100644
index 0000000..874480b
--- /dev/null
+++ b/odb/vector-traits.hxx
@@ -0,0 +1,104 @@
+// file      : odb/vector-traits.hxx
+// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_VECTOR_TRAITS_HXX
+#define ODB_VECTOR_TRAITS_HXX
+
+#include <odb/pre.hxx>
+
+#include <odb/vector.hxx>
+#include <odb/vector-impl.hxx>
+#include <odb/container-traits.hxx>
+#include <odb/transaction.hxx>
+
+namespace odb
+{
+  template <typename V, typename A>
+  class access::container_traits<vector<V, A> >
+  {
+  public:
+    static const container_kind kind = ck_ordered;
+    static const bool smart = true;
+
+    typedef vector<V, A> container_type;
+
+    typedef V value_type;
+    typedef typename container_type::size_type index_type;
+
+    typedef smart_ordered_functions<index_type, value_type> functions;
+    typedef ordered_functions<index_type, value_type> dumb_functions;
+
+  public:
+    static void
+    persist (const container_type& c, const functions& f)
+    {
+      for (index_type i (0), n (c.size ()); i < n; ++i)
+        f.insert (i, c[i]);
+
+      // Now that this container is persistent, start tracking changes.
+      //
+      c._start ();
+    }
+
+    static void
+    load (container_type& c, bool more, const functions& f)
+    {
+      // Stop tracking changes.
+      //
+      c._stop ();
+
+      // Load.
+      //
+      c.clear ();
+      while (more)
+      {
+        index_type dummy;
+        c.push_back (value_type ());
+        more = f.select (dummy, c.modify_back ());
+      }
+
+      // Start tracking changes.
+      //
+      c._start ();
+    }
+
+    static void
+    update (const container_type&, const functions&);
+
+    static void
+    erase (const container_type* c, const functions& f)
+    {
+      f.delete_ (0);
+
+      // Stop tracking changes.
+      //
+      if (c != 0)
+        c->_stop ();
+    }
+
+    // Version of load() for dumb functions. Used to support
+    // inverse members of the container type. The implementation
+    // is identical to the smart one except we don't turn off/on
+    // change tracking.
+    //
+    static void
+    load (container_type& c, bool more, const dumb_functions& f)
+    {
+      c.clear ();
+
+      while (more)
+      {
+        index_type dummy;
+        c.push_back (value_type ());
+        more = f.select (dummy, c.modify_back ());
+      }
+    }
+  };
+}
+
+#include <odb/vector-traits.txx>
+
+#include <odb/post.hxx>
+
+#endif // ODB_VECTOR_TRAITS_HXX
diff --git a/odb/vector-traits.txx b/odb/vector-traits.txx
new file mode 100644
index 0000000..255b074
--- /dev/null
+++ b/odb/vector-traits.txx
@@ -0,0 +1,73 @@
+// file      : odb/vector-traits.txx
+// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+namespace odb
+{
+  template <typename V, typename A>
+  void access::container_traits<vector<V, A> >::
+  update (const container_type& c, const functions& f)
+  {
+    bool u (false); // Updated flag.
+
+    if (c._tracking ())
+    {
+      const vector_impl& impl (c._impl ());
+
+      for (std::size_t i (0), n (impl.size ()); i < n; ++i)
+      {
+        vector_impl::element_state_type s (impl.state (i));
+
+        switch (s)
+        {
+        case vector_impl::state_unchanged:
+          {
+            break;
+          }
+        case vector_impl::state_inserted:
+          {
+            f.insert (i, c[static_cast<index_type> (i)]);
+            u = u || true;
+            break;
+          }
+        case vector_impl::state_updated:
+          {
+            f.update (i, c[static_cast<index_type> (i)]);
+            u = u || true;
+            break;
+          }
+        case vector_impl::state_erased:
+          {
+            f.delete_ (i); // Delete from i onwards.
+            u = u || true;
+            break;
+          }
+        }
+
+        // We delete all trailing elements in one go.
+        //
+        if (s == vector_impl::state_erased)
+          break;
+      }
+    }
+    else
+    {
+      // Fall back to delete all/insert all.
+      //
+      f.delete_ (0);
+
+      for (index_type i (0), n (c.size ()); i < n; ++i)
+        f.insert (i, c[i]);
+
+      u = true;
+    }
+
+    // Arm the rollback callback and (re)start change tracking.
+    //
+    if (u)
+    {
+      c._arm (transaction::current ());
+      c._start ();
+    }
+  }
+}
diff --git a/odb/vector.hxx b/odb/vector.hxx
new file mode 100644
index 0000000..17f8653
--- /dev/null
+++ b/odb/vector.hxx
@@ -0,0 +1,546 @@
+// file      : odb/vector.hxx
+// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_VECTOR_HXX
+#define ODB_VECTOR_HXX
+
+#include <odb/pre.hxx>
+#include <odb/details/config.hxx> // ODB_CXX11
+
+#include <vector>
+#include <iterator>
+
+#ifdef ODB_CXX11
+#  include <utility>          // std::move, std::forward
+#  ifdef ODB_CXX11_INITIALIZER_LIST
+#    include <initializer_list>
+#  endif
+#endif
+
+#include <odb/vector-impl.hxx>
+
+namespace odb
+{
+  // An std::vector-like container that keeps track of changes.
+  //
+  // Note that the style and order of definitions is as appears
+  // in the standard.
+  //
+  template <class V, class I>
+  class vector_iterator;
+
+  template <class T, class A = std::allocator<T> >
+  class vector: public vector_base
+  {
+  public:
+    typedef std::vector<T, A>                   base_vector_type;
+    typedef typename base_vector_type::iterator base_iterator_type;
+    typedef typename base_vector_type::reverse_iterator
+                                                base_reverse_iterator_type;
+    // types:
+    //
+    typedef typename base_vector_type::reference        reference;
+    typedef typename base_vector_type::const_reference  const_reference;
+    typedef vector_iterator<vector, base_iterator_type> iterator;
+    typedef typename base_vector_type::const_iterator   const_iterator;
+    typedef typename base_vector_type::size_type        size_type;
+    typedef typename base_vector_type::difference_type  difference_type;
+    typedef T                                           value_type;
+    typedef A                                           allocator_type;
+    typedef typename base_vector_type::pointer          pointer;
+    typedef typename base_vector_type::const_pointer    const_pointer;
+    typedef vector_iterator<vector, base_reverse_iterator_type>
+                                                        reverse_iterator;
+    typedef typename base_vector_type::const_reverse_iterator
+                                                        const_reverse_iterator;
+    // construct/copy/destroy:
+    //
+    explicit vector(const A& a = A()): v_ (a) {}
+    explicit vector(size_type n): v_ (n) {} // C++11
+    vector(size_type n, const T& v, const A& a = A()): v_ (n, v, a) {}
+    template <class I>
+    vector(I f, I l, const A& a = A()) : v_ (f, l, a) {}
+    vector(const vector& x): vector_base (x), v_ (x.v_) {}
+    // ~vector() {}
+    vector& operator=(const vector&);
+    template <class I>
+    void assign(I f, I l);
+    void assign(size_type n, const T& u);
+    allocator_type get_allocator() const /*noexcept*/
+    {return v_.get_allocator ();}
+
+#ifdef ODB_CXX11
+    vector(vector&& x): vector_base (std::move (x)), v_ (std::move (x.v_)) {}
+    vector(const vector& x, const A& a): vector_base (x), v_ (x.v_, a) {}
+    vector(vector&& x, const A& a)
+        : vector_base (std::move (x)), v_ (std::move (x.v_), a) {}
+    vector& operator=(vector&&);
+#ifdef ODB_CXX11_INITIALIZER_LIST
+    vector(std::initializer_list<T> il, const A& a = A()): v_ (il, a) {}
+    vector& operator=(std::initializer_list<T>);
+    void assign(std::initializer_list<T>);
+#endif
+#endif
+
+    // iterators: (all /*noexcept*/)
+    //
+    iterator               begin() {return iterator (this, v_.begin ());}
+    const_iterator         begin() const {return v_.begin ();}
+    iterator               end() {return iterator (this, v_.end ());}
+    const_iterator         end() const {return v_.end ();}
+    reverse_iterator       rbegin() {return reverse_iterator (this, v_.rbegin ());}
+    const_reverse_iterator rbegin() const {return v_.rbegin ();}
+    reverse_iterator       rend() {return reverse_iterator (this, v_.rend ());}
+    const_reverse_iterator rend() const {return v_.rend ();}
+
+    // Return standard vector iterators. The begin() functions mark all
+    // the elements as modified.
+    //
+    base_iterator_type         mbegin ();
+    base_iterator_type         mend () {return v_.end ();}
+    base_reverse_iterator_type mrbegin ();
+    base_reverse_iterator_type mrend () {return v_.rend ();}
+
+#ifdef ODB_CXX11
+    const_iterator         cbegin() const {return v_.cbegin ();}
+    const_iterator         cend() const {return v_.cend ();}
+    const_reverse_iterator crbegin() const {return v_.crbegin ();}
+    const_reverse_iterator crend() const {return v_.crend ();}
+#endif
+
+    // capacity:
+    //
+    size_type size() const /*noexcept*/ {return v_.size ();}
+    size_type max_size() const /*noexcept*/ {return v_.max_size ();}
+    void      resize(size_type); // C++11
+    void      resize(size_type, const T&);
+    size_type capacity() const /*noexcept*/ {return v_.capacity ();}
+    bool      empty() const /*noexcept*/ {return v_.empty ();}
+    void      reserve(size_type);
+
+#ifdef ODB_CXX11
+    void shrink_to_fit();
+#endif
+
+    // element access:
+    //
+    //reference        operator[](size_type n);
+    reference          modify(size_type n);
+    const_reference    operator[](size_type n) const {return v_[n];}
+    //reference        at(size_type n);
+    reference          modify_at(size_type n);
+    const_reference    at(size_type n) const {return v_.at (n);}
+    //reference        front();
+    reference          modify_front();
+    const_reference    front() const {return v_.front ();}
+    //reference        back();
+    reference          modify_back();
+    const_reference    back() const {return v_.back ();}
+
+    // data access:
+    //
+#ifdef ODB_CXX11
+    //T*        data() noexcept;
+    T*        modify_data() /*noexcept*/;
+    const T*  data() const /*noexcept*/ {return v_.data ();}
+#endif
+
+    // modifiers:
+    //
+    void push_back(const T& x);
+    void pop_back();
+    iterator insert(iterator position, const T& x);
+    void     insert(iterator position, size_type n, const T& x);
+    template <class I>
+    void insert(iterator position, I first, I last);
+    iterator erase(iterator position);
+    iterator erase(iterator first, iterator last);
+    void     swap(vector&);
+    void     clear() /*noexcept*/;
+
+#ifdef ODB_CXX11
+    // In C++11 all modifiers use const_iterator instead of iterator
+    // to represent position. However, some standard libraries (notably
+    // GCC's) still use iterator and so we will do that as well, for now.
+    //
+    void push_back(T&& x);
+    iterator insert(iterator position, T&& x);
+
+#ifdef ODB_CXX11_VARIADIC_TEMPLATE
+    template <class... Args>
+    void emplace_back(Args&&... args);
+    template <class... Args>
+    iterator emplace(iterator position, Args&&... args);
+#endif
+#endif
+
+    // Interfacing with the base vector.
+    //
+    vector (const base_vector_type& x): v_ (x) {}
+    vector& operator= (const base_vector_type&);
+    operator const base_vector_type& () const {return v_;}
+    base_vector_type& base () {return v_;}
+    const base_vector_type& base () const {return v_;}
+
+#ifdef ODB_CXX11
+    vector (base_vector_type&& x): v_ (std::move (x)) {}
+    vector& operator= (base_vector_type&&);
+#endif
+
+    // Change tracking (the rest comes from vector_base).
+    //
+  public:
+    void
+    _start () const {impl_.start (v_.size ());}
+
+  private:
+    base_vector_type v_;
+  };
+
+  namespace core
+  {
+    using odb::vector;
+  }
+
+  template <class T, class A>
+  inline bool operator==(const vector<T,A>& x, const vector<T,A>& y)
+  {return x.base () == y.base ();}
+
+  template <class T, class A>
+  inline bool operator==(const vector<T,A>& x, const std::vector<T,A>& y)
+  {return x.base () == y;}
+
+  template <class T, class A>
+  inline bool operator==(const std::vector<T,A>& x, const vector<T,A>& y)
+  {return x == y.base ();}
+
+  template <class T, class A>
+  inline bool operator< (const vector<T,A>& x, const vector<T,A>& y)
+  {return x.base () < y.base ();}
+
+  template <class T, class A>
+  inline bool operator<(const vector<T,A>& x, const std::vector<T,A>& y)
+  {return x.base () < y;}
+
+  template <class T, class A>
+  inline bool operator<(const std::vector<T,A>& x, const vector<T,A>& y)
+  {return x < y.base ();}
+
+  template <class T, class A>
+  inline bool operator!=(const vector<T,A>& x, const vector<T,A>& y)
+  {return x.base () != y.base ();}
+
+  template <class T, class A>
+  inline bool operator!=(const vector<T,A>& x, const std::vector<T,A>& y)
+  {return x.base () != y;}
+
+  template <class T, class A>
+  inline bool operator!=(const std::vector<T,A>& x, const vector<T,A>& y)
+  {return x != y.base ();}
+
+  template <class T, class A>
+  inline bool operator> (const vector<T,A>& x, const vector<T,A>& y)
+  {return x.base () > y.base ();}
+
+  template <class T, class A>
+  inline bool operator>=(const vector<T,A>& x, const vector<T,A>& y)
+  {return x.base () >= y.base ();}
+
+  template <class T, class A>
+  inline bool operator>=(const vector<T,A>& x, const std::vector<T,A>& y)
+  {return x.base () >= y;}
+
+  template <class T, class A>
+  inline bool operator>=(const std::vector<T,A>& x, const vector<T,A>& y)
+  {return x >= y.base ();}
+
+  template <class T, class A>
+  inline bool operator<=(const vector<T,A>& x, const vector<T,A>& y)
+  {return x.base () <= y.base ();}
+
+  template <class T, class A>
+  inline bool operator<=(const vector<T,A>& x, const std::vector<T,A>& y)
+  {return x.base () <= y;}
+
+  template <class T, class A>
+  inline bool operator<=(const std::vector<T,A>& x, const vector<T,A>& y)
+  {return x <= y.base ();}
+
+  template <class V, class I>
+  class vector_iterator
+  {
+  public:
+    typedef V vector_type;
+    typedef I base_iterator_type;
+    typedef typename vector_type::const_iterator const_iterator_type;
+    typedef std::iterator_traits<base_iterator_type> base_iterator_traits;
+
+    typedef typename base_iterator_traits::value_type value_type;
+    typedef typename base_iterator_traits::difference_type difference_type;
+    typedef typename base_iterator_traits::pointer pointer;
+    typedef typename base_iterator_traits::reference reference;
+    typedef typename base_iterator_traits::iterator_category iterator_category;
+
+    typedef typename vector_type::size_type size_type;
+    typedef typename vector_type::const_reference const_reference;
+    typedef typename vector_type::const_pointer const_pointer;
+
+    vector_iterator (): v_ (0), i_ () {}
+    vector_iterator (vector_type* v, const base_iterator_type& i)
+        : v_ (v), i_ (i) {}
+    operator const_iterator_type () const {return i_;}
+    base_iterator_type base () const {return i_;}
+    vector_type* vector () const {return v_;}
+
+    // Note: const_{reference,pointer}.
+    //
+    const_reference operator* () const {return *i_;}
+    const_pointer   operator-> () const {return i_.operator -> ();}
+    const_reference operator[] (difference_type n) const {return i_[n];}
+
+    // Modifiers.
+    //
+    reference modify () const;
+    reference modify (difference_type n) const;
+
+    vector_iterator& operator++ () {++i_; return *this;}
+    vector_iterator  operator++ (int) {return vector_iterator (v_, i_++);}
+    vector_iterator& operator-- () {--i_; return *this;}
+    vector_iterator  operator-- (int) {return vector_iterator (v_, i_--);}
+
+    vector_iterator operator+ (difference_type n) const
+    {return vector_iterator (v_, i_ + n);}
+    vector_iterator& operator+= (difference_type n) {i_ += n; return *this;}
+    vector_iterator operator- (difference_type n) const
+    {return vector_iterator (v_, i_ - n);}
+    vector_iterator& operator-= (difference_type n) {i_ -= n; return *this;}
+
+    // Implementation details.
+    //
+  public:
+    base_iterator_type _base () const {return i_;} // Same as base ().
+
+  private:
+    vector_type* v_;
+    base_iterator_type i_;
+  };
+
+  template <class V, class J>
+  class vector_iterator<V, std::reverse_iterator<J> >
+  {
+  public:
+    typedef V vector_type;
+    typedef std::reverse_iterator<J> base_iterator_type;
+    typedef typename vector_type::const_reverse_iterator const_iterator_type;
+    typedef std::iterator_traits<base_iterator_type> base_iterator_traits;
+
+    typedef typename vector_type::iterator iterator_type;
+    typedef typename base_iterator_traits::value_type value_type;
+    typedef typename base_iterator_traits::difference_type difference_type;
+    typedef typename base_iterator_traits::pointer pointer;
+    typedef typename base_iterator_traits::reference reference;
+    typedef typename base_iterator_traits::iterator_category iterator_category;
+
+    typedef typename vector_type::size_type size_type;
+    typedef typename vector_type::const_reference const_reference;
+    typedef typename vector_type::const_pointer const_pointer;
+
+    vector_iterator (): v_ (0), i_ () {}
+    explicit vector_iterator (const iterator_type& i)
+        : v_ (i.vector ()), i_ (i.base ()) {}
+    vector_iterator (vector_type* v, const base_iterator_type& i)
+        : v_ (v), i_ (i) {}
+    operator const_iterator_type () const {return i_;}
+    iterator_type base () const {return iterator_type (v_, i_.base ());}
+    base_iterator_type rbase () const {return i_;}
+    vector_type* vector () const {return v_;}
+
+    // Note: const_{reference,pointer}.
+    //
+    const_reference operator* () const {return *i_;}
+    const_pointer   operator-> () const {return i_.operator -> ();}
+    const_reference operator[] (difference_type n) const {return i_[n];}
+
+    // Modifiers.
+    //
+    reference modify () const;
+    reference modify (difference_type n) const;
+
+    vector_iterator& operator++ () {++i_; return *this;}
+    vector_iterator  operator++ (int) {return vector_iterator (v_, i_++);}
+    vector_iterator& operator-- () {--i_; return *this;}
+    vector_iterator  operator-- (int) {return vector_iterator (v_, i_--);}
+
+    vector_iterator operator+ (difference_type n) const
+    {return vector_iterator (v_, i_ + n);}
+    vector_iterator& operator+= (difference_type n) {i_ += n; return *this;}
+    vector_iterator operator- (difference_type n) const
+    {return vector_iterator (v_, i_ - n);}
+    vector_iterator& operator-= (difference_type n) {i_ -= n; return *this;}
+
+    // Implementation details.
+    //
+  public:
+    base_iterator_type _base () const {return i_;} // Same as rbase().
+
+  private:
+    vector_type* v_;
+    base_iterator_type i_;
+  };
+
+  // operator==
+  //
+  template <class V, class I>
+  inline bool
+  operator== (const vector_iterator<V, I>& x, const vector_iterator<V, I>& y)
+  {return x._base () == y._base ();}
+
+  template <class V, class I>
+  inline bool
+  operator== (const vector_iterator<V, I>& x,
+              const typename vector_iterator<V, I>::const_iterator_type& y)
+  {return x._base () == y;}
+
+  template <class V, class I>
+  inline bool
+  operator== (const typename vector_iterator<V, I>::const_iterator_type& x,
+              const vector_iterator<V, I>& y)
+  {return x == y._base ();}
+
+  // operator<
+  //
+  template <class V, class I>
+  inline bool
+  operator< (const vector_iterator<V, I>& x, const vector_iterator<V, I>& y)
+  {return x._base () < y._base ();}
+
+  template <class V, class I>
+  inline bool
+  operator< (const vector_iterator<V, I>& x,
+             const typename vector_iterator<V, I>::const_iterator_type& y)
+  {return x._base () < y;}
+
+  template <class V, class I>
+  inline bool
+  operator< (const typename vector_iterator<V, I>::const_iterator_type& x,
+             const vector_iterator<V, I>& y)
+  {return x < y._base ();}
+
+  // operator!=
+  //
+  template <class V, class I>
+  inline bool
+  operator!= (const vector_iterator<V, I>& x, const vector_iterator<V, I>& y)
+  {return x._base () != y._base ();}
+
+  template <class V, class I>
+  inline bool
+  operator!= (const vector_iterator<V, I>& x,
+              const typename vector_iterator<V, I>::const_iterator_type& y)
+  {return x._base () != y;}
+
+  template <class V, class I>
+  inline bool
+  operator!= (const typename vector_iterator<V, I>::const_iterator_type& x,
+              const vector_iterator<V, I>& y)
+  {return x != y._base ();}
+
+  // operator>
+  //
+  template <class V, class I>
+  inline bool
+  operator> (const vector_iterator<V, I>& x, const vector_iterator<V, I>& y)
+  {return x._base () > y._base ();}
+
+  template <class V, class I>
+  inline bool
+  operator> (const vector_iterator<V, I>& x,
+              const typename vector_iterator<V, I>::const_iterator_type& y)
+  {return x._base () > y;}
+
+  template <class V, class I>
+  inline bool
+  operator> (const typename vector_iterator<V, I>::const_iterator_type& x,
+              const vector_iterator<V, I>& y)
+  {return x > y._base ();}
+
+  // operator>=
+  //
+  template <class V, class I>
+  inline bool
+  operator>= (const vector_iterator<V, I>& x, const vector_iterator<V, I>& y)
+  {return x._base () >= y._base ();}
+
+  template <class V, class I>
+  inline bool
+  operator>= (const vector_iterator<V, I>& x,
+              const typename vector_iterator<V, I>::const_iterator_type& y)
+  {return x._base () >= y;}
+
+  template <class V, class I>
+  inline bool
+  operator>= (const typename vector_iterator<V, I>::const_iterator_type& x,
+              const vector_iterator<V, I>& y)
+  {return x >= y._base ();}
+
+  // operator<=
+  //
+  template <class V, class I>
+  inline bool
+  operator<= (const vector_iterator<V, I>& x, const vector_iterator<V, I>& y)
+  {return x._base () <= y._base ();}
+
+  template <class V, class I>
+  inline bool
+  operator<= (const vector_iterator<V, I>& x,
+              const typename vector_iterator<V, I>::const_iterator_type& y)
+  {return x._base () <= y;}
+
+  template <class V, class I>
+  inline bool
+  operator<= (const typename vector_iterator<V, I>::const_iterator_type& x,
+              const vector_iterator<V, I>& y)
+  {return x <= y._base ();}
+
+  // operator-
+  //
+  template <class V, class I>
+  inline typename vector_iterator<V, I>::difference_type
+  operator-(const vector_iterator<V, I>& x, const vector_iterator<V, I>& y)
+  {return x._base () - y._base ();}
+
+  template <class V, class I>
+  inline typename vector_iterator<V, I>::difference_type
+  operator-(const vector_iterator<V, I>& x,
+            const typename vector_iterator<V, I>::const_iterator_type& y)
+  {return x._base () - y;}
+
+  template <class V, class I>
+  inline typename vector_iterator<V, I>::difference_type
+  operator-(const typename vector_iterator<V, I>::const_iterator_type& x,
+            const vector_iterator<V, I>& y)
+  {return x - y._base ();}
+
+  // operator+
+  //
+  template <class V, class I>
+  inline vector_iterator<V, I>
+  operator+(typename vector_iterator<V, I>::difference_type n,
+            const vector_iterator<V, I>& x)
+  {return vector_iterator<V, I> (x.vector (), n + x._base ());}
+}
+
+namespace std
+{
+  template <class T, class A>
+  inline void swap(odb::vector<T,A>& x, odb::vector<T,A>& y) {x.swap (y);}
+}
+
+#include <odb/vector.ixx>
+
+#include <odb/vector-traits.hxx>
+
+#include <odb/post.hxx>
+
+#endif // ODB_VECTOR_HXX
diff --git a/odb/vector.ixx b/odb/vector.ixx
new file mode 100644
index 0000000..1e36fe1
--- /dev/null
+++ b/odb/vector.ixx
@@ -0,0 +1,397 @@
+// file      : odb/vector.ixx
+// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+namespace odb
+{
+  //
+  // vector
+  //
+
+  // construct/copy/destroy:
+  //
+  template <class T, class A>
+  inline vector<T, A>& vector<T, A>::
+  operator= (const vector& x)
+  {
+    v_ = x.v_;
+    if (_tracking ())
+      impl_.assign (v_.size ());
+    return *this;
+  }
+
+  template <class T, class A>
+  template <class I>
+  inline void vector<T, A>::
+  assign (I f, I l)
+  {
+    v_.assign (f, l);
+    if (_tracking ())
+      impl_.assign (v_.size ());
+  }
+
+  template <class T, class A>
+  inline void vector<T, A>::
+  assign (size_type n, const T& u)
+  {
+    v_.assign (n, u);
+    if (_tracking ())
+      impl_.assign (n);
+  }
+
+#ifdef ODB_CXX11
+  template <class T, class A>
+  inline vector<T, A>& vector<T, A>::
+  vector& operator=(vector&& x)
+  {
+    v_ = std::move (x.v_);
+    if (_tracking ())
+      impl_.assign (v_.size ());
+    return *this;
+  }
+
+#ifdef ODB_CXX11_INITIALIZER_LIST
+  template <class T, class A>
+  inline vector<T, A>& vector<T, A>::
+  operator= (std::initializer_list<T> il)
+  {
+    v_ = il;
+    if (_tracking ())
+      impl_.assign (v_.size ());
+    return *this;
+  }
+
+  template <class T, class A>
+  inline void vector<T, A>::
+  assign (std::initializer_list<T> il)
+  {
+    v_.assign (il);
+    if (_tracking ())
+      impl_.assign (v_.size ());
+  }
+#endif
+#endif
+
+  // iterators:
+  //
+  template <class T, class A>
+  inline typename vector<T, A>::base_iterator_type vector<T, A>::
+  mbegin ()
+  {
+    if (_tracking ())
+      impl_.modify (0, v_.size ());
+    return v_.begin ();
+  }
+
+  template <class T, class A>
+  inline typename vector<T, A>::base_reverse_iterator_type vector<T, A>::
+  mrbegin ()
+  {
+    if (_tracking ())
+      impl_.modify (0, v_.size ());
+    return v_.rbegin ();
+  }
+
+  // capacity:
+  //
+  template <class T, class A>
+  inline void vector<T, A>::
+  resize (size_type n)
+  {
+    v_.resize (n);
+    if (_tracking ())
+      impl_.resize (n);
+  }
+
+  template <class T, class A>
+  inline void vector<T, A>::
+  resize (size_type n, const T& c)
+  {
+    v_.resize (n, c);
+    if (_tracking ())
+      impl_.resize (n);
+  }
+
+  template <class T, class A>
+  inline void vector<T, A>::
+  reserve (size_type n)
+  {
+    v_.reserve (n);
+    if (_tracking ())
+      impl_.reserve (n);
+  }
+
+#ifdef ODB_CXX11
+  template <class T, class A>
+  inline void vector<T, A>::
+  shrink_to_fit ()
+  {
+    v_.shrink_to_fit ();
+    impl_.shrink_to_fit ();
+  }
+#endif
+
+  // element access:
+  //
+  template <class T, class A>
+  inline typename vector<T, A>::reference vector<T, A>::
+  modify (size_type n)
+  {
+    reference& r (v_[n]);
+    if (_tracking ())
+      impl_.modify (n);
+    return r;
+  }
+
+  template <class T, class A>
+  inline typename vector<T, A>::reference vector<T, A>::
+  modify_at (size_type n)
+  {
+    reference& r (v_.at (n));
+    if (_tracking ())
+      impl_.modify (n);
+    return r;
+  }
+
+  template <class T, class A>
+  inline typename vector<T, A>::reference vector<T, A>::
+  modify_front ()
+  {
+    reference& r (v_.front ());
+    if (_tracking ())
+      impl_.modify (0);
+    return r;
+  }
+
+  template <class T, class A>
+  inline typename vector<T, A>::reference vector<T, A>::
+  modify_back ()
+  {
+    reference& r (v_.back ());
+    if (_tracking ())
+      impl_.modify (v_.size () - 1);
+    return r;
+  }
+
+#ifdef ODB_CXX11
+  template <class T, class A>
+  inline T* vector<T, A>::
+  modify_data() /*noexcept*/
+  {
+    if (_tracking ())
+      impl_.modify (0, v_.size ());
+    return v_.data ();
+  }
+#endif
+
+  // modifiers:
+  //
+  template <class T, class A>
+  inline void vector<T, A>::
+  push_back (const T& x)
+  {
+    v_.push_back (x);
+    if (_tracking ())
+      impl_.push_back ();
+  }
+
+  template <class T, class A>
+  inline void vector<T, A>::
+  pop_back ()
+  {
+    v_.pop_back ();
+    if (_tracking ())
+      impl_.pop_back ();
+  }
+
+  template <class T, class A>
+  inline typename vector<T, A>::iterator vector<T, A>::
+  insert (iterator p, const T& x)
+  {
+    if (_tracking ())
+      impl_.insert (static_cast<size_type> (p.base () - v_.begin ()));
+    return iterator (this, v_.insert (p.base (), x));
+  }
+
+  template <class T, class A>
+  inline void vector<T, A>::
+  insert (iterator p, size_type n, const T& x)
+  {
+    if (_tracking ())
+      impl_.insert (static_cast<size_type> (p.base () - v_.begin ()), n);
+    v_.insert (p.base (), n, x);
+  }
+
+  template <class T, class A>
+  template <class I>
+  inline void vector<T, A>::
+  insert (iterator p, I f, I l)
+  {
+    size_type i, n;
+    if (_tracking ())
+    {
+      i = static_cast<size_type> (p.base () - v_.begin ());
+      n = v_.size ();
+    }
+
+    v_.insert (p.base (), f, l);
+
+    if (_tracking ())
+      impl_.insert (i, v_.size () - n);
+  }
+
+  template <class T, class A>
+  inline typename vector<T, A>::iterator vector<T, A>::
+  erase (iterator p)
+  {
+    if (_tracking ())
+      impl_.erase (static_cast<size_type> (p.base () - v_.begin ()));
+    return iterator (this, v_.erase (p.base ()));
+  }
+
+  template <class T, class A>
+  inline typename vector<T, A>::iterator vector<T, A>::
+  erase (iterator f, iterator l)
+  {
+    if (_tracking ())
+      impl_.erase (static_cast<size_type> (f.base () - v_.begin ()),
+                   static_cast<size_type> (l - f));
+    return iterator (this, v_.erase (f.base (), l.base ()));
+  }
+
+  template <class T, class A>
+  inline void vector<T, A>::
+  swap (vector& x)
+  {
+    v_.swap (x.v_);
+    vector_base::swap (x);
+  }
+
+  template <class T, class A>
+  inline void vector<T, A>::
+  clear ()
+  {
+    v_.clear ();
+    if (_tracking ())
+      impl_.clear ();
+  }
+
+#ifdef ODB_CXX11
+  template <class T, class A>
+  inline void vector<T, A>::
+  push_back(T&& x)
+  {
+    v_.push_back (std::move (x));
+    if (_tracking ())
+      impl_.push_back ();
+  }
+
+  template <class T, class A>
+  inline typename vector<T, A>::iterator vector<T, A>::
+  insert (iterator p, T&& x)
+  {
+    base_iterator_type r (v_.insert (p.base (), std::move (x)));
+    if (_tracking ())
+      impl_.insert (static_cast<size_type> (r - v_.begin ()));
+    return iterator (this, r);
+  }
+
+#ifdef ODB_CXX11_VARIADIC_TEMPLATE
+  template <class T, class A>
+  template <class... Args>
+  inline void vector<T, A>::
+  emplace_back (Args&&... args)
+  {
+    v_.push_back (std::forward<Args> (args)...);
+    if (_tracking ())
+      impl_.push_back ();
+  }
+
+  template <class T, class A>
+  template <class... Args>
+  inline typename vector<T, A>::iterator vector<T, A>::
+  emplace (iterator p, Args&&... args)
+  {
+    base_iterator_type r (
+      v_.emplace (p.base (), std::forward<Args> (args)...));
+    if (_tracking ())
+      impl_.insert (static_cast<size_type> (r - v_.begin ()));
+    return iterator (this, r);
+  }
+#endif
+#endif
+
+  // Interfacing with base vector.
+  //
+  template <class T, class A>
+  inline vector<T, A>& vector<T, A>::
+  operator= (const base_vector_type& x)
+  {
+    v_ = x;
+    if (_tracking ())
+      impl_.assign (v_.size ());
+    return *this;
+  }
+
+#ifdef ODB_CXX11
+  template <class T, class A>
+  inline vector<T, A>& vector<T, A>::
+  operator= (base_vector_type&& x)
+  {
+    v_ = std::move (x);
+    if (_tracking ())
+      impl_.assign (v_.size ());
+    return *this;
+  }
+#endif
+
+  //
+  // vector_iterator
+  //
+
+  template <class V, class I>
+  inline typename vector_iterator<V, I>::reference vector_iterator<V, I>::
+  modify () const
+  {
+    if (v_->_tracking ())
+      v_->_impl ().modify (static_cast<size_type> (i_ - v_->base ().begin ()));
+    return *i_;
+  }
+
+  template <class V, class I>
+  inline typename vector_iterator<V, I>::reference vector_iterator<V, I>::
+  modify (difference_type n) const
+  {
+    if (v_->_tracking ())
+      v_->_impl ().modify (
+        static_cast<size_type> (i_ - v_->base ().begin () + n));
+    return i_[n];
+  }
+
+  //
+  // vector_iterator<std::reverse_iterator>
+  //
+
+  template <class V, class J>
+  inline typename vector_iterator<V, std::reverse_iterator<J> >::reference
+  vector_iterator<V, std::reverse_iterator<J> >::
+  modify () const
+  {
+    if (v_->_tracking ())
+      v_->_impl ().modify (
+        static_cast<size_type> (v_->base ().rend () - i_ - 1));
+    return *i_;
+  }
+
+  template <class V, class J>
+  inline typename vector_iterator<V, std::reverse_iterator<J> >::reference
+  vector_iterator<V, std::reverse_iterator<J> >::
+  modify (difference_type n) const
+  {
+    if (v_->_tracking ())
+      // Note: going in the opposite direction.
+      v_->_impl ().modify (
+        static_cast<size_type> (v_->base ().rend () - i_ - 1 - n));
+    return i_[n];
+  }
+}