include “detail/define_method_and_auto_wrap.hpp” include “Object.hpp” include “Address_Registration_Guard.hpp” include “Data_Object.hpp” include “Data_Type.hpp” include “Symbol.hpp” include “protect.hpp”
include “Module.hpp” include “Class.hpp” include “Data_Type.hpp”
include “detail/ruby.hpp” include “detail/method_data.hpp” include “detail/Iterator.hpp”
inline
- Rice::Module_base
-
Module_base(VALUE v)
: Object(v) , handler_(Qnil) , handler_guard_(&handler_)
{ }
inline
- Rice::Module_base
-
Module_base(Module_base const & other)
: Object(other) , handler_(other.handler_) , handler_guard_(&handler_)
{ }
inline Rice::Module_base &
- Rice::Module_base
-
operator=(Module_base const & other) {
Module_base tmp(other); swap(tmp); return *this;
}
inline void
- Rice::Module_base
-
swap(Module_base & other) {
std::swap(handler_, other.handler_); Object::swap(other);
}
template<typename Exception_T, typename Functor_T> inline void
- Rice::Module_base
-
add_handler(Functor_T functor) {
Data_Object<detail::Exception_Handler> handler( new detail:: Functor_Exception_Handler<Exception_T, Functor_T>( functor, this->handler()), rb_cObject); this->handler_.swap(handler);
}
inline Rice::Object
- Rice::Module_base
-
handler() const {
if(!handler_.test()) { Data_Object<Rice::detail::Default_Exception_Handler> handler( new Rice::detail::Default_Exception_Handler, rb_cObject); handler_.swap(handler); } return handler_;
}
template<typename Base_T, typename Derived_T> inline
- Rice::Module_impl<Base_T, Derived_T>
-
Module_impl()
: Base_T()
{ }
template<typename Base_T, typename Derived_T> template<typename T> inline
- Rice::Module_impl<Base_T, Derived_T>
-
Module_impl(T const & arg)
: Base_T(arg)
{ }
template<typename Base_T, typename Derived_T> template<typename Exception_T, typename Functor_T> inline Derived_T &
- Rice::Module_impl<Base_T, Derived_T>
-
add_handler(
Functor_T functor)
{
Module_base::add_handler<Exception_T>(functor); return (Derived_T &)*this;
}
template<typename Base_T, typename Derived_T> template<typename Func_T> inline Derived_T &
- Rice::Module_impl<Base_T, Derived_T>
-
define_method(
Identifier name, Func_T func, Arguments* arguments)
{
detail::define_method_and_auto_wrap( *this, name, func, this->handler(), arguments); return (Derived_T &)*this;
}
template<typename Base_T, typename Derived_T> template<typename Func_T> inline Derived_T &
- Rice::Module_impl<Base_T, Derived_T>
-
define_method(
Identifier name, Func_T func, Arg const& arg)
{
Arguments* args = new Arguments(); args->add(arg); return define_method(name, func, args);
}
template<typename Base_T, typename Derived_T> template<typename Func_T> inline Derived_T &
- Rice::Module_impl<Base_T, Derived_T>
-
define_singleton_method(
Identifier name, Func_T func, Arguments* arguments)
{
detail::define_method_and_auto_wrap( rb_singleton_class(*this), name, func, this->handler(), arguments); return (Derived_T &)*this;
}
template<typename Base_T, typename Derived_T> template<typename Func_T> inline Derived_T &
- Rice::Module_impl<Base_T, Derived_T>
-
define_singleton_method(
Identifier name, Func_T func, Arg const& arg)
{
Arguments* args = new Arguments(); args->add(arg); return define_singleton_method(name, func, args);
}
template<typename Base_T, typename Derived_T> template<typename Func_T> inline Derived_T &
- Rice::Module_impl<Base_T, Derived_T>
-
define_module_function(
Identifier name, Func_T func, Arguments* arguments)
{
if(this->rb_type() != T_MODULE) { throw std::runtime_error("can only define module functions for modules"); } define_method(name, func, arguments); define_singleton_method(name, func, arguments); return (Derived_T &)*this;
}
template<typename Base_T, typename Derived_T> template<typename Func_T> inline Derived_T &
- Rice::Module_impl<Base_T, Derived_T>
-
define_module_function(
Identifier name, Func_T func, Arg const& arg)
{
Arguments* args = new Arguments(); args->add(arg); return define_module_function(name, func, args);
}
template<typename Base_T, typename Derived_T> template<typename T, typename Iterator_T> inline Derived_T &
- Rice::Module_impl<Base_T, Derived_T>
-
define_iterator(
Iterator_T (T::*begin)(), Iterator_T (T::*end)(), Identifier name)
{
detail::define_iterator(*this, name, begin, end); return (Derived_T &)*this;
}
namespace Rice {
namespace detail {
inline VALUE
include_module(VALUE mod, VALUE inc)
{
rb_include_module(mod, inc); return Qnil;
}
inline VALUE const_set(VALUE mod, ID name, VALUE value) {
rb_const_set(mod, name, value); return Qnil;
}
} // namespace detail
} // namespace Rice
template<typename Base_T, typename Derived_T> inline Derived_T &
- Rice::Module_impl<Base_T, Derived_T>
-
include_module(
Module const & inc)
{
protect(detail::include_module, *this, inc); return (Derived_T &)*this;
}
template<typename Base_T, typename Derived_T> inline Derived_T &
- Rice::Module_impl<Base_T, Derived_T>
-
const_set(
Identifier name, Object value)
{
protect(detail::const_set, *this, name, value); return (Derived_T &)*this;
}
template<typename Base_T, typename Derived_T> inline Rice::Object
- Rice::Module_impl<Base_T, Derived_T>
-
const_get(
Identifier name) const
{
return protect(rb_const_get, *this, name);
}
template<typename Base_T, typename Derived_T> inline bool
- Rice::Module_impl<Base_T, Derived_T>
-
const_defined(Identifier name) const {
int result = protect(rb_const_defined, *this, name); return bool(result);
}
template<typename Base_T, typename Derived_T> inline void
- Rice::Module_impl<Base_T, Derived_T>
-
remove_const(Identifier name) {
protect(rb_mod_remove_const, *this, name.to_sym());
}
template<typename Base_T, typename Derived_T> inline Rice::Module
- Rice::Module_impl<Base_T, Derived_T>
-
define_module(
char const * name)
{
return Rice::define_module_under(*this, name);
}
template<typename Base_T, typename Derived_T> inline Rice::Class
- Rice::Module_impl<Base_T, Derived_T>
-
define_class(
char const * name, Object superclass)
{
return Rice::define_class_under(*this, name, superclass);
}
template<typename Base_T, typename Derived_T> template<typename T> inline Rice::Data_Type<T>
- Rice::Module_impl<Base_T, Derived_T>
-
define_class_with_object_as_base(
char const * name)
{
return Rice::define_class_under<T>(*this, name);
}
template<typename Base_T, typename Derived_T> template<typename T, typename T_Base_T> inline Rice::Data_Type<T>
- Rice::Module_impl<Base_T, Derived_T>
-
define_class(
char const * name)
{
return Rice::define_class_under<T, T_Base_T>( *this, name);
}