ruby_class.hpp

#ifndef Exc_Ruby__ruby_class__hpp_
#define Exc_Ruby__ruby_class__hpp_

#include "../detail/Iterator_Definer.hpp"
#include "ruby_module.hpp"

namespace Exc_Ruby
{

class Class
  : public Module
  // TODO: Can't do this without making define_iterator ambiguous
  // , public detail::Iterator_Definer<Class>
{
public:
  explicit Class(VALUE v);

  // TODO: Move this to creation_funcs.hpp
  // (there is no need for the default allocation func to be a template
  // function, and it's not portably useful if it is one).
  static VALUE default_allocation_func(VALUE klass)
  {
    return Exc_Ruby::default_allocation_func<int>(klass);
  }

  template<typename Constructor_T>
  Class & define_constructor(
      Constructor_T constructor);

  // define the methods used to allocate and initialize an instance
  template<typename Initialize_Func_T>
  Class & define_creation_funcs(
      RUBY_VALUE_FUNC allocate_func,
      Initialize_Func_T initialize_func);

  // disallow creation of an instance from Ruby code
  Class & undef_creation_funcs();

  // define an exception handler to be used with every method in this
  // class defined hereafter
  template<typename Exception_T, typename Functor_T>
  Class & add_handler(
      Functor_T functor);

  // define an instance method called name and implemented by function
  // func
  template<typename Func_T>
  Class & define_method(
      char const * name,
      Func_T func);

  // define an singleton method called name and implemented by function
  // func
  template<typename Func_T>
  Class & define_singleton_method(
      char const * name,
      Func_T func);

  // define a module function called name and implemented by function
  // func
  template<typename Func_T>
  Class & define_module_function(
      char const * name,
      Func_T func);
};

Class define_class_under(
    Value_Holder module,
    char const * name,
    Value_Holder superclass = rb_cObject);

Class define_class(
    char const * name,
    Value_Holder superclass = rb_cObject);

} // namespace Exc_Ruby

#include "ruby_class.ipp"

#endif // Exc_Ruby__ruby_class__hpp_

---