From 6bd95f51beb26d87fd5d5db22391c73f333eee6e Mon Sep 17 00:00:00 2001 From: Boris Kolpackov Date: Wed, 19 Oct 2011 10:47:41 +0200 Subject: Add support for const data members Const data members are automatically treated as readonly. New test: const-member. --- odb/relational/pgsql/common.cxx | 27 ++++++++++++++++++----- odb/relational/pgsql/common.hxx | 30 ++++++++++++++++++------- odb/relational/pgsql/schema.cxx | 3 ++- odb/relational/pgsql/source.cxx | 49 +++++++++++++++++++++++++++-------------- 4 files changed, 77 insertions(+), 32 deletions(-) (limited to 'odb/relational/pgsql') 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 ("wrapper-hint")); + hint = wrapper->get ("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 -- cgit v1.1