Data_Type_defn.hpp

#ifndef Rice__Data_Type_defn__hpp_
#define Rice__Data_Type_defn__hpp_
 
#include "Class_defn.hpp"
#include "Data_Type_fwd.hpp"
#include "detail/ruby.hpp"
#include <memory>
#include <map>
#include <set>
 
namespace Rice
{
 
namespace detail
{
  class Abstract_Caster;
}
 
class Module;
 
class Data_Type_Base
  : public Module_impl<Class, Data_Type_Base>
{
public:
  Data_Type_Base();
 
  Data_Type_Base(VALUE v);
 
  virtual ~Data_Type_Base() = 0;
 
  // Must be public to workaround gcc 3.3
  typedef std::map<VALUE, detail::Abstract_Caster *> Casters;
 
  virtual detail::Abstract_Caster * caster() const = 0;
 
  static Casters & casters();
 
private:
  static Casters * casters_;
};
 
 
template<typename T>
Rice::Data_Type<T> define_class_under(
    Object module,
    char const * name);
 
 
template<typename T, typename Base_T>
Rice::Data_Type<T> define_class_under(
    Object module,
    char const * name);
 
 
template<typename T>
Rice::Data_Type<T> define_class(
    char const * name);
 
 
template<typename T, typename Base_T>
Rice::Data_Type<T> define_class(
    char const * name);
 
 
template<typename From_T, typename To_T>
void define_implicit_cast();
 
 
template<typename T>
class Data_Type
  : public Module_impl<Data_Type_Base, Data_Type<T> >
{
public:
  typedef T Type;
 
 
  Data_Type();
 
 
  Data_Type(Module const & v);
 
  virtual ~Data_Type();
 
 
  static Module klass();
 
 
  virtual Data_Type & operator=(Module const & klass);
 
 
  template<typename Constructor_T>
  Data_Type<T> & define_constructor(
      Constructor_T constructor,
      Arguments * arguments = 0);
 
  template<typename Constructor_T>
  Data_Type<T> & define_constructor(
      Constructor_T constructor,
      Arg const& arg);
 
 
  template<typename Director_T>
  Data_Type<T>& define_director();
 
 
  static T * from_ruby(Object x);
 
 
  static bool is_bound();
 
  virtual detail::Abstract_Caster * caster() const;
 
  static std_unique_ptr<detail::Abstract_Caster> caster_;
 
protected:
 
  template<typename Base_T>
  static Data_Type bind(Module const & klass);
 
  template<typename T_>
  friend Rice::Data_Type<T_> define_class_under(
      Object module,
      char const * name);
 
  template<typename T_, typename Base_T_>
  friend Rice::Data_Type<T_> define_class_under(
      Object module,
      char const * name);
 
  template<typename T_>
  friend Rice::Data_Type<T_> Rice::define_class(
      char const * name);
 
  template<typename T_, typename Base_T_>
  friend Rice::Data_Type<T_> define_class(
      char const * name);
 
private:
  template<typename T_>
  friend class Data_Type;
 
  static void check_is_bound();
 
  static VALUE klass_;
 
  typedef std::set<Data_Type<T> *> Instances;
 
  static Instances & unbound_instances()
  {
    static Instances unbound_instances;
    return unbound_instances;
  }
};
 
 
} // namespace Rice
 
#include "Data_Type.ipp"
 
#endif // Rice__Data_Type_defn__hpp_