Module_impl.hpp

#ifndef Rice__Module_impl__hpp_
#define Rice__Module_impl__hpp_
 
#include "detail/Exception_Handler_defn.hpp"
#include "detail/ruby.hpp"
#include "Object_defn.hpp"
#include "Address_Registration_Guard_defn.hpp"
#include "Arg.hpp"
 
namespace Rice
{
 
class Module;
class Class;
template<typename T> class Data_Type;
 
class Module_base
  : public Object
{
public:
  Module_base(VALUE v = rb_cObject);
  Module_base(Module_base const & other);
 
  Module_base & operator=(Module_base const & other);
 
  void swap(Module_base & other);
 
protected:
  template<typename Exception_T, typename Functor_T>
  void add_handler(Functor_T functor);
 
  Object handler() const;
 
private:
  Object mutable handler_;
  Address_Registration_Guard handler_guard_;
};
 
template<typename Base_T, typename Derived_T>
class Module_impl
  : public Base_T
{
public:
  Module_impl();
 
  template<typename T>
  Module_impl(T const & arg);
 
 
  template<typename Exception_T, typename Functor_T>
  Derived_T & add_handler(
      Functor_T functor);
 
 
  template<typename Func_T>
  Derived_T & define_method(
      Identifier name,
      Func_T func,
      Arguments* arguments = 0);
 
  // FIXME There's GOT to be a better way to
  // do this. Handles the case where there is a single
  // argument defined for this method
  template<typename Func_T>
  Derived_T & define_method(
      Identifier name,
      Func_T func,
      Arg const& arg);
 
 
  template<typename Func_T>
  Derived_T & define_singleton_method(
      Identifier name,
      Func_T func,
      Arguments* arguments = 0);
 
  // FIXME: See define_method with Arg above
  template<typename Func_T>
  Derived_T & define_singleton_method(
      Identifier name,
      Func_T func,
      Arg const& arg);
 
 
  template<typename Func_T>
  Derived_T & define_module_function(
      Identifier name,
      Func_T func,
      Arguments* arguments = 0);
 
  // FIXME: See define_method with Arg above
  template<typename Func_T>
  Derived_T & define_module_function(
      Identifier name,
      Func_T func,
      Arg const& arg);
 
 
  template<typename T, typename Iterator_T>
  Derived_T & define_iterator(
      Iterator_T (T::*begin)(),
      Iterator_T (T::*end)(),
      Identifier name = "each");
 
 
  Derived_T & include_module(
      Module const & inc);
 
 
  Derived_T & const_set(
      Identifier name,
      Object value);
 
 
  Object const_get(
      Identifier name) const;
 
 
  bool const_defined(
      Identifier name) const;
 
 
  void remove_const(
      Identifier name);
 
 
  Module define_module(
      char const * name);
 
 
  Class define_class(
      char const * name,
      Object superclass = rb_cObject);
 
 
  // This function needs to be defined inline to work around a bug in
  // g++ 3.3.3.
  template<typename T>
  Data_Type<T>
  define_class(
      char const * name)
  {
    return this->define_class_with_object_as_base<T>(name);
  }
 
 
  template<typename T, typename T_Base_T>
  Data_Type<T>
  define_class(
      char const * name);
 
private:
  // Workaround for g++ 3.3.3 (see above).
  template<typename T>
  Data_Type<T>
  define_class_with_object_as_base(
      char const * name);
};
 
} // namespace Rice
 
#endif // Rice__Module_impl__hpp_