Object_defn.hpp

#ifndef Rice__Object_defn__hpp_
#define Rice__Object_defn__hpp_
 
#include "Identifier.hpp"
#include "detail/ruby.hpp"
 
#include <iosfwd>
#include <vector>
 
namespace Rice
{
 
class Class;
class String;
class Array;
 
 
class Object
{
public:
  Object(VALUE value = Qnil) : value_(value) { }
 
  Object(Object const & other) : value_(other.value()) { }
 
  virtual ~Object() { }
 
  // Having this conversion also prevents accidental conversion to
  // undesired integral types (e.g. long or int) by making the
  // conversion ambiguous.
  bool test() const { return RTEST(value_); }
 
  operator bool() const { return test(); }
 
  bool is_nil() const { return NIL_P(value_); }
 
  operator VALUE() const { return value_; }
 
  // Returns a const ref so that Address_Registration_Guard can access
  // the address where the VALUE is stored
  VALUE const volatile & value() const { return value_; }
 
 
  Class class_of() const;
 
 
  int compare(Object const & other) const;
 
 
  String to_s() const;
 
 
  String inspect() const;
 
  void freeze();
 
 
  bool is_frozen() const;
 
  void swap(Object & other);
 
 
  Object instance_eval(String const & s);
 
 
  int rb_type() const;
 
 
  bool is_a(Object klass) const;
 
 
  bool respond_to(Identifier id) const;
 
 
  bool is_instance_of(Object klass) const;
 
 
  template<typename T>
  void iv_set(
      Identifier name,
      T const & value);
 
 
  Object iv_get(
      Identifier name) const;
 
  //unset.
  Object attr_get(
      Identifier name) const;
 
 
  template<typename ...ArgT>
  Object call(Identifier id, ArgT... args) const;
 
 
  Object vcall(Identifier id, Array args);
 
  void mark() const;
 
protected:
  void set_value(VALUE v);
 
  template<typename ...ArgT>
  std::vector<VALUE> convert_args(ArgT&... args) const;
 
private:
  volatile VALUE value_;
};
 
std::ostream & operator<<(std::ostream & out, Object const & obj);
 
bool operator==(Object const & lhs, Object const & rhs);
bool operator!=(Object const & lhs, Object const & rhs);
bool operator<(Object const & lhs, Object const & rhs);
bool operator>(Object const & lhs, Object const & rhs);
 
extern Object const Nil;
extern Object const True;
extern Object const False;
extern Object const Undef;
 
} // namespace Rice
 
#endif // Rice__Object_defn__hpp_