From 9ad0acf37561de9bf359a561faed53de17c2ca3b Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Wed, 21 Nov 2012 13:11:43 +0200
Subject: Add dynamic multi-database query support

---
 odb/instance.hxx | 279 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 279 insertions(+)
 create mode 100644 odb/instance.hxx

(limited to 'odb/instance.hxx')

diff --git a/odb/instance.hxx b/odb/instance.hxx
new file mode 100644
index 0000000..76e72c3
--- /dev/null
+++ b/odb/instance.hxx
@@ -0,0 +1,279 @@
+// file      : odb/instance.hxx
+// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC
+// license   : GNU GPL v3; see accompanying LICENSE file
+
+#ifndef ODB_INSTANCE_HXX
+#define ODB_INSTANCE_HXX
+
+#include <map>
+#include <string>
+#include <cstddef>  // std::size_t
+#include <typeinfo>
+
+#include <odb/option-types.hxx>
+#include <odb/context.hxx>
+
+#include <odb/traversal/elements.hxx>
+#include <odb/traversal/relational/elements.hxx>
+
+//
+// Dynamic traversal instantiation support.
+//
+
+template <typename B>
+struct factory
+{
+  static B*
+  create (B const& prototype)
+  {
+    std::string kind, name;
+    database db (context::current ().options.database ()[0]);
+
+    switch (db)
+    {
+    case database::common:
+      {
+        name = "common";
+        break;
+      }
+    case database::mssql:
+    case database::mysql:
+    case database::oracle:
+    case database::pgsql:
+    case database::sqlite:
+      {
+        kind = "relational";
+        name = kind + "::" + db.string ();
+        break;
+      }
+    }
+
+    if (map_ != 0)
+    {
+      typename map::const_iterator i;
+
+      if (!name.empty ())
+        i = map_->find (name);
+
+      if (i == map_->end ())
+        i = map_->find (kind);
+
+      if (i != map_->end ())
+        return i->second (prototype);
+    }
+
+    return new B (prototype);
+  }
+
+private:
+  template <typename>
+  friend struct entry;
+
+  static void
+  init ()
+  {
+    if (factory<B>::count_++ == 0)
+      factory<B>::map_ = new typename factory<B>::map;
+  }
+
+  static void
+  term ()
+  {
+    if (--factory<B>::count_ == 0)
+      delete factory<B>::map_;
+  }
+
+  typedef B* (*create_func) (B const&);
+  typedef std::map<std::string, create_func> map;
+  static map* map_;
+  static std::size_t count_;
+};
+
+template <typename B>
+typename factory<B>::map* factory<B>::map_;
+
+template <typename B>
+std::size_t factory<B>::count_;
+
+struct entry_base
+{
+  static std::string
+  name (std::type_info const&);
+};
+
+template <typename D>
+struct entry: entry_base
+{
+  typedef typename D::base base;
+
+  entry ()
+  {
+    factory<base>::init ();
+    (*factory<base>::map_)[name (typeid (D))] = &create;
+  }
+
+  ~entry ()
+  {
+    factory<base>::term ();
+  }
+
+  static base*
+  create (base const& prototype)
+  {
+    return new D (prototype);
+  }
+};
+
+template <typename B>
+struct instance
+{
+  typedef typename B::base base_type;
+  typedef ::factory<base_type> factory_type;
+
+  ~instance ()
+  {
+    delete x_;
+  }
+
+  instance ()
+  {
+    base_type prototype;
+    x_ = factory_type::create (prototype);
+  }
+
+  template <typename A1>
+  instance (A1& a1)
+  {
+    base_type prototype (a1);
+    x_ = factory_type::create (prototype);
+  }
+
+  template <typename A1>
+  instance (A1 const& a1)
+  {
+    base_type prototype (a1);
+    x_ = factory_type::create (prototype);
+  }
+
+  template <typename A1, typename A2>
+  instance (A1& a1, A2& a2)
+  {
+    base_type prototype (a1, a2);
+    x_ = factory_type::create (prototype);
+  }
+
+  template <typename A1, typename A2>
+  instance (A1 const& a1, A2 const& a2)
+  {
+    base_type prototype (a1, a2);
+    x_ = factory_type::create (prototype);
+  }
+
+  template <typename A1, typename A2, typename A3>
+  instance (A1& a1, A2& a2, A3& a3)
+  {
+    base_type prototype (a1, a2, a3);
+    x_ = factory_type::create (prototype);
+  }
+
+  template <typename A1, typename A2, typename A3>
+  instance (A1 const& a1, A2 const& a2, A3 const& a3)
+  {
+    base_type prototype (a1, a2, a3);
+    x_ = factory_type::create (prototype);
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4>
+  instance (A1& a1, A2& a2, A3& a3, A4& a4)
+  {
+    base_type prototype (a1, a2, a3, a4);
+    x_ = factory_type::create (prototype);
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4>
+  instance (A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4)
+  {
+    base_type prototype (a1, a2, a3, a4);
+    x_ = factory_type::create (prototype);
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5>
+  instance (A1& a1, A2& a2, A3& a3, A4& a4, A5& a5)
+  {
+    base_type prototype (a1, a2, a3, a4, a5);
+    x_ = factory_type::create (prototype);
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5>
+  instance (A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4,
+            A5 const& a5)
+  {
+    base_type prototype (a1, a2, a3, a4, a5);
+    x_ = factory_type::create (prototype);
+  }
+
+  instance (instance const& i)
+  {
+    // This is tricky: use the other instance as a prototype.
+    //
+    x_ = factory_type::create (*i.x_);
+  }
+
+  base_type*
+  operator-> () const
+  {
+    return x_;
+  }
+
+  base_type&
+  operator* () const
+  {
+    return *x_;
+  }
+
+  base_type*
+  get () const
+  {
+    return x_;
+  }
+
+private:
+  instance& operator= (instance const&);
+
+private:
+  base_type* x_;
+};
+
+template <typename T>
+inline traversal::edge_base&
+operator>> (instance<T>& n, traversal::edge_base& e)
+{
+  n->edge_traverser (e);
+  return e;
+}
+
+template <typename T>
+inline traversal::relational::edge_base&
+operator>> (instance<T>& n, traversal::relational::edge_base& e)
+{
+  n->edge_traverser (e);
+  return e;
+}
+
+template <typename T>
+inline traversal::node_base&
+operator>> (traversal::edge_base& e, instance<T>& n)
+{
+  e.node_traverser (*n);
+  return *n;
+}
+
+template <typename T>
+inline traversal::relational::node_base&
+operator>> (traversal::relational::edge_base& e, instance<T>& n)
+{
+  e.node_traverser (*n);
+  return *n;
+}
+
+#endif // ODB_INSTANCE_HXX
-- 
cgit v1.1