octave-nkf: libinterp/octave-value/ov-classdef.cc comparison

comparison libinterp/octave-value/ov-classdef.cc @ 15909:b8bff84022d6 classdef

Use strong reference between objects and their class. * libinterp/octave-value/ov-classdef.h (cdef_object_rep::cname): Remove member. (cdef_object_rep::cdef_object_rep (void), cdef_object_rep::cdef_object_rep (cdef_object_rep)): Do not initialize it. (cdef_object_rep::cdef_object_rep (std::string)): Remove constructor. (cdef_object_rep::set_class_name): Remove method. (cdef_object_rep::grip_invalid_object): New private method. (cdef_object_rep::set_class, cdef_object_rep::is_class, cdef_object_rep::is_property, cdef_object_rep::is_method, cdef_object_rep::is_package): New methods. (cdef_object_rep::map, cdef_object_rep::ctor_list): Move members to cdef_object_scalar. (cdef_object_rep::put, cdef_object_rep::get, cdef_object_rep::subsref, cdef_object_rep::subsasgn, cdef_object_rep::mark_for_construction, cdef_object_rep::is_constructed_for, cdef_object_rep::mark_as_constructed, cdef_object_rep::is_partially_constructed_for, cdef_object_rep::is_constructed): Move implementation to cdef_object_scalar. (cdef_object_rep::is_constructed_for, cdef_object_rep::mark_as_constructed, cdef_object_rep::is_partially_constructed_for): Change signature, use cdef_class argument instead of std::string. (cdef_object_rep::class_name): Use get_class () and move inline definition after cdef_class declaration. (cdef_object::set_class_name): Remove method. (cdef_object::is_class, cdef_object::is_property, cdef_object::is_method, cdef_object::is_package): New methods. (cdef_object::is_constructed_for, cdef_object::mark_as_constructed, cdef_object::is_partially_constructed_for): Change signature, use cdef_class instead of std::string. (class cdef_object_base, class cdef_object_scalar): New classes. (class handle_cdef_object, class value_cdef_object): Inherits from cdef_object_scalar. (handle_cdef_object::handle_cdef_object (std::string)): Remove constructor. (value_cdef_object::value_cdef_object (std::string)): Likewise. (value_cdef_object::value_cdef_object (value_cdef_object)): Implement copy constructor. (value_cdef_object::clone): Use it. (cdef_class::cdef_class_rep::cdef_class_rep): Remove first string argument. (cdef_class::cdef_class_rep::is_class, cdef_class::cdef_class_rep::set_name, cdef_class::cdef_class_rep::wrap): New methods. (cdef_class::cdef_class_rep::implicit_ctor_list): Change type to std::list<cdef_class>. (cdef_class::cdef_class (std::string): Remove constructor. (cdef_class::cdef_class (std::list<cdef_class>)): Use string argument as the class name. (cdef_class::cdef_class (cdef_object), cdef_class::operator= (cdef_object)): Use is_class method. (cdef_class::_meta_class, cdef_class::_meta_property, cdef_class::_meta_method, cdef_class::_meta_package): New static members. (cdef_class::meta_class, cdef_class::meta_property, cdef_class::meta_method, cdef_class::meta_package): New static methods. (operator< (cdef_cass, cdef_class)): New function. (cdef_property::cdef_property_rep::cdef_property_rep): Remove first argument string. (cdef_property::cdef_property_rep::is_property, cdef_property::cdef_property_rep::get_name, cdef_property::cdef_property_rep::set_name, cdef_property::cdef_property_rep::is_constant): New methods. (cdef_property::get_name, cdef_property::is_constant): Use them. (cdef_property::cdef_property (std::string)): Use string argument as property name. (cdef_property::cdef_property (cdef_object)): Use is_property method. (cdef_method::cdef_method_rep::cdef_method_rep): Remove first argument string. (cdef_method::cdef_method_rep::is_method, cdef_method::cdef_method_rep::get_name, cdef_method::cdef_method_rep::set_name, cdef_method::cdef_method_rep::is_static): New methods. (cdef_method::get_name, cdef_method::is_static): Use them. (cdef_method::cdef_method (std::string)): Use string argument as method name. (cdef_method::cdef_method (cdef_object)): Use is_method method. (cdef_package::cdef_package_rep::cdef_package_rep): Remove first argument string. (cdef_package::cdef_package_rep::is_package, cdef_package::cdef_package_rep::get_name, cdef_package::cdef_package_rep::set_name): New methods. (cdef_package::get_name): Likewise. (cdef_package::cdef_package (std::string)): Use string argument as package name. (cdef_package::cdef_package (cdef_object)): Use is_package method. (cdef_package::_meta): New static member. (cdef_package::meta): New static method. * libinterp/octave-value/ov-classdef.cc (lookup_class (cdef_class), lookup_class (octave_value)): New static function overloads. (lookup_classes): Change argument name to reflect the fact we're using now a list of cdef_class objects, not a list of names. (make_class, make_property, make_method, make_package): Use name as constructor argument. Set object class. (cdef_object_rep::get_class): Move implementation to header. (cdef_object_rep::subsref, cdef_object_rep::subsasgn, cdef_object_rep::mark_for_construction): Move implementation to cdef_object_scalar. (cdef_object_scalar::is_constructed_for, cdef_object_scalar::is_partially_constructed_for): Moved from cdef_object_rep. (handle_cdef_object::~handle_cdef_object, value_cdef_object::~value_cdef_object): Do not use cname. (cdef_class::cdef_class_rep::cdef_class_rep (std::list<cdef_class>)): Remove first string argument. Keep strong references to cdef_class superclass objects. (cdef_class::cdef_class_rep::find_method, cdef_class::cdef_class_rep::find_methods, cdef_class::cdef_class_rep::find_property, cdef_class::cdef_class_rep::find_properties, cdef_class::cdef_class_rep::find_names, cdef_class::cdef_class_rep::delete_object): Superclasses are now strong references for cdef_class objects. (ctor_analyzer::available_ctor_list): Remove member. (ctor_analyzer::ctor_analyzer): Do not use it. (ctor_analyzer::ctor_list): Change type to std::list<cdef_class>. (ctor_analyzer::visit_funcall): Use it. Do not produce any error. (cdef_class::cdef_class_rep::install_method): Use strong references to cdef_class superclass objects. (cdef_class::cdef_class_rep::run_constructor): Likewise. (cdef_class::cdef_class_rep::construct): Use strong reference to cdef_class object. (cdef_property::cdef_property_rep::get_value, cdef_property::cdef_property_rep::set_value): Likewise. (cdef_class::_meta_class, cdef_class::_meta_property, cdef_class::_meta_method, cdef_class::_meta_package): Initialize static members. (cdef_package::_meta): Likewise. (install_classdef): Bootstrap meta classes with strong references to cdef_class. Assign cdef_class and cdef_package static members.

author	Michael Goffioul <michael.goffioul@gmail.com>
date	Sun, 06 Jan 2013 12:19:16 -0500
parents	a413c6fe1726
children	dfd0dc594c4f

comparison

equal deleted inserted replaced

-:a413c6fe1726
+:b8bff84022d6
 }
 return cdef_class ();
 }
+static cdef_class
+lookup_class (const cdef_class& cls)
+{
+// FIXME: placeholder for the time being, the purpose
+//        is to centralized any class update activity here.
+return cls;
+}
+static cdef_class
+lookup_class (const octave_value& ov)
+{
+if (ov.is_string())
+return lookup_class (ov.string_value ());
+else
+{
+cdef_class cls (to_cdef (ov));
+if (! error_state)
+return lookup_class (cls);
+}
+return cdef_class ();
+}
 static std::list<cdef_class>
-lookup_classes (const Cell& cls_names)
+lookup_classes (const Cell& cls_list)
 {
 std::list<cdef_class> retval;
-for (int i = 0; i < cls_names.numel (); i++)
+for (int i = 0; i < cls_list.numel (); i++)
 {
-cdef_class c = lookup_class (cls_names(i).string_value ());
+cdef_class c = lookup_class (cls_list(i));
 if (! error_state)
 retval.push_back (c);
 else
 {
 {
 Cell c = clsb.get ("SuperClasses").cell_value ();
 for (int i = 0; ! error_state && ! retval && i < c.numel (); i++)
 	{
-	  cdef_class cls = lookup_class (c(i).string_value ());
+	  cdef_class cls = lookup_class (c(i));
 	  if (! error_state)
 	    retval = is_superclass (clsa, cls, true,
 max_depth < 0 ? max_depth : max_depth-1);
 	}
 static cdef_class
 make_class (const std::string& name,
 const std::list<cdef_class>& super_list = std::list<cdef_class> ())
 {
-cdef_class cls ("meta.class", super_list);
+cdef_class cls (name, super_list);
+cls.set_class (cdef_class::meta_class ());
 cls.put ("ConstructOnLoad", false);
 cls.put ("ContainingPackage", Matrix ());
 cls.put ("Description", std::string ());
 cls.put ("DetailedDescription", std::string ());
 cls.put ("Events", Cell ());
 cls.put ("Hidden", false);
 cls.put ("InferiorClasses", Cell ());
 cls.put ("Methods", Cell ());
-cls.put ("Name", name);
 cls.put ("Properties", Cell ());
 cls.put ("Sealed", false);
 if (name == "handle")
 {
 	       const octave_value& set_method = Matrix (),
 	       const std::string& set_access = "public")
 {
 // FIXME: what about default value?
-cdef_property prop ("meta.property");
+cdef_property prop (name);
-prop.put ("Name", name);
+prop.set_class (cdef_class::meta_property ());
 prop.put ("Description", std::string ());
 prop.put ("DetailedDescription", std::string ());
 prop.put ("Abstract", false);
 prop.put ("Constant", false);
 prop.put ("GetAccess", get_access);
 static cdef_method
 make_method (const cdef_class& cls, const std::string& name,
 const octave_value& fcn,const std::string& m_access = "public",
 bool is_static = false)
 {
-cdef_method meth ("meta.method");
+cdef_method meth (name);
+meth.set_class (cdef_class::meta_method ());
 meth.put ("Abstract", false);
 meth.put ("Access", m_access);
 meth.put ("DefiningClass", to_ov (cls));
 meth.put ("Description", std::string ());
 meth.put ("DetailedDescription", std::string ());
 meth.put ("Hidden", false);
-meth.put ("Name", name);
 meth.put ("Sealed", true);
 meth.put ("Static", is_static);
 make_function_of_class (cls, fcn);
 make_package (const std::string& nm,
 const std::string& parent = std::string ())
 {
 cdef_package pack ("meta.package");
-all_packages[nm] = pack;
+pack.set_class (cdef_class::meta_package ());
 pack.put ("Name", nm);
 pack.put ("ContainingPackage", to_ov (all_packages[parent]));
+all_packages[nm] = pack;
 return pack;
 }
 //----------------------------------------------------------------------------
 octave_value_list args;
 };
 //----------------------------------------------------------------------------
-cdef_class
-cdef_object_rep::get_class (void) const
-{
-cdef_class cls = lookup_class (class_name ());
-return cls;
-}
 string_vector
 cdef_object_rep::map_keys (void) const
 {
 cdef_class cls = get_class ();
 return string_vector ();
 }
 octave_value_list
-cdef_object_rep::subsref (const std::string& type,
+cdef_object_scalar::subsref (const std::string& type,
 const std::list<octave_value_list>& idx,
 int nargout, size_t& skip,
 const cdef_class& context)
 {
 skip = 0;
 cdef_class cls = (context.ok () ? context : get_class ());
 return retval;
 }
 octave_value
-cdef_object_rep::subsasgn (const std::string& type,
+cdef_object_scalar::subsasgn (const std::string& type,
 const std::list<octave_value_list>& idx,
 const octave_value& rhs)
 {
 octave_value retval;
 cdef_class cls = get_class ();
 return retval;
 }
 void
-cdef_object_rep::mark_for_construction (const cdef_class& cls)
+cdef_object_scalar::mark_for_construction (const cdef_class& cls)
 {
 std::string cls_name = cls.get_name ();
 Cell supcls = cls.get ("SuperClasses").cell_value ();
 if (! error_state)
 {
-std::list<std::string> supcls_names;
+std::list<cdef_class> supcls_list = lookup_classes (supcls);
-for (int i = 0; ! error_state && i < supcls.numel (); i++)
-supcls_names.push_back (supcls(i).string_value ());
 if (! error_state)
-ctor_list[cls_name] = supcls_names;
+ctor_list[cls] = supcls_list;
 }
+}
+bool cdef_object_scalar::is_constructed_for (const cdef_class& cls) const
+{
+return (is_constructed ()
+|| ctor_list.find (cls) == ctor_list.end ());
+}
+bool cdef_object_scalar::is_partially_constructed_for (const cdef_class& cls) const
+{
+std::map< cdef_class, std::list<cdef_class> >::const_iterator it;
+if (is_constructed ())
+return true;
+else if ((it = ctor_list.find (cls)) == ctor_list.end ()
+|| it->second.empty ())
+return true;
+for (std::list<cdef_class>::const_iterator lit = it->second.begin ();
+lit != it->second.end (); ++lit)
+if (! is_constructed_for (*lit))
+return false;
+return true;
 }
 handle_cdef_object::~handle_cdef_object (void)
 {
-gnulib::printf ("deleting %s object (handle)\n", cname.c_str ());
+gnulib::printf ("deleting %s object (handle)\n",
+get_class ().get_name ().c_str ());
 }
 value_cdef_object::~value_cdef_object (void)
 {
-gnulib::printf ("deleting %s object (value)\n", cname.c_str ());
+gnulib::printf ("deleting %s object (value)\n",
-}
+get_class ().get_name ().c_str ());
+}
-cdef_class::cdef_class_rep::cdef_class_rep (const std::string& nm,
-const std::list<cdef_class>& superclasses)
+cdef_class::cdef_class_rep::cdef_class_rep (const std::list<cdef_class>& superclasses)
-: handle_cdef_object (nm), handle_class (false)
+: handle_cdef_object (), handle_class (false)
 {
-for (std::list<cdef_class>::const_iterator it = superclasses.begin ();
+put ("SuperClasses", to_ov (superclasses));
-it != superclasses.end (); ++it)
+implicit_ctor_list = superclasses;
-implicit_ctor_list.push_back (it->get_name ());
-put ("SuperClasses", Cell (implicit_ctor_list));
 }
 cdef_method
 cdef_class::cdef_class_rep::find_method (const std::string& nm, bool local)
 {
 Cell super_classes = get ("SuperClasses").cell_value ();
 for (int i = 0; i < super_classes.numel (); i++)
 {
-cdef_class cls = lookup_class (super_classes(i).string_value ());
+cdef_class cls = lookup_class (super_classes(i));
 if (! error_state)
 {
 cdef_method meth = cls.find_method (nm);
 }
 class ctor_analyzer : public tree_walker
 {
 public:
-ctor_analyzer (const std::string& ctor, const std::string& obj,
+ctor_analyzer (const std::string& ctor, const std::string& obj)
-const std::list<std::string>& l)
+: tree_walker (), who (ctor), obj_name (obj) { }
-: tree_walker (), who (ctor), obj_name (obj), available_ctor_list (l) { }
 void visit_statement_list (tree_statement_list& t)
 {
 for (tree_statement_list::const_iterator it = t.begin ();
 ! error_state && it != t.end (); ++it)
 std::string ctor_name = (package_name.empty ()
 ? class_name
 : package_name + "." + class_name);
-if (std::find (available_ctor_list.begin (),
+cdef_class cls = lookup_class (ctor_name, false);
-available_ctor_list.end (), ctor_name)
-== available_ctor_list.end ())
+if (cls.ok ())
-::error ("`%s' is not a direct superclass of `%s'",
+ctor_list.push_back (cls);
-ctor_name.c_str (), who.c_str ());
-else if (std::find (ctor_list.begin (), ctor_list.end (),
-ctor_name) != ctor_list.end ())
-::error ("calling constructor `%s' more than once",
-ctor_name.c_str ());
-ctor_list.push_back (ctor_name);
 }
 }
 }
 }
 }
-std::list<std::string> get_constructor_list (void) const
+std::list<cdef_class> get_constructor_list (void) const
 { return ctor_list; }
 // NO-OP
 void visit_anon_fcn_handle (tree_anon_fcn_handle&) { }
 void visit_argument_list (tree_argument_list&) { }
 /* The name of the first output argument of the constructor */
 std::string obj_name;
 /* The list of superclass constructors that are explicitly called */
-std::list<std::string> ctor_list;
+std::list<cdef_class> ctor_list;
-/* The list of possible superclass constructors */
-std::list<std::string> available_ctor_list;
 };
 void
 cdef_class::cdef_class_rep::install_method (const cdef_method& meth)
 {
 tree_statement_list *body = uf->body ();
 if (ret_list && ret_list->size () == 1)
 {
 std::string obj_name = ret_list->front ()->name ();
-ctor_analyzer a (meth.get_name (), obj_name,
+ctor_analyzer a (meth.get_name (), obj_name);
-implicit_ctor_list);
 body->accept (a);
 if (! error_state)
 {
-std::list<std::string> explicit_ctor_list
+std::list<cdef_class> explicit_ctor_list
 = a.get_constructor_list ();
-for (std::list<std::string>::const_iterator it = explicit_ctor_list.begin ();
+for (std::list<cdef_class>::const_iterator it = explicit_ctor_list.begin ();
 ! error_state && it != explicit_ctor_list.end (); ++it)
 {
 gnulib::printf ("explicit superclass constructor: %s\n",
-it->c_str ());
+it->get_name ().c_str ());
 implicit_ctor_list.remove (*it);
 }
 }
 }
 else
 Cell super_classes = get ("SuperClasses").cell_value ();
 for (int i = 0; i < super_classes.numel (); i++)
 {
-cdef_class cls = lookup_class (super_classes(i).string_value ());
+cdef_class cls = lookup_class (super_classes(i));
 if (! error_state)
 	cls.get_rep ()->find_methods (meths, true);
 else
 	break;
 Cell super_classes = get ("SuperClasses").cell_value ();
 for (int i = 0; i < super_classes.numel (); i++)
 {
-cdef_class cls = lookup_class (super_classes(i).string_value ());
+cdef_class cls = lookup_class (super_classes(i));
 if (! error_state)
 	{
 	  cdef_property prop = cls.find_property (nm);
 Cell super_classes = get ("SuperClasses").cell_value ();
 for (int i = 0; ! error_state && i < super_classes.numel (); i++)
 {
-cdef_class cls = lookup_class (super_classes(i).string_value ());
+cdef_class cls = lookup_class (super_classes(i));
 if (! error_state)
 	cls.get_rep ()->find_properties (props, true);
 else
 	break;
 Cell super_classes = get ("SuperClasses").cell_value ();
 for (int i = 0; ! error_state && i < super_classes.numel (); i++)
 {
-cdef_class cls = lookup_class (super_classes(i).string_value ());
+cdef_class cls = lookup_class (super_classes(i));
 if (! error_state)
 	cls.get_rep ()->find_names (names, all);
 else
 	break;
 {
 method_iterator it = method_map.find ("delete");
 if (it != method_map.end ())
 {
-std::string cls_name = obj.class_name ();
+cdef_class cls = obj.get_class ();
-obj.set_class_name (get ("Name").string_value ());
+obj.set_class (wrap ());
 it->second.execute (obj, octave_value_list (), 0);
-obj.set_class_name (cls_name);
+obj.set_class (cls);
 }
 // FIXME: should we destroy corresponding properties here?
 // Call "delete" in super classes
 Cell super_classes = get ("SuperClasses").cell_value ();
 for (int i = 0; i < super_classes.numel (); i++)
 {
-cdef_class cls = lookup_class (super_classes(i).string_value ());
+cdef_class cls = lookup_class (super_classes(i));
 if (!error_state)
 	cls.delete_object (obj);
 }
 }
 cdef_class::cdef_class_rep::run_constructor (cdef_object& obj,
 const octave_value_list& args)
 {
 octave_value_list empty_args;
-for (std::list<std::string>::const_iterator it = implicit_ctor_list.begin ();
+for (std::list<cdef_class>::const_iterator it = implicit_ctor_list.begin ();
 ! error_state && it != implicit_ctor_list.end (); ++it)
 {
 cdef_class supcls = lookup_class (*it);
 if (! error_state)
 return;
 }
 }
 }
-obj.mark_as_constructed (cls_name);
+obj.mark_as_constructed (wrap ());
 }
 octave_value
 cdef_class::cdef_class_rep::construct (const octave_value_list& args)
 {
 cdef_object_rep *r;
 if (is_handle_class ())
-r = new handle_cdef_object (get_name ());
+r = new handle_cdef_object ();
 else
-r = new value_cdef_object (get_name ());
+r = new value_cdef_object ();
+r->set_class (wrap ());
 cdef_object obj (r);
 initialize_object (obj);
 if (! obj.is_constructed ())
 {
 cdef_class cls (to_cdef (get ("DefiningClass")));
-if (! obj.is_partially_constructed_for (cls.get_name ()))
+if (! obj.is_partially_constructed_for (cls))
 {
 ::error ("cannot reference properties of class `%s' for non-constructed object",
 cls.get_name ().c_str ());
 return retval;
 }
 {
 if (! obj.is_constructed ())
 {
 cdef_class cls (to_cdef (get ("DefiningClass")));
-if (! obj.is_partially_constructed_for (cls.get_name ()))
+if (! obj.is_partially_constructed_for (cls))
 {
 ::error ("cannot reference properties of class `%s' for non-constructed object",
 cls.get_name ().c_str ());
 return;
 }
 Cell
 cdef_package::cdef_package_rep::get_packages (void) const
 { return map2Cell (package_map); }
+cdef_class cdef_class::_meta_class = cdef_class ();
+cdef_class cdef_class::_meta_property = cdef_class ();
+cdef_class cdef_class::_meta_method = cdef_class ();
+cdef_class cdef_class::_meta_package = cdef_class ();
+cdef_package cdef_package::_meta = cdef_package ();
 void
 install_classdef (void)
 {
 octave_classdef::register_type ();
+/* bootstrap */
+cdef_class handle = make_class ("handle");
+cdef_class meta_class = cdef_class::_meta_class = make_class ("meta.class", handle);
+handle.set_class (meta_class);
+meta_class.set_class (meta_class);
 /* meta classes */
-cdef_class handle = make_class ("handle");
+cdef_class meta_property = cdef_class::_meta_property = make_class ("meta.property", handle);
-cdef_class meta_class = make_class ("meta.class", handle);
+cdef_class meta_method = cdef_class::_meta_method = make_class ("meta.method", handle);
-cdef_class meta_property = make_class ("meta.property", handle);
+cdef_class meta_package = cdef_class::_meta_package = make_class ("meta.package", handle);
-cdef_class meta_method = make_class ("meta.method", handle);
 cdef_class meta_event = make_class ("meta.event", handle);
-cdef_class meta_package = make_class ("meta.package", handle);
 cdef_class meta_dynproperty = make_class ("meta.dynamicproperty", handle);
 /* meta classes are all sealed */
 meta_class.put ("Sealed", true);
 meta_property.put ("Sealed", true);
 meta_method.put ("Sealed", true);
+meta_package.put ("Sealed", true);
 meta_event.put ("Sealed", true);
-meta_package.put ("Sealed", true);
 meta_dynproperty.put ("Sealed", true);
 /* meta.class properties */
 meta_class.install_property (make_attribute (meta_class, "ConstructOnLoad"));
 meta_class.install_property (make_property  (meta_class, "ContainingPackage"));
 		      "public", Matrix (), "private"));
 meta_package.install_method (make_method (meta_package, "fromName", package_fromName,
 "public", true));
 /* create "meta" package */
-cdef_package package_meta = make_package ("meta");
+cdef_package package_meta = cdef_package::_meta = make_package ("meta");
 package_meta.install_class (meta_class,       "class");
 package_meta.install_class (meta_property,    "property");
 package_meta.install_class (meta_method,      "method");
 package_meta.install_class (meta_package,     "package");
 package_meta.install_class (meta_event,       "event");

Mercurial > octave-nkf

comparison libinterp/octave-value/ov-classdef.cc @ 15909:b8bff84022d6 classdef