clipsruby 0.0.25 → 0.0.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1856bf108cc073000e859ba1b7552a781471fef0503640a2741d555990b74ae8
-  data.tar.gz: 667938c636e983f3ae6f90c3ba20363273f7189c5cdfc9e0d472c34c97656b01
+  metadata.gz: 78727d42b56ea442a2ff5b487d3cc209bcfda2068724a7507021fa44845dee9c
+  data.tar.gz: f22f44dc57cdf4d8e1491b1b9790c45a15264b9fcad34b3b768e6deb9655a475
 SHA512:
-  metadata.gz: d2c746946cb8d3bcf43c59587d61c95e636d04b233c8065354f1b16319ef5e195cd5004ddf56e2083a9837995ed21685c71d3bc7bad815066f50039e33af18ec
-  data.tar.gz: 5ef09dd92b97e409b012c7183673d11871a3bba2e494467bbf84f91d31e1db29d40c67b6fd2c242d22af113f6a9c6c14ebdde771a7486bbf7299f324608ba216
+  metadata.gz: abd28dcfe9303c838636a209fdcd1d043ae7c0fa72b84ae49ea52c2e79aed9f2d65c58cd02746cdfd9bc4230476dcb4289ea32cc36f2e335ba54371008146e3b
+  data.tar.gz: a9dd833a9d045713eb20ab356d65bb80c7a61d528518f5b7dd83482a059042a3499f3fb33f06259ab667af3fc2dea22102bcb103acf50f41900537301980d5d0

data/README.md

@@ -621,6 +621,101 @@ CLIPS::Environment::Deftemplate.slot_default_value(deftemplate, :foo)
 deftemplate.slot_default_value('bar')
 ```
 
+### `CLIPS::Environment::Deftemplate.slot_types`
+### `CLIPS::Environment::Deftemplate#slot_types`
+
+Returns the slot type(s) for the named slot of a deftemplate as symbols.
+Possible types are as follows:
+
+```ruby
+:SYMBOL
+:STRING
+:LEXEME
+:INTEGER
+:FLOAT
+:NUMBER
+:"INSTANCE-NAME"
+:"INSTANCE-ADDRESS"
+:INSTANCE
+:"EXTERNAL-ADDRESS"
+:"FACT-ADDRESS"
+```
+
+```ruby
+CLIPS::Environment::Deftemplate.slot_types(deftemplate, :foo)
+deftemplate.slot_types('bar')
+```
+
+### `CLIPS::Environment::Deftemplate.slot_range`
+### `CLIPS::Environment::Deftemplate#slot_range`
+
+Returns the range of a named slot of a deftemplate as integers or symbols (in case of infinity).
+
+```ruby
+CLIPS::Environment::Deftemplate.slot_range(deftemplate, :foo)
+deftemplate.slot_range('bar')
+```
+
+### `CLIPS::Environment::Deftemplate.slot_cardinality`
+### `CLIPS::Environment::Deftemplate#slot_cardinality`
+
+Returns the cardinality of a named slot of a deftemplate as integers or symbols (in case of infinity).
+
+```ruby
+CLIPS::Environment::Deftemplate.slot_cardinality(deftemplate, :foo)
+deftemplate.slot_cardinality('bar')
+```
+
+### `CLIPS::Environment::Deftemplate.slot_existp`
+### `CLIPS::Environment::Deftemplate#slot_existp`
+
+Returns a boolean for whether or not the slot with a given name
+exists on the Deftemplate.
+
+```ruby
+CLIPS::Environment::Deftemplate.slot_existp(deftemplate, :foo)
+deftemplate.slot_existp('bar')
+```
+
+### `CLIPS::Environment::Deftemplate.slot_singlep`
+### `CLIPS::Environment::Deftemplate#slot_singlep`
+
+Returns a boolean for whether or not the slot with a given name
+on the Deftemplate is a single slot.
+
+```ruby
+CLIPS::Environment::Deftemplate.slot_singlep(deftemplate, :foo)
+deftemplate.slot_singlep('bar')
+```
+
+### `CLIPS::Environment::Deftemplate.slot_multip`
+### `CLIPS::Environment::Deftemplate#slot_multip`
+
+Returns a boolean for whether or not the slot with a given name
+on the Deftemplate is a multislot.
+
+```ruby
+CLIPS::Environment::Deftemplate.slot_multip(deftemplate, :foo)
+deftemplate.slot_multip('bar')
+```
+
+### `CLIPS::Environment::Deftemplate.slot_defaultp`
+### `CLIPS::Environment::Deftemplate#slot_defaultp`
+
+Returns a symbol representing the type of default value a slot has
+on the Deftemplate. Possible return values are as follows:
+
+```ruby
+:NO_DEFAULT
+:STATIC_DEFAULT
+:DYNAMIC_DEFAULT
+```
+
+```ruby
+CLIPS::Environment::Deftemplate.slot_defaultp(deftemplate, :foo)
+deftemplate.slot_defaultp('bar')
+```
+
 ### `CLIPS::Environment::Defmodule.get_deftemplate_list`
 ### `CLIPS::Environment::Defmodule#get_deftemplate_list`
 

data/ext/clipsruby/clipsruby.c

@@ -1300,6 +1300,99 @@ static VALUE clips_environment_deftemplate_static_slot_default_value(VALUE self,
 }
 
 
+static VALUE clips_environment_deftemplate_slot_types(VALUE self, VALUE slot_name)
+{
+	Deftemplate *template;
+	CLIPSValue slot_types;
+	VALUE out;
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+
+	TypedData_Get_Struct(self, Deftemplate, &Deftemplate_type, template);
+
+	switch (TYPE(slot_name)) {
+		case T_STRING:
+			DeftemplateSlotTypes(template, StringValueCStr(slot_name), &slot_types);
+			break;
+		case T_SYMBOL:
+			DeftemplateSlotTypes(template, rb_id2name(SYM2ID(slot_name)), &slot_types);
+			break;
+                default:
+			rb_warn("slot name must be string or symbol in call to slot_types!");
+			return Qnil;
+        }
+
+	CLIPSValue_to_VALUE(&slot_types, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_deftemplate_static_slot_types(VALUE self, VALUE rbEnvironment, VALUE slot_name)
+{
+	return clips_environment_deftemplate_slot_types(rbEnvironment, slot_name);
+}
+
+static VALUE clips_environment_deftemplate_slot_range(VALUE self, VALUE slot_name)
+{
+	Deftemplate *template;
+	CLIPSValue slot_range;
+	VALUE out;
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+
+	TypedData_Get_Struct(self, Deftemplate, &Deftemplate_type, template);
+
+	switch (TYPE(slot_name)) {
+		case T_STRING:
+			DeftemplateSlotRange(template, StringValueCStr(slot_name), &slot_range);
+			break;
+		case T_SYMBOL:
+			DeftemplateSlotRange(template, rb_id2name(SYM2ID(slot_name)), &slot_range);
+			break;
+                default:
+			rb_warn("slot name must be string or symbol in call to slot_range!");
+			return Qnil;
+        }
+
+	CLIPSValue_to_VALUE(&slot_range, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_deftemplate_static_slot_range(VALUE self, VALUE rbEnvironment, VALUE slot_name)
+{
+	return clips_environment_deftemplate_slot_range(rbEnvironment, slot_name);
+}
+
+static VALUE clips_environment_deftemplate_slot_cardinality(VALUE self, VALUE slot_name)
+{
+	Deftemplate *template;
+	CLIPSValue slot_cardinality;
+	VALUE out;
+	VALUE rbEnvironment = rb_iv_get(self, "@environment");
+
+	TypedData_Get_Struct(self, Deftemplate, &Deftemplate_type, template);
+
+	switch (TYPE(slot_name)) {
+		case T_STRING:
+			DeftemplateSlotCardinality(template, StringValueCStr(slot_name), &slot_cardinality);
+			break;
+		case T_SYMBOL:
+			DeftemplateSlotCardinality(template, rb_id2name(SYM2ID(slot_name)), &slot_cardinality);
+			break;
+                default:
+			rb_warn("slot name must be string or symbol in call to slot_cardinality!");
+			return Qnil;
+        }
+
+	CLIPSValue_to_VALUE(&slot_cardinality, &out, &rbEnvironment);
+
+	return out;
+}
+
+static VALUE clips_environment_deftemplate_static_slot_cardinality(VALUE self, VALUE rbEnvironment, VALUE slot_name)
+{
+	return clips_environment_deftemplate_slot_cardinality(rbEnvironment, slot_name);
+}
+
 static VALUE clips_environment_fact_retract(VALUE self)
 {
 	Fact *fact;
@@ -1999,6 +2092,136 @@ static VALUE clips_environment_deftemplate_static_is_deletable(VALUE self, VALUE
 	return clips_environment_deftemplate_is_deletable(rbDeftemplate);
 }
 
+static VALUE clips_environment_deftemplate_slot_existp(VALUE self, VALUE slot_name)
+{
+	Deftemplate *deftemplate;
+	const char *cslot_name;
+	switch(TYPE(slot_name))
+	{
+		case T_SYMBOL:
+			cslot_name = rb_id2name(SYM2ID(slot_name));
+			break;
+		case T_STRING:
+			cslot_name = StringValueCStr(slot_name);
+			break;
+		default:
+			rb_raise(rb_eTypeError, "Slot name must be a String or a Symbol");
+			return ST_CONTINUE;
+	}
+
+	TypedData_Get_Struct(self, Deftemplate, &Deftemplate_type, deftemplate);
+
+	if (DeftemplateSlotExistP(deftemplate, cslot_name)) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+static VALUE clips_environment_deftemplate_static_slot_existp(VALUE self, VALUE rbDeftemplate, VALUE slot_name)
+{
+	return clips_environment_deftemplate_slot_existp(rbDeftemplate, slot_name);
+}
+
+static VALUE clips_environment_deftemplate_slot_singlep(VALUE self, VALUE slot_name)
+{
+	Deftemplate *deftemplate;
+	const char *cslot_name;
+	switch(TYPE(slot_name))
+	{
+		case T_SYMBOL:
+			cslot_name = rb_id2name(SYM2ID(slot_name));
+			break;
+		case T_STRING:
+			cslot_name = StringValueCStr(slot_name);
+			break;
+		default:
+			rb_raise(rb_eTypeError, "Slot name must be a String or a Symbol");
+			return ST_CONTINUE;
+	}
+
+	TypedData_Get_Struct(self, Deftemplate, &Deftemplate_type, deftemplate);
+
+	if (DeftemplateSlotSingleP(deftemplate, cslot_name)) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+static VALUE clips_environment_deftemplate_static_slot_singlep(VALUE self, VALUE rbDeftemplate, VALUE slot_name)
+{
+	return clips_environment_deftemplate_slot_singlep(rbDeftemplate, slot_name);
+}
+
+static VALUE clips_environment_deftemplate_slot_multip(VALUE self, VALUE slot_name)
+{
+	Deftemplate *deftemplate;
+	const char *cslot_name;
+	switch(TYPE(slot_name))
+	{
+		case T_SYMBOL:
+			cslot_name = rb_id2name(SYM2ID(slot_name));
+			break;
+		case T_STRING:
+			cslot_name = StringValueCStr(slot_name);
+			break;
+		default:
+			rb_raise(rb_eTypeError, "Slot name must be a String or a Symbol");
+			return ST_CONTINUE;
+	}
+
+	TypedData_Get_Struct(self, Deftemplate, &Deftemplate_type, deftemplate);
+
+	if (DeftemplateSlotMultiP(deftemplate, cslot_name)) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+static VALUE clips_environment_deftemplate_static_slot_multip(VALUE self, VALUE rbDeftemplate, VALUE slot_name)
+{
+	return clips_environment_deftemplate_slot_multip(rbDeftemplate, slot_name);
+}
+
+static VALUE clips_environment_deftemplate_slot_defaultp(VALUE self, VALUE slot_name)
+{
+	Deftemplate *deftemplate;
+	const char *cslot_name;
+	switch(TYPE(slot_name))
+	{
+		case T_SYMBOL:
+			cslot_name = rb_id2name(SYM2ID(slot_name));
+			break;
+		case T_STRING:
+			cslot_name = StringValueCStr(slot_name);
+			break;
+		default:
+			rb_warn("Slot name must be a String or a Symbol");
+			return Qnil;
+	}
+
+	TypedData_Get_Struct(self, Deftemplate, &Deftemplate_type, deftemplate);
+
+	switch (DeftemplateSlotDefaultP(deftemplate, cslot_name)) {
+		case NO_DEFAULT:
+			return ID2SYM(rb_intern("NO_DEFAULT"));
+		case STATIC_DEFAULT:
+			return ID2SYM(rb_intern("STATIC_DEFAULT"));
+		case DYNAMIC_DEFAULT:
+			return ID2SYM(rb_intern("DYNAMIC_DEFAULT"));
+		default:
+			rb_warn("CLIPS returned something we didn't expect for slot_defaultp...");
+			return Qnil;
+	}
+}
+
+static VALUE clips_environment_deftemplate_static_slot_defaultp(VALUE self, VALUE rbDeftemplate, VALUE slot_name)
+{
+	return clips_environment_deftemplate_slot_defaultp(rbDeftemplate, slot_name);
+}
+
 static VALUE clips_environment_defrule_has_breakpoint(VALUE self)
 {
 	Defrule *defrule;
@@ -2844,6 +3067,20 @@ void Init_clipsruby(void)
 	rb_define_method(rbDeftemplate, "slot_allowed_values", clips_environment_deftemplate_slot_allowed_values, 1);
 	rb_define_singleton_method(rbDeftemplate, "slot_default_value", clips_environment_deftemplate_static_slot_default_value, 2);
 	rb_define_method(rbDeftemplate, "slot_default_value", clips_environment_deftemplate_slot_default_value, 1);
+	rb_define_singleton_method(rbDeftemplate, "slot_types", clips_environment_deftemplate_static_slot_types, 2);
+	rb_define_method(rbDeftemplate, "slot_types", clips_environment_deftemplate_slot_types, 1);
+	rb_define_singleton_method(rbDeftemplate, "slot_range", clips_environment_deftemplate_static_slot_range, 2);
+	rb_define_method(rbDeftemplate, "slot_range", clips_environment_deftemplate_slot_range, 1);
+	rb_define_singleton_method(rbDeftemplate, "slot_cardinality", clips_environment_deftemplate_static_slot_cardinality, 2);
+	rb_define_method(rbDeftemplate, "slot_cardinality", clips_environment_deftemplate_slot_cardinality, 1);
+	rb_define_singleton_method(rbDeftemplate, "slot_existp", clips_environment_deftemplate_static_slot_existp, 2);
+	rb_define_method(rbDeftemplate, "slot_existp", clips_environment_deftemplate_slot_existp, 1);
+	rb_define_singleton_method(rbDeftemplate, "slot_singlep", clips_environment_deftemplate_static_slot_singlep, 2);
+	rb_define_method(rbDeftemplate, "slot_singlep", clips_environment_deftemplate_slot_singlep, 1);
+	rb_define_singleton_method(rbDeftemplate, "slot_multip", clips_environment_deftemplate_static_slot_multip, 2);
+	rb_define_method(rbDeftemplate, "slot_multip", clips_environment_deftemplate_slot_multip, 1);
+	rb_define_singleton_method(rbDeftemplate, "slot_defaultp", clips_environment_deftemplate_static_slot_defaultp, 2);
+	rb_define_method(rbDeftemplate, "slot_defaultp", clips_environment_deftemplate_slot_defaultp, 1);
 
 	VALUE rbDefmodule = rb_define_class_under(rbEnvironment, "Defmodule", rb_cObject);
 	rb_define_alloc_func(rbDefmodule, defmodule_alloc);

metadata

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