Add support for const data members

Const data members are automatically treated as readonly. New test:
const-member.

4 files changed, 77 insertions, 32 deletions

diff --git a/odb/relational/pgsql/common.cxx b/odb/relational/pgsql/common.cxx
index 26f4b12..4993408 100644
--- a/odb/relational/pgsql/common.cxx
+++ b/odb/relational/pgsql/common.cxx
@@ -33,14 +33,20 @@ namespace relational
         var = name + (name[name.size () - 1] == '_' ? "" : "_");
       }
 
-      semantics::type& t (type_override_ != 0 ? *type_override_ : m.type ());
+      bool cq (type_override_ != 0 ? false: const_type (m.type ()));
+      semantics::type& t (type_override_ != 0 ? *type_override_ : utype (m));
 
       if (semantics::class_* c = composite_wrapper (t))
       {
         // If t is a wrapper, pass the wrapped type. Also pass the
         // original, wrapper type.
         //
-        member_info mi (m, *c, (wrapper (t) ? &t : 0), var, fq_type_override_);
+        member_info mi (m,
+                        *c,
+                        (wrapper (t) ? &t : 0),
+                        cq,
+                        var,
+                        fq_type_override_);
         if (pre (mi))
         {
           traverse_composite (mi);
@@ -51,7 +57,12 @@ namespace relational
       {
         // The same unwrapping logic as for composite values.
         //
-        member_info mi (m, *c, (wrapper (t) ? &t : 0), var, fq_type_override_);
+        member_info mi (m,
+                        *c,
+                        (wrapper (t) ? &t : 0),
+                        cq,
+                        var,
+                        fq_type_override_);
         if (pre (mi))
         {
           traverse_container (mi);
@@ -64,8 +75,12 @@ namespace relational
 
         if (semantics::class_* c = object_pointer (t))
         {
-          member_info mi (
-            m, id_member (*c)->type (), 0, var, fq_type_override_);
+          member_info mi (m,
+                          utype (*id_member (*c)),
+                          0,
+                          cq,
+                          var,
+                          fq_type_override_);
           mi.st = &st;
           if (pre (mi))
           {
@@ -75,7 +90,7 @@ namespace relational
         }
         else
         {
-          member_info mi (m, t, 0, var, fq_type_override_);
+          member_info mi (m, t, 0, cq, var, fq_type_override_);
           mi.st = &st;
           if (pre (mi))
           {
diff --git a/odb/relational/pgsql/common.hxx b/odb/relational/pgsql/common.hxx
index a91c40a..7a92a4a 100644
--- a/odb/relational/pgsql/common.hxx
+++ b/odb/relational/pgsql/common.hxx
@@ -29,9 +29,13 @@ namespace relational
       struct member_info
       {
         semantics::data_member& m; // Member.
-        semantics::type& t;        // Member C++ type (m.type () may != t).
-        semantics::type* wrapper;  // Wrapper type if member is a wrapper.
+        semantics::type& t;        // Cvr-unqualified member C++ type, note
+                                   // that m.type () may not be the same as t.
+        semantics::type* wrapper;  // Wrapper type if member is a composite or
+                                   // container wrapper, also cvr-unqualified.
                                    // In this case t is the wrapped type.
+        bool cq;                   // True if the original (wrapper) type
+                                   // is const-qualified.
         sql_type const* st;        // Member SQL type (only simple values).
         string& var;               // Member variable name with trailing '_'.
 
@@ -40,21 +44,29 @@ namespace relational
         string
         fq_type (bool unwrap = true) const
         {
+          semantics::names* hint;
+
           if (wrapper != 0 && unwrap)
           {
-            // Use the hint from the wrapper.
+            // Use the hint from the wrapper unless the wrapped type
+            // is qualified.
             //
-            return t.fq_name (
-              wrapper->get<semantics::names*> ("wrapper-hint"));
+            hint = wrapper->get<semantics::names*> ("wrapper-hint");
+            utype (*context::wrapper (*wrapper), hint);
+            return t.fq_name (hint);
           }
 
           // Use the original type from 'm' instead of 't' since the hint
           // may be invalid for a different type. Plus, if a type is
           // overriden, then the fq_type must be as well.
           //
-          return fq_type_.empty ()
-            ? m.type ().fq_name (m.belongs ().hint ())
-            : fq_type_;
+          if (fq_type_.empty ())
+          {
+            semantics::type& t (utype (m, hint));
+            return t.fq_name (hint);
+          }
+          else
+            return fq_type_;
         }
 
         string const& fq_type_;
@@ -62,11 +74,13 @@ namespace relational
         member_info (semantics::data_member& m_,
                      semantics::type& t_,
                      semantics::type* wrapper_,
+                     bool cq_,
                      string& var_,
                      string const& fq_type)
             : m (m_),
               t (t_),
               wrapper (wrapper_),
+              cq (cq_),
               st (0),
               var (var_),
               fq_type_ (fq_type)
diff --git a/odb/relational/pgsql/schema.cxx b/odb/relational/pgsql/schema.cxx
index 70d4979..450d056 100644
--- a/odb/relational/pgsql/schema.cxx
+++ b/odb/relational/pgsql/schema.cxx
@@ -139,7 +139,8 @@ namespace relational
           if (inverse (m))
             return false;
 
-          if (semantics::class_* c = object_pointer (member_type (m, prefix_)))
+          if (semantics::class_* c =
+              object_pointer (member_utype (m, prefix_)))
           {
             pre_statement ();
 
diff --git a/odb/relational/pgsql/source.cxx b/odb/relational/pgsql/source.cxx
index 8547df3..c45b40e 100644
--- a/odb/relational/pgsql/source.cxx
+++ b/odb/relational/pgsql/source.cxx
@@ -535,7 +535,7 @@ namespace relational
             // When handling a pointer, mi.t is the id type of the referenced
             // object.
             //
-            semantics::type& mt (member_type (mi.m, key_prefix_));
+            semantics::type& mt (member_utype (mi.m, key_prefix_));
 
             if (semantics::class_* c = object_pointer (mt))
             {
@@ -608,7 +608,7 @@ namespace relational
             // When handling a pointer, mi.t is the id type of the referenced
             // object.
             //
-            if (object_pointer (member_type (mi.m, key_prefix_)))
+            if (object_pointer (member_utype (mi.m, key_prefix_)))
             {
               os << "}";
 
@@ -756,6 +756,10 @@ namespace relational
             string const& name (mi.m.name ());
             member = "o." + name;
 
+            if (mi.cq)
+              member = "const_cast< " + mi.fq_type (false) + "& > (" +
+                member + ")";
+
             os << "// " << name << endl
                << "//" << endl;
           }
@@ -769,7 +773,7 @@ namespace relational
             // Here we need the wrapper type, not the wrapped type.
             //
             member = "wrapper_traits< " + mi.fq_type (false) + " >::" +
-              "set_ref (" + member + ")";
+              "set_ref (\n" + member + ")";
           }
 
           if (composite (mi.t))
@@ -779,7 +783,7 @@ namespace relational
             // When handling a pointer, mi.t is the id type of the referenced
             // object.
             //
-            semantics::type& mt (member_type (mi.m, key_prefix_));
+            semantics::type& mt (member_utype (mi.m, key_prefix_));
 
             if (semantics::class_* c = object_pointer (mt))
             {
@@ -830,13 +834,20 @@ namespace relational
           // When handling a pointer, mi.t is the id type of the referenced
           // object.
           //
-          semantics::type& mt (member_type (mi.m, key_prefix_));
+          semantics::type& mt (member_utype (mi.m, key_prefix_));
 
           if (object_pointer (mt))
           {
-            member = member_override_.empty ()
-              ? "o." + mi.m.name ()
-              : member_override_;
+            if (!member_override_.empty ())
+              member = member_override_;
+            else
+            {
+              member = "o." + mi.m.name ();
+
+              if (mi.cq)
+                member = "const_cast< " + mi.fq_type (false) + "& > (" +
+                  member + ")";
+            }
 
             if (lazy_pointer (mt))
               os << member << " = ptr_traits::pointer_type (db, id);";
@@ -867,8 +878,9 @@ namespace relational
         traverse_integer (member_info& mi)
         {
           os << traits << "::set_value (" << endl
-             << member << ", i." << mi.var << "value, " <<
-            "i." << mi.var << "null);"
+             << member << "," << endl
+             << "i." << mi.var << "value," << endl
+             << "i." << mi.var << "null);"
              << endl;
         }
 
@@ -876,8 +888,9 @@ namespace relational
         traverse_float (member_info& mi)
         {
           os << traits << "::set_value (" << endl
-             << member << ", i." << mi.var << "value, " <<
-            "i." << mi.var << "null);"
+             << member << "," << endl
+             << "i." << mi.var << "value," << endl
+             << "i." << mi.var << "null);"
              << endl;
         }
 
@@ -896,8 +909,9 @@ namespace relational
         traverse_date_time (member_info& mi)
         {
           os << traits << "::set_value (" << endl
-             << member << ", i." << mi.var << "value, " <<
-            "i." << mi.var << "null);"
+             << member << "," << endl
+             << "i." << mi.var << "value," << endl
+             << "i." << mi.var << "null);"
              << endl;
         }
 
@@ -942,8 +956,9 @@ namespace relational
         traverse_uuid (member_info& mi)
         {
           os << traits << "::set_value (" << endl
-             << member << ", i." << mi.var << "value, " <<
-            "i." << mi.var << "null);"
+             << member << "," << endl
+             << "i." << mi.var << "value," << endl
+             << "i." << mi.var << "null);"
              << endl;
         }
 
@@ -1190,7 +1205,7 @@ namespace relational
             {
               // many(i)-to-many
               //
-              if (container_wrapper (inv_m->type ()))
+              if (container_wrapper (utype (*inv_m)))
                 os << oids[column_sql_type (*inv_m, "value").type];
 
               // many(i)-to-one