ruby_type.hpp

#ifndef Exc_Ruby__ruby_value__hpp_
#define Exc_Ruby__ruby_value__hpp_

#include "ruby_reference.hpp"
#include "value_holder.hpp"
#include <ruby.h>
#undef TYPE

namespace Exc_Ruby
{

struct Ruby_Type_Wrapper
{
  typedef void (*Ruby_Data_Func)(RClass * obj);

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

  static RClass * unwrap(VALUE value);

private:
  Ruby_Type_Wrapper();
};

class Module;

// ---------------------------------------------------------------------
template<typename T>
class Ruby_Type
  : public Ruby_Reference<RClass, Ruby_Type_Wrapper>
{
public:
  Ruby_Type();
 
  explicit Ruby_Type(VALUE type);
 
  // explicit Ruby_Type(Module & module);

  operator VALUE() const { return value_; }

  operator Value_Holder() const { return value_; }

  VALUE type() const { return value_; }

  bool is_bound() const { return is_bound_; }

  virtual Ruby_Type & bind(VALUE type);

  virtual Ruby_Type & operator=(VALUE type);

  typedef T CPP_Type;

private:
  bool is_bound_;
};

} // namespace Exc_Ruby

#include "ruby_type.ipp"

#endif // Exc_Ruby__ruby_value__hpp_

---