ruby_reference.hpp

Go to the documentation of this file.

#ifndef Exc_Ruby__ruby_reference__hpp_
#define Exc_Ruby__ruby_reference__hpp_

#include "value_holder.hpp"

namespace Exc_Ruby
{

#include <ruby.h>
#undef TYPE

// ---------------------------------------------------------------------
// These are not determined at compile-time, since only some of the
// Ruby_Reference constructors needs them.
template<typename T>
struct Ruby_Delete_Strategy
{
  static void ruby_delete(T * obj);

  static void ruby_delete_bracket(T * obj);

  static void ruby_delete_xfree(T * obj);

private:
  Ruby_Delete_Strategy();
};

// ---------------------------------------------------------------------
template<typename T>
struct Fast_Ruby_Data_Wrapper
{
  typedef void (*Ruby_Data_Func)(T * obj);

  static VALUE wrap(
      VALUE klass,
      Ruby_Data_Func mark,
      Ruby_Data_Func free,
      T * obj);

  static T * unwrap(VALUE value);

private:
  Fast_Ruby_Data_Wrapper();
};

// ---------------------------------------------------------------------
template<typename T>
struct Exception_Safe_Ruby_Data_Wrapper
{
  typedef void (*Ruby_Data_Func)(T * obj);

  static VALUE wrap(
      VALUE klass,
      Ruby_Data_Func mark,
      Ruby_Data_Func free,
      T * obj);

  static T * unwrap(VALUE value);

private:
  Exception_Safe_Ruby_Data_Wrapper();
};

// ---------------------------------------------------------------------
//
// Note that mark and free are ignored for builtin types.
//
template<typename T, int Ruby_Type>
struct Fast_Builtin_Wrapper
{
  typedef void (*Ruby_Data_Func)(T * obj);

  static VALUE wrap(
      VALUE klass,
      Ruby_Data_Func mark,
      Ruby_Data_Func free,
      T * obj);

  static T * unwrap(VALUE value);

private:
  Fast_Builtin_Wrapper();
};

// ---------------------------------------------------------------------
//
// Note that mark and free are ignored for builtin types.
//
template<typename T, int Ruby_Type>
struct Exception_Safe_Builtin_Wrapper
{
  typedef void (*Ruby_Data_Func)(T * obj);

  static VALUE wrap(
      VALUE klass,
      Ruby_Data_Func mark,
      Ruby_Data_Func free,
      T * obj);

  static T * unwrap(VALUE value);

private:
  Exception_Safe_Builtin_Wrapper();
};

template<typename T> class Ruby_Type;

// ---------------------------------------------------------------------

// TODO: Add a third template parameter so the user can specify whether
// he wants to mark register this object's address with the GC; if he
// does that, it's safe to put a Ruby_Reference on the heap.
template<
  typename T,
  class Data_Wrapper = Exception_Safe_Ruby_Data_Wrapper<T> >
struct Ruby_Reference
{
public:
  typedef void (*Ruby_Data_Func)(T * obj);

  //
  // Note that mark_func and free_func are ignored for builtin types.
  //
  Ruby_Reference(
      T * obj,
      VALUE klass,
      Ruby_Data_Func mark_func = 0,
      Ruby_Data_Func free_func = Ruby_Delete_Strategy<T>::ruby_delete);

  template<typename U>
  Ruby_Reference(Value_Holder value, Ruby_Type<U> const & klass, bool include_super=false);

  Ruby_Reference(Value_Holder value, VALUE klass, bool include_super=false);

  Ruby_Reference(Value_Holder value);

  Ruby_Reference(Ruby_Reference const & other);

  virtual ~Ruby_Reference();

  T & operator*() const { return *obj_; } 
  T * operator->() const { return obj_; } 
  T * get() const { return obj_; }        
  VALUE value() const { return value_; }  

private:
  static void check_cpp_type(Ruby_Type<T> const & klass);

protected:
  T * obj_;

  volatile VALUE value_;
};

// ---------------------------------------------------------------------
#define REGISTER_WITH_RUBY_GC(type, ptr) \
  Ruby_Reference<type, Fast_Ruby_Data_Wrapper<type> > ( \
      ptr, rb_cObject).get()

// ---------------------------------------------------------------------
#define REGISTER_WITH_RUBY_GC_AS_GLOBAL(type, ptr, v) \
  *v = Ruby_Reference<type, Fast_Ruby_Data_Wrapper<type> > ( \
      ptr, rb_cObject).value(); \
  rb_global_variable(v);

} // namespace Exc_Ruby

#include "ruby_reference.ipp"

#endif // Exc_Ruby__ruby_reference__hpp_

---