Enum.hpp

#ifndef Rice__Enum__hpp_
#define Rice__Enum__hpp_
 
#include "to_from_ruby_defn.hpp"
#include "Address_Registration_Guard.hpp"
#include "Array.hpp"
#include "Hash.hpp"
#include "String.hpp"
#include "Module.hpp"
#include "Data_Type.hpp"
 
namespace Rice
{
 
template<typename Enum_T>
struct Default_Enum_Traits
{
  static long as_long(Enum_T value);
};
 
 
template<typename Enum_T, typename Enum_Traits = Default_Enum_Traits<Enum_T> >
class Enum
  : public Module_impl<Data_Type<Enum_T>, Enum<Enum_T, Enum_Traits> >
{
public:
  Enum();
 
  Enum(
      char const * name,
      Module module = rb_cObject);
 
  Enum(Enum const & other);
 
  Enum & operator=(Enum const & other);
 
  virtual ~Enum();
 
 
  Enum<Enum_T, Enum_Traits> & define_value(
      char const * name,
      Enum_T value);
 
  void swap(Enum & other);
 
private:
 
  Enum<Enum_T, Enum_Traits> & initialize(
      char const * name,
      Module module = rb_cObject);
 
private:
  static Object each(Object self);
  static Object to_s(Object self);
  static Object to_i(Object self);
  static Object inspect(Object self);
  static Object compare(Object lhs, Object rhs);
  static Object eql(Object lhs, Object rhs);
  static Object hash(Object self);
  static Object from_int(Class klass, Object i);
 
private:
  Array enums_;
  Address_Registration_Guard enums_guard_;
 
  Hash names_;
  Address_Registration_Guard names_guard_;
};
 
template<typename T>
Enum<T> define_enum(
    char const * name,
    Module module = rb_cObject);
 
} // namespace Rice
 
#include "Enum.ipp"
 
#endif // Rice__Enum__hpp_