From af12ffe836de09ec84f666effa4df347eeb07a43 Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Thu, 26 Jan 2012 12:43:16 +0200
Subject: Implement support for database schema

New pragma qualifier: namespace. New pragma specifier: schema. The table
specifier was extended to accept a schema prefix. New option: --default-
schema. The common/schema test was extended to cover the new functionality.
---
 odb/semantics/relational/name.hxx | 146 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 146 insertions(+)
 create mode 100644 odb/semantics/relational/name.hxx

(limited to 'odb/semantics/relational/name.hxx')

diff --git a/odb/semantics/relational/name.hxx b/odb/semantics/relational/name.hxx
new file mode 100644
index 0000000..ae06708
--- /dev/null
+++ b/odb/semantics/relational/name.hxx
@@ -0,0 +1,146 @@
+// file      : odb/semantics/relational/name.hxx
+// author    : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC
+// license   : GNU GPL v3; see accompanying LICENSE file
+
+#ifndef ODB_SEMANTICS_RELATIONAL_NAME_HXX
+#define ODB_SEMANTICS_RELATIONAL_NAME_HXX
+
+#include <string>
+#include <vector>
+#include <iosfwd>
+
+namespace semantics
+{
+  namespace relational
+  {
+    typedef std::string uname;
+
+    class qname
+    {
+    public:
+      typedef relational::uname uname_type;
+
+      qname () {}
+
+      explicit
+      qname (uname_type const& n) {append (n);}
+
+      template <typename I>
+      qname (I begin, I end)
+      {
+        for (; begin != end; ++begin)
+          append (*begin);
+      }
+
+      qname&
+      operator= (uname_type const& n)
+      {
+        components_.resize (1);
+        components_[0] = n;
+        return *this;
+      }
+
+      void
+      append (uname_type const& n) {components_.push_back (n);}
+
+      void
+      append (qname const& n)
+      {
+        components_.insert (components_.end (),
+                            n.components_.begin (),
+                            n.components_.end ());
+      }
+
+      void
+      clear () {components_.clear ();}
+
+      // Append a string to the last component.
+      //
+      qname&
+      operator+= (std::string const& s)
+      {
+        if (empty ())
+          append (s);
+        else
+          uname () += s;
+
+        return *this;
+      }
+
+      friend qname
+      operator+ (qname const& n, std::string const& s)
+      {
+        qname r (n);
+
+        if (r.empty ())
+          r.append (s);
+        else
+          r.uname () += s;
+
+        return r;
+      }
+
+      void
+      swap (qname& n) {components_.swap (n.components_);}
+
+    public:
+      bool
+      empty () const {return components_.empty ();}
+
+      bool
+      qualified () const {return components_.size () > 1;}
+
+      bool
+      fully_qualified () const
+      {
+        return qualified () && components_.front ().empty ();
+      }
+
+    public:
+      typedef std::vector<uname_type> components;
+      typedef components::const_iterator iterator;
+
+      iterator
+      begin () const {return components_.begin ();}
+
+      iterator
+      end () const {return components_.end ();}
+
+      uname_type&
+      uname () {return components_.back ();}
+
+      uname_type const&
+      uname () const {return components_.back ();}
+
+      qname
+      qualifier () const
+      {
+        return empty ()
+          ? qname ()
+          : qname (components_.begin (), components_.end () - 1);
+      }
+
+      std::string
+      string () const;
+
+    public:
+      friend bool
+      operator< (qname const& x, qname const& y)
+      {
+        return x.components_ < y.components_;
+      }
+
+    private:
+      components components_;
+    };
+
+    std::ostream&
+    operator<< (std::ostream&, qname const&);
+
+    std::istream&
+    operator>> (std::istream&, qname&);
+  }
+}
+
+#endif // ODB_SEMANTICS_RELATIONAL_NAME_HXX
-- 
cgit v1.1