machine/object_utils.hpp

   1 #ifndef RBX_VM_OBJECT_UTILS_HPP
   2 #define RBX_VM_OBJECT_UTILS_HPP
   3
   4 #include "class/object.hpp"
   5 #include "exception.hpp"
   6
   7 /**
   8  *  @file   object_utils.hpp
   9  *
  10  *  Defines all the most common operations for dealing with
  11  *  objects, such as type checking and casting.
  12  */
  13
  14 #define SPECIALIZATION_STORAGE
  15
  16 namespace rubinius {
  17
  18   /**
  19    *  Ruby type system subtype check.
  20    *
  21    *  Given builtin-class +T+, return true if +obj+ is of class +T+
  22    */
  23   template <class T>
  24     static bool kind_of(const MemoryHeader* obj) {
  25       if(obj->reference_p()) {
  26         return obj->type_id() == T::type;
  27       }
  28       return false;
  29     }
  30
  31   template <class T>
  32     static bool kind_of(const Object* obj) {
  33       if(obj->reference_p()) {
  34         return obj->type_id() == T::type;
  35       }
  36       return false;
  37     }
  38
  39   /**
  40    * A specialized version for completeness.
  41    */
  42   template <>
  43     bool kind_of<Object>(const Object* obj) {
  44       return true;
  45     }
  46
  47   /**
  48    *  Ruby type system class check.
  49    *
  50    *  Another version of kind_of that shouldn't be specialized for subtype
  51    *  compatibility. I.e., only whether object's class is this specific
  52    *  one.
  53    */
  54   template <class T>
  55     static bool instance_of(const Object* obj) {
  56       if(obj->reference_p()) {
  57         return obj->type_id() == T::type;
  58       }
  59       return false;
  60     }
  61
  62   /**
  63    * A specialized version for completeness.
  64    */
  65   template <>
  66     bool instance_of<Object>(const Object* obj) {
  67       return obj->reference_p() && (obj->type_id() == ObjectType);
  68     }
  69
  70   /*
  71    *  There is NO reason why as() or try_as() should be getting
  72    *  NULL arguments. That means something has not been properly
  73    *  initialised (to cNil if nothing else.)
  74    */
  75
  76   /**
  77    *  Cast Object* into builtin T*.
  78    *
  79    *  Given builtin class +T+, return +obj+ cast as type +T*+. If
  80    *  +obj+ is not of type +T+, throw's a TypeError exception.
  81    *
  82    *  @see  builtin/object.cpp has specialised versions.
  83    */
  84   template <class T>
  85     static T* as(Object* obj) {
  86       if(!kind_of<T>(obj)) {
  87         TypeError::raise(T::type, obj);
  88       }
  89
  90       return static_cast<T*>(obj);
  91     }
  92
  93   /**
  94    *  Cast const Object* into builtin const T*.
  95    *
  96    *  Given builtin class +T+, return +obj+ cast as type +T*+. If
  97    *  +obj+ is not of type +T+, throw's a TypeError exception.
  98    *
  99    *  @see  builtin/object.cpp has specialised versions.
 100    */
 101   template <class T>
 102     static const T* as(const Object* obj) {
 103       if(!kind_of<T>(obj)) {
 104         TypeError::raise(T::type, obj);
 105       }
 106
 107       return static_cast<const T*>(obj);
 108     }
 109
 110   /**
 111    * A specialized version for completeness.
 112    */
 113   template <>
 114     Object* as<Object>(Object* obj) {
 115       return obj;
 116     }
 117
 118   /**
 119    * A specialized version for completeness.
 120    */
 121   template <>
 122     const Object* as<Object>(const Object* obj) {
 123       return obj;
 124     }
 125
 126   /**
 127    *  Cast Object* into builtin T*.
 128    *
 129    *  Given builtin class +T+, return +obj+ cast as type +T*+. If
 130    *  +obj+ is not exactly of type +T+, throw's a TypeError exception.
 131    *
 132    *  @see  builtin/object.cpp has specialised versions.
 133    */
 134   template <class T>
 135     static T* as_instance(Object* obj) {
 136       if(!instance_of<T>(obj)) {
 137         TypeError::raise(T::type, obj);
 138       }
 139
 140       return static_cast<T*>(obj);
 141     }
 142
 143   /**
 144    *  Cast const Object* into builtin const T*.
 145    *
 146    *  Given builtin class +T+, return +obj+ cast as type +T*+. If
 147    *  +obj+ is not exactly of type +T+, throw's a TypeError exception.
 148    *
 149    *  @see  builtin/object.cpp has specialised versions.
 150    */
 151   template <class T>
 152     static const T* as_instance(const Object* obj) {
 153       if(!instance_of<T>(obj)) {
 154         TypeError::raise(T::type, obj);
 155       }
 156
 157       return static_cast<const T*>(obj);
 158     }
 159
 160   /**
 161    *  Non-raising version of as().
 162    *
 163    *  Similar to as<>, but returns NULL if the type is invalid. ONLY
 164    *  use this when doing a conditional cast.
 165    *
 166    *  @see  builtin/object.cpp has specialised versions.
 167    */
 168   template <class T>
 169     static T* try_as(MemoryHeader* obj) {
 170       if(!kind_of<T>(obj)) {
 171         return nullptr;
 172       }
 173
 174       return static_cast<T*>(obj);
 175     }
 176
 177   template <class T>
 178     static T* try_as(Object* obj) {
 179       if(!kind_of<T>(obj)) {
 180         return NULL;
 181       }
 182
 183       return static_cast<T*>(obj);
 184     }
 185
 186   /**
 187    *  Non-raising version of as(), for const objects.
 188    *
 189    *  Similar to as<>, but returns NULL if the type is invalid. ONLY
 190    *  use this when doing a conditional cast.
 191    *
 192    *  @see  builtin/object.cpp has specialised versions.
 193    */
 194   template <class T>
 195     static const T* try_as(const MemoryHeader* obj) {
 196       if(!kind_of<T>(obj)) {
 197         return nullptr;
 198       }
 199
 200       return static_cast<const T*>(obj);
 201     }
 202
 203   template <class T>
 204     static const T* try_as(const Object* obj) {
 205       if(!kind_of<T>(obj)) {
 206         return NULL;
 207       }
 208
 209       return static_cast<const T*>(obj);
 210     }
 211
 212   /**
 213    *  Non-raising version of as_instance().
 214    *
 215    *  Similar to as_instance<>, but returns NULL if the type is invalid. ONLY
 216    *  use this when doing a conditional cast.
 217    *
 218    *  @see  builtin/object.cpp has specialised versions.
 219    */
 220   template <class T>
 221     static T* try_as_instance(Object* obj) {
 222       if(!instance_of<T>(obj)) {
 223         return NULL;
 224       }
 225
 226       return static_cast<T*>(obj);
 227     }
 228
 229   /**
 230    *  Non-raising version of as(), for const objects.
 231    *
 232    *  Similar to as<>, but returns NULL if the type is invalid. ONLY
 233    *  use this when doing a conditional cast.
 234    *
 235    *  @see  builtin/object.cpp has specialised versions.
 236    */
 237   template <class T>
 238     static const T* try_as_instance(const Object* obj) {
 239       if(!instance_of<T>(obj)) {
 240         return NULL;
 241       }
 242
 243       return static_cast<const T*>(obj);
 244     }
 245
 246   /**
 247    *  Returns cNil cast to another type of rubinius::Object. Useful in
 248    *  cases where e.g. a String* would be returned but cNil is returned
 249    *  as an exceptional value.
 250    *
 251    */
 252   template <class T>
 253     static T* nil() { return static_cast<T*>(cNil); }
 254
 255   /**
 256    *  Converts one type into another without a type check. This is
 257    *  like reinterprete_cast<>(), but we use it so we can easily
 258    *  find where we're doing explicit force casts.
 259    */
 260   template <class T>
 261     static T* force_as(ObjectHeader* obj) {
 262       return reinterpret_cast<T*>(obj);
 263     }
 264
 265   template <class T>
 266     static const T* force_as(const ObjectHeader* obj) {
 267       return reinterpret_cast<const T*>(obj);
 268     }
 269
 270   void type_assert(STATE, Object* obj, object_type type, const char* reason);
 271
 272 #include "kind_of.hpp"
 273
 274 }
 275
 276 #endif