rice 3.0.0 → 4.0.0

data/rice/Struct.cpp

@@ -1,117 +0,0 @@
-#include "Struct.hpp"
-#include "Symbol.hpp"
-
-#include <stdexcept>
-
-Rice::Struct::
-Struct()
-  : Module_impl<Class, Struct>(rb_cObject)
-  , members_()
-  , members_guard_(&members_)
-  , member_offset_()
-  , member_offset_guard_(&member_offset_)
-{
-}
-
-Rice::Struct::
-Struct(Rice::Struct const & s)
-  : Module_impl<Class, Struct>(s)
-  , members_(s.members_.value())
-  , members_guard_(&members_)
-  , member_offset_(s.member_offset_.value())
-  , member_offset_guard_(&member_offset_)
-{
-}
-
-Rice::Struct::
-~Struct()
-{
-}
-
-Rice::Struct & Rice::Struct::
-initialize(
-    Module module,
-    Identifier name)
-{
-  Class struct_class(rb_cStruct);
-  Object type = struct_class.vcall("new", members_);
-
-  set_value(type);
-  module.const_set(name, type);
-
-  return *this;
-}
-
-Rice::Struct & Rice::Struct::
-define_member(
-    Identifier name)
-{
-  if(value() != rb_cObject)
-  {
-    throw std::runtime_error("struct is already initialized");
-  }
-
-  // TODO: not exception-safe
-  Symbol ruby_name(name);
-  member_offset_[ruby_name] = members_.size();
-  members_.push(ruby_name);
-
-  return *this;
-}
-
-unsigned long Rice::Struct::
-offset_of(Identifier name) const
-{
-  Symbol ruby_name(name);
-  return from_ruby<unsigned long>(member_offset_[ruby_name]);
-}
-
-void Rice::Struct::
-swap(Rice::Struct & other)
-{
-  members_.swap(other.members_);
-  members_guard_.swap(other.members_guard_);
-  member_offset_.swap(other.member_offset_);
-  member_offset_guard_.swap(other.member_offset_guard_);
-  Class::swap(other);
-}
-
-Rice::Struct::Instance
-Rice::Struct::
-new_instance(Array args) const
-{
-  Object instance = const_cast<Struct *>(this)->vcall("new", args);
-  return Instance(*this, instance);
-}
-
-Rice::Struct::Instance::
-Instance(
-    Struct const & type,
-    Array args)
-  : Builtin_Object<T_STRUCT>(type.new_instance(args))
-  , type_(type)
-{
-}
-
-Rice::Struct::Instance::
-Instance(
-    Struct const & type,
-    Object s)
-  : Builtin_Object<T_STRUCT>(s)
-  , type_(type)
-{
-}
-
-void Rice::Struct::Instance::
-swap(Instance & other)
-{
-  type_.swap(other.type_);
-  Builtin_Object<T_STRUCT>::swap(other);
-}
-
-Rice::Struct Rice::
-define_struct()
-{
-  return Struct();
-}
-

data/rice/Struct.hpp

@@ -1,162 +0,0 @@
-#ifndef Rice__ruby_struct__hpp_
-#define Rice__ruby_struct__hpp_
-
-#include "Array.hpp"
-#include "Hash.hpp"
-#include "Module.hpp"
-#include "Class.hpp"
-#include "Builtin_Object.hpp"
-#include "Address_Registration_Guard.hpp"
-
-namespace Rice
-{
-	class Struct;
-
-//! Define a new Struct
-Struct define_struct();
-
-//! A wrapper for creating Struct classes.
-/*! The Struct class is used for creating new Classes.  Note that the
- *  notation used here differs slightly from the notation inside the
- *  interpreter.
- *
- *  Inside the interpreter, calling Struct.new creates a new Class:
- *  \code
- *  irb(main):001:0> MyStruct = Struct.new(:a, :b, :c)
- *  => S
- *  irb(main):002:0> MyStruct.class
- *  => Class
- *  \endcode
- *
- *  Instantiating that Class creates an instance of that Class:
- *  \code
- *  irb(main):003:0> mystruct_instance = MyStruct.new
- *  => #<struct MyStruct a=nil, b=nil, c=nil>
- *  irb(main):004:0> mystruct_instance.class
- *  => MyStruct
- *  irb(main):005:0> mystruct_instance.class.ancestors
- *  => [MyStruct, Struct, Enumerable, Object, Kernel]
- *  \endcode
- *
- *  Thus, inside the interpreter, MyStruct is a Class which inherits
- *  from Struct, and mystruct_instance is an instance of MyStruct.
- *
- *  At the C++ level, we might do this instead:
- *  \code
- *  Struct rb_cMyStruct = define_struct()
- *    .define_member("a")
- *    .define_member("b")
- *    .define_member("c")
- *    .initialize("MyStruct");
- *  Struct::Instance mystruct_instance(rb_cMyStruct.new_instance());
- *  \endcode
- *
- * Here rb_cMyStruct is an instance of Struct and that mystruct_instance
- * is an instance of Struct::Instance.
- */
-class Struct
-  : public Module_impl<Class, Struct>
-{
-public:
-  //! Create a new Struct.
-  Struct();
-
-  //! Copy constructor.
-  Struct(Struct const & s);
-
-  //! Destructor.
-  virtual ~Struct();
-
-  //! Define a new Struct member.
-  /*! Defines a new member of the Struct.  Must be called before the
-   *  Struct is initialized.
-   *  \return *this
-   */
-  Struct & define_member(
-      Identifier name);
-
-  //! Initialize the Struct class.
-  /*! Must be called after all Struct members have been defined.
-   *  \param module the module under which to define the Struct.
-   *  \param name the name of the Class at the ruby level.
-   */
-  Struct & initialize(
-      Module module,
-      Identifier name);
-
-  //! Get the offset of a member in the Struct.
-  /*! Internally, Struct members are stored as a single array of VALUE.
-   *  This function determines the offset of a given member in that
-   *  array.
-   *  \param member the name of the desired member.
-   *  \return the index of the given member.
-   */
-  unsigned long offset_of(Identifier name) const;
-
-  class Instance;
-  friend class Instance;
-  friend Struct Rice::define_struct();
-
-  //! Create a new instance of the Struct
-  /*! \param args the arguments to the constructor.
-   *  \return a new Struct::Instance
-   */
-  Instance new_instance(Array args = Array()) const;
-
-  //! Swap with another Struct.
-  void swap(Struct & other);
-
-  Array members() const { return members_; }
-
-private:
-  Array members_;
-  Address_Registration_Guard members_guard_;
-
-  Hash member_offset_;
-  Address_Registration_Guard member_offset_guard_;
-};
-
-
-//! An instance of a Struct
-//! \sa Struct
-class Struct::Instance
-  : public Builtin_Object<T_STRUCT>
-{
-public:
-  //! Create a new Instance of a Struct.
-  /*! \param type the Struct type to create.
-   *  \param args the initial values for the objects of the instance.
-   */
-  Instance(
-      Struct const & type,
-      Array args = Array());
-
-  //! Encapsulate an existing Struct instance.
-  /*! \param type the Struct type to encapsulate.
-   *  \param s the instance to encapsulate.
-   */
-  Instance(
-      Struct const & type,
-      Object s);
-
-  //! Get a member, given its offset.
-  /*! \param index the (integral) index into the Struct's internal
-   *  array or its name (an Identifier or char const *)
-   *  \return the member.
-   */
-  template<typename T>
-  Object operator[](T index);
-
-  //! Swap with another Struct::Instance.
-  void swap(Instance & other);
-
-private:
-  Struct type_;
-};
-
-} // namespace Rice
-
-#include "Struct.ipp"
-
-#endif // Rice__ruby_struct__hpp_
-

data/rice/Struct.ipp

@@ -1,26 +0,0 @@
-namespace Rice
-{
-
-template<typename T>
-inline Object Struct::Instance::
-operator[](T index)
-{
-  return rb_struct_aref(value(), ULONG2NUM(index));
-}
-
-template<>
-inline Object Struct::Instance::
-operator[]<Identifier>(Identifier member)
-{
-  unsigned long index = type_.offset_of(member);
-  return (*this)[index];
-}
-
-template<>
-inline Object Struct::Instance::
-operator[]<char const *>(char const * name)
-{
-  return (*this)[Identifier(name)];
-}
-
-} // Rice

data/rice/Symbol.cpp

@@ -1,25 +0,0 @@
-#include "Symbol.hpp"
-
-namespace
-{
-  VALUE check_type(Rice::Object value, int type)
-  {
-    rb_check_type(value, type);
-    return Qnil;
-  }
-}
-
-Rice::Symbol::
-Symbol(VALUE v)
-  : Object(v)
-{
-  protect(check_type, v, T_SYMBOL);
-}
-
-Rice::Symbol::
-Symbol(Object v)
-  : Object(v)
-{
-  protect(check_type, v, T_SYMBOL);
-}
-

data/rice/Symbol.hpp

@@ -1,66 +0,0 @@
-#ifndef Rice__Symbol__hpp_
-#define Rice__Symbol__hpp_
-
-#include "Identifier.hpp"
-#include "Object.hpp"
-#include "detail/ruby.hpp"
-#include <string>
-
-namespace Rice
-{
-
-//! A wrapper for ruby's Symbol class.
-/*! Symbols are internal identifiers in ruby.  They are singletons and
- *  can be thought of as frozen strings.  They differ from an Identifier
- *  in that they are in fact real Objects, but they can be converted
- *  back and forth between Identifier and Symbol.
- */
-class Symbol
-  : public Object
-{
-public:
-  //! Wrap an existing symbol.
-  Symbol(VALUE v);
-
-  //! Wrap an existing symbol.
-  Symbol(Object v);
-
-  //! Construct a Symbol from an Identifier.
-  Symbol(Identifier id);
-
-  //! Construct a Symbol from a null-terminated C string.
-  Symbol(char const * s = "");
-
-  //! Construct a Symbol from an std::string.
-  Symbol(std::string const & s);
-
-  //! Return a string representation of the Symbol.
-  char const * c_str() const;
-
-  //! Return a string representation of the Symbol.
-  std::string str() const;
-
-  //! Return the Symbol as an Identifier.
-  Identifier to_id() const;
-};
-
-} // namespace Rice
-
-template<>
-inline
-Rice::Symbol from_ruby<Rice::Symbol>(Rice::Object x)
-{
-  return Rice::Symbol(x);
-}
-
-template<>
-inline
-Rice::Object to_ruby<Rice::Symbol>(Rice::Symbol const & x)
-{
-  return x;
-}
-
-#include "Symbol.ipp"
-
-#endif // Rice__Symbol__hpp_
-

data/rice/Symbol.ipp

@@ -1,44 +0,0 @@
-#ifndef Rice__Symbol__ipp_
-#define Rice__Symbol__ipp_
-
-#include "protect.hpp"
-#include "detail/ruby.hpp"
-
-inline Rice::Symbol::
-Symbol(char const * s)
-  : Object(ID2SYM(rb_intern(s)))
-{
-}
-
-inline Rice::Symbol::
-Symbol(std::string const & s)
-  : Object(ID2SYM(rb_intern(s.c_str())))
-{
-}
-
-inline Rice::Symbol::
-Symbol(Identifier id)
-  : Object(ID2SYM(id))
-{
-}
-
-inline char const * Rice::Symbol::
-c_str() const
-{
-  return to_id().c_str();
-}
-
-inline std::string Rice::Symbol::
-str() const
-{
-  return to_id().str();
-}
-
-inline Rice::Identifier Rice::Symbol::
-to_id() const
-{
-  return rb_to_id(value());
-}
-
-#endif // Rice__Symbol__ipp_
-