Re: Overloaded constructors and cast operators for Glib::Value?

[Murray Cumming <murrayc murrayc com>]

On Fri, 2005-01-07 at 20:26 +0100, Jan Hudec wrote:
> Hello All,
> 
> I am planning a project. It's in a design stage. For that project,
> I need a generic value type.
> 
> By that I mean, that it should be possible to construct that type from
> any (some reasonable set) other type and be castable to any such type,
> perhaps using dynamic_cast method like RefPtr does. This cast or method
> would throw bad_cast, if the object actualy contained incompatible type.
> 
> What I want is to allow:
> 
>     void foo(int x);
> 
>     Value a = 1;
>     Value b = "string";
>     
>     foo(a); // OK, a is an integer
>     foo(b); // throws bad_cast, because it's not a number.
> 
> Since I will be passing that type to Gtkmm calls a lot, I want it
> convertible to Glib::ValueBase.

Glib::Value and Glib::ValueBase base are used only rarely in the gtkmm
API, so this would not be a big advantage.

However, I can see the advantage of reusing the existing code.

>  Thus I thought that it could in fact be
> based on the existing Glib::Value infrastructure.
> 
> I thought about something like this:
> 
> class Value : Glib::ValueBase {
>   protected:
>     void swap(Value &that)
>     {
>         GValue tmp;
>         tmp = that.gobject_;
>         that.gobject_ = this->gobject_;
>         this->gobject_ = tmp;
>     }
>   public:
>     // some not-interesting default constructor
>     
>     // template constructor from anything
>     template <class VT> Value(VT &val)
>     {
>         Glib::Value<VT> tmp;
>         tmp.set(val);
>         this->swap(tmp);
>     }
>     template <> Value(Glib::ValueBase &val) :
> 	Glib::ValueBase(val)
>     {};
> 
>     // operator= using above constructors and swap
> 
>     // And now the highest madness! The cast operators!
>     // FIXME This won't work. It does not do sane checking.
>     template <class VT> operator VT()
>     {
> 	Glib::Value<VT> tmp;
> 	tmp = *this; // FIXME This does not exist!
> 	return tmp.get();
>     }
> 
>     // Perhaps some more operations should be defined too, like
>     // a stringification operation for printing and such.
> }
> 
> The FIXME denotes the point where I am in trouble. What I need is an
> operation, that would copy one Glib::ValueBase to a Glib::ValueBase
> descendant calling g_value_transform and throwing a bad_cast exception
> if it returns NULL.
> 
> I think it should be possible to implement the operation here -- after
> all, it inherits Glib::ValueBase and thus has access to it's guts. I am
> nowever not completely sure HOW it should be done. What are your
> opinions on this?
> 
> Also it does not work with enums and flags, because enums are
> Glib::Value_Enum and flags are Glib::Value_Flags. It would suffice to
> use static constructor methods for enums. Does anyone have a better
> idea?
> 
> Since I don't have much experience with C++, it's quite possible that
> there are other bugs too. Please correct me if I am wrong somewhere.
> 
> -------------------------------------------------------------------------------
> 						 Jan 'Bulb' Hudec <bulb ucw cz>
> _______________________________________________
> gtkmm-list mailing list
> gtkmm-list gnome org
> http://mail.gnome.org/mailman/listinfo/gtkmm-list
-- 
Murray Cumming
murrayc murrayc com
www.murrayc.com
www.openismus.com