ifndef Rice__Object_defn__hpp_ define Rice__Object_defn__hpp_

! \file Object.hpp

include “Identifier.hpp” include “detail/ruby.hpp”

include <iosfwd>

namespace Rice {

class Class; class String; class Array;

//! The base class for all Objects /*! Perhaps the name “Object” is a misnomer, because this class really

  holds an object reference, not an object.
/

class Object { public:

//! Encapsulate an existing ruby object.
Object(VALUE value = Qnil) : value_(value) { }

//! Copy constructor
Object(Object const & other) : value_(other.value()) { }

//! Destructor
virtual ~Object() { }

//! Returns false if the object is nil or false; returns true
//! otherwise.
// 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_); }

//! Returns false if the object is nil or false; returns true
//! otherwise.
operator bool() const { return test(); }

//! Returns true if the object is nil, false otherwise.
bool is_nil() const { return NIL_P(value_); }

//! Implicit conversion to VALUE.
operator VALUE() const { return value_; }

//! Explicitly get the encapsulated 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_; }

//! Get the class of an object.
/*! \return the object's Class.
  /
Class class_of() const;

//! Compare this object to another object.
/*! Gets the result of self <=> other and returns the result.  The
    result will be less than zero if self < other, greater than zero
    if self > other, and equal to zero if self == other.
  /
int compare(Object const & other) const;

//! Return a string representation of an object.
/*! \return the result of calling to_s on the object.  A String is not
    returned, because it is not possible to return an instance of a
    derived class.
  /
String to_s() const;

//! Inspect the object.
/*! \return the result of calling inspect on the object.  A String is
    not returned, because it is not possible to return an instance of
    a derived class.
  /
String inspect() const;

//! Freeze the object.
void freeze();

//! Determine if the object is frozen.
/*! \return true if the object is frozen, false otherwise.
  /
bool is_frozen() const;

//! Swap with another Object.
void swap(Object & other);

//! Evaluate the given string in the context of the object.
/*! This is equivalant to calling obj.instance_eval(s) from inside the
    interpreter.
    \return the result of the expression.
  /
Object instance_eval(String const & s);

//! Return the type of the underlying C object.
/*! This is equivalent to calling rb_type(obj).
   \return the type of the underlying C object (e.g. T_DATA, T_ARRAY,
   etc.).
  /
int rb_type() const;

//! Determine whether the object is an instance of a class/module.
/*! \param klass a class or module.
    \return true if the object is an instance of the given
    class/module or one of its descendants.
  /
bool is_a(Object klass) const;

//! Determine if the objects responds to a method.
/*! \param id the name of the method
    \return true if the objects responds to the method, false
    otherwise.
  /
bool respond_to(Identifier id) const;

//! Determine whether class is the object's class.
/*! \param klass a class.
    \return true if the object is an instance of the given class.
  /
bool is_instance_of(Object klass) const;

//! Set an instance variable.
/*! \param name the name of the instance variable to set (including
    the leading @ sign)
    \param value the value of the variable, which will be converted to
    a Ruby type if necessary.
  /
template<typename T>
void iv_set(
    Identifier name,
    T const & value);

//! Get the value of an instance variable.
/*! \param name the name of the instance variable to get
    \return the value of the instance variable
  /
Object iv_get(
    Identifier name) const;

//! Get the value of an instance variable, but don't warn if it is
//unset.
/*! \param name the name of the instance variable to get
    \return the value of the instance variable
  /
Object attr_get(
    Identifier name) const;

include “detail/object_call.hpp”

//! Vectorized call.
/*! Calls the method identified by id with the list of arguments
    identified by args.
    \param id the name of the method to call
    \param args the arguments to the method
    \return the return value of the method call
  /
Object vcall(Identifier id, Array args);

//! Mark the object with the garbage collector.
void mark() const;

protected:

//! Set the encapsulated value.
void set_value(VALUE v);

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_