libs/glibmm2/glibmm/value_custom.h

   1 // -*- c++ -*-
   2 /* $Id$ */
   3
   4 /* Copyright 2002 The gtkmm Development Team
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the Free
  18  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  22 #ifndef _GLIBMM_VALUE_H_INCLUDE_VALUE_CUSTOM_H
  23 #error "glibmm/value_custom.h cannot be included directly"
  24 #endif
  25 #endif
  26
  27 #include <new>
  28 #include <typeinfo>
  29 #include <glibmmconfig.h>
  30
  31 GLIBMM_USING_STD(nothrow)
  32
  33
  34 namespace Glib
  35 {
  36
  37 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  38
  39 extern "C"
  40 {
  41   typedef void (* ValueInitFunc) (GValue*);
  42   typedef void (* ValueFreeFunc) (GValue*);
  43   typedef void (* ValueCopyFunc) (const GValue*, GValue*);
  44 }
  45
  46 /* When using Glib::Value<T> with custom types, each T will be registered
  47  * as subtype of G_TYPE_BOXED, via this function.  The type_name argument
  48  * should be the C++ RTTI name.
  49  */
  50 GType custom_boxed_type_register(const char*   type_name,
  51                                  ValueInitFunc init_func,
  52                                  ValueFreeFunc free_func,
  53                                  ValueCopyFunc copy_func);
  54
  55 /* When using Glib::Value<T*> or Glib::Value<const T*> with custom types,
  56  * each T* or const T* will be registered as a subtype of G_TYPE_POINTER,
  57  * via this function.  The type_name argument should be the C++ RTTI name.
  58  */
  59 GType custom_pointer_type_register(const char* type_name);
  60
  61 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  62
  63
  64 /**
  65  * @ingroup glibmmValue
  66  */
  67 template <class T, class PtrT>
  68 class Value_Pointer : public ValueBase_Object
  69 {
  70 public:
  71   typedef PtrT  CppType;
  72   typedef void* CType;
  73
  74   static inline GType value_type() G_GNUC_CONST;
  75
  76   inline void set(CppType data);
  77   inline CppType get() const;
  78
  79 private:
  80   inline
  81   static GType value_type_(Glib::Object*);
  82   static GType value_type_(void*);
  83
  84   inline void set_(CppType data, Glib::Object*);
  85   inline void set_(CppType data, void*);
  86
  87   inline CppType get_(Glib::Object*) const;
  88   inline CppType get_(void*) const;
  89 };
  90
  91
  92 /** Generic value implementation for custom types.
  93  * @ingroup glibmmValue
  94  * Any type to be used with this template must implement:
  95  * - default constructor
  96  * - copy constructor
  97  * - assignment operator
  98  * - destructor
  99  *
 100  * Compiler-generated implementations are OK, provided they do the
 101  * right thing for the type.  In other words, any type that works with
 102  * <tt>std::vector</tt> will work with Glib::Value<>.
 103  *
 104  * @note None of the operations listed above are allowed to throw.  If you
 105  * cannot ensure that no exceptions will be thrown, consider using either
 106  * a normal pointer or a smart pointer to hold your objects indirectly.
 107  */
 108 template <class T>
 109 class Value : public ValueBase_Boxed
 110 {
 111 public:
 112   typedef T  CppType;
 113   typedef T* CType;
 114
 115   static GType value_type() G_GNUC_CONST;
 116
 117   inline void set(const CppType& data);
 118   inline CppType get() const;
 119
 120 private:
 121   static GType custom_type_;
 122
 123   static void value_init_func(GValue* value);
 124   static void value_free_func(GValue* value);
 125   static void value_copy_func(const GValue* src_value, GValue* dest_value);
 126 };
 127
 128
 129 /** Specialization for pointers to instances of any type.
 130  * @ingroup glibmmValue
 131  * No attempt is made to manage the memory associated with the
 132  * pointer, you must take care of that yourself.
 133  */
 134 template <class T>
 135 class Value<T*> : public Value_Pointer<T,T*>
 136 {};
 137
 138 /** Specialization for pointers to const instances of any type.
 139  * @ingroup glibmmValue
 140  * No attempt is made to manage the memory associated with the
 141  * pointer, you must take care of that yourself.
 142  */
 143 template <class T>
 144 class Value<const T*> : public Value_Pointer<T,const T*>
 145 {};
 146
 147
 148 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 149
 150 /**** Glib::Value_Pointer<T, PtrT> *****************************************/
 151
 152 /** Implementation for Glib::Object pointers **/
 153
 154 // static
 155 template <class T, class PtrT> inline
 156 GType Value_Pointer<T,PtrT>::value_type_(Glib::Object*)
 157 {
 158   return T::get_base_type();
 159 }
 160
 161 template <class T, class PtrT> inline
 162 void Value_Pointer<T,PtrT>::set_(PtrT data, Glib::Object*)
 163 {
 164   set_object(const_cast<T*>(data));
 165 }
 166
 167 //More spec-compliant compilers (such as Tru64) need this to be near Glib::Object instead.
 168 #ifdef GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION
 169 template <class T, class PtrT> inline
 170 PtrT Value_Pointer<T,PtrT>::get_(Glib::Object*) const
 171 {
 172   return dynamic_cast<T*>(get_object());
 173 }
 174 #endif //GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION
 175
 176 /** Implementation for custom pointers **/
 177
 178 // static
 179 template <class T, class PtrT>
 180 GType Value_Pointer<T,PtrT>::value_type_(void*)
 181 {
 182   static GType custom_type = 0;
 183
 184   if(!custom_type)
 185     custom_type = Glib::custom_pointer_type_register(typeid(PtrT).name());
 186
 187   return custom_type;
 188 }
 189
 190 template <class T, class PtrT> inline
 191 void Value_Pointer<T,PtrT>::set_(PtrT data, void*)
 192 {
 193   gobject_.data[0].v_pointer = const_cast<T*>(data);
 194 }
 195
 196 template <class T, class PtrT> inline
 197 PtrT Value_Pointer<T,PtrT>::get_(void*) const
 198 {
 199   return static_cast<T*>(gobject_.data[0].v_pointer);
 200 }
 201
 202 /** Public forwarding interface **/
 203
 204 // static
 205 template <class T, class PtrT> inline
 206 GType Value_Pointer<T,PtrT>::value_type()
 207 {
 208   // Dispatch to the specific value_type_() overload.
 209   return Value_Pointer<T,PtrT>::value_type_(static_cast<T*>(0));
 210 }
 211
 212 template <class T, class PtrT> inline
 213 void Value_Pointer<T,PtrT>::set(PtrT data)
 214 {
 215   // Dispatch to the specific set_() overload.
 216   this->set_(data, static_cast<T*>(0));
 217 }
 218
 219 template <class T, class PtrT> inline
 220 PtrT Value_Pointer<T,PtrT>::get() const
 221 {
 222   // Dispatch to the specific get_() overload.
 223   return this->get_(static_cast<T*>(0));
 224 }
 225
 226
 227 /**** Glib::Value<T> *******************************************************/
 228
 229 // Static data, specific to each template instantiation.
 230 template <class T>
 231 GType Value<T>::custom_type_ = 0;
 232
 233 template <class T> inline
 234 void Value<T>::set(const typename Value<T>::CppType& data)
 235 {
 236   // Assume the value is already default-initialized.  See value_init_func().
 237   *static_cast<T*>(gobject_.data[0].v_pointer) = data;
 238 }
 239
 240 template <class T> inline
 241 typename Value<T>::CppType Value<T>::get() const
 242 {
 243   // Assume the pointer is not NULL.  See value_init_func().
 244   return *static_cast<T*>(gobject_.data[0].v_pointer);
 245 }
 246
 247 // static
 248 template <class T>
 249 GType Value<T>::value_type()
 250 {
 251   if(!custom_type_)
 252   {
 253     custom_type_ = Glib::custom_boxed_type_register(
 254         typeid(CppType).name(),
 255         &Value<T>::value_init_func,
 256         &Value<T>::value_free_func,
 257         &Value<T>::value_copy_func);
 258   }
 259   return custom_type_;
 260 }
 261
 262 // static
 263 template <class T>
 264 void Value<T>::value_init_func(GValue* value)
 265 {
 266   // Never store a NULL pointer (unless we're out of memory).
 267   value->data[0].v_pointer = new(std::nothrow) T();
 268 }
 269
 270 // static
 271 template <class T>
 272 void Value<T>::value_free_func(GValue* value)
 273 {
 274   delete static_cast<T*>(value->data[0].v_pointer);
 275 }
 276
 277 // static
 278 template <class T>
 279 void Value<T>::value_copy_func(const GValue* src_value, GValue* dest_value)
 280 {
 281   // Assume the source is not NULL.  See value_init_func().
 282   const T& source = *static_cast<T*>(src_value->data[0].v_pointer);
 283   dest_value->data[0].v_pointer = new(std::nothrow) T(source);
 284 }
 285
 286 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 287
 288 } // namespace Glib
 289