ifndef Rice__Module_defn__hpp_ define Rice__Module_defn__hpp_
include “Object_defn.hpp” include “Module_impl.hpp” include “to_from_ruby_defn.hpp” include <memory>
namespace Rice {
class Array; class Class; class String;
//! A helper for defining a Module and its methods.
! This class provides a C++-style interface to ruby's Module class and for defining methods on that module. Many of the methods are defined in Module_impl.hpp so that they can return a reference to the most derived type.
class Module
// TODO: we can't inherit from Builtin_Object, because Class needs // type T_CLASS and Module needs type T_MODULE : public Module_impl<Module_base, Module>
{ public:
//! Default construct a Module and initialize it to rb_cObject. Module(); //! Construct a Module from an existing Module object. Module(VALUE v); //! Return the name of the module. String name() const; //! Swap with another Module. void swap(Module & other); //! Return an array containing the Module's ancestors. /*! You will need to include Array.hpp to use this function. / Array ancestors() const; //! Return the module's singleton class. /*! You will need to include Class.hpp to use this function. / Class singleton_class() const;
};
//! Define a new module in the namespace given by module. /*! param module the module in which to define the new module.
\param name the name of the new module. /
Module define_module_under(
Object module, char const * name);
//! Define a new module in the default namespace. /*! param name the name of the new module.
/
Module define_module(
char const * name);
//! Create a new anonymous module. /*! return the new module.
/
Module anonymous_module();
} // namespace Rice
template<> inline Rice::Module from_ruby<Rice::Module>(Rice::Object x) {
return Rice::Module(x);
}
template<> inline Rice::Object to_ruby<Rice::Module>(Rice::Module const & x) {
return x;
}
endif // Rice__Module_defn__hpp_