clipsruby 0.0.34 → 0.0.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d62cc0e5ccc41bfc4e88590c7a3873859271163fa5dd73b416c0cf2d61b7ed1
-  data.tar.gz: d3cd61d58609c516b8c952dbc32393d54251f09bdc3a8a5f15f531cdf2d707ee
+  metadata.gz: 50cc209eb6a473cd3a980b8d551079a4db6632f86afbc43bff8a582a89efb2cf
+  data.tar.gz: 2e2dd6648850df2dc496111334e68aebb9048fb2f823a6b6ddd865449cb34254
 SHA512:
-  metadata.gz: c6473260b0da57bb78894841385c6cc1b4ecddb4448dc80edf7c0542e654b8dca6884efdc37b9be976d6b0bed22fadd24da5313ef8ba59b5cd71639a18cd2f42
-  data.tar.gz: 90af7d185f0ca31b1d543e0550cf4520d021525225e3bba8087d5f449591ffe40fa6a34380293b689876ec9d84dc9b3d8860c18b50b525610b3ca890ff727c5a
+  metadata.gz: 9bf9b814174620c68ee826d8051f09bb4d3e989537f4dcce642ba84a651b9dcdfa5acb403378865e05429b1dd03019e07568163c121a58e05368bc664ebd96e4
+  data.tar.gz: e3690e9f5b2f28203366e75d845d06dc3ad22173db4ed0a0cdb0ff7246cb0b31f804fc60fde0b6e2be58b29b074f3692ade5f3da6c4f947a2acfc40b1ab1ae21

data/README.md

@@ -454,14 +454,14 @@ CLIPS::Environment::Instance.pp_form(instance)
 instance.pp_form
 ```
 
-### `CLIPS::Environment::Instance._class`
-### `CLIPS::Environment::Instance#_class`
+### `CLIPS::Environment::Instance.defclass`
+### `CLIPS::Environment::Instance#defclass`
 
 Returns the Defclass of an Instance
 
 ```ruby
-CLIPS::Environment::Instance._class(instance)
-instance._class
+CLIPS::Environment::Instance.defclass(instance)
+instance.defclass
 ```
 
 ### `CLIPS::Environment::Defclass.name`
@@ -494,6 +494,46 @@ CLIPS::Environment::Defclass.defmodule_name(defclass)
 defclass.defmodule_name
 ```
 
+### `CLIPS::Environment::Defclass.get_instance_list`
+### `CLIPS::Environment::Defclass#get_instance_list`
+
+Return an array of Instances of the Defclass.
+Pass `true` as an argument to include instances of subclasses
+of this Defclass.
+
+```ruby
+CLIPS::Environment::Defclass.get_instance_list(defclass)
+CLIPS::Environment::Defclass.get_instance_list(defclass, true)
+defclass.get_instance_list
+defclass.get_instance_list(true)
+```
+
+### `CLIPS::Environment::Defclass.superclasses`
+### `CLIPS::Environment::Defclass#superclasses`
+
+Return an array of superclasses of the Defclass.
+Pass `true` as an argument to include inherited superclasses.
+
+```ruby
+CLIPS::Environment::Defclass.superclasses(defclass)
+CLIPS::Environment::Defclass.superclasses(defclass, true)
+defclass.superclasses
+defclass.superclasses(true)
+```
+
+### `CLIPS::Environment::Defclass.subclasses`
+### `CLIPS::Environment::Defclass#subclasses`
+
+Return an array of subclasses of the Defclass.
+Pass `true` as an argument to include inherited subclasses.
+
+```ruby
+CLIPS::Environment::Defclass.subclasses(defclass)
+CLIPS::Environment::Defclass.subclasses(defclass, true)
+defclass.subclasses
+defclass.subclasses(true)
+```
+
 ### `CLIPS::Environment.find_defrule`
 ### `CLIPS::Environment#find_defrule`
 
@@ -504,6 +544,24 @@ CLIPS::Environment.find_defrule(:a)
 env.find_defrule("foo")
 ```
 
+### `CLIPS::Environment.find_instance`
+### `CLIPS::Environment#find_instance`
+
+Finds an instance by name and returns a CLIPS::Environment::Instance object.
+Can take an optional second and third argument for Defmodule or Demodule name
+and a boolean that represents whether or not the instance should be searched for
+in imported modules.
+If the second argument is `nil`, `find_instance` will search the current module only.
+
+```ruby
+CLIPS::Environment.find_definstance(:a)
+env.find_definstance("foo")
+CLIPS::Environment.find_definstance(:a, :my_module)
+env.find_definstance("foo", "my_module")
+CLIPS::Environment.find_definstance(:a, :my_module, true)
+env.find_definstance("foo", nil, true)
+```
+
 ### `CLIPS::Environment::Defrule.name`
 ### `CLIPS::Environment::Defrule#name`
 
@@ -634,6 +692,21 @@ CLIPS::Environment::Defmodule.get_fact_list(defmodule)
 defmodule.get_fact_list
 ```
 
+### `CLIPS::Environment::Defmodule.find_instance`
+### `CLIPS::Environment::Defmodule#find_instance`
+
+Finds an instance by name and returns a CLIPS::Environment::Instance object.
+Can take an optional second argument
+of a boolean that represents whether or not the instance should be searched for
+in imported modules.
+
+```ruby
+CLIPS::Environment::Defmodule.find_instance(:a)
+defmodule.find_instance("foo")
+CLIPS::Environment::Defmodule.find_instance(:a, true)
+defmodule.find_instance("foo", true)
+```
+
 ### `CLIPS::Environment.get_defclass_list`
 ### `CLIPS::Environment#get_defclass_list`
 
@@ -650,6 +723,26 @@ CLIPS::Environment.get_defclass_list(env, defmodule)
 env.get_defclass_list(defmodule)
 ```
 
+### `CLIPS::Environment.get_instance_list`
+### `CLIPS::Environment#get_instance_list`
+
+Return an array of Instances in the environment. Pass an argument of a
+symbol, string, or Defclass object in order to only get Instances
+in that Defclass. If you do not, it will return all Instances of all Defclasses.
+If you do, you may also pass `true` as the second argument
+to include instances of subclasses of this Defclass.
+
+```ruby
+CLIPS::Environment.get_instance_list(env)
+env.get_instance_list
+CLIPS::Environment.get_instance_list(env, :foo_class)
+env.get_instance_list(:"my-class")
+CLIPS::Environment.get_instance_list(env, defclass)
+env.get_instance_list(defclass)
+CLIPS::Environment.get_instance_list(env, defclass, true)
+env.get_instance_list(defclass, true)
+```
+
 ### `CLIPS::Environment.get_deftemplate_list`
 ### `CLIPS::Environment#get_deftemplate_list`
 

data/ext/clipsruby/clipsruby.c

@@ -293,6 +293,93 @@ static VALUE clips_environment_defclass_static_pp_form(VALUE self, VALUE rbDefcl
 	return clips_environment_defclass_pp_form(rbDefclass);
 }
 
+static VALUE clips_environment_defclass_get_instance_list(int argc, VALUE *argv, VALUE rbDefclass)
+{
+	VALUE rbEnvironment, rbInstance, include_subclasses, returnArray;
+	Defclass *defclass;
+	Instance *theInstance;
+	UDFValue iterator;
+
+	rbEnvironment = rb_iv_get(rbDefclass, "@environment");
+
+	returnArray = rb_ary_new2(0);
+
+	rb_scan_args(argc, argv, "01", &include_subclasses);
+
+	TypedData_Get_Struct(rbDefclass, Defclass, &Defclass_type, defclass);
+
+	if (include_subclasses != Qtrue) {
+		for (
+			theInstance = GetNextInstanceInClass(defclass,NULL);
+			theInstance != NULL;
+			theInstance = GetNextInstanceInClass(defclass,theInstance)
+		) {
+			rbInstance =
+				TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Instance")), &Instance_type, theInstance);
+
+			rb_iv_set(rbInstance, "@environment", rbEnvironment);
+			rb_ary_push(returnArray, rbInstance);
+		}
+	} else {
+		for (
+			theInstance = GetNextInstanceInClassAndSubclasses(&defclass,NULL,&iterator);
+			theInstance != NULL;
+			theInstance = GetNextInstanceInClassAndSubclasses(&defclass,theInstance,&iterator)
+		) {
+			rbInstance =
+				TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Instance")), &Instance_type, theInstance);
+
+			rb_iv_set(rbInstance, "@environment", rbEnvironment);
+			rb_ary_push(returnArray, rbInstance);
+		}
+	}
+	return returnArray;
+}
+
+static VALUE clips_environment_defclass_static_get_instance_list(int argc, VALUE *argv, VALUE rbDefclass)
+{
+	VALUE rbEnvironment, rbInstance, include_subclasses, returnArray;
+	Defclass *defclass;
+	Instance *theInstance;
+	UDFValue iterator;
+
+	returnArray = rb_ary_new2(0);
+
+	rb_scan_args(argc, argv, "11", &rbDefclass, &include_subclasses);
+
+	rbEnvironment = rb_iv_get(rbDefclass, "@environment");
+
+	TypedData_Get_Struct(rbDefclass, Defclass, &Defclass_type, defclass);
+
+	if (include_subclasses != Qtrue) {
+		for (
+			theInstance = GetNextInstanceInClass(defclass,NULL);
+			theInstance != NULL;
+			theInstance = GetNextInstanceInClass(defclass,theInstance)
+		) {
+			rbInstance =
+				TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Instance")), &Instance_type, theInstance);
+
+			rb_iv_set(rbInstance, "@environment", rbEnvironment);
+			rb_ary_push(returnArray, rbInstance);
+		}
+	} else {
+		for (
+			theInstance = GetNextInstanceInClassAndSubclasses(&defclass,NULL,&iterator);
+			theInstance != NULL;
+			theInstance = GetNextInstanceInClassAndSubclasses(&defclass,theInstance,&iterator)
+		) {
+			rbInstance =
+				TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Instance")), &Instance_type, theInstance);
+
+			rb_iv_set(rbInstance, "@environment", rbEnvironment);
+			rb_ary_push(returnArray, rbInstance);
+		}
+	}
+	return returnArray;
+}
+
+
 static VALUE clips_environment_make_instance(VALUE self, VALUE string)
 {
 	Environment *env;
@@ -380,7 +467,7 @@ static VALUE clips_environment_instance_static_delete(VALUE self, VALUE rbInstan
 	return clips_environment_instance_delete(rbInstance);
 }
 
-static VALUE clips_environment_instance_class(VALUE self)
+static VALUE clips_environment_instance_defclass(VALUE self)
 {
 	Defclass *defclass;
 	Instance *instance;
@@ -400,9 +487,9 @@ static VALUE clips_environment_instance_class(VALUE self)
 	return rb_defclass;
 }
 
-static VALUE clips_environment_instance_static_class(VALUE self, VALUE rbInstance)
+static VALUE clips_environment_instance_static_defclass(VALUE self, VALUE rbInstance)
 {
-	return clips_environment_instance_class(rbInstance);
+	return clips_environment_instance_defclass(rbInstance);
 }
 
 static VALUE clips_environment_instance_name(VALUE self)
@@ -787,8 +874,13 @@ static void CLIPSValue_to_VALUE(CLIPSValue *from, VALUE *value, VALUE *rbEnviron
 
 			rb_iv_set(*value, "@environment", *rbEnvironment);
 			break;
-		case EXTERNAL_ADDRESS_TYPE:
 		case INSTANCE_ADDRESS_TYPE:
+			*value =
+				TypedData_Wrap_Struct(rb_const_get(CLASS_OF(*rbEnvironment), rb_intern("Instance")), &Instance_type, from->instanceValue);
+
+			rb_iv_set(*value, "@environment", *rbEnvironment);
+			break;
+		case EXTERNAL_ADDRESS_TYPE:
 		default:
 			WriteString(env,STDERR,"Unsupported data type returned from function\n");
 			*value = Qnil;
@@ -839,8 +931,13 @@ static void UDFValue_to_VALUE(UDFValue *from, VALUE *value, VALUE *rbEnvironment
 
 			rb_iv_set(*value, "@environment", *rbEnvironment);
 			break;
-		case EXTERNAL_ADDRESS_TYPE:
 		case INSTANCE_ADDRESS_TYPE:
+			*value =
+				TypedData_Wrap_Struct(rb_const_get(CLASS_OF(*rbEnvironment), rb_intern("Instance")), &Instance_type, from->instanceValue);
+
+			rb_iv_set(*value, "@environment", *rbEnvironment);
+			break;
+		case EXTERNAL_ADDRESS_TYPE:
 		default:
 			WriteString(env,STDERR,"Unsupported data type returned from function\n");
 			*value = Qnil;
@@ -1018,6 +1115,93 @@ static VALUE clips_environment_deftemplate_static_slot_names(VALUE self, VALUE r
 	return clips_environment_deftemplate_slot_names(rbDeftemplate);
 }
 
+static VALUE clips_environment_defclass_superclasses(int argc, VALUE *argv, VALUE rbDefclass)
+{
+	VALUE rbEnvironment, inherit;
+	Defclass *defclass;
+	CLIPSValue value;
+	VALUE out;
+
+	rbEnvironment = rb_iv_get(rbDefclass, "@environment");
+
+	rb_scan_args(argc, argv, "01", &inherit);
+
+	if (NIL_P(inherit)) {
+		inherit = Qfalse;
+	}
+
+	TypedData_Get_Struct(rbDefclass, Defclass, &Defclass_type, defclass);
+
+	ClassSuperclasses(defclass, &value, RTEST(inherit));
+
+	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_defclass_static_superclasses(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE rbEnvironment, inherit, rbDefclass;
+	Defclass *defclass;
+	CLIPSValue value;
+	VALUE out;
+
+	rb_scan_args(argc, argv, "11", &rbDefclass, &inherit);
+
+	TypedData_Get_Struct(rbDefclass, Defclass, &Defclass_type, defclass);
+
+	rbEnvironment = rb_iv_get(rbDefclass, "@environment");
+
+	ClassSuperclasses(defclass, &value, RTEST(inherit));
+
+	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_defclass_subclasses(int argc, VALUE *argv, VALUE rbDefclass)
+{
+	VALUE rbEnvironment, inherit;
+	Defclass *defclass;
+	CLIPSValue value;
+	VALUE out;
+
+	rbEnvironment = rb_iv_get(rbDefclass, "@environment");
+
+	rb_scan_args(argc, argv, "01", &inherit);
+
+	if (NIL_P(inherit)) {
+		inherit = Qfalse;
+	}
+
+	TypedData_Get_Struct(rbDefclass, Defclass, &Defclass_type, defclass);
+
+	ClassSubclasses(defclass, &value, RTEST(inherit));
+
+	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_defclass_static_subclasses(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE rbEnvironment, inherit, rbDefclass;
+	Defclass *defclass;
+	CLIPSValue value;
+	VALUE out;
+
+	rb_scan_args(argc, argv, "11", &rbDefclass, &inherit);
+
+	TypedData_Get_Struct(rbDefclass, Defclass, &Defclass_type, defclass);
+
+	rbEnvironment = rb_iv_get(rbDefclass, "@environment");
+
+	ClassSubclasses(defclass, &value, RTEST(inherit));
+
+	CLIPSValue_to_VALUE(&value, &out, &rbEnvironment);
+
+	return out;
+}
 
 static VALUE clips_environment_run(int argc, VALUE *argv, VALUE environment) {
 	VALUE integer;
@@ -1925,6 +2109,223 @@ static VALUE clips_environment_static_find_defmodule(VALUE self, VALUE rbEnviron
 	return clips_environment_find_defmodule(rbEnvironment, defmodule_name);
 }
 
+static VALUE clips_environment_find_instance(int argc, VALUE *argv, VALUE rbEnvironment) {
+	VALUE instanceName, search_imports, rbInstance, rbDefmodule;
+	Defmodule *defmodule;
+	Environment *env;
+	Instance *instance;
+
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	rb_scan_args(argc, argv, "12", &instanceName, &rbDefmodule, &search_imports);
+
+	const char *cinstanceName;
+	switch(TYPE(instanceName))
+	{
+		case T_SYMBOL:
+			cinstanceName = rb_id2name(SYM2ID(instanceName));
+			break;
+		case T_STRING:
+			cinstanceName = StringValueCStr(instanceName);
+			break;
+		default:
+			rb_warn("instance name must be a String or a Symbol");
+			return Qnil;
+	}
+
+	switch (TYPE(rbDefmodule)) {
+		case T_NIL:
+			defmodule = NULL;
+			break;
+		case T_STRING:
+		case T_SYMBOL:
+			rbDefmodule = clips_environment_find_defmodule(rbEnvironment, rbDefmodule);
+			if (rbDefmodule == Qnil) {
+				return Qnil;
+			}
+			TypedData_Get_Struct(rbDefmodule, Defmodule, &Defmodule_type, defmodule);
+			break;
+		case T_DATA:
+			TypedData_Get_Struct(rbDefmodule, Defmodule, &Defmodule_type, defmodule);
+			break;
+                default:
+			rb_warn("defmodule name must be a symbol or string");
+			return Qnil;
+        }
+
+	instance = FindInstance(
+		env,
+		defmodule,
+		cinstanceName,
+		RTEST(search_imports));
+
+	if (instance == NULL) {
+		return Qnil;
+	} else {
+		rbInstance =
+			TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Instance")), &Instance_type, instance);
+
+		rb_iv_set(rbInstance, "@environment", rbEnvironment);
+
+		return rbInstance;
+	}
+}
+
+static VALUE clips_environment_static_find_instance(int argc, VALUE *argv, VALUE klass) {
+	VALUE rbEnvironment, instanceName, rbInstance, rbDefmodule, search_imports;
+	Defmodule *defmodule;
+	Environment *env;
+	Instance *instance;
+
+	rb_scan_args(argc, argv, "22", &rbEnvironment, &instanceName, &rbDefmodule, &search_imports);
+
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	const char *cinstanceName;
+	switch(TYPE(instanceName))
+	{
+		case T_SYMBOL:
+			cinstanceName = rb_id2name(SYM2ID(instanceName));
+			break;
+		case T_STRING:
+			cinstanceName = StringValueCStr(instanceName);
+			break;
+		default:
+			rb_warn("instance name must be a String or a Symbol");
+			return Qnil;
+	}
+
+	switch (TYPE(rbDefmodule)) {
+		case T_NIL:
+			defmodule = NULL;
+			break;
+		case T_STRING:
+		case T_SYMBOL:
+			rbDefmodule = clips_environment_find_defmodule(rbEnvironment, rbDefmodule);
+			if (rbDefmodule == Qnil) {
+				return Qnil;
+			}
+			TypedData_Get_Struct(rbDefmodule, Defmodule, &Defmodule_type, defmodule);
+			break;
+		case T_DATA:
+			TypedData_Get_Struct(rbDefmodule, Defmodule, &Defmodule_type, defmodule);
+			break;
+                default:
+			rb_warn("defmodule name must be a symbol or string");
+			return Qnil;
+        }
+
+	instance = FindInstance(
+		env,
+		defmodule,
+		cinstanceName,
+		RTEST(search_imports));
+
+	if (instance == NULL) {
+		return Qnil;
+	} else {
+		rbInstance =
+			TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Instance")), &Instance_type, instance);
+
+		rb_iv_set(rbInstance, "@environment", rbEnvironment);
+
+		return rbInstance;
+	}
+}
+
+static VALUE clips_environment_defmodule_find_instance(int argc, VALUE *argv, VALUE rbDefmodule) {
+	VALUE instanceName, search_imports, rbInstance, rbEnvironment;
+	Defmodule *defmodule;
+	Environment *env;
+	Instance *instance;
+	const char *cinstanceName;
+
+	TypedData_Get_Struct(rbDefmodule, Defmodule, &Defmodule_type, defmodule);
+
+	rbEnvironment = rb_iv_get(rbDefmodule, "@environment");
+
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+	TypedData_Get_Struct(rbDefmodule, Defmodule, &Defmodule_type, defmodule);
+
+	rb_scan_args(argc, argv, "11", &instanceName, &search_imports);
+
+	switch(TYPE(instanceName))
+	{
+		case T_SYMBOL:
+			cinstanceName = rb_id2name(SYM2ID(instanceName));
+			break;
+		case T_STRING:
+			cinstanceName = StringValueCStr(instanceName);
+			break;
+		default:
+			rb_warn("instance name must be a String or a Symbol");
+			return Qnil;
+	}
+
+	instance = FindInstance(
+		env,
+		defmodule,
+		cinstanceName,
+		RTEST(search_imports));
+
+	if (instance == NULL) {
+		return Qnil;
+	} else {
+		rbInstance =
+			TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Instance")), &Instance_type, instance);
+
+		rb_iv_set(rbInstance, "@environment", rbEnvironment);
+
+		return rbInstance;
+	}
+}
+
+static VALUE clips_environment_defmodule_static_find_instance(int argc, VALUE *argv, VALUE klass) {
+	VALUE rbDefmodule, rbEnvironment, instanceName, search_imports, rbInstance;
+	Defmodule *defmodule;
+	Environment *env;
+	Instance *instance;
+	const char *cinstanceName;
+
+	rb_scan_args(argc, argv, "21", &rbDefmodule, &instanceName, &search_imports);
+
+	rbEnvironment = rb_iv_get(rbDefmodule, "@environment");
+
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+	TypedData_Get_Struct(rbDefmodule, Defmodule, &Defmodule_type, defmodule);
+
+	switch(TYPE(instanceName))
+	{
+		case T_SYMBOL:
+			cinstanceName = rb_id2name(SYM2ID(instanceName));
+			break;
+		case T_STRING:
+			cinstanceName = StringValueCStr(instanceName);
+			break;
+		default:
+			rb_warn("instance name must be a String or a Symbol");
+			return Qnil;
+	}
+
+	instance = FindInstance(
+		env,
+		defmodule,
+		cinstanceName,
+		RTEST(search_imports));
+
+	if (instance == NULL) {
+		return Qnil;
+	} else {
+		rbInstance =
+			TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Instance")), &Instance_type, instance);
+
+		rb_iv_set(rbInstance, "@environment", rbEnvironment);
+
+		return rbInstance;
+	}
+}
+
+
 static VALUE clips_environment_find_deftemplate(VALUE self, VALUE deftemplate_name)
 {
 	Environment *env;
@@ -2159,6 +2560,186 @@ static VALUE clips_environment_static_get_fact_list(int argc, VALUE *argv, VALUE
 	return out;
 }
 
+static VALUE clips_environment_get_instance_list(int argc, VALUE *argv, VALUE rbEnvironment) {
+	VALUE rbDefclass_or_defclass_name, rbDefclass, include_subclasses, rbInstance, returnArray;
+	Environment *env;
+	Defclass *defclass;
+	UDFValue iterator;
+	Instance *theInstance;
+
+	returnArray = rb_ary_new2(0);
+
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+
+	rb_scan_args(argc, argv, "02", &rbDefclass_or_defclass_name, &include_subclasses);
+	// defclass is undefined, ignore include_subclasses
+	if (rbDefclass_or_defclass_name == Qnil) {
+		for (
+			theInstance = GetNextInstance(env,NULL);
+			theInstance != NULL;
+			theInstance = GetNextInstance(env,theInstance)
+		) {
+			rbInstance =
+				TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Instance")), &Instance_type, theInstance);
+
+			rb_iv_set(rbInstance, "@environment", rbEnvironment);
+			rb_ary_push(returnArray, rbInstance);
+		}
+	} else if (include_subclasses != Qtrue) {
+		switch (TYPE(rbDefclass_or_defclass_name)) {
+			case T_STRING:
+			case T_SYMBOL:
+				if (Qnil == (rbDefclass = clips_environment_find_defclass(rbEnvironment, rbDefclass_or_defclass_name))) {
+					rb_warn("could not find defclass");
+					return Qnil;
+				}
+				TypedData_Get_Struct(rbDefclass, Defclass, &Defclass_type, defclass);
+				break;
+			case T_DATA:
+				TypedData_Get_Struct(rbDefclass_or_defclass_name, Defclass, &Defclass_type, defclass);
+				break;
+			default:
+				rb_warn("defclass name must be a symbol or string");
+				return Qnil;
+		}
+		for (
+			theInstance = GetNextInstanceInClass(defclass,NULL);
+			theInstance != NULL;
+			theInstance = GetNextInstanceInClass(defclass,theInstance)
+		) {
+			rbInstance =
+				TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Instance")), &Instance_type, theInstance);
+
+			rb_iv_set(rbInstance, "@environment", rbEnvironment);
+			rb_ary_push(returnArray, rbInstance);
+		}
+	} else if (include_subclasses == Qtrue) {
+		switch (TYPE(rbDefclass_or_defclass_name)) {
+			case T_STRING:
+			case T_SYMBOL:
+				if (Qnil == (rbDefclass = clips_environment_find_defclass(rbEnvironment, rbDefclass_or_defclass_name))) {
+					rb_warn("could not find defclass");
+					return Qnil;
+				}
+				TypedData_Get_Struct(rbDefclass, Defclass, &Defclass_type, defclass);
+				break;
+			case T_DATA:
+				TypedData_Get_Struct(rbDefclass_or_defclass_name, Defclass, &Defclass_type, defclass);
+				break;
+			default:
+				rb_warn("defclass name must be a symbol or string");
+				return Qnil;
+		}
+		for (
+			theInstance = GetNextInstanceInClassAndSubclasses(&defclass,NULL,&iterator);
+			theInstance != NULL;
+			theInstance = GetNextInstanceInClassAndSubclasses(&defclass,theInstance,&iterator)
+		) {
+			rbInstance =
+				TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Instance")), &Instance_type, theInstance);
+
+			rb_iv_set(rbInstance, "@environment", rbEnvironment);
+			rb_ary_push(returnArray, rbInstance);
+		}
+	// unexpected input of some kind...
+	} else {
+		rb_warn("unexpected arguments sent to get_instance_list!");
+		return Qnil;
+	}
+
+	return returnArray;
+}
+
+static VALUE clips_environment_static_get_instance_list(int argc, VALUE *argv, VALUE klass) {
+	VALUE rbEnvironment, rbDefclass_or_defclass_name, rbDefclass, include_subclasses, rbInstance, returnArray;
+	Environment *env;
+	Defclass *defclass;
+	UDFValue iterator;
+	Instance *theInstance;
+
+	returnArray = rb_ary_new2(0);
+
+	rb_scan_args(argc, argv, "12", &rbEnvironment, &rbDefclass_or_defclass_name, &include_subclasses);
+
+	TypedData_Get_Struct(rbEnvironment, Environment, &Environment_type, env);
+	// defclass is undefined, ignore include_subclasses
+	if (rbDefclass_or_defclass_name == Qnil) {
+		for (
+			theInstance = GetNextInstance(env,NULL);
+			theInstance != NULL;
+			theInstance = GetNextInstance(env,theInstance)
+		) {
+			rbInstance =
+				TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Instance")), &Instance_type, theInstance);
+
+			rb_iv_set(rbInstance, "@environment", rbEnvironment);
+			rb_ary_push(returnArray, rbInstance);
+		}
+	} else if (include_subclasses != Qtrue) {
+		switch (TYPE(rbDefclass_or_defclass_name)) {
+			case T_STRING:
+			case T_SYMBOL:
+				if (Qnil == (rbDefclass = clips_environment_find_defclass(rbEnvironment, rbDefclass_or_defclass_name))) {
+					rb_warn("could not find defclass");
+					return Qnil;
+				}
+				TypedData_Get_Struct(rbDefclass, Defclass, &Defclass_type, defclass);
+				break;
+			case T_DATA:
+				TypedData_Get_Struct(rbDefclass_or_defclass_name, Defclass, &Defclass_type, defclass);
+				break;
+			default:
+				rb_warn("defclass name must be a symbol or string");
+				return Qnil;
+		}
+		for (
+			theInstance = GetNextInstanceInClass(defclass,NULL);
+			theInstance != NULL;
+			theInstance = GetNextInstanceInClass(defclass,theInstance)
+		) {
+			rbInstance =
+				TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Instance")), &Instance_type, theInstance);
+
+			rb_iv_set(rbInstance, "@environment", rbEnvironment);
+			rb_ary_push(returnArray, rbInstance);
+		}
+	} else if (include_subclasses == Qtrue) {
+		switch (TYPE(rbDefclass_or_defclass_name)) {
+			case T_STRING:
+			case T_SYMBOL:
+				if (Qnil == (rbDefclass = clips_environment_find_defclass(rbEnvironment, rbDefclass_or_defclass_name))) {
+					rb_warn("could not find defclass");
+					return Qnil;
+				}
+				TypedData_Get_Struct(rbDefclass, Defclass, &Defclass_type, defclass);
+				break;
+			case T_DATA:
+				TypedData_Get_Struct(rbDefclass_or_defclass_name, Defclass, &Defclass_type, defclass);
+				break;
+			default:
+				rb_warn("defclass name must be a symbol or string");
+				return Qnil;
+		}
+		for (
+			theInstance = GetNextInstanceInClassAndSubclasses(&defclass,NULL,&iterator);
+			theInstance != NULL;
+			theInstance = GetNextInstanceInClassAndSubclasses(&defclass,theInstance,&iterator)
+		) {
+			rbInstance =
+				TypedData_Wrap_Struct(rb_const_get(CLASS_OF(rbEnvironment), rb_intern("Instance")), &Instance_type, theInstance);
+
+			rb_iv_set(rbInstance, "@environment", rbEnvironment);
+			rb_ary_push(returnArray, rbInstance);
+		}
+	// unexpected input of some kind...
+	} else {
+		rb_warn("unexpected arguments sent to get_instance_list!");
+		return Qnil;
+	}
+
+	return returnArray;
+}
+
 static VALUE clips_environment_get_deftemplate_list(int argc, VALUE *argv, VALUE rbEnvironment) {
 	VALUE defmodule_or_defmodule_name;
 	Environment *env;
@@ -3506,12 +4087,16 @@ void Init_clipsruby(void)
 	rb_define_method(rbEnvironment, "find_deftemplate", clips_environment_find_deftemplate, 1);
 	rb_define_singleton_method(rbEnvironment, "find_defclass", clips_environment_static_find_defclass, 2);
 	rb_define_method(rbEnvironment, "find_defclass", clips_environment_find_defclass, 1);
+	rb_define_singleton_method(rbEnvironment, "find_instance", clips_environment_static_find_instance, -1);
+	rb_define_method(rbEnvironment, "find_instance", clips_environment_find_instance, -1);
 	rb_define_singleton_method(rbEnvironment, "get_current_module", clips_environment_static_get_current_module, 1);
 	rb_define_method(rbEnvironment, "get_current_module", clips_environment_get_current_module, 0);
 	rb_define_singleton_method(rbEnvironment, "set_current_module", clips_environment_static_set_current_module, 2);
 	rb_define_method(rbEnvironment, "set_current_module", clips_environment_set_current_module, 1);
 	rb_define_singleton_method(rbEnvironment, "get_fact_list", clips_environment_static_get_fact_list, -1);
 	rb_define_method(rbEnvironment, "get_fact_list", clips_environment_get_fact_list, -1);
+	rb_define_singleton_method(rbEnvironment, "get_instance_list", clips_environment_static_get_instance_list, -1);
+	rb_define_method(rbEnvironment, "get_instance_list", clips_environment_get_instance_list, -1);
 	rb_define_singleton_method(rbEnvironment, "get_deftemplate_list", clips_environment_static_get_deftemplate_list, -1);
 	rb_define_method(rbEnvironment, "get_deftemplate_list", clips_environment_get_deftemplate_list, -1);
 	rb_define_singleton_method(rbEnvironment, "get_defclass_list", clips_environment_static_get_defclass_list, -1);
@@ -3649,6 +4234,8 @@ void Init_clipsruby(void)
 	rb_define_method(rbDefmodule, "get_deftemplate_list", clips_environment_defmodule_get_deftemplate_list, 0);
 	rb_define_singleton_method(rbDefmodule, "get_defrule_list", clips_environment_defmodule_static_get_defrule_list, 1);
 	rb_define_method(rbDefmodule, "get_defrule_list", clips_environment_defmodule_get_defrule_list, 0);
+	rb_define_singleton_method(rbDefmodule, "find_instance", clips_environment_defmodule_static_find_instance, -1);
+	rb_define_method(rbDefmodule, "find_instance", clips_environment_defmodule_find_instance, -1);
 
 	VALUE rbFact = rb_define_class_under(rbEnvironment, "Fact", rb_cObject);
 	rb_define_alloc_func(rbFact, fact_alloc);
@@ -3700,6 +4287,12 @@ void Init_clipsruby(void)
 	rb_define_method(rbDefclass, "defmodule_name", clips_environment_defclass_defmodule_name, 0);
 	rb_define_singleton_method(rbDefclass, "pp_form", clips_environment_defclass_static_pp_form, 1);
 	rb_define_method(rbDefclass, "pp_form", clips_environment_defclass_pp_form, 0);
+	rb_define_singleton_method(rbDefclass, "get_instance_list", clips_environment_defclass_static_get_instance_list, -1);
+	rb_define_method(rbDefclass, "get_instance_list", clips_environment_defclass_get_instance_list, -1);
+	rb_define_singleton_method(rbDefclass, "superclasses", clips_environment_defclass_static_superclasses, -1);
+	rb_define_method(rbDefclass, "superclasses", clips_environment_defclass_superclasses, -1);
+	rb_define_singleton_method(rbDefclass, "subclasses", clips_environment_defclass_static_subclasses, -1);
+	rb_define_method(rbDefclass, "subclasses", clips_environment_defclass_subclasses, -1);
 
 	VALUE rbInstance = rb_define_class_under(rbEnvironment, "Instance", rb_cObject);
 	rb_define_alloc_func(rbInstance, instance_alloc);
@@ -3707,8 +4300,8 @@ void Init_clipsruby(void)
 	rb_define_method(rbInstance, "unmake", clips_environment_instance_unmake, 0);
 	rb_define_singleton_method(rbInstance, "delete", clips_environment_instance_static_delete, 1);
 	rb_define_method(rbInstance, "delete", clips_environment_instance_delete, 0);
-	rb_define_singleton_method(rbInstance, "_class", clips_environment_instance_static_class, 1);
-	rb_define_method(rbInstance, "_class", clips_environment_instance_class, 0);
+	rb_define_singleton_method(rbInstance, "defclass", clips_environment_instance_static_defclass, 1);
+	rb_define_method(rbInstance, "defclass", clips_environment_instance_defclass, 0);
 	rb_define_singleton_method(rbInstance, "name", clips_environment_instance_static_name, 1);
 	rb_define_method(rbInstance, "name", clips_environment_instance_name, 0);
 	rb_define_singleton_method(rbInstance, "pp_form", clips_environment_instance_static_pp_form, 1);

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: clipsruby
 version: !ruby/object:Gem::Version
-  version: 0.0.34
+  version: 0.0.36
 platform: ruby
 authors:
 - Ryan Johnston
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-25 00:00:00.000000000 Z
+date: 2024-09-28 00:00:00.000000000 Z
 dependencies: []
 description: Calling the CLIPS programming language from within Ruby
 email: mrryanjohnston@gmail.com