mochapowered/mocha-dotnet
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

massive update implementing more method types with all green tests:)

Browse Source
This commit is contained in:
Michael Becker 2024-08-01 22:52:29 -04:00
parent e69a5abafb
commit 8f7ac58456
60 changed files with 1973 additions and 260 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
mocha-dotnet/src/lib/Mocha.Core/InstanceHandle.cs
View File

@ -79,6 +79,10 @@ namespace Mocha.Core
if (IsEmpty)
return "(empty) ";
if (Oms.DebugOms != null)
{
return Oms.DebugOms.GetInstanceText(this);
}
return _ID.ToString();
}

1
mocha-dotnet/src/lib/Mocha.Core/KnownAttributeGuids.cs
View File

@ -29,6 +29,7 @@ namespace Mocha.Core
}
public static class Boolean
{
public static Guid MethodIsOfTypeSpecified { get; } = new Guid("{6e9df667-0f95-4320-a4be-5cdb00f1d4ee}");
public static Guid DisplayVersionInBadge { get; } = new Guid("{BE5966A4-C4CA-49A6-B504-B6E8759F392D}");
public static Guid Editable { get; } = new Guid("{957fd8b3-fdc4-4f35-87d6-db1c0682f53c}");
public static Guid Static { get; } = new Guid("{9A3A0719-64C2-484F-A55E-22CD4597D9FD}");

57
mocha-dotnet/src/lib/Mocha.Core/KnownInstanceGuids.cs
View File

@ -44,10 +44,15 @@ namespace Mocha.Core
public static Guid Method { get; } = new Guid("{D2813913-80B6-4DD6-9AD6-56D989169734}");
public static Guid AccumulationFunction { get; } = new Guid("{64f1b972-63c8-46c9-94a5-17a3cab957fe}");
public static Guid SelectionFunction { get; } = new Guid("{bdaef55d-9905-4d24-84c2-7439d43a79df}");
// public static Guid MethodCall { get; } = new Guid("{084A6D58-32C9-4A5F-9D2B-86C46F74E522}");
public static Guid ConditionGroup { get; } = new Guid("{df2059e6-650c-49a8-8188-570ccbe4fd2d}");
public static Guid ConditionalEvaluationCase { get; } = new Guid("{ba18abdc-11ae-46af-850a-eb30280b0ffa}");
public static Guid ConditionalSelectAttributeCase { get; } = new Guid("{a1115690-c400-4e3e-9c8f-24e2a9477e8f}");
public static Guid ConditionalSelectFromInstanceSetCase { get; } = new Guid("{d799b07a-3f9e-4cb2-bd91-40ffa688ccb1}");
public static Guid AccessModifier { get; } = new Guid("{ca4fcc11-16c8-4872-a712-82e589d382ce}");
@ -136,6 +141,11 @@ namespace Mocha.Core
public static Guid CommonBoolean { get; } = new Guid("{5b025da3-b7bd-45a9-b084-48c4a922bf72}");
public static Guid CommonInstanceSet { get; } = new Guid("{3382da21-4fc5-45dc-bbd1-f7ba3ece1a1b}");
public static Guid BooleanOperator { get; } = new Guid("{fb85933c-e2ad-4b1c-ac2a-f92c9cc57e1c}");
public static Guid RelationalOperator { get; } = new Guid("{f1b5d26f-2347-49cb-8aae-d80dd706fce2}");
public static Guid LogicalOperator { get; } = new Guid("{340d464a-b47d-40a2-a185-be4d974b5899}");
public static Guid ArithmeticOperator { get; } = new Guid("{8196e8b1-849d-4b18-a78b-5684dca7b7f4}");
}
public static class Methods
{
@ -148,6 +158,16 @@ namespace Mocha.Core
public static Guid Tenant__get__Current_Tenant { get; } = new Guid("{22ec44d5-bede-48bb-96ca-03481611422c}");
public static Guid Instance__get__This_Instance { get; } = new Guid("{d78fe3ca-3c15-41a0-bccf-0a701b4712a4}");
}
public static class GetRelationship
{
public static Guid Instance__get__Parent_Class { get; } = new Guid("{bac8c59f-8994-41e8-b0c0-659ec8efc4e2}");
// public static Guid Method__get__Parent_Class__HACK { get; } = new Guid("{89034a1c-50e5-47a1-abb8-076ece5343a8}");
}
public static class ConditionalSelectAttribute
{
public static Guid Method__get__Method_Abbreviation { get; } = new Guid("{f0c64709-385d-481b-8f58-83e507fb261c}");
public static Guid Method_Binding__get__Method_Binding_Abbreviation { get; } = new Guid("{7154cb08-0f80-4af4-bca5-c2c12e54479a}");
}
}
[ExportEntities(Prefix = "IDC_", Suffix = null)]
@ -202,12 +222,19 @@ namespace Mocha.Core
public static Guid InstanceOpMethod { get; } = new Guid("{4c814982-938f-4116-bdc1-827bae6a5f71}");
public static Guid ConditionalSelectAttributeMethod { get; } = new Guid("{d534a369-321e-4c32-bd7f-8ff2017f191e}"); // 13038
// SSC - Conditional Select from Instance Set Method - 13039
public static Guid ConditionalSelectFromInstanceSetMethod { get; } = new Guid("{ffea8e52-06e5-4e95-8c40-da3ba54ce95f}"); // 13039
}
public static class SystemAttributeRoutines
{
public static Guid GetRuntimeVersion { get; } = new Guid("{dc4e6c8d-936d-457f-90e9-af47e229b80c}");
// public static Guid SystemInstanceSetRoutine { get; } = new Guid("{d17a6d27-da03-4b5d-9256-f67f978f403d}");
}
public static class SystemInstanceSetRoutines
{
public static Guid GetRuntimeVersion { get; } = new Guid("{dc4e6c8d-936d-457f-90e9-af47e229b80c}");
// public static Guid SystemInstanceSetRoutine { get; } = new Guid("{d17a6d27-da03-4b5d-9256-f67f978f403d}");
}
public static class PromptValueClasses
{
public static Guid InstancePromptValue { get; } = new Guid("{0A6E2CF2-97B6-4339-B1DA-1DBBFE9806C6}");
@ -327,5 +354,35 @@ namespace Mocha.Core
/// <value>The GUID of the `Obscured Text` EC Display Option.</value>
public static Guid ObscuredText { get; } = new Guid("{e42fb627-6559-42e7-a8fe-59c9d674eec4}");
}
public static class AccumulationFunctions
{
public static Guid Sum { get; } = new Guid("{c84c3615-c418-4273-8212-cb7766d95ee4}");
public static Guid Average { get; } = new Guid("{57eb3ded-96fe-4faa-98af-3edd9ed13ab4}");
}
public static class SelectionFunctions
{
public static Guid Minimum { get; } = new Guid("{1ff7be8c-fe48-4154-9028-8ee84b7dc367}");
public static Guid Maximum { get; } = new Guid("{dda6c31d-5bea-41a9-a6bc-0e5c189784da}");
}
public static class RelationalOperators
{
public static Guid SubsetOfSelectionList { get; } = new Guid("{76d42d7c-f7da-4df6-92cc-b362e3a87d7b}");
public static Guid IsEmpty { get; } = new Guid("{b416747b-537f-46f9-b855-e71ca361d265}");
public static Guid CountGreaterThan { get; } = new Guid("{dbc516aa-0fd9-47a9-bab5-8cede4102af6}");
public static Guid CountLessThan { get; } = new Guid("{5101eb0d-bce3-4f1e-b4b1-e75f68a42829}");
public static Guid CountEqualTo { get; } = new Guid("{beef419c-4375-41f2-909a-af8dded51d04}");
public static Guid CountGreaterThanOrEqualTo { get; } = new Guid("{3579168f-52bc-49f3-be6f-a548ac74f502}");
public static Guid CountLessThanOrEqualTo { get; } = new Guid("{bc05d0b7-59ee-42cc-91e9-90a1e0b3ed85}");
public static Guid SupersetOfSelectionList { get; } = new Guid("{67d2da4e-d147-4526-9a94-526f0d79ec9c}");
public static Guid CountNotEqualTo { get; } = new Guid("{92ac4ea4-b034-4b09-be67-c39608ae2ecf}");
public static Guid IsNotEmpty { get; } = new Guid("{aeb5a45f-2aff-4b2b-8f6d-f05f50bc8f8c}");
public static Guid NotInSelectionList { get; } = new Guid("{7fde8600-680b-4c07-be3b-2660f00b01c2}");
public static Guid InSelectionList { get; } = new Guid("{824417e6-61e5-4e74-9e95-514905c01846}");
public static Guid NotSupersetOfSelectionList { get; } = new Guid("{8e695935-548a-4177-a474-581fc960eddb}");
public static Guid NotSubsetOfSelectionList { get; } = new Guid("{ef7726d6-2feb-426c-bf2c-770014d35f68}");
public static Guid NotExactMatchWithSelectionList { get; } = new Guid("{f08a632a-1f3e-4979-8ec5-17fefc33b865}");
public static Guid ExactMatchWithSelectionList { get; } = new Guid("{93611da1-e21e-4021-9ddd-f7575e0c79ec}");
}
}
}

69
mocha-dotnet/src/lib/Mocha.Core/KnownRelationshipGuids.cs
View File

@ -101,8 +101,10 @@ namespace Mocha.Core
public static Guid Parameter_Assignment__assigns_to__Parameter { get; } = new Guid("{a6d30e78-7bff-4fcc-b109-ee96681b0a9e}");
public static Guid Parameter__assigned_from__Parameter_Assignment { get; } = new Guid("{2085341e-5e7e-4a7f-bb8d-dfa58f6030d9}");
public static Guid Method_Binding__assigned_to__Parameter_Assignment { get; } = new Guid("{cbcb23b7-10c4-49eb-a1ca-b9da73fe8b83}");
public static Guid Parameter_Assignment__assigns_from__Method_Binding { get; } = new Guid("{1e055d30-a968-49d8-93fe-541994fc0c51}");
public static Guid Executable_returning_Work_Data__assigned_from__Parameter_Assignment { get; } = new Guid("{40540642-69b3-4713-ac55-6946060bd385}");
public static Guid Parameter_Assignment__assigns_from__Executable_returning_Work_Data { get; } = new Guid("{6f3687ed-7d88-4ece-914e-c47c57c1146d}");
public static Guid Parameter_Assignment__assigns_to__Work_Data { get; } = new Guid("{51c37636-35d2-4528-99ca-50cf09fa1427}");
public static Guid Work_Data__assigned_by__Parameter_Assignment { get; } = new Guid("{b9e0cc99-ef20-435f-b7b2-e19c5cd44916}");
public static Guid Method_Call__has__Method { get; } = new Guid("{3D3B601B-4EF0-49F3-AF05-86CEA0F00619}");
public static Guid Method_Call__has__Prompt_Value { get; } = new Guid("{765BD0C9-117D-4D0E-88C9-2CEBD4898135}");
@ -128,8 +130,17 @@ namespace Mocha.Core
public static Guid Get_Referenced_Instance_Set_Method__loop_on__Instance_Set { get; } = new Guid("{2978238f-7cb0-4ba3-8c6f-473df782cfef}");
public static Guid Get_Referenced_Instance_Set_Method__has_relationship__Method { get; } = new Guid("{6a65819e-c8cb-4575-9af8-ee221364049b}");
public static Guid Get_Referenced_Attribute_Method__has__Attribute { get; } = new Guid("{87f90fe9-5ec6-4b09-8f51-b8a4d1544cae}");
public static Guid Get_Referenced_Attribute_Method__loop_on__Instance_Set { get; } = new Guid("{c7ecd498-6d05-4e07-b1bc-f7127d0d6666}");
public static Guid Get_Referenced_Attribute_Method__returns__Attribute { get; } = new Guid("{87f90fe9-5ec6-4b09-8f51-b8a4d1544cae}");
public static Guid Attribute__returned_by__Get_Referenced_Attribute_Method { get; } = new Guid("{80e4ffd8-77d8-4835-a4e0-73a176e7f646}");
public static Guid Get_Referenced_Attribute_Method__uses_reference__Executable_returning_Instance_Set { get; } = new Guid("{c7ecd498-6d05-4e07-b1bc-f7127d0d6666}");
public static Guid Executable_returning_Instance_Set__reference_used_by__Get_Referenced_Attribute_Method { get; } = new Guid("{b9a44398-e6c5-48f9-8ec5-a8b158a7adf5}");
public static Guid Get_Referenced_Attribute_Method__uses_answer__Executable_returning_Attribute { get; } = new Guid("{022ccde3-2b9e-4573-a8fc-e7568f420cd3}");
public static Guid Executable_returning_Attribute__answer_used_by__Get_Referenced_Attribute_Method { get; } = new Guid("{738ff9a4-eb71-476e-a0a4-524f1de56add}");
public static Guid Get_Referenced_Attribute_Method__uses__Accumulation_Function { get; } = new Guid("{68888355-a162-40b3-8dd6-532bf84d219a}");
public static Guid Accumulation_Function__used_by__Get_Referenced_Attribute_Method { get; } = new Guid("{a3af2e78-78ab-4c99-a2d2-f359aa7966cd}");
public static Guid Get_Referenced_Attribute_Method__uses_order__Executable_returning_Attribute { get; } = new Guid("{ee8e21c4-1afc-403a-a3f0-4c1544285f5c}");
public static Guid Executable_returning_Attribute__order_used_by__Get_Referenced_Attribute_Method { get; } = new Guid("{dec00186-e3c8-4440-ae23-dc9e91bccb49}");
public static Guid Evaluate_Boolean_Expression_Method__has_source_attribute__Method { get; } = new Guid("{45d76d56-01ed-4641-9f68-cfe0c7d0d265}");
public static Guid Evaluate_Boolean_Expression_Method__equal_to_attribute__Method { get; } = new Guid("{0646df91-7e3e-4d59-be71-b978a22ced8e}");
@ -230,7 +241,9 @@ namespace Mocha.Core
public static Guid Method__provides_content_for__Content_Page_Component { get; } = new Guid("{5E75000D-2421-4AD4-9E5F-B9FDD9CB4744}");
public static Guid Securable_Item__secured_by__Method { get; } = new Guid("{15199c49-9595-4288-846d-13b0ad5dcd4b}");
public static Guid Get_Relationship_Method__has__Relationship { get; } = new Guid("{321581d6-60c1-4547-8344-9d5bda027adc}");
public static Guid Get_Relationship_Method__returns__Relationship { get; } = new Guid("{321581d6-60c1-4547-8344-9d5bda027adc}");
public static Guid Relationship__returned_by__Get_Relationship_Method { get; } = new Guid("{174242ec-7615-42d9-9639-c70ff6e84e0d}");
public static Guid Integration_ID__has__Integration_ID_Usage { get; } = new Guid("{6cd30735-df83-4253-aabe-360d6e1a3701}");
public static Guid Integration_ID_Usage__for__Integration_ID { get; } = new Guid("{d8d981ec-7686-40da-b89f-006c85042444}");
@ -241,11 +254,11 @@ namespace Mocha.Core
public static Guid Conditional_Method_Case__has_return_attribute__Method_Binding { get; } = new Guid("{b6715132-b438-4073-b81d-3ecf19584b7d}");
public static Guid Method_Binding__returns_attribute_for__Conditional_Method_Case { get; } = new Guid("{1c868a06-8fb7-432d-839b-7a5a02a50eb6}");
public static Guid Conditional_Method_Case__has_true_condition__Method_Binding { get; } = new Guid("{d955da3f-7ef4-4374-8b86-167c73434f75}");
public static Guid Method_Binding__true_condition_for__Conditional_Method_Case { get; } = new Guid("{1acdefd1-e1b4-45bb-99e1-bf73dea71da5}");
public static Guid Condition_Group__has_true_condition__Executable_returning_Work_Data { get; } = new Guid("{d955da3f-7ef4-4374-8b86-167c73434f75}");
public static Guid Executable_returning_Work_Data__true_condition_for__Condition_Group { get; } = new Guid("{1acdefd1-e1b4-45bb-99e1-bf73dea71da5}");
public static Guid Conditional_Method_Case__has_false_condition__Method_Binding { get; } = new Guid("{e46dbc4f-ae8d-4ad8-b9e6-10cedfa68b73}");
public static Guid Method_Binding__false_condition_for__Conditional_Method_Case { get; } = new Guid("{633af008-bf7f-4da1-94d6-67a9a80586d6}");
public static Guid Condition_Group__has_false_condition__Executable_returning_Work_Data { get; } = new Guid("{e46dbc4f-ae8d-4ad8-b9e6-10cedfa68b73}");
public static Guid Executable_returning_Work_Data__false_condition_for__Condition_Group { get; } = new Guid("{633af008-bf7f-4da1-94d6-67a9a80586d6}");
public static Guid Audit_Line__has__Instance { get; } = new Guid("{c91807ed-0d73-4729-990b-d90750764fb5}");
public static Guid Audit_Line__has__User { get; } = new Guid("{7c1e048d-3dcb-4473-9f2e-e21014a76aa5}");
@ -298,5 +311,43 @@ namespace Mocha.Core
public static Guid Style__implements__Style { get; } = new Guid("{99b1c16a-f2cb-4cc5-a3bb-82a96335aa39}");
public static Guid Style__implemented_for__Style { get; } = new Guid("{271ef816-1e94-4f02-a805-4f9536c28dca}");
public static Guid Select_From_Instance_Set_Method__returns__Work_Set { get; } = new Guid("{e7805b49-0eb3-46ea-bc8a-a5ed676a7726}");
public static Guid Work_Set__returned_by__Select_from_Instance_Set_Method { get; } = new Guid("{df12608a-e157-4a1b-bae2-0224a18f5b94}");
public static Guid Select_from_Instance_Set_Method__uses__Executable_returning_Instance_Set { get; } = new Guid("{a907f814-b996-4294-b347-ca16ccaf1f5b}");
public static Guid Executable_returning_Instance_Set__used_by__Select_from_Instance_Set_Method { get; } = new Guid("{a3ec06f9-54e8-4279-a31d-d221f8697a6a}");
public static Guid Select_from_Instance_Set_Method__uses__Set_Function { get; } = new Guid("{abda76ae-a969-40e3-aed2-1a20fcec8b31}");
public static Guid Set_Function__used_by__Select_from_Instance_Set_Method { get; } = new Guid("{753f9f4f-3fe3-470a-890d-d799c24e47af}");
public static Guid Select_from_Instance_Set_Method__uses__Selection_Function { get; } = new Guid("{6498e72e-f321-4be2-acfd-dfd6f916ce54}");
public static Guid Selection_Function__used_by__Select_from_Instance_Set_Method { get; } = new Guid("{e5e6a392-a436-41f7-bc80-cb6603503be1}");
public static Guid Select_from_Instance_Set_Method__uses_function__Executable_returning_Attribute { get; } = new Guid("{30905c53-0d64-4332-9023-12a03e60cd09}");
public static Guid Executable_returning_Attribute__function_used_by__Select_from_Instance_Set_Method { get; } = new Guid("{79adb5ea-0257-445b-9f7c-e5f8508a59a2}");
public static Guid Select_from_Instance_Set_Method__uses_order__Executable_returning_Attribute { get; } = new Guid("{c7a5ef47-fce3-4e7c-87b8-f5cab93b1b10}");
public static Guid Executable_returning_Attribute__order_used_by__Select_from_Instance_Set_Method { get; } = new Guid("{48c984ea-f4da-4090-bdd0-fd659b9be13d}");
public static Guid Select_from_Instance_Set_Method__uses_subset_index__Executable_returning_Attribute { get; } = new Guid("{b5ef8d8b-683a-4cb9-9e6c-bc470324f4e3}");
public static Guid Executable_returning_Attribute__as_subset_index_for__Select_from_Instance_Set_Method { get; } = new Guid("{7d03574f-db28-4aff-a96c-8013832b8269}");
public static Guid Select_from_Instance_Set_Method__uses_comparator__Executable_returning_Work_Data { get; } = new Guid("{974c6e8b-b04f-4e3c-8719-298052afa9c7}");
public static Guid Executable_returning_Work_Data__comparator_for__Select_from_Instance_Set_Method { get; } = new Guid("{c877ea85-ee9f-4e22-bae7-4a0d7b9272e1}");
public static Guid Conditional_Select_From_Instance_Set_Method__returns__Work_Set { get; } = new Guid("{49396bd0-b5a9-4384-99f4-2126d80b3b66}");
public static Guid Work_Set__returned_by__Conditional_Select_from_Instance_Set_Method { get; } = new Guid("{221a23dd-1230-4690-a15a-26345b111b0d}");
public static Guid Conditional_Select_from_Instance_Set_Method__has__Conditional_Select_from_Instance_Set_Case { get; } = new Guid("{b6715132-b438-4073-b81d-3ecf19584b7d}");
public static Guid Conditional_Select_from_Instance_Set_Case__for__Conditional_Select_from_Instance_Set_Method { get; } = new Guid("{8fde1baa-ce2e-4245-a775-bc4c66eac7b5}");
public static Guid Conditional_Select_Attribute_Method__returns__Attribute { get; } = new Guid("{b2b9d9cc-c4dd-491b-853e-e3669ea4e66a}");
public static Guid Attribute__returned_by__Conditional_Select_Attribute_Method { get; } = new Guid("{e3e734ce-953b-49b8-b50d-b1826b519053}");
public static Guid Conditional_Select_Attribute_Method__has__Conditional_Select_Attribute_Case { get; } = new Guid("{49396bd0-b5a9-4384-99f4-2126d80b3b66}");
public static Guid Conditional_Select_Attribute_Case__for__Conditional_Select_Attribute_Method { get; } = new Guid("{38e2816e-ccb4-4e89-86ab-4981f5c2d7ac}");
public static Guid Evaluate_Boolean_Expression_Method__returns__Boolean_Attribute { get; } = new Guid("{53cf2cb6-f5f2-499f-9f18-26b86bf671c4}");
public static Guid Boolean_Attribute__returned_by__Evaluate_Boolean_Expression_Method { get; } = new Guid("{24397b98-65da-4f5a-93a3-e933bab1f59b}");
public static Guid Evaluate_Boolean_Expression_Method__has_source__Executable_returning_Work_Data { get; } = new Guid("{45d76d56-01ed-4641-9f68-cfe0c7d0d265}");
public static Guid Executable_returning_Work_Data__source_for__Evaluate_Boolean_Expression_Method { get; } = new Guid("{eef048af-179e-4375-8a85-2856bb14aea3}");
public static Guid Evaluate_Boolean_Expression_Method__has_target__Executable_returning_Work_Data { get; } = new Guid("{0646df91-7e3e-4d59-be71-b978a22ced8e}");
public static Guid Executable_returning_Work_Data__target_for__Evaluate_Boolean_Expression_Method { get; } = new Guid("{be7a6285-d700-40f3-868e-c0878a3e94a6}");
public static Guid Evaluate_Boolean_Expression_Method__uses__Boolean_Operator { get; } = new Guid("{aa9e17a2-e4d9-4598-bcfc-2d729031d11c}");
public static Guid Boolean_Operator__used_by__Evaluate_Boolean_Expression_Method { get; } = new Guid("{1e9915a9-3c91-4532-ab9c-82419660e31a}");
}
}

60
mocha-dotnet/src/lib/Mocha.Core/MethodImplementations/ConditionalSelectAttributeMethodImplementation.cs Normal file
View File

@ -0,0 +1,60 @@
namespace Mocha.Core.MethodImplementations;
public class ConditionalSelectAttributeMethodImplementation : MethodImplementation
{
public override Guid MethodClassGuid => KnownInstanceGuids.MethodClasses.ConditionalSelectAttributeMethod;
protected override InstanceHandle ExecuteInternal(Oms oms, OmsContext context, InstanceHandle method)
{
InstanceHandle returnsAttribute = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Conditional_Select_Attribute_Method__returns__Attribute));
IReadOnlyCollection<InstanceHandle> cases = oms.GetRelatedInstances(method, oms.GetInstance(KnownRelationshipGuids.Conditional_Select_Attribute_Method__has__Conditional_Select_Attribute_Case));
foreach (InstanceHandle cas in cases)
{
bool value = false;
IEnumerable<InstanceHandle> trueConditions = oms.GetRelatedInstances(cas, oms.GetInstance(KnownRelationshipGuids.Condition_Group__has_true_condition__Executable_returning_Work_Data));
IEnumerable<InstanceHandle> falseConditions = oms.GetRelatedInstances(cas, oms.GetInstance(KnownRelationshipGuids.Condition_Group__has_false_condition__Executable_returning_Work_Data));
bool useAnyCondition = oms.GetAttributeValue<bool>(cas, oms.GetInstance(KnownAttributeGuids.Boolean.UseAnyCondition));
if (trueConditions != null)
{
foreach (InstanceHandle trueCondition in trueConditions)
{
InstanceHandle ret = oms.Execute(context, trueCondition);
object? retval = context.GetWorkData(ret);
if (retval is bool && ((bool)retval))
{
value = true;
break;
}
}
}
if (falseConditions != null)
{
foreach (InstanceHandle falseCondition in falseConditions)
{
InstanceHandle ret = oms.Execute(context, falseCondition);
object? retval = context.GetWorkData(ret);
if (retval is bool && (!(bool)retval))
{
value = true;
break;
}
}
}
if (value)
{
InstanceHandle execAttr = oms.GetRelatedInstance(cas, oms.GetInstance(KnownRelationshipGuids.Conditional_Select_Attribute_Case__invokes__Executable_returning_Attribute));
InstanceHandle hwd = oms.Execute(context, execAttr);
object? val = context.GetWorkData(hwd);
context.SetWorkData(returnsAttribute, val);
break; // we don't need to check another case do we?
}
}
return returnsAttribute;
}
}

12
mocha-dotnet/src/lib/Mocha.Core/MethodImplementations/ConditionalSelectFromInstanceSetMethodImplementation.cs Normal file
View File

@ -0,0 +1,12 @@
namespace Mocha.Core.MethodImplementations;
public class ConditionalSelectFromInstanceSetMethodImplementation : MethodImplementation
{
public override Guid MethodClassGuid => KnownInstanceGuids.MethodClasses.ConditionalSelectFromInstanceSetMethod;
protected override InstanceHandle ExecuteInternal(Oms oms, OmsContext context, InstanceHandle method)
{
throw new NotImplementedException();
}
}

66
mocha-dotnet/src/lib/Mocha.Core/MethodImplementations/EvaluateBooleanExpressionMethodImplementation.cs Normal file
View File

@ -0,0 +1,66 @@
using System.Formats.Asn1;
using MBS.Core.Collections;
namespace Mocha.Core.MethodImplementations;
public class EvaluateBooleanExpressionMethodImplementation : MethodImplementation
{
public override Guid MethodClassGuid => KnownInstanceGuids.MethodClasses.EvaluateBooleanExpressionMethod;
protected override InstanceHandle ExecuteInternal(Oms oms, OmsContext context, InstanceHandle method)
{
InstanceHandle c_Class = oms.GetInstance(KnownInstanceGuids.Classes.Class);
InstanceHandle irForClass = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Method__for__Class));
InstanceHandle returnsAttribute = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Evaluate_Boolean_Expression_Method__returns__Boolean_Attribute));
if (returnsAttribute == InstanceHandle.Empty)
{
throw new InvalidOperationException("no return Attribute specified for method");
}
/*
IEnumerable<InstanceHandle> source = oms.GetRelatedInstances(method, oms.GetInstance(KnownRelationshipGuids.Evaluate_Boolean_Expression_Method__has_source__Executable_returning_Work_Data));
InstanceHandle comparison = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Evaluate_Boolean_Expression_Method__uses__Boolean_Operator));
IEnumerable<InstanceHandle> target = oms.GetRelatedInstances(method, oms.GetInstance(KnownRelationshipGuids.Evaluate_Boolean_Expression_Method__has_target__Executable_returning_Work_Data));
*/
InstanceHandle source = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Evaluate_Boolean_Expression_Method__has_source__Executable_returning_Work_Data));
InstanceHandle comparison = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Evaluate_Boolean_Expression_Method__uses__Boolean_Operator));
InstanceHandle target = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Evaluate_Boolean_Expression_Method__has_target__Executable_returning_Work_Data));
InstanceHandle[] rtarget_value = new InstanceHandle[0];
InstanceHandle rsource = oms.Execute(context, source);
object? rsource_valueraw = context.GetWorkData(rsource);
InstanceHandle[] rsource_value = new InstanceHandle[0];
if (rsource_valueraw is InstanceHandle[])
{
rsource_value = (InstanceHandle[])rsource_valueraw;
}
if (oms.IsInstanceOf(target, c_Class))
{
rtarget_value = new InstanceHandle[] { target };
}
else
{
InstanceHandle rtarget = oms.Execute(context, target);
object? rtarget_valueraw = context.GetWorkData(rtarget);
}
bool value = false;
if (comparison == oms.GetInstance(KnownInstanceGuids.RelationalOperators.InSelectionList))
{
if (rtarget_value.ContainsAny(rsource_value))
{
value = true;
}
}
context.SetWorkData(returnsAttribute, value);
return returnsAttribute;
}
}

9
mocha-dotnet/src/lib/Mocha.Core/MethodImplementations/GetAttributeMethodImplementation.cs
View File

@ -13,8 +13,13 @@ public class GetAttributeMethodImplementation : MethodImplementation
throw new InvalidOperationException("no Work Set specified for method");
}
InstanceHandle forInstance = (InstanceHandle) context.GetWorkData(irForClass);
object? value = oms.UnsafeGetAttributeValue(forInstance, returnsAttribute);
InstanceHandle? forInstance = (InstanceHandle?) context.GetWorkData(irForClass);
if (forInstance == null)
{
throw new NullReferenceException(String.Format("non-static method call without instance reference {0}", oms.GetGlobalIdentifier(irForClass)));
}
object? value = oms.UnsafeGetAttributeValue((InstanceHandle) forInstance, returnsAttribute);
context.SetWorkData(returnsAttribute, value);
return returnsAttribute;
}

80
mocha-dotnet/src/lib/Mocha.Core/MethodImplementations/GetReferencedAttributeMethodImplementation.cs Normal file
View File

@ -0,0 +1,80 @@
namespace Mocha.Core.MethodImplementations;
public class GetReferencedAttributeMethodImplementation : MethodImplementation
{
public override Guid MethodClassGuid => KnownInstanceGuids.MethodClasses.GetReferencedAttributeMethod;
protected override InstanceHandle ExecuteInternal(Oms oms, OmsContext context, InstanceHandle method)
{
Guid methodId = oms.GetGlobalIdentifier(method);
InstanceHandle irForClass = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Method__for__Class));
InstanceHandle returnsAttribute = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Get_Referenced_Attribute_Method__returns__Attribute));
InstanceHandle referenceInstanceSet = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Get_Referenced_Attribute_Method__uses_reference__Executable_returning_Instance_Set));
InstanceHandle answerAttribute = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Get_Referenced_Attribute_Method__uses_answer__Executable_returning_Attribute));
InstanceHandle usesAccumulationFunction = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Get_Referenced_Attribute_Method__uses__Accumulation_Function));
InstanceHandle usesOrderAttribute = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Get_Referenced_Attribute_Method__uses_order__Executable_returning_Attribute));
if (returnsAttribute == InstanceHandle.Empty)
{
throw new InvalidOperationException(String.Format("no return Attribute specified for method {0}", methodId));
}
InstanceHandle referenceInstanceSetWS = oms.Execute(context, referenceInstanceSet);
object? referenceInstanceSetValue = context.GetWorkData(referenceInstanceSetWS);
if (referenceInstanceSetValue is IReadOnlyCollection<InstanceHandle>)
{
IReadOnlyCollection<InstanceHandle> list = (IReadOnlyCollection<InstanceHandle>)referenceInstanceSetValue;
object? retval = null;
int avg_c = 0;
foreach (InstanceHandle inst in list)
{
InstanceHandle pclass = oms.GetParentClass(inst);
context.SetWorkData(pclass, inst);
InstanceHandle answerAttributeValueWD = oms.Execute(context, answerAttribute);
object? answerAttributeValue = context.GetWorkData(answerAttributeValueWD);
if (usesAccumulationFunction == oms.GetInstance(KnownInstanceGuids.AccumulationFunctions.Sum))
{
if (retval == null)
{
retval = 0M;
}
if (retval is decimal && answerAttributeValue is decimal)
{
retval = (decimal)retval + (decimal)answerAttributeValue;
}
}
else if (usesAccumulationFunction == oms.GetInstance(KnownInstanceGuids.AccumulationFunctions.Average))
{
if (retval == null)
{
retval = 0M;
}
if (retval is decimal && answerAttributeValue is decimal)
{
retval = (decimal)retval + (decimal)answerAttributeValue;
avg_c++;
}
}
else
{
retval = answerAttributeValue;
}
}
if (avg_c > 0)
{
retval = (decimal)retval / avg_c;
}
context.SetWorkData(returnsAttribute, retval);
}
// 1$12740 NIM - Native Instance Set Method
// 1$12741 NAM - Native Attribute Method
// 1$12742 NUM - Native Update Method
return returnsAttribute;
}
}

49
mocha-dotnet/src/lib/Mocha.Core/MethodImplementations/GetRelationshipMethodImplementation.cs Normal file
View File

@ -0,0 +1,49 @@
using System.ComponentModel.Design;
namespace Mocha.Core.MethodImplementations;
public class GetRelationshipMethodImplementation : MethodImplementation
{
public override Guid MethodClassGuid => KnownInstanceGuids.MethodClasses.GetRelationshipMethod;
protected override InstanceHandle ExecuteInternal(Oms oms, OmsContext context, InstanceHandle method)
{
Guid methodId = oms.GetGlobalIdentifier(method);
InstanceHandle irForClass = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Method__for__Class));
InstanceHandle? forClassInstanceV = context.GetWorkData<InstanceHandle?>(irForClass);
bool singular = oms.GetAttributeValue<bool>(method, oms.GetInstance(KnownAttributeGuids.Boolean.Singular), false);
InstanceHandle returnsRelationship = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Get_Relationship_Method__returns__Relationship));
if (returnsRelationship == InstanceHandle.Empty)
{
throw new InvalidOperationException(String.Format("no return Relationship specified for method {0}", methodId));
}
IEnumerable<InstanceHandle> ihs = new InstanceHandle[0];
// HACK: there is no `GR - Get Relationship Method.returns Work Set`
if (forClassInstanceV != null)
{
ihs = oms.GetRelatedInstances((InstanceHandle)forClassInstanceV, returnsRelationship);
}
if (singular)
{
if (ihs.Count() > 0)
{
context.SetWorkData(returnsRelationship, ihs.First());
}
else
{
context.SetWorkData(returnsRelationship, null);
}
}
else
{
context.SetWorkData(returnsRelationship, ihs);
}
return returnsRelationship;
}
}

79
mocha-dotnet/src/lib/Mocha.Core/MethodImplementations/SelectFromInstanceSetMethodImplementation.cs Normal file
View File

@ -0,0 +1,79 @@
using System.ComponentModel.Design;
using Mocha.Core.Oop;
namespace Mocha.Core.MethodImplementations;
public class SelectFromInstanceSetMethodImplementation : MethodImplementation
{
private struct OrderableData
{
public string Order;
public object Data;
}
public override Guid MethodClassGuid => KnownInstanceGuids.MethodClasses.SelectFromInstanceSetMethod;
protected override InstanceHandle ExecuteInternal(Oms oms, OmsContext context, InstanceHandle method)
{
Guid methodId = oms.GetGlobalIdentifier(method);
InstanceHandle irForClass = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Method__for__Class));
InstanceHandle? forClassInstanceV = context.GetWorkData<InstanceHandle?>(irForClass);
InstanceHandle returnsWorkSet = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Select_From_Instance_Set_Method__returns__Work_Set));
if (returnsWorkSet == InstanceHandle.Empty)
{
throw new InvalidOperationException(String.Format("no return Work Set specified for method {0}", methodId));
}
InstanceHandle usesInstanceSet = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Select_from_Instance_Set_Method__uses__Executable_returning_Instance_Set));
object? instanceSetValues = context.GetWorkData(usesInstanceSet);
InstanceHandle selectionFunction = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Select_from_Instance_Set_Method__uses__Selection_Function));
InstanceHandle setFunction = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Select_from_Instance_Set_Method__uses__Set_Function));
InstanceHandle orderAttribute = oms.GetRelatedInstance(method, oms.GetInstance(KnownRelationshipGuids.Select_from_Instance_Set_Method__uses_order__Executable_returning_Attribute));
List<OrderableData> list = new List<OrderableData>();
if (instanceSetValues is IEnumerable<InstanceHandle>)
{
}
else if (instanceSetValues is IEnumerable<InstanceWrapper>)
{
IEnumerable<InstanceWrapper> vals = (IEnumerable<InstanceWrapper>)instanceSetValues;
foreach (InstanceWrapper inst in vals)
{
OrderableData od = new OrderableData();
od.Data = inst.Handle;
if (orderAttribute != InstanceHandle.Empty)
{
InstanceHandle ihWorkData = oms.Execute(context, orderAttribute, inst.Handle);
string order = context.GetWorkData<string>(ihWorkData);
od.Order = order;
}
else
{
od.Order = String.Empty;
}
list.Add(od);
}
list.Sort((c, d) => c.Order.CompareTo(d.Order));
}
if (list.Count > 0)
{
// FIXME: this assumes a hardcoded singular work set
if (selectionFunction == oms.GetInstance(KnownInstanceGuids.SelectionFunctions.Minimum))
{
context.SetWorkData(returnsWorkSet, list[0].Data);
}
else if (selectionFunction == oms.GetInstance(KnownInstanceGuids.SelectionFunctions.Maximum))
{
context.SetWorkData(returnsWorkSet, list[list.Count - 1].Data);
}
}
return returnsWorkSet;
}
}

142
mocha-dotnet/src/lib/Mocha.Core/Oms.cs
View File

@ -15,6 +15,8 @@ using Mocha.Core.Oop;
public abstract class Oms
{
public static Oms DebugOms { get; private set; }
public Version RuntimeVersion { get; } = new Version(2, 0, 38762, 5);
/// <summary>
@ -33,6 +35,7 @@ public abstract class Oms
public void Initialize()
{
InitializeInternal();
DebugOms = this;
MethodImplementation[] methodImplementations = MBS.Core.Reflection.TypeLoader.GetAvailableTypes<MethodImplementation>(new System.Reflection.Assembly[] { Assembly.GetExecutingAssembly() });
foreach (MethodImplementation impl in methodImplementations)
@ -89,7 +92,10 @@ public abstract class Oms
{
return GetGlobalIdentifierInternal(instance);
}
public Guid GetGlobalIdentifier(InstanceWrapper wrapper)
{
return GetGlobalIdentifier(wrapper.Handle);
}
protected abstract void AssignRelationshipInternal(InstanceHandle source, InstanceHandle relationship, IEnumerable<InstanceHandle> targets, DateTime effectiveDate);
public void AssignRelationship(InstanceHandle source, InstanceHandle relationship, IEnumerable<InstanceHandle> targets, DateTime effectiveDate)
@ -173,6 +179,36 @@ public abstract class Oms
throw new KeyNotFoundException();
}
public bool TryGetInstance<T>(Guid globalIdentifier, out T instance) where T : ConcreteInstanceWrapper
{
if (TryGetInstance(globalIdentifier, out InstanceHandle ih))
{
InstanceHandle parentClass = GetParentClass(ih);
Type tType = typeof(T);
ConcreteInstanceWrapper ci = (ConcreteInstanceWrapper) tType.Assembly.CreateInstance(tType.FullName, false, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { ih }, null, null);
if (ci != null)
{
if (ci.ClassId == GetGlobalIdentifier(parentClass))
{
instance = (T)ci;
return true;
}
}
}
instance = null;
return false;
}
public T GetInstance<T>(Guid globalIdentifier) where T : ConcreteInstanceWrapper
{
if (TryGetInstance<T>(globalIdentifier, out T ih))
{
return ih;
}
throw new KeyNotFoundException();
}
protected abstract IReadOnlyCollection<InstanceHandle> GetRelatedInstancesInternal(InstanceHandle source, InstanceHandle relationship, DateTime effectiveDate);
public IReadOnlyCollection<InstanceHandle> GetRelatedInstances(InstanceHandle source, InstanceHandle relationship, DateTime effectiveDate)
{
@ -322,7 +358,8 @@ public abstract class Oms
if (!RecursiveClassHasAttribute(sourceParentClass, attribute))
{
string name = GetAttributeValue<string>(attribute, GetInstance(KnownAttributeGuids.Text.Name));
throw new ArgumentException(String.Format("Undefined attribute `{0}` on class {1}", name, GetGlobalIdentifier(sourceParentClass)));
string sourceParentClassName = GetAttributeValue<string>(sourceParentClass, GetInstance(KnownAttributeGuids.Text.Name));
throw new ArgumentException(String.Format("Undefined attribute `{0}` on class `{1}`", name, sourceParentClassName));
}
if (IsInstanceOf(attribute, a_TextAttribute))
@ -471,6 +508,11 @@ public abstract class Oms
return CreateRelationship(sourceClass, relationshipName, destinationClass, relationshipGuid, singular, null, Guid.Empty);
}
public InstanceHandle CreateRelationship(InstanceHandle sourceClass, string relationshipName, InstanceHandle destinationClass, Guid relationshipGuid, bool singular, string siblingRelationshipName, Guid siblingRelationshipGuid)
{
InstanceHandle relationshipInstance = CreateRelationship(sourceClass, relationshipName, destinationClass, relationshipGuid, singular, siblingRelationshipName, siblingRelationshipGuid, out InstanceHandle siblingRelationshipInstance);
return relationshipInstance;
}
public InstanceHandle CreateRelationship(InstanceHandle sourceClass, string relationshipName, InstanceHandle destinationClass, Guid relationshipGuid, bool singular, string siblingRelationshipName, Guid siblingRelationshipGuid, out InstanceHandle siblingRelationshipInstance)
{
InstanceHandle c_Relationship = GetInstance(KnownInstanceGuids.Classes.Relationship);
if (c_Relationship == InstanceHandle.Empty)
@ -513,6 +555,7 @@ public abstract class Oms
SetAttributeValue(irRelationship, a_Singular, singular);
AssignRelationship(irRelationship, r_Relationship__has_destination__Class, destinationClass);
siblingRelationshipInstance = InstanceHandle.Empty;
if (siblingRelationshipName != null)
{
if (siblingRelationshipGuid == Guid.Empty)
@ -520,13 +563,13 @@ public abstract class Oms
siblingRelationshipGuid = Guid.NewGuid();
}
InstanceHandle irSiblingRelationship = CreateInstanceOf(c_Relationship, siblingRelationshipGuid);
AssignRelationship(irSiblingRelationship, r_Relationship__has_source__Class, destinationClass);
SetAttributeValue(irSiblingRelationship, a_RelationshipType, siblingRelationshipName);
AssignRelationship(irSiblingRelationship, r_Relationship__has_destination__Class, sourceClass);
siblingRelationshipInstance = CreateInstanceOf(c_Relationship, siblingRelationshipGuid);
AssignRelationship(siblingRelationshipInstance, r_Relationship__has_source__Class, destinationClass);
SetAttributeValue(siblingRelationshipInstance, a_RelationshipType, siblingRelationshipName);
AssignRelationship(siblingRelationshipInstance, r_Relationship__has_destination__Class, sourceClass);
AssignRelationship(irRelationship, r_Relationship__has_sibling__Relationship, irSiblingRelationship);
AssignRelationship(irSiblingRelationship, r_Relationship__has_sibling__Relationship, irRelationship);
AssignRelationship(irRelationship, r_Relationship__has_sibling__Relationship, siblingRelationshipInstance);
AssignRelationship(siblingRelationshipInstance, r_Relationship__has_sibling__Relationship, irRelationship);
}
return irRelationship;
}
@ -586,11 +629,15 @@ public abstract class Oms
implementation.Initialize(this);
}
public InstanceHandle Execute(OmsContext context, MethodBinding methodBinding, InstanceHandle? targetInstance = null)
{
return Execute(context, methodBinding.Handle, targetInstance);
}
public InstanceHandle Execute(OmsContext context, Method method, InstanceHandle? targetInstance = null)
{
return Execute(context, method.Handle, targetInstance);
}
public InstanceHandle Execute(OmsContext context, ReturnInstanceSetMethodBinding methodBinding)
public InstanceHandle Execute(OmsContext context, MethodBinding methodBinding)
{
return Execute(context, methodBinding.Handle);
}
@ -614,6 +661,18 @@ public abstract class Oms
if (IsInstanceOf(methodOrMethodBinding, GetInstance(KnownInstanceGuids.Classes.ReturnAttributeMethodBinding))
|| IsInstanceOf(methodOrMethodBinding, GetInstance(KnownInstanceGuids.Classes.ReturnInstanceSetMethodBinding)))
{
IEnumerable<InstanceHandle> parameterAssignments = GetRelatedInstances(methodOrMethodBinding, GetInstance(KnownRelationshipGuids.Method_Binding__has__Parameter_Assignment));
foreach (InstanceHandle parm in parameterAssignments)
{
InstanceHandle assignsToParm = GetRelatedInstance(parm, GetInstance(KnownRelationshipGuids.Parameter_Assignment__assigns_to__Work_Data));
InstanceHandle assignsFromWorkData = GetRelatedInstance(parm, GetInstance(KnownRelationshipGuids.Parameter_Assignment__assigns_from__Executable_returning_Work_Data));
if (IsInstanceOf(assignsFromWorkData, GetInstance(KnownInstanceGuids.Classes.Class)))
{
assignsFromWorkData = context.GetWorkData<InstanceHandle>(assignsFromWorkData);
}
context.SetWorkData(assignsToParm, assignsFromWorkData);
}
return ExecuteMethodBinding(context, methodOrMethodBinding);
}
else
@ -666,15 +725,17 @@ public abstract class Oms
{
return CreateWorkSet(name, false, new InstanceHandle[0]);
}
public WorkSet CreateWorkSet(string name, bool singular, ICollection<InstanceHandle> validClasses)
public WorkSet CreateWorkSet(string name, bool singular, ICollection<InstanceHandle> validClasses = null)
{
InstanceHandle workSet = CreateInstanceOf(GetInstance(KnownInstanceGuids.Classes.WorkSet));
SetAttributeValue(workSet, GetInstance(KnownAttributeGuids.Text.Name), name);
SetAttributeValue(workSet, GetInstance(KnownAttributeGuids.Boolean.Singular), singular);
if (validClasses.Count > 0)
if (validClasses != null)
{
AssignRelationship(workSet, GetInstance(KnownRelationshipGuids.Work_Set__has_valid__Class), validClasses);
if (validClasses.Count > 0)
{
AssignRelationship(workSet, GetInstance(KnownRelationshipGuids.Work_Set__has_valid__Class), validClasses);
}
}
return new WorkSet(workSet);
}
@ -713,11 +774,10 @@ public abstract class Oms
InstanceHandle ramb = GetRelatedInstance(parentClass, ihLabeledByRAMB);
OmsContext context = CreateContext();
object value = Execute(context, ramb);
if (value is string)
{
return (string)value;
}
InstanceHandle wd = Execute(context, ramb);
string value = context.GetWorkData<string>(wd);
return value;
}
// FIXME: remove when we have Class@get Instance Text implemented
@ -731,6 +791,25 @@ public abstract class Oms
string name = GetAttributeValue<string>(inst, GetInstance(KnownAttributeGuids.Text.Name));
sb.Append(name);
}
else if (IsInstanceOf(inst, GetInstance(KnownInstanceGuids.Classes.Attribute)))
{
string name = GetAttributeValue<string>(inst, GetInstance(KnownAttributeGuids.Text.Name));
sb.Append(name);
}
else if (IsInstanceOf(inst, GetInstance(KnownInstanceGuids.Classes.Relationship)))
{
InstanceHandle sourceClass = GetRelatedInstance(inst, GetInstance(KnownRelationshipGuids.Relationship__has_source__Class));
string relationshipType = GetAttributeValue<string>(inst, GetInstance(KnownAttributeGuids.Text.RelationshipType));
InstanceHandle destinationClass = GetRelatedInstance(inst, GetInstance(KnownRelationshipGuids.Relationship__has_destination__Class));
string sourceClassName = GetInstanceText(sourceClass);
string destinationClassName = GetInstanceText(destinationClass);
sb.Append(sourceClassName);
sb.Append('.');
sb.Append(relationshipType);
sb.Append(' ');
sb.Append(destinationClassName);
}
else if (IsInstanceOf(inst, GetInstance(KnownInstanceGuids.Classes.Method)))
{
InstanceHandle forClass = GetRelatedInstance(inst, GetInstance(KnownRelationshipGuids.Method__for__Class));
@ -796,9 +875,34 @@ public abstract class Oms
string _name = GetAttributeValue<string>(method, a_Name);
if (_verb.Equals(verb) && _name.Equals(name))
{
return Method.CreateFromInstance(this, method);
return (Method)ConcreteInstanceWrapper.Wrap(this, method);
}
}
return null;
}
/// <summary>
/// Convenience function to create an enumeration of instances based on global identifiers.
/// </summary>
/// <param name="globalIdentifier">The global identifier of the resulting enumeration class.</param>
/// <param name="memberGlobalIdentifiers">The global identifiers of the instances (members) of the enumeration class.</param>
/// <returns></returns>
public InstanceHandle CreateEnumeration(Guid globalIdentifier, Guid[] memberGlobalIdentifiers)
{
InstanceHandle c_Enum = CreateEnumeration(globalIdentifier, memberGlobalIdentifiers, out InstanceHandle[] memberInstanceHandles);
return c_Enum;
}
public InstanceHandle CreateEnumeration(Guid globalIdentifier, Guid[] memberGlobalIdentifiers, out InstanceHandle[] memberInstanceHandles)
{
if (!TryGetInstance(globalIdentifier, out InstanceHandle c_Enum))
{
c_Enum = CreateInstanceOf(GetInstance(KnownInstanceGuids.Classes.Class), globalIdentifier);
}
memberInstanceHandles = new InstanceHandle[memberGlobalIdentifiers.Length];
for (int i = 0; i < memberGlobalIdentifiers.Length; i++)
{
memberInstanceHandles[i] = CreateInstanceOf(c_Enum, memberGlobalIdentifiers[i]);
}
return c_Enum;
}
}

48
mocha-dotnet/src/lib/Mocha.Core/OmsContext.cs
View File

@ -26,10 +26,24 @@ public class OmsContext
return null;
}
public T GetWorkData<T>(InstanceHandle parm, T defaultValue = default(T))
{
object? val = GetWorkData(parm);
if (val is T)
{
return (T)val;
}
return defaultValue;
}
public void SetWorkData(WorkSet parm, object? value)
{
SetWorkData(parm.Handle, value);
}
public void SetWorkData(InstanceHandle parm, IInstanceWrapper value)
{
SetWorkData(parm, value.Handle);
}
public void SetWorkData(InstanceHandle parm, object? value)
{
if (oms.IsInstanceOf(parm, oms.GetInstance(KnownInstanceGuids.Classes.WorkSet)))
@ -53,14 +67,14 @@ public class OmsContext
}
}
}
else if (value is IReadOnlyCollection<InstanceHandle>)
else if (value is IEnumerable<InstanceHandle>)
{
IReadOnlyCollection<InstanceHandle> insts = (IReadOnlyCollection<InstanceHandle>)value;
if (singular && insts.Count > 1)
IEnumerable<InstanceHandle> insts = (IEnumerable<InstanceHandle>)value;
if (singular && insts.Count() > 1)
{
throw new InvalidOperationException("Singular Work Set must only contain a single InstanceReference or be an array of InstanceReference that contains exactly zero or one item.");
}
IReadOnlyCollection<InstanceHandle> irs = oms.GetRelatedInstances(parm, oms.GetInstance(KnownRelationshipGuids.Work_Set__has_valid__Class));
IEnumerable<InstanceHandle> irs = oms.GetRelatedInstances(parm, oms.GetInstance(KnownRelationshipGuids.Work_Set__has_valid__Class));
if (irs != null)
{
foreach (InstanceHandle ir in insts)
@ -73,9 +87,33 @@ public class OmsContext
}
}
}
else if (value is IEnumerable<InstanceWrapper>)
{
IEnumerable<InstanceWrapper> insts = (IEnumerable<InstanceWrapper>)value;
if (singular && insts.Count() > 1)
{
throw new InvalidOperationException("Singular Work Set must only contain a single InstanceReference or be an array of InstanceReference that contains exactly zero or one item.");
}
IEnumerable<InstanceHandle> irs = oms.GetRelatedInstances(parm, oms.GetInstance(KnownRelationshipGuids.Work_Set__has_valid__Class));
if (irs != null)
{
if (irs.Count() > 0)
{
foreach (InstanceWrapper iw in insts)
{
InstanceHandle ir = iw.Handle;
InstanceHandle parentClass = oms.GetParentClass(ir);
if (!irs.Contains(parentClass))
{
throw new ArgumentException("instance reference must be an instance of appropriate class");
}
}
}
}
}
else
{
throw new ArgumentException("cannot assign literal data to a Work Set");
throw new ArgumentException(String.Format("cannot assign literal data '{0}' to a Work Set", value));
}
}
_WorkData[parm] = value;

2
mocha-dotnet/src/lib/Mocha.Core/OmsImplementations/Mini/MiniOms.cs
View File

@ -68,6 +68,7 @@ public class MiniOms : MemoryOms
a_ContentType = CreateInstanceOf(c_TextAttribute, KnownAttributeGuids.Text.ContentType);
a_RelationshipType = CreateInstanceOf(c_TextAttribute, KnownAttributeGuids.Text.RelationshipType);
a_Singular = CreateInstanceOf(c_BooleanAttribute, KnownAttributeGuids.Boolean.Singular);
CreateInstanceOf(c_BooleanAttribute, KnownAttributeGuids.Boolean.MethodIsOfTypeSpecified);
a_MinimumLength = CreateInstanceOf(c_NumericAttribute, KnownAttributeGuids.Numeric.MinimumLength);
a_MaximumLength = CreateInstanceOf(c_NumericAttribute, KnownAttributeGuids.Numeric.MaximumLength);
@ -140,6 +141,7 @@ public class MiniOms : MemoryOms
c_Instance = CreateClass("Instance", KnownInstanceGuids.Classes.Instance);
SetInstanceKey(c_Instance, new InstanceKey(1, 17));
CreateClass("Work Data", KnownInstanceGuids.Classes.WorkData);
c_OMS = CreateClass("OMS", KnownInstanceGuids.Classes.OMS);
// ?============ MODULES ============?

3
mocha-dotnet/src/lib/Mocha.Core/OmsImplementations/Mini/MiniOmsModule.cs
View File

@ -2,13 +2,14 @@ namespace Mocha.Core.OmsImplementations.Mini;
public abstract class MiniOmsModule
{
protected InstanceHandle c_Class, c_Attribute, c_TextAttribute, c_BooleanAttribute, c_NumericAttribute, c_DateAttribute, c_WorkSet, c_Instance;
protected InstanceHandle c_Class, c_Attribute, c_Relationship, c_TextAttribute, c_BooleanAttribute, c_NumericAttribute, c_DateAttribute, c_WorkSet, c_Instance;
protected abstract void BuildInternal(Oms oms);
public void Build(Oms oms)
{
c_Class = oms.GetInstance(KnownInstanceGuids.Classes.Class);
c_Attribute = oms.GetInstance(KnownInstanceGuids.Classes.Attribute);
c_Relationship = oms.GetInstance(KnownInstanceGuids.Classes.Relationship);
c_TextAttribute = oms.GetInstance(KnownInstanceGuids.Classes.TextAttribute);
c_BooleanAttribute = oms.GetInstance(KnownInstanceGuids.Classes.BooleanAttribute);
c_NumericAttribute = oms.GetInstance(KnownInstanceGuids.Classes.NumericAttribute);

186
mocha-dotnet/src/lib/Mocha.Core/OmsImplementations/Mini/Modules/MethodsModule.cs
View File

@ -2,7 +2,9 @@ namespace Mocha.Core.OmsImplementations.Mini;
using System;
using MBS.Core;
using Microsoft.VisualBasic;
using Mocha.Core.Oop;
using Mocha.Core.Oop.Methods;
/// <summary>
/// Builds additional support for Executables and Methods. These must be defined in order to call
@ -10,30 +12,53 @@ using Mocha.Core.Oop;
/// </summary>
public class MethodsModule : MiniOmsModule
{
private InstanceHandle c_OMS;
private InstanceHandle c_Method, c_MethodBinding;
private InstanceHandle a_Name, a_Order, a_Verb, a_Static;
private InstanceHandle c_WorkData, c_OMS;
private InstanceHandle c_ParameterAssignment, c_Method, c_MethodBinding;
private InstanceHandle a_Name, a_Order, a_Singular, a_Verb, a_Static, a_UseAnyCondition, a_Value;
private InstanceHandle c_ReturnAttributeMethodBinding, c_ReturnInstanceSetMethodBinding;
private InstanceHandle c_BuildAttributeMethod, c_GetAttributeMethod, c_GetSpecifiedInstancesMethod, c_GetAttributeBySystemRoutineMethod, c_AssignAttributeMethod;
private InstanceHandle c_ConditionGroup;
private InstanceHandle c_BuildAttributeMethod, c_GetAttributeMethod, c_GetSpecifiedInstancesMethod, c_GetAttributeBySystemRoutineMethod, c_AssignAttributeMethod, c_GetRelationshipMethod, c_GetReferencedAttributeMethod, c_SelectFromInstanceSetMethod, c_ConditionalSelectFromInstanceSetCase, c_ConditionalSelectFromInstanceSetMethod, c_ConditionalSelectAttributeMethod, c_ConditionalSelectAttributeCase, c_EvaluateBooleanExpressionMethod;
private InstanceHandle c_AccessModifier, i_AccessModifier_Private, i_AccessModifier_Protected, i_AccessModifier_Public, i_AccessModifier_RootA2;
private InstanceHandle c_SystemRoutine, c_SystemAttributeRoutine, c_SystemInstanceSetRoutine;
private InstanceHandle c_AccumulationFunction, c_SelectionFunction, c_SetFunction;
protected override void BuildInternal(Oms oms)
{
c_Method = oms.CreateInstanceOf(c_Class, KnownInstanceGuids.Classes.Method);
protected override void BuildInternal(Oms oms)
{
c_WorkData = oms.GetInstance(KnownInstanceGuids.Classes.WorkData);
c_ParameterAssignment = oms.CreateClass("Parameter Assignment", KnownInstanceGuids.Classes.ParameterAssignment);
oms.CreateRelationship(c_ParameterAssignment, "assigns from", c_Instance, KnownRelationshipGuids.Parameter_Assignment__assigns_from__Executable_returning_Work_Data, true, "assigned from", KnownRelationshipGuids.Executable_returning_Work_Data__assigned_from__Parameter_Assignment);
oms.CreateRelationship(c_ParameterAssignment, "assigns to", c_WorkData, KnownRelationshipGuids.Parameter_Assignment__assigns_to__Work_Data, true, "assigned to", KnownRelationshipGuids.Work_Data__assigned_by__Parameter_Assignment);
c_Method = oms.CreateClass("Method", KnownInstanceGuids.Classes.Method);
c_MethodBinding = oms.CreateClass("Method Binding", KnownInstanceGuids.Classes.MethodBinding);
c_ReturnAttributeMethodBinding = oms.CreateClass("Return Attribute Method Binding", KnownInstanceGuids.Classes.ReturnAttributeMethodBinding);
c_ReturnInstanceSetMethodBinding = oms.CreateClass("Return Instance Set Method Binding", KnownInstanceGuids.Classes.ReturnInstanceSetMethodBinding);
c_AccumulationFunction = oms.CreateEnumeration(KnownInstanceGuids.Classes.AccumulationFunction, new Guid[]
{
KnownInstanceGuids.AccumulationFunctions.Sum,
KnownInstanceGuids.AccumulationFunctions.Average
});
c_SelectionFunction = oms.CreateEnumeration(KnownInstanceGuids.Classes.SelectionFunction, new Guid[]
{
KnownInstanceGuids.SelectionFunctions.Maximum,
KnownInstanceGuids.SelectionFunctions.Minimum
});
a_Name = oms.GetInstance(KnownAttributeGuids.Text.Name);
a_Order = oms.GetInstance(KnownAttributeGuids.Text.Order);
a_Verb = oms.CreateInstanceOf(c_TextAttribute, KnownAttributeGuids.Text.Verb);
a_Static = oms.CreateInstanceOf(c_BooleanAttribute, KnownAttributeGuids.Boolean.Static);
a_Singular = oms.GetInstance(KnownAttributeGuids.Boolean.Singular);
a_Value = oms.GetInstance(KnownAttributeGuids.Text.Value);
a_UseAnyCondition = oms.CreateInstanceOf(oms.GetInstance(KnownInstanceGuids.Classes.BooleanAttribute), KnownAttributeGuids.Boolean.UseAnyCondition);
oms.SetAttributeValue(a_UseAnyCondition, a_Name, "Use Any Condition");
c_AccessModifier = oms.CreateInstanceOf(c_Class, KnownInstanceGuids.Classes.AccessModifier);
oms.AddAttribute(c_AccessModifier, a_Name);
oms.AddAttribute(c_AccessModifier, a_Order);
i_AccessModifier_Private = oms.CreateInstanceOf(c_AccessModifier, KnownInstanceGuids.AccessModifiers.Private);
oms.SetAttributeValue(i_AccessModifier_Private, a_Name, "Private");
oms.SetAttributeValue(i_AccessModifier_Private, a_Order, "a");
@ -41,11 +66,11 @@ public class MethodsModule : MiniOmsModule
i_AccessModifier_Protected = oms.CreateInstanceOf(c_AccessModifier, KnownInstanceGuids.AccessModifiers.Protected);
oms.SetAttributeValue(i_AccessModifier_Protected, a_Name, "Protected");
oms.SetAttributeValue(i_AccessModifier_Protected, a_Order, "b");
i_AccessModifier_Public = oms.CreateInstanceOf(c_AccessModifier, KnownInstanceGuids.AccessModifiers.Public);
oms.SetAttributeValue(i_AccessModifier_Public, a_Name, "Public");
oms.SetAttributeValue(i_AccessModifier_Public, a_Order, "c");
i_AccessModifier_RootA2 = oms.CreateInstanceOf(c_AccessModifier, KnownInstanceGuids.AccessModifiers.RootA2);
oms.SetAttributeValue(i_AccessModifier_RootA2, a_Name, "Root (A2)");
oms.SetAttributeValue(i_AccessModifier_RootA2, a_Order, "z");
@ -54,9 +79,11 @@ public class MethodsModule : MiniOmsModule
AccessModifier.Protected = new AccessModifier(i_AccessModifier_Protected);
AccessModifier.Public = new AccessModifier(i_AccessModifier_Public);
AccessModifier.RootA2 = new AccessModifier(i_AccessModifier_RootA2);
oms.CreateRelationship(c_Class, "has", c_Method, KnownRelationshipGuids.Class__has__Method, false, "for", KnownRelationshipGuids.Method__for__Class);
oms.CreateRelationship(c_MethodBinding, "executes", c_Method, KnownRelationshipGuids.Method_Binding__executes__Method, true, "executed by", KnownRelationshipGuids.Method__executed_by__Method_Binding);
oms.CreateRelationship(c_MethodBinding, "has", c_ParameterAssignment, KnownRelationshipGuids.Method_Binding__has__Parameter_Assignment, false, "for", KnownRelationshipGuids.Parameter_Assignment__for__Method_Binding);
c_BuildAttributeMethod = oms.CreateClass("BA - Build Attribute Method", KnownInstanceGuids.MethodClasses.BuildAttributeMethod);
oms.AddAttribute(c_BuildAttributeMethod, oms.GetInstance(KnownAttributeGuids.Text.Value));
@ -90,6 +117,76 @@ public class MethodsModule : MiniOmsModule
oms.CreateRelationship(c_AssignAttributeMethod, "assigns", c_Attribute, KnownRelationshipGuids.Assign_Attribute_Method__assigns__Attribute, false, "assigned by", KnownRelationshipGuids.Attribute__assigned_by__Assign_Attribute_Method);
oms.AddSuperClass(c_AssignAttributeMethod, c_Method);
c_GetRelationshipMethod = oms.CreateClass("GR - Get Relationship Method", KnownInstanceGuids.MethodClasses.GetRelationshipMethod);
oms.CreateRelationship(c_GetRelationshipMethod, "returns", c_Relationship, KnownRelationshipGuids.Get_Relationship_Method__returns__Relationship, true, "returned by", KnownRelationshipGuids.Relationship__returned_by__Get_Relationship_Method);
oms.AddSuperClass(c_GetRelationshipMethod, c_Method);
oms.AddAttribute(c_GetRelationshipMethod, a_Singular);
c_GetReferencedAttributeMethod = oms.CreateClass("GRA - Get Referenced Attribute Method", KnownInstanceGuids.MethodClasses.GetReferencedAttributeMethod);
oms.CreateRelationship(c_GetReferencedAttributeMethod, "returns", c_Attribute, KnownRelationshipGuids.Get_Referenced_Attribute_Method__returns__Attribute, true, "returned by", KnownRelationshipGuids.Attribute__returned_by__Get_Referenced_Attribute_Method);
oms.CreateRelationship(c_GetReferencedAttributeMethod, "uses reference", c_Instance, KnownRelationshipGuids.Get_Referenced_Attribute_Method__uses_reference__Executable_returning_Instance_Set, true, "reference used by", KnownRelationshipGuids.Executable_returning_Instance_Set__reference_used_by__Get_Referenced_Attribute_Method);
oms.CreateRelationship(c_GetReferencedAttributeMethod, "uses answer", c_Instance, KnownRelationshipGuids.Get_Referenced_Attribute_Method__uses_answer__Executable_returning_Attribute, true, "reference used by", KnownRelationshipGuids.Executable_returning_Attribute__answer_used_by__Get_Referenced_Attribute_Method);
oms.CreateRelationship(c_GetReferencedAttributeMethod, "uses", c_AccumulationFunction, KnownRelationshipGuids.Get_Referenced_Attribute_Method__uses__Accumulation_Function, true, "used by", KnownRelationshipGuids.Accumulation_Function__used_by__Get_Referenced_Attribute_Method);
oms.CreateRelationship(c_GetReferencedAttributeMethod, "uses order", c_Attribute, KnownRelationshipGuids.Get_Referenced_Attribute_Method__uses_order__Executable_returning_Attribute, true, "order used by", KnownRelationshipGuids.Executable_returning_Attribute__order_used_by__Get_Referenced_Attribute_Method);
oms.AddSuperClass(c_GetReferencedAttributeMethod, c_Method);
c_SelectFromInstanceSetMethod = oms.CreateClass("SS - Select from Instance Set Method", KnownInstanceGuids.MethodClasses.SelectFromInstanceSetMethod);
oms.CreateRelationship(c_GetReferencedAttributeMethod, "returns", c_Attribute, KnownRelationshipGuids.Select_From_Instance_Set_Method__returns__Work_Set, true, "returned by", KnownRelationshipGuids.Work_Set__returned_by__Select_from_Instance_Set_Method);
oms.CreateRelationship(c_GetReferencedAttributeMethod, "uses", c_Instance, KnownRelationshipGuids.Select_from_Instance_Set_Method__uses__Executable_returning_Instance_Set, true, "used by", KnownRelationshipGuids.Executable_returning_Instance_Set__used_by__Select_from_Instance_Set_Method);
oms.CreateRelationship(c_GetReferencedAttributeMethod, "uses", c_Instance, KnownRelationshipGuids.Select_from_Instance_Set_Method__uses__Selection_Function, true, "used by", KnownRelationshipGuids.Selection_Function__used_by__Select_from_Instance_Set_Method);
oms.CreateRelationship(c_GetReferencedAttributeMethod, "uses", c_AccumulationFunction, KnownRelationshipGuids.Select_from_Instance_Set_Method__uses__Set_Function, true, "used by", KnownRelationshipGuids.Set_Function__used_by__Select_from_Instance_Set_Method);
oms.CreateRelationship(c_GetReferencedAttributeMethod, "uses order", c_Attribute, KnownRelationshipGuids.Select_from_Instance_Set_Method__uses_order__Executable_returning_Attribute, true, "order used by", KnownRelationshipGuids.Executable_returning_Attribute__order_used_by__Get_Referenced_Attribute_Method);
oms.AddSuperClass(c_SelectFromInstanceSetMethod, c_Method);
c_ConditionGroup = oms.CreateClass("Condition Group", KnownInstanceGuids.Classes.ConditionGroup);
oms.CreateRelationship(c_ConditionGroup, "has true condition", c_Instance, KnownRelationshipGuids.Condition_Group__has_true_condition__Executable_returning_Work_Data, false, "true condition for", KnownRelationshipGuids.Executable_returning_Work_Data__true_condition_for__Condition_Group);
oms.CreateRelationship(c_ConditionGroup, "has false condition", c_Instance, KnownRelationshipGuids.Condition_Group__has_false_condition__Executable_returning_Work_Data, false, "false condition for", KnownRelationshipGuids.Executable_returning_Work_Data__false_condition_for__Condition_Group);
oms.AddAttribute(c_ConditionGroup, a_UseAnyCondition);
c_ConditionalSelectFromInstanceSetCase = oms.CreateClass("Conditional Select from Instance Set Case", KnownInstanceGuids.Classes.ConditionalSelectFromInstanceSetCase);
oms.AddSuperClass(c_ConditionalSelectFromInstanceSetCase, c_ConditionGroup);
c_ConditionalSelectFromInstanceSetMethod = oms.CreateClass("SSC - Conditional Select from Instance Set Method", KnownInstanceGuids.MethodClasses.ConditionalSelectFromInstanceSetMethod);
oms.CreateRelationship(c_ConditionalSelectFromInstanceSetMethod, "returns", c_WorkSet, KnownRelationshipGuids.Conditional_Select_From_Instance_Set_Method__returns__Work_Set, true, "returned by", KnownRelationshipGuids.Work_Set__returned_by__Conditional_Select_from_Instance_Set_Method);
oms.CreateRelationship(c_ConditionalSelectFromInstanceSetMethod, "has", c_ConditionalSelectFromInstanceSetCase, KnownRelationshipGuids.Conditional_Select_from_Instance_Set_Method__has__Conditional_Select_from_Instance_Set_Case, false, "for", KnownRelationshipGuids.Conditional_Select_from_Instance_Set_Case__for__Conditional_Select_from_Instance_Set_Method);
oms.AddSuperClass(c_ConditionalSelectFromInstanceSetMethod, c_Method);
c_ConditionalSelectAttributeCase = oms.CreateClass("Conditional Select Attribute Case", KnownInstanceGuids.Classes.ConditionalSelectAttributeCase);
oms.CreateRelationship(c_ConditionalSelectAttributeCase, "invokes", c_Attribute, KnownRelationshipGuids.Conditional_Select_Attribute_Case__invokes__Executable_returning_Attribute, true, "invoked by", KnownRelationshipGuids.Executable_returning_Attribute__invoked_by__Conditional_Select_Attribute_Case);
oms.AddSuperClass(c_ConditionalSelectAttributeCase, c_ConditionGroup);
c_ConditionalSelectAttributeMethod = oms.CreateClass("SAC - Conditional Select Attribute Method", KnownInstanceGuids.MethodClasses.ConditionalSelectAttributeMethod);
oms.CreateRelationship(c_ConditionalSelectAttributeMethod, "returns", c_Attribute, KnownRelationshipGuids.Conditional_Select_Attribute_Method__returns__Attribute, true, "returned by", KnownRelationshipGuids.Attribute__returned_by__Conditional_Select_Attribute_Method);
oms.CreateRelationship(c_ConditionalSelectAttributeMethod, "has", c_ConditionalSelectAttributeCase, KnownRelationshipGuids.Conditional_Select_Attribute_Method__has__Conditional_Select_Attribute_Case, false, "for", KnownRelationshipGuids.Conditional_Select_Attribute_Case__for__Conditional_Select_Attribute_Method);
oms.AddSuperClass(c_ConditionalSelectAttributeMethod, c_Method);
InstanceHandle c_BooleanOperator = oms.CreateClass("Boolean Operator", KnownInstanceGuids.Classes.BooleanOperator);
InstanceHandle c_RelationalOperator = oms.CreateClass("Relational Operator", KnownInstanceGuids.Classes.RelationalOperator);
RelationalOperator.CountEqualTo = new RelationalOperator(oms.CreateInstanceOf(c_RelationalOperator, KnownInstanceGuids.RelationalOperators.CountEqualTo));
RelationalOperator.CountGreaterThan = new RelationalOperator(oms.CreateInstanceOf(c_RelationalOperator, KnownInstanceGuids.RelationalOperators.CountGreaterThan));
RelationalOperator.CountGreaterThanOrEqualTo = new RelationalOperator(oms.CreateInstanceOf(c_RelationalOperator, KnownInstanceGuids.RelationalOperators.CountGreaterThanOrEqualTo));
RelationalOperator.CountLessThan = new RelationalOperator(oms.CreateInstanceOf(c_RelationalOperator, KnownInstanceGuids.RelationalOperators.CountLessThan));
RelationalOperator.CountLessThanOrEqualTo = new RelationalOperator(oms.CreateInstanceOf(c_RelationalOperator, KnownInstanceGuids.RelationalOperators.CountLessThanOrEqualTo));
RelationalOperator.CountNotEqualTo = new RelationalOperator(oms.CreateInstanceOf(c_RelationalOperator, KnownInstanceGuids.RelationalOperators.CountNotEqualTo));
RelationalOperator.ExactMatchWithSelectionList = new RelationalOperator(oms.CreateInstanceOf(c_RelationalOperator, KnownInstanceGuids.RelationalOperators.ExactMatchWithSelectionList));
RelationalOperator.InSelectionList = new RelationalOperator(oms.CreateInstanceOf(c_RelationalOperator, KnownInstanceGuids.RelationalOperators.InSelectionList));
RelationalOperator.IsEmpty = new RelationalOperator(oms.CreateInstanceOf(c_RelationalOperator, KnownInstanceGuids.RelationalOperators.IsEmpty));
RelationalOperator.IsNotEmpty = new RelationalOperator(oms.CreateInstanceOf(c_RelationalOperator, KnownInstanceGuids.RelationalOperators.IsNotEmpty));
RelationalOperator.NotExactMatchWithSelectionList = new RelationalOperator(oms.CreateInstanceOf(c_RelationalOperator, KnownInstanceGuids.RelationalOperators.NotExactMatchWithSelectionList));
RelationalOperator.NotInSelectionList = new RelationalOperator(oms.CreateInstanceOf(c_RelationalOperator, KnownInstanceGuids.RelationalOperators.NotInSelectionList));
RelationalOperator.NotSubsetOfSelectionList = new RelationalOperator(oms.CreateInstanceOf(c_RelationalOperator, KnownInstanceGuids.RelationalOperators.NotSubsetOfSelectionList));
RelationalOperator.NotSupersetOfSelectionList = new RelationalOperator(oms.CreateInstanceOf(c_RelationalOperator, KnownInstanceGuids.RelationalOperators.NotSupersetOfSelectionList));
RelationalOperator.SubsetOfSelectionList = new RelationalOperator(oms.CreateInstanceOf(c_RelationalOperator, KnownInstanceGuids.RelationalOperators.SubsetOfSelectionList));
RelationalOperator.SupersetOfSelectionList = new RelationalOperator(oms.CreateInstanceOf(c_RelationalOperator, KnownInstanceGuids.RelationalOperators.SupersetOfSelectionList));
c_EvaluateBooleanExpressionMethod = oms.CreateClass("EBE - Evaluate Boolean Expression Method", KnownInstanceGuids.MethodClasses.EvaluateBooleanExpressionMethod);
oms.CreateRelationship(c_EvaluateBooleanExpressionMethod, "returns", c_BooleanAttribute, KnownRelationshipGuids.Evaluate_Boolean_Expression_Method__returns__Boolean_Attribute, true, "returned by", KnownRelationshipGuids.Boolean_Attribute__returned_by__Evaluate_Boolean_Expression_Method);
oms.CreateRelationship(c_EvaluateBooleanExpressionMethod, "has source", c_Instance, KnownRelationshipGuids.Evaluate_Boolean_Expression_Method__has_source__Executable_returning_Work_Data, true, "source for", KnownRelationshipGuids.Executable_returning_Work_Data__source_for__Evaluate_Boolean_Expression_Method);
oms.CreateRelationship(c_EvaluateBooleanExpressionMethod, "uses", c_BooleanOperator, KnownRelationshipGuids.Evaluate_Boolean_Expression_Method__uses__Boolean_Operator, true, "source for", KnownRelationshipGuids.Executable_returning_Work_Data__source_for__Evaluate_Boolean_Expression_Method);
oms.CreateRelationship(c_EvaluateBooleanExpressionMethod, "has target", c_Instance, KnownRelationshipGuids.Evaluate_Boolean_Expression_Method__has_target__Executable_returning_Work_Data, true, "target for", KnownRelationshipGuids.Executable_returning_Work_Data__target_for__Evaluate_Boolean_Expression_Method);
oms.AddSuperClass(c_EvaluateBooleanExpressionMethod, c_Method);
oms.AddAttribute(c_Method, a_Name);
oms.AddAttribute(c_Method, a_Verb);
oms.AddAttribute(c_Method, a_Static);
@ -99,5 +196,70 @@ public class MethodsModule : MiniOmsModule
OmsSystemRoutineBuilder srb = new OmsSystemRoutineBuilder(oms);
SystemAttributeRoutine sr = srb.CreateSystemAttributeRoutine(KnownInstanceGuids.SystemAttributeRoutines.GetRuntimeVersion, new Func<object?>(delegate () { return oms.RuntimeVersion.ToString(); }));
mb.CreateGetAttributeBySystemRoutineMethod(c_OMS, "get", "Runtime Version", null, true, oms.GetInstance(KnownAttributeGuids.Text.Value), sr);
mb.CreateGetRelationshipMethod(c_Instance, "get", "Parent Class", AccessModifier.Public, false, KnownInstanceGuids.Methods.GetRelationship.Instance__get__Parent_Class, oms.GetInstance(KnownRelationshipGuids.Instance__for__Class));
CreateGetMethodAbbreviation(oms);
CreateGetMethodBindingAbbreviation(oms);
}
private void CreateGetMethodAbbreviation(Oms oms)
{
OmsMethodBuilder mb = new OmsMethodBuilder(oms);
GetRelationshipMethod Instance__get__Parent_Class = oms.GetInstance<GetRelationshipMethod>(KnownInstanceGuids.Methods.GetRelationship.Instance__get__Parent_Class);
ReturnInstanceSetMethodBinding Instance__get__Parent_Class_rsmb = Instance__get__Parent_Class.CreateMethodBinding(oms, new KeyValuePair<InstanceHandle, object?>[]
{
new KeyValuePair<InstanceHandle, object?>(c_Instance, c_Method)
});
BuildAttributeMethod Method__get__SAC_Method_Suffix = mb.CreateBuildAttributeMethod(c_Method, "get", "SAC Method Suffix", AccessModifier.Public, true, a_Value, "SAC");
ReturnAttributeMethodBinding Method__get__SAC_Method_Suffix_ramb = Method__get__SAC_Method_Suffix.CreateMethodBinding(oms);
EvaluateBooleanExpressionMethod Method__is__Conditional_Select_Attribute_Method = mb.CreateEvaluateBooleanExpressionMethod(c_Method, "is", "SAC", AccessModifier.Public, false, oms.GetInstance(KnownAttributeGuids.Boolean.MethodIsOfTypeSpecified), Instance__get__Parent_Class_rsmb.Handle, RelationalOperator.InSelectionList, oms.GetInstance(KnownInstanceGuids.MethodClasses.ConditionalSelectAttributeMethod));
ReturnAttributeMethodBinding Method__is__Conditional_Select_Attribute_Method_ramb = Method__is__Conditional_Select_Attribute_Method.CreateMethodBinding(oms);
BuildAttributeMethod Method__get__GR_Method_Suffix = mb.CreateBuildAttributeMethod(c_Method, "get", "GR Method Suffix", AccessModifier.Public, true, a_Value, "GR");
ReturnAttributeMethodBinding Method__get__GR_Method_Suffix_ramb = Method__get__GR_Method_Suffix.CreateMethodBinding(oms);
EvaluateBooleanExpressionMethod Method__is__Get_Relationship_Method = mb.CreateEvaluateBooleanExpressionMethod(c_Method, "is", "GR", AccessModifier.Public, false, oms.GetInstance(KnownAttributeGuids.Boolean.MethodIsOfTypeSpecified), Instance__get__Parent_Class_rsmb.Handle, RelationalOperator.InSelectionList, oms.GetInstance(KnownInstanceGuids.MethodClasses.GetRelationshipMethod));
ReturnAttributeMethodBinding Method__is__Get_Relationship_Method_ramb = Method__is__Get_Relationship_Method.CreateMethodBinding(oms);
mb.CreateConditionalSelectAttributeMethod(c_Method, "get", "Method Abbreviation", AccessModifier.Public, false, KnownInstanceGuids.Methods.ConditionalSelectAttribute.Method__get__Method_Abbreviation, a_Value, new ConditionalSelectAttributeCase[]
{
new ConditionalSelectAttributeCase(new IExecutableReturningAttribute[] { Method__is__Get_Relationship_Method_ramb }, null, false, Method__get__GR_Method_Suffix_ramb),
new ConditionalSelectAttributeCase(new IExecutableReturningAttribute[] { Method__is__Conditional_Select_Attribute_Method_ramb }, null, false, Method__get__SAC_Method_Suffix_ramb)
});
}
private void CreateGetMethodBindingAbbreviation(Oms oms)
{
OmsMethodBuilder mb = new OmsMethodBuilder(oms);
GetRelationshipMethod Instance__get__Parent_Class = oms.GetInstance<GetRelationshipMethod>(KnownInstanceGuids.Methods.GetRelationship.Instance__get__Parent_Class);
ReturnInstanceSetMethodBinding Instance__get__Parent_Class_rsmb = Instance__get__Parent_Class.CreateMethodBinding(oms, new KeyValuePair<InstanceHandle, object?>[]
{
new KeyValuePair<InstanceHandle, object?>(c_Instance, c_MethodBinding)
});
// RAMB
BuildAttributeMethod Method_Binding__get__RAMB_Method_Binding_Suffix = mb.CreateBuildAttributeMethod(c_MethodBinding, "get", "RAMB Method Suffix", AccessModifier.Public, true, a_Value, "ramb");
ReturnAttributeMethodBinding Method_Binding__get__RAMB_Method_Binding_Suffix_ramb = Method_Binding__get__RAMB_Method_Binding_Suffix.CreateMethodBinding(oms);
EvaluateBooleanExpressionMethod Method_Binding__is__Return_Attribute_Method_Binding = mb.CreateEvaluateBooleanExpressionMethod(c_MethodBinding, "is", "RAMB", AccessModifier.Public, false, oms.GetInstance(KnownAttributeGuids.Boolean.MethodIsOfTypeSpecified), Instance__get__Parent_Class_rsmb.Handle, RelationalOperator.InSelectionList, oms.GetInstance(KnownInstanceGuids.Classes.ReturnAttributeMethodBinding));
ReturnAttributeMethodBinding Method_Binding__is__Return_Attribute_Method_Binding_ramb = Method_Binding__is__Return_Attribute_Method_Binding.CreateMethodBinding(oms);
// RSMB
BuildAttributeMethod Method_Binding__get__RSMB_Method_Binding_Suffix = mb.CreateBuildAttributeMethod(c_MethodBinding, "get", "RSMB Method Suffix", AccessModifier.Public, true, a_Value, "rsmb");
ReturnAttributeMethodBinding Method_Binding__get__RSMB_Method_Binding_Suffix_ramb = Method_Binding__get__RSMB_Method_Binding_Suffix.CreateMethodBinding(oms);
EvaluateBooleanExpressionMethod Method_Binding__is__Return_Instance_Set_Method_Binding = mb.CreateEvaluateBooleanExpressionMethod(c_MethodBinding, "is", "RSMB", AccessModifier.Public, false, oms.GetInstance(KnownAttributeGuids.Boolean.MethodIsOfTypeSpecified), Instance__get__Parent_Class_rsmb.Handle, RelationalOperator.InSelectionList, oms.GetInstance(KnownInstanceGuids.Classes.ReturnInstanceSetMethodBinding));
ReturnAttributeMethodBinding Method_Binding__is__Return_Instance_Set_Method_Binding_ramb = Method_Binding__is__Return_Instance_Set_Method_Binding.CreateMethodBinding(oms);
mb.CreateConditionalSelectAttributeMethod(c_MethodBinding, "get", "Method Binding Abbreviation", AccessModifier.Public, false, KnownInstanceGuids.Methods.ConditionalSelectAttribute.Method_Binding__get__Method_Binding_Abbreviation, a_Value, new ConditionalSelectAttributeCase[]
{
new ConditionalSelectAttributeCase(new IExecutableReturningAttribute[] { Method_Binding__is__Return_Attribute_Method_Binding_ramb }, null, false, Method_Binding__get__RAMB_Method_Binding_Suffix_ramb),
new ConditionalSelectAttributeCase(new IExecutableReturningAttribute[] { Method_Binding__is__Return_Instance_Set_Method_Binding_ramb }, null, false, Method_Binding__get__RSMB_Method_Binding_Suffix_ramb)
});
}
}

167
mocha-dotnet/src/lib/Mocha.Core/OmsMethodBuilder.cs
View File

@ -58,7 +58,11 @@ public class OmsMethodBuilder
private InstanceHandle CreateMethodBase(InstanceHandle methodClassInstance, InstanceHandle forClassInstance, string verb, string name, AccessModifier accessModifier, bool isStatic)
{
InstanceHandle method = Oms.CreateInstanceOf(methodClassInstance);
return CreateMethodBase(methodClassInstance, forClassInstance, verb, name, accessModifier, isStatic, Guid.NewGuid());
}
private InstanceHandle CreateMethodBase(InstanceHandle methodClassInstance, InstanceHandle forClassInstance, string verb, string name, AccessModifier accessModifier, bool isStatic, Guid globalIdentifier)
{
InstanceHandle method = Oms.CreateInstanceOf(methodClassInstance, globalIdentifier);
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Method__for__Class), forClassInstance);
if (!Oms.ValidateConstraints)
{
@ -98,4 +102,165 @@ public class OmsMethodBuilder
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Assign_Attribute_Method__assigns__Attribute), assignsToAttribute);
return new AssignAttributeMethod(method);
}
public GetRelationshipMethod CreateGetRelationshipMethod(InstanceHandle forClassInstance, string verb, string name, AccessModifier accessModifier, bool isStatic, InstanceHandle returnsRelationship)
{
return CreateGetRelationshipMethod(forClassInstance, verb, name, accessModifier, isStatic, Guid.NewGuid(), returnsRelationship);
}
public GetRelationshipMethod CreateGetRelationshipMethod(InstanceHandle forClassInstance, string verb, string name, AccessModifier accessModifier, bool isStatic, Guid globalIdentifier, InstanceHandle returnsRelationship)
{
InstanceHandle method = CreateMethodBase(Oms.GetInstance(KnownInstanceGuids.MethodClasses.GetRelationshipMethod), forClassInstance, verb, name, accessModifier, isStatic, globalIdentifier);
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Get_Relationship_Method__returns__Relationship), returnsRelationship);
return new GetRelationshipMethod(method);
}
public GetReferencedAttributeMethod CreateGetReferencedAttributeMethod(InstanceHandle forClassInstance, string verb, string name, AccessModifier accessModifier, bool isStatic, InstanceHandle returnsAttribute, IExecutableReturningInstanceSet usesReferenceInstanceSet, IExecutableReturningAttribute usesAnswerExecutableReturningAttribute, InstanceHandle? usesAccumulationFunction = null, InstanceHandle? usesOrderExecutableReturningAttribute = null)
{
return CreateGetReferencedAttributeMethod(forClassInstance, verb, name, accessModifier, isStatic, returnsAttribute, usesReferenceInstanceSet.Handle, usesAnswerExecutableReturningAttribute.Handle, usesAccumulationFunction, usesOrderExecutableReturningAttribute);
}
public GetReferencedAttributeMethod CreateGetReferencedAttributeMethod(InstanceHandle forClassInstance, string verb, string name, AccessModifier accessModifier, bool isStatic, InstanceHandle returnsAttribute, InstanceHandle usesReferenceInstanceSet, InstanceHandle usesAnswerExecutableReturningAttribute, InstanceHandle? usesAccumulationFunction = null, InstanceHandle? usesOrderExecutableReturningAttribute = null)
{
InstanceHandle method = CreateMethodBase(Oms.GetInstance(KnownInstanceGuids.MethodClasses.GetReferencedAttributeMethod), forClassInstance, verb, name, accessModifier, isStatic);
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Get_Referenced_Attribute_Method__returns__Attribute), returnsAttribute);
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Get_Referenced_Attribute_Method__uses_reference__Executable_returning_Instance_Set), usesReferenceInstanceSet);
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Get_Referenced_Attribute_Method__uses_answer__Executable_returning_Attribute), usesAnswerExecutableReturningAttribute);
if (usesAccumulationFunction != null)
{
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Get_Referenced_Attribute_Method__uses__Accumulation_Function), usesAccumulationFunction.GetValueOrDefault());
}
if (usesOrderExecutableReturningAttribute != null)
{
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Get_Referenced_Attribute_Method__uses_order__Executable_returning_Attribute), usesOrderExecutableReturningAttribute.GetValueOrDefault());
}
return new GetReferencedAttributeMethod(method);
}
public SelectFromInstanceSetMethod CreateSelectFromInstanceSetMethod(InstanceHandle forClassInstance, string verb, string name, AccessModifier accessModifier, bool isStatic, WorkSet returnsWorkSet, InstanceWrapper usesExecutableReturningInstanceSet, InstanceHandle? usesSetFunction = null, InstanceHandle? usesSelectionFunction = null, InstanceHandle? usesOrderExecutableReturningAttribute = null)
{
return CreateSelectFromInstanceSetMethod(forClassInstance, verb, name, accessModifier, isStatic, returnsWorkSet.Handle, usesExecutableReturningInstanceSet.Handle, usesSetFunction, usesSelectionFunction, usesOrderExecutableReturningAttribute);
}
public SelectFromInstanceSetMethod CreateSelectFromInstanceSetMethod(InstanceHandle forClassInstance, string verb, string name, AccessModifier accessModifier, bool isStatic, InstanceHandle returnsWorkSet, InstanceHandle usesExecutableReturningInstanceSet, InstanceHandle? usesSetFunction = null, InstanceHandle? usesSelectionFunction = null, InstanceHandle? usesOrderExecutableReturningAttribute = null)
{
InstanceHandle method = CreateMethodBase(Oms.GetInstance(KnownInstanceGuids.MethodClasses.SelectFromInstanceSetMethod), forClassInstance, verb, name, accessModifier, isStatic);
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Select_From_Instance_Set_Method__returns__Work_Set), returnsWorkSet);
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Select_from_Instance_Set_Method__uses__Executable_returning_Instance_Set), usesExecutableReturningInstanceSet);
if (usesSetFunction != null)
{
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Select_from_Instance_Set_Method__uses__Set_Function), usesSetFunction.GetValueOrDefault());
}
if (usesSelectionFunction != null)
{
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Select_from_Instance_Set_Method__uses__Selection_Function), usesSelectionFunction.GetValueOrDefault());
}
if (usesOrderExecutableReturningAttribute != null)
{
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Select_from_Instance_Set_Method__uses_order__Executable_returning_Attribute), usesOrderExecutableReturningAttribute.GetValueOrDefault());
}
/*
if (usesAccumulationFunction != null)
{
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Get_Referenced_Attribute_Method__uses__Accumulation_Function), usesAccumulationFunction.GetValueOrDefault());
}
if (usesOrderExecutableReturningAttribute != null)
{
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Get_Referenced_Attribute_Method__uses_order__Executable_returning_Attribute), usesOrderExecutableReturningAttribute.GetValueOrDefault());
}
*/
return new SelectFromInstanceSetMethod(method);
}
public ConditionalSelectFromInstanceSetMethod CreateConditionalSelectFromInstanceSetMethod(InstanceHandle forClassInstance, string verb, string name, AccessModifier accessModifier, bool isStatic, WorkSet returnsWorkSet, InstanceWrapper[] cases, InstanceHandle? usesSetFunction = null, InstanceHandle? usesSelectionFunction = null, InstanceHandle? usesOrderExecutableReturningAttribute = null)
{
List<InstanceHandle> cases2 = new List<InstanceHandle>();
foreach (InstanceWrapper wrapper in cases)
{
cases2.Add(wrapper.Handle);
}
return CreateConditionalSelectFromInstanceSetMethod(forClassInstance, verb, name, accessModifier, isStatic, returnsWorkSet.Handle, cases2.ToArray(), usesSetFunction, usesSelectionFunction, usesOrderExecutableReturningAttribute);
}
public ConditionalSelectFromInstanceSetMethod CreateConditionalSelectFromInstanceSetMethod(InstanceHandle forClassInstance, string verb, string name, AccessModifier accessModifier, bool isStatic, InstanceHandle returnsWorkSet, InstanceHandle[] cases, InstanceHandle? usesSetFunction = null, InstanceHandle? usesSelectionFunction = null, InstanceHandle? usesOrderExecutableReturningAttribute = null)
{
InstanceHandle method = CreateMethodBase(Oms.GetInstance(KnownInstanceGuids.MethodClasses.ConditionalSelectFromInstanceSetMethod), forClassInstance, verb, name, accessModifier, isStatic);
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Conditional_Select_From_Instance_Set_Method__returns__Work_Set), returnsWorkSet);
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Conditional_Select_from_Instance_Set_Method__has__Conditional_Select_from_Instance_Set_Case), cases);
if (usesSetFunction != null)
{
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Select_from_Instance_Set_Method__uses__Set_Function), usesSetFunction.GetValueOrDefault());
}
if (usesSelectionFunction != null)
{
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Select_from_Instance_Set_Method__uses__Selection_Function), usesSelectionFunction.GetValueOrDefault());
}
if (usesOrderExecutableReturningAttribute != null)
{
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Select_from_Instance_Set_Method__uses_order__Executable_returning_Attribute), usesOrderExecutableReturningAttribute.GetValueOrDefault());
}
/*
if (usesAccumulationFunction != null)
{
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Get_Referenced_Attribute_Method__uses__Accumulation_Function), usesAccumulationFunction.GetValueOrDefault());
}
if (usesOrderExecutableReturningAttribute != null)
{
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Get_Referenced_Attribute_Method__uses_order__Executable_returning_Attribute), usesOrderExecutableReturningAttribute.GetValueOrDefault());
}
*/
return new ConditionalSelectFromInstanceSetMethod(method);
}
public ConditionalSelectAttributeMethod CreateConditionalSelectAttributeMethod(InstanceHandle forClassInstance, string verb, string name, AccessModifier accessModifier, bool isStatic, InstanceHandle returnsAttribute, ConditionalSelectAttributeCase[] cases, InstanceHandle? usesSetFunction = null, InstanceHandle? usesSelectionFunction = null, InstanceHandle? usesOrderExecutableReturningAttribute = null)
{
return CreateConditionalSelectAttributeMethod(forClassInstance, verb, name, accessModifier, isStatic, Guid.NewGuid(), returnsAttribute, cases, usesSetFunction, usesSelectionFunction, usesOrderExecutableReturningAttribute);
}
public ConditionalSelectAttributeMethod CreateConditionalSelectAttributeMethod(InstanceHandle forClassInstance, string verb, string name, AccessModifier accessModifier, bool isStatic, Guid globalIdentifier, InstanceHandle returnsAttribute, ConditionalSelectAttributeCase[] cases, InstanceHandle? usesSetFunction = null, InstanceHandle? usesSelectionFunction = null, InstanceHandle? usesOrderExecutableReturningAttribute = null)
{
InstanceHandle method = CreateMethodBase(Oms.GetInstance(KnownInstanceGuids.MethodClasses.ConditionalSelectAttributeMethod), forClassInstance, verb, name, accessModifier, isStatic, globalIdentifier);
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Conditional_Select_Attribute_Method__returns__Attribute), returnsAttribute);
InstanceHandle[] ihCases = new InstanceHandle[cases.Length];
for (int i = 0; i < cases.Length; i++)
{
ihCases[i] = CreateConditionalSelectAttributeCase(cases[i]);
}
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Conditional_Select_Attribute_Method__has__Conditional_Select_Attribute_Case), ihCases);
return new ConditionalSelectAttributeMethod(method);
}
private InstanceHandle CreateConditionalSelectAttributeCase(ConditionalSelectAttributeCase sacCase)
{
InstanceHandle ih = Oms.CreateInstanceOf(Oms.GetInstance(KnownInstanceGuids.Classes.ConditionalSelectAttributeCase));
Oms.SetAttributeValue(ih, Oms.GetInstance(KnownAttributeGuids.Boolean.UseAnyCondition), sacCase.UseAnyCondition);
IEnumerable<InstanceHandle> trueConditions = sacCase.TrueConditions.ToInstanceHandleArray();
if (trueConditions != null)
{
Oms.AssignRelationship(ih, Oms.GetInstance(KnownRelationshipGuids.Condition_Group__has_true_condition__Executable_returning_Work_Data), trueConditions);
}
IEnumerable<InstanceHandle> falseConditions = sacCase.FalseConditions.ToInstanceHandleArray();
if (falseConditions != null)
{
Oms.AssignRelationship(ih, Oms.GetInstance(KnownRelationshipGuids.Condition_Group__has_false_condition__Executable_returning_Work_Data), falseConditions);
}
Oms.AssignRelationship(ih, Oms.GetInstance(KnownRelationshipGuids.Conditional_Select_Attribute_Case__invokes__Executable_returning_Attribute), sacCase.UsesExecutableReturningAttribute.Handle);
return ih;
}
public EvaluateBooleanExpressionMethod CreateEvaluateBooleanExpressionMethod(InstanceHandle forClassInstance, string verb, string name, AccessModifier accessModifier, bool isStatic, InstanceHandle returnsAttribute, IInstanceWrapper sourceWorkData, BooleanOperator booleanOperator, IInstanceWrapper compareToWorkData)
{
return CreateEvaluateBooleanExpressionMethod(forClassInstance, verb, name, accessModifier, isStatic, returnsAttribute, sourceWorkData.Handle, booleanOperator, compareToWorkData.Handle);
}
public EvaluateBooleanExpressionMethod CreateEvaluateBooleanExpressionMethod(InstanceHandle forClassInstance, string verb, string name, AccessModifier accessModifier, bool isStatic, InstanceHandle returnsAttribute, InstanceHandle sourceWorkData, BooleanOperator booleanOperator, InstanceHandle compareToWorkData)
{
InstanceHandle method = CreateMethodBase(Oms.GetInstance(KnownInstanceGuids.MethodClasses.EvaluateBooleanExpressionMethod), forClassInstance, verb, name, accessModifier, isStatic);
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Evaluate_Boolean_Expression_Method__returns__Boolean_Attribute), returnsAttribute);
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Evaluate_Boolean_Expression_Method__has_source__Executable_returning_Work_Data), sourceWorkData);
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Evaluate_Boolean_Expression_Method__uses__Boolean_Operator), booleanOperator.Handle);
Oms.AssignRelationship(method, Oms.GetInstance(KnownRelationshipGuids.Evaluate_Boolean_Expression_Method__has_target__Executable_returning_Work_Data), compareToWorkData);
return new EvaluateBooleanExpressionMethod(method);
}
}

5
mocha-dotnet/src/lib/Mocha.Core/Oop/AccessModifier.cs
View File

@ -1,8 +1,11 @@
namespace Mocha.Core.Oop;
public class AccessModifier : ConcreteInstanceWrapper
{
internal AccessModifier(InstanceHandle handle) : base(handle) { }
public override Guid ClassId => KnownInstanceGuids.Classes.AccessModifier;
internal AccessModifier(InstanceHandle handle) : base(handle) { }
public static AccessModifier Public { get; internal set; } = null;
public static AccessModifier Private { get; internal set; } = null;

8
mocha-dotnet/src/lib/Mocha.Core/Oop/ArithmeticOperator.cs Normal file
View File

@ -0,0 +1,8 @@
namespace Mocha.Core.Oop;
public class ArithmeticOperator : ConcreteInstanceWrapper
{
public override Guid ClassId => KnownInstanceGuids.Classes.ArithmeticOperator;
internal ArithmeticOperator(InstanceHandle handle) : base(handle) { }
}

6
mocha-dotnet/src/lib/Mocha.Core/Oop/BooleanOperator.cs Normal file
View File

@ -0,0 +1,6 @@
namespace Mocha.Core.Oop;
public abstract class BooleanOperator : ConcreteInstanceWrapper
{
internal BooleanOperator(InstanceHandle handle) : base(handle) { }
}

23
mocha-dotnet/src/lib/Mocha.Core/Oop/ConcreteInstanceWrapper.cs
View File

@ -1,7 +1,9 @@
namespace Mocha.Core.Oop;
public class ConcreteInstanceWrapper : InstanceWrapper
public abstract class ConcreteInstanceWrapper : InstanceWrapper
{
public abstract Guid ClassId { get; }
private InstanceHandle TheHandle { get; }
internal ConcreteInstanceWrapper(InstanceHandle handle)
{
@ -12,4 +14,23 @@ public class ConcreteInstanceWrapper : InstanceWrapper
{
return TheHandle;
}
internal static ConcreteInstanceWrapper? Wrap(Oms oms, InstanceHandle methodInstance)
{
Type[] methodTypes = MBS.Core.Reflection.TypeLoader.GetAvailableTypes(new Type[] { typeof(ConcreteInstanceWrapper) }, new System.Reflection.Assembly[] { System.Reflection.Assembly.GetExecutingAssembly() });
InstanceHandle parentClass = oms.GetParentClass(methodInstance);
foreach (Type methodType in methodTypes)
{
if (methodType.IsAbstract)
continue;
ConcreteInstanceWrapper m = (ConcreteInstanceWrapper)methodType.Assembly.CreateInstance(methodType.FullName, false, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null, new object[] { methodInstance }, null, null);
if (m.ClassId == oms.GetGlobalIdentifier(parentClass))
{
return m;
}
}
return null;
}
}

15
mocha-dotnet/src/lib/Mocha.Core/Oop/ConditionGroup.cs Normal file
View File

@ -0,0 +1,15 @@
namespace Mocha.Core.Oop;
public abstract class ConditionGroup
{
public IInstanceWrapper[] TrueConditions { get; }
public IInstanceWrapper[] FalseConditions { get; }
public bool UseAnyCondition { get; set; } = false;
public ConditionGroup(IInstanceWrapper[] trueConditions, IInstanceWrapper[] falseConditions, bool useAnyCondition)
{
TrueConditions = trueConditions;
FalseConditions = falseConditions;
UseAnyCondition = useAnyCondition;
}
}

6
mocha-dotnet/src/lib/Mocha.Core/Oop/IExecutableReturningAttribute.cs Normal file
View File

@ -0,0 +1,6 @@
namespace Mocha.Core.Oop;
public interface IExecutableReturningAttribute : IInstanceWrapper
{
}

6
mocha-dotnet/src/lib/Mocha.Core/Oop/IExecutableReturningInstanceSet.cs Normal file
View File

@ -0,0 +1,6 @@
namespace Mocha.Core.Oop;
public interface IExecutableReturningInstanceSet : IInstanceWrapper
{
}

23
mocha-dotnet/src/lib/Mocha.Core/Oop/IInstanceWrapper.cs Normal file
View File

@ -0,0 +1,23 @@
namespace Mocha.Core.Oop;
public interface IInstanceWrapper
{
InstanceHandle Handle { get; }
}
public static class InstanceWrapperArrayExtensions
{
public static InstanceHandle[] ToInstanceHandleArray(this IInstanceWrapper[] z)
{
if (z == null)
{
return null;
}
InstanceHandle[] array = new InstanceHandle[z.Length];
for (int i = 0; i < z.Length; i++)
{
array[i] = z[i].Handle;
}
return array;
}
}

13
mocha-dotnet/src/lib/Mocha.Core/Oop/InstanceWrapper.cs
View File

@ -1,11 +1,11 @@
namespace Mocha.Core.Oop;
public abstract class InstanceWrapper
public abstract class InstanceWrapper : IInstanceWrapper
{
private InstanceHandle _Handle = InstanceHandle.Empty;
protected abstract InstanceHandle GetHandleInternal();
internal InstanceHandle Handle
public InstanceHandle Handle
{
get
{
@ -16,4 +16,13 @@ public abstract class InstanceWrapper
return _Handle;
}
}
public override bool Equals(object? obj)
{
if (obj is InstanceWrapper)
{
return Handle.Equals(((InstanceWrapper)obj).Handle);
}
return base.Equals(obj);
}
}

8
mocha-dotnet/src/lib/Mocha.Core/Oop/LogicalOperator.cs Normal file
View File

@ -0,0 +1,8 @@
namespace Mocha.Core.Oop;
public class LogicalOperator : BooleanOperator
{
public override Guid ClassId => KnownInstanceGuids.Classes.LogicalOperator;
internal LogicalOperator(InstanceHandle handle) : base(handle) { }
}

43
mocha-dotnet/src/lib/Mocha.Core/Oop/Method.cs
View File

@ -5,22 +5,39 @@ namespace Mocha.Core.Oop;
public abstract class Method : ConcreteInstanceWrapper
{
public abstract Guid MethodClassGuid { get; }
internal Method(InstanceHandle handle) : base(handle) { }
internal static Method CreateFromInstance(Oms oms, InstanceHandle methodInstance)
protected void SetupMethodBinding(Oms oms, MethodBinding mb, IEnumerable<KeyValuePair<InstanceHandle, object?>> parameterAssignments)
{
Type[] methodTypes = MBS.Core.Reflection.TypeLoader.GetAvailableTypes(new Type[] { typeof(Method) }, new System.Reflection.Assembly[] { System.Reflection.Assembly.GetExecutingAssembly() });
InstanceHandle parentClass = oms.GetParentClass(methodInstance);
if (parameterAssignments != null)
{
InstanceHandle c_ParameterAssignment = oms.GetInstance(KnownInstanceGuids.Classes.ParameterAssignment);
InstanceHandle r_Method_Binding__has__Parameter_Assignment = oms.GetInstance(KnownRelationshipGuids.Method_Binding__has__Parameter_Assignment);
InstanceHandle r_Parameter_Assignment__assigns_from__Executable_returning_Work_Data = oms.GetInstance(KnownRelationshipGuids.Parameter_Assignment__assigns_from__Executable_returning_Work_Data);
InstanceHandle r_Parameter_Assignment__assigns_to__Work_Data = oms.GetInstance(KnownRelationshipGuids.Parameter_Assignment__assigns_to__Work_Data);
foreach (Type methodType in methodTypes)
{
Method m = (Method)methodType.Assembly.CreateInstance(methodType.FullName, false, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null, new object[] { methodInstance }, null, null);
if (m.MethodClassGuid == oms.GetGlobalIdentifier(parentClass))
{
return m;
}
}
return null;
List<InstanceHandle> parms = new List<InstanceHandle>();
foreach (KeyValuePair<InstanceHandle, object?> kvp in parameterAssignments)
{
InstanceHandle parm = oms.CreateInstanceOf(c_ParameterAssignment);
InstanceHandle assignsToParm = kvp.Key;
InstanceHandle assignsFromWorkData = InstanceHandle.Empty;
if (kvp.Value is InstanceHandle)
{
assignsFromWorkData = (InstanceHandle)kvp.Value;
}
else if (kvp.Value is InstanceWrapper)
{
assignsFromWorkData = ((InstanceWrapper)kvp.Value).Handle;
}
oms.AssignRelationship(parm, r_Parameter_Assignment__assigns_to__Work_Data, assignsToParm);
oms.AssignRelationship(parm, r_Parameter_Assignment__assigns_from__Executable_returning_Work_Data, assignsFromWorkData);
parms.Add(parm);
}
oms.AssignRelationship(mb.Handle, r_Method_Binding__has__Parameter_Assignment, parms.ToArray());
}
}
}

9
mocha-dotnet/src/lib/Mocha.Core/Oop/MethodBinding.cs
View File

@ -1,14 +1,17 @@
namespace Mocha.Core.Oop;
public abstract class MethodBinding : ConcreteInstanceWrapper
{
internal MethodBinding(InstanceHandle handle) : base(handle) { }
}
public class ReturnAttributeMethodBinding : MethodBinding
public class ReturnAttributeMethodBinding : MethodBinding, IExecutableReturningAttribute
{
internal ReturnAttributeMethodBinding(InstanceHandle handle) : base(handle) { }
public override Guid ClassId => KnownInstanceGuids.Classes.ReturnAttributeMethodBinding;
internal ReturnAttributeMethodBinding(InstanceHandle handle) : base(handle) { }
}
public class ReturnInstanceSetMethodBinding : MethodBinding
public class ReturnInstanceSetMethodBinding : MethodBinding, IExecutableReturningInstanceSet
{
public override Guid ClassId => KnownInstanceGuids.Classes.ReturnInstanceSetMethodBinding;
internal ReturnInstanceSetMethodBinding(InstanceHandle handle) : base(handle) { }
}

14
mocha-dotnet/src/lib/Mocha.Core/Oop/MethodReturningAttribute.cs Normal file
View File

@ -0,0 +1,14 @@
namespace Mocha.Core.Oop;
public abstract class MethodReturningAttribute : Method, IExecutableReturningAttribute
{
public MethodReturningAttribute(InstanceHandle handle) : base(handle) { }
public ReturnAttributeMethodBinding CreateMethodBinding(Oms oms, IEnumerable<KeyValuePair<InstanceHandle, object?>> parameterAssignments = null)
{
OmsMethodBuilder builder = new OmsMethodBuilder(oms);
ReturnAttributeMethodBinding mb = builder.CreateReturnAttributeMethodBinding(this);
SetupMethodBinding(oms, mb, parameterAssignments);
return mb;
}
}

14
mocha-dotnet/src/lib/Mocha.Core/Oop/MethodReturningInstanceSet.cs Normal file
View File

@ -0,0 +1,14 @@
namespace Mocha.Core.Oop;
public abstract class MethodReturningInstanceSet : Method
{
public MethodReturningInstanceSet(InstanceHandle handle) : base(handle) { }
public ReturnInstanceSetMethodBinding CreateMethodBinding(Oms oms, IEnumerable<KeyValuePair<InstanceHandle, object?>> parameterAssignments = null)
{
OmsMethodBuilder builder = new OmsMethodBuilder(oms);
ReturnInstanceSetMethodBinding mb = builder.CreateReturnInstanceSetMethodBinding(this);
SetupMethodBinding(oms, mb, parameterAssignments);
return mb;
}
}

4
mocha-dotnet/src/lib/Mocha.Core/Oop/Methods/AssignAttributeMethod.cs
View File

@ -1,8 +1,8 @@
namespace Mocha.Core.Oop;
namespace Mocha.Core.Oop.Methods;
public class AssignAttributeMethod : Method
{
public override Guid MethodClassGuid => KnownInstanceGuids.MethodClasses.AssignAttributeMethod;
public override Guid ClassId => KnownInstanceGuids.MethodClasses.AssignAttributeMethod;
public AssignAttributeMethod(InstanceHandle handle) : base(handle) { }
}

4
mocha-dotnet/src/lib/Mocha.Core/Oop/Methods/BuildAttributeMethod.cs
View File

@ -1,8 +1,8 @@
namespace Mocha.Core.Oop.Methods;
public class BuildAttributeMethod : Method
public class BuildAttributeMethod : MethodReturningAttribute
{
public override Guid MethodClassGuid => KnownInstanceGuids.MethodClasses.BuildAttributeMethod;
public override Guid ClassId => KnownInstanceGuids.MethodClasses.BuildAttributeMethod;
internal BuildAttributeMethod(InstanceHandle handle) : base(handle) { }
}

18
mocha-dotnet/src/lib/Mocha.Core/Oop/Methods/ConditionalSelectAttributeMethod.cs Normal file
View File

@ -0,0 +1,18 @@
namespace Mocha.Core.Oop.Methods;
public class ConditionalSelectAttributeMethod : MethodReturningAttribute
{
public override Guid ClassId => KnownInstanceGuids.MethodClasses.ConditionalSelectAttributeMethod;
internal ConditionalSelectAttributeMethod(InstanceHandle handle) : base(handle) { }
}
public class ConditionalSelectAttributeCase : ConditionGroup
{
public IExecutableReturningAttribute UsesExecutableReturningAttribute { get; }
public ConditionalSelectAttributeCase(IExecutableReturningAttribute[] trueConditions, IExecutableReturningAttribute[] falseConditions, bool useAnyCondition, IExecutableReturningAttribute usesExecutableReturningAttribute)
: base(trueConditions, falseConditions, useAnyCondition)
{
UsesExecutableReturningAttribute = usesExecutableReturningAttribute;
}
}

18
mocha-dotnet/src/lib/Mocha.Core/Oop/Methods/ConditionalSelectFromInstanceSetMethod.cs Normal file
View File

@ -0,0 +1,18 @@
namespace Mocha.Core.Oop.Methods;
public class ConditionalSelectFromInstanceSetMethod : MethodReturningInstanceSet
{
public override Guid ClassId => KnownInstanceGuids.MethodClasses.ConditionalSelectFromInstanceSetMethod;
internal ConditionalSelectFromInstanceSetMethod(InstanceHandle handle) : base(handle) { }
}
public class ConditionalSelectFromInstanceSetCase : ConditionGroup
{
public IExecutableReturningInstanceSet UsesExecutableReturningInstanceSet { get; }
public ConditionalSelectFromInstanceSetCase(IExecutableReturningAttribute[] trueConditions, IExecutableReturningAttribute[] falseConditions, bool useAnyCondition, IExecutableReturningInstanceSet usesExecutableReturningInstanceSet)
: base(trueConditions, falseConditions, useAnyCondition)
{
UsesExecutableReturningInstanceSet = usesExecutableReturningInstanceSet;
}
}

7
mocha-dotnet/src/lib/Mocha.Core/Oop/Methods/EvaluateBooleanExpressionMethod.cs Normal file
View File

@ -0,0 +1,7 @@
namespace Mocha.Core.Oop.Methods;
public class EvaluateBooleanExpressionMethod : MethodReturningAttribute
{
public override Guid ClassId => KnownInstanceGuids.MethodClasses.EvaluateBooleanExpressionMethod;
internal EvaluateBooleanExpressionMethod(InstanceHandle handle) : base(handle) { }
}

2
mocha-dotnet/src/lib/Mocha.Core/Oop/Methods/GetAttributeBySystemRoutineMethod.cs
View File

@ -3,6 +3,6 @@ namespace Mocha.Core.Oop.Methods;
public class GetAttributeBySystemRoutineMethod : Method
{
public override Guid MethodClassGuid => KnownInstanceGuids.MethodClasses.GetAttributeBySystemRoutineMethod;
public override Guid ClassId => KnownInstanceGuids.MethodClasses.GetAttributeBySystemRoutineMethod;
internal GetAttributeBySystemRoutineMethod(InstanceHandle handle) : base(handle) { }
}

4
mocha-dotnet/src/lib/Mocha.Core/Oop/Methods/GetAttributeMethod.cs
View File

@ -1,8 +1,8 @@
namespace Mocha.Core.Oop.Methods;
public class GetAttributeMethod : Method
public class GetAttributeMethod : MethodReturningAttribute
{
public override Guid MethodClassGuid => KnownInstanceGuids.MethodClasses.GetAttributeMethod;
public override Guid ClassId => KnownInstanceGuids.MethodClasses.GetAttributeMethod;
internal GetAttributeMethod(InstanceHandle handle) : base(handle) { }
}

8
mocha-dotnet/src/lib/Mocha.Core/Oop/Methods/GetReferencedAttributeMethod.cs Normal file
View File

@ -0,0 +1,8 @@
namespace Mocha.Core.Oop.Methods;
public class GetReferencedAttributeMethod : MethodReturningAttribute
{
public override Guid ClassId => KnownInstanceGuids.MethodClasses.GetReferencedAttributeMethod;
public GetReferencedAttributeMethod(InstanceHandle handle) : base(handle) { }
}

8
mocha-dotnet/src/lib/Mocha.Core/Oop/Methods/GetRelationshipMethod.cs Normal file
View File

@ -0,0 +1,8 @@
namespace Mocha.Core.Oop.Methods;
public class GetRelationshipMethod : MethodReturningInstanceSet
{
public override Guid ClassId => KnownInstanceGuids.MethodClasses.GetRelationshipMethod;
public GetRelationshipMethod(InstanceHandle handle) : base(handle) { }
}

4
mocha-dotnet/src/lib/Mocha.Core/Oop/Methods/GetSpecifiedInstancesMethod.cs
View File

@ -1,8 +1,8 @@
namespace Mocha.Core.Oop.Methods;
public class GetSpecifiedInstancesMethod : Method
public class GetSpecifiedInstancesMethod : MethodReturningInstanceSet
{
public override Guid MethodClassGuid => KnownInstanceGuids.MethodClasses.GetSpecifiedInstancesMethod;
public override Guid ClassId => KnownInstanceGuids.MethodClasses.GetSpecifiedInstancesMethod;
internal GetSpecifiedInstancesMethod(InstanceHandle handle) : base(handle) { }
}

8
mocha-dotnet/src/lib/Mocha.Core/Oop/Methods/SelectFromInstanceSetMethod.cs Normal file
View File

@ -0,0 +1,8 @@
namespace Mocha.Core.Oop.Methods;
public class SelectFromInstanceSetMethod : MethodReturningInstanceSet
{
public override Guid ClassId => KnownInstanceGuids.MethodClasses.SelectFromInstanceSetMethod;
internal SelectFromInstanceSetMethod(InstanceHandle handle) : base(handle) { }
}

24
mocha-dotnet/src/lib/Mocha.Core/Oop/RelationalOperator.cs Normal file
View File

@ -0,0 +1,24 @@
namespace Mocha.Core.Oop;
public class RelationalOperator : BooleanOperator
{
public override Guid ClassId => KnownInstanceGuids.Classes.RelationalOperator;
internal RelationalOperator(InstanceHandle handle) : base(handle) { }
public static RelationalOperator SubsetOfSelectionList { get; internal set; } = null;
public static RelationalOperator IsEmpty { get; internal set; } = null;
public static RelationalOperator CountGreaterThan { get; internal set; } = null;
public static RelationalOperator CountLessThan { get; internal set; } = null;
public static RelationalOperator CountEqualTo { get; internal set; } = null;
public static RelationalOperator CountGreaterThanOrEqualTo { get; internal set; } = null;
public static RelationalOperator CountLessThanOrEqualTo { get; internal set; } = null;
public static RelationalOperator SupersetOfSelectionList { get; internal set; } = null;
public static RelationalOperator CountNotEqualTo { get; internal set; } = null;
public static RelationalOperator IsNotEmpty { get; internal set; } = null;
public static RelationalOperator NotInSelectionList { get; internal set; } = null;
public static RelationalOperator InSelectionList { get; internal set; } = null;
public static RelationalOperator NotSupersetOfSelectionList { get; internal set; } = null;
public static RelationalOperator NotSubsetOfSelectionList { get; internal set; } = null;
public static RelationalOperator NotExactMatchWithSelectionList { get; internal set; } = null;
public static RelationalOperator ExactMatchWithSelectionList { get; internal set; } = null;
}

1
mocha-dotnet/src/lib/Mocha.Core/Oop/SystemRoutines/SystemAttributeRoutine.cs
View File

@ -2,6 +2,7 @@ namespace Mocha.Core.Oop;
public class SystemAttributeRoutine : SystemRoutine
{
public override Guid ClassId => KnownInstanceGuids.Classes.SystemAttributeRoutine;
private Func<object?> Func { get; }
internal SystemAttributeRoutine(InstanceHandle handle, Func<object?> func) : base(handle)
{

1
mocha-dotnet/src/lib/Mocha.Core/Oop/SystemRoutines/SystemInstanceSetRoutine.cs
View File

@ -2,6 +2,7 @@ namespace Mocha.Core.Oop;
public class SystemInstanceSetRoutine : SystemRoutine
{
public override Guid ClassId => KnownInstanceGuids.Classes.SystemInstanceSetRoutine;
private Func<InstanceHandle> Func { get; }
internal SystemInstanceSetRoutine(InstanceHandle handle, Func<InstanceHandle> func) : base(handle)
{

1
mocha-dotnet/src/lib/Mocha.Core/Oop/WorkSet.cs
View File

@ -2,5 +2,6 @@ namespace Mocha.Core.Oop;
public class WorkSet : ConcreteInstanceWrapper
{
public override Guid ClassId => KnownInstanceGuids.Classes.WorkSet;
internal WorkSet(InstanceHandle handle) : base(handle) { }
}

182
mocha-dotnet/tests/Mocha.Core.Tests/MethodTests.cs
View File

@ -1,182 +0,0 @@
using System.ComponentModel.DataAnnotations;
using Mocha.Core.OmsImplementations.Mini;
using Mocha.Core.Oop;
using Mocha.Core.Oop.Methods;
namespace Mocha.Core.Tests;
public class MethodTests : OmsTestsBase
{
protected override Oms CreateOms()
{
return new MiniOms(new MiniOmsModule[] { new MethodsModule() });
}
[Test]
public void BuildAttributeMethodTest()
{
InstanceHandle irTestClass = Oms.GetInstance(TEST_CLASS_GUID);
InstanceHandle irTestClassInstance = Oms.CreateInstanceOf(irTestClass);
string test_value = "Jackdaws love my big sphinx of quartz.";
OmsMethodBuilder builder = new OmsMethodBuilder(Oms);
BuildAttributeMethod ih_BA = builder.CreateBuildAttributeMethod(irTestClass, "build", "Test Attribute", AccessModifier.Public, true, Oms.GetInstance(KnownAttributeGuids.Text.Name), test_value);
OmsContext context = Oms.CreateContext();
InstanceHandle ih_test = Oms.Execute(context, ih_BA);
object value = context.GetWorkData(ih_test);
Assert.That(value, Is.EqualTo(test_value));
}
[Test]
public void GetAttributeMethodTest()
{
InstanceHandle irTestClass = Oms.GetInstance(TEST_CLASS_GUID);
InstanceHandle irTestClassInstance = Oms.CreateInstanceOf(irTestClass);
InstanceHandle irTestAttribute = Oms.CreateInstanceOf(Oms.GetInstance(KnownInstanceGuids.Classes.TextAttribute), TEST_ATTR_GUID);
Assert.That(irTestAttribute, Is.Not.EqualTo(InstanceHandle.Empty));
Oms.AddAttribute(irTestClass, irTestAttribute);
Oms.SetAttributeValue(irTestClassInstance, irTestAttribute, TEST_ATTR_VALUE);
string testAttributeValue = Oms.GetAttributeValue<string>(irTestClassInstance, irTestAttribute);
Assert.That(testAttributeValue, Is.EqualTo(TEST_ATTR_VALUE));
// here, the test attribute has a particular value.
// let's make sure that calling a GA- Get Attribute method on TestClass returns the same
OmsMethodBuilder methodBuilder = new OmsMethodBuilder(Oms);
GetAttributeMethod gaMethod = methodBuilder.CreateGetAttributeMethod(irTestClass, "get", "Test Attribute", irTestAttribute);
// Method is: `Test Class@get Test Attribute(GA)`
ReturnAttributeMethodBinding gaMethodRamb = methodBuilder.CreateReturnAttributeMethodBinding(gaMethod);
OmsContext context = Oms.CreateContext();
object? testAttributeValue2 = Oms.ExecuteInstanceMethodReturningAttribute(context, irTestClassInstance, gaMethodRamb);
Assert.That(testAttributeValue2, Is.TypeOf<String>());
Assert.That(testAttributeValue2, Is.EqualTo(testAttributeValue));
}
[Test]
public void NonStaticMethodInStaticContext()
{
InstanceHandle irTestClass = Oms.GetInstance(TEST_CLASS_GUID);
Assert.That(irTestClass, Is.Not.EqualTo(InstanceHandle.Empty));
// create a Work Set to hold our data
WorkSet ws = Oms.CreateWorkSet("Test Work Set");
OmsMethodBuilder methodBuilder = new OmsMethodBuilder(Oms);
GetSpecifiedInstancesMethod dummyMethod = methodBuilder.CreateGetSpecifiedInstancesMethod(irTestClass, "get", "Empty Set", null, false, ws, new InstanceHandle[0]);
ReturnInstanceSetMethodBinding dummyMethodRsmb = methodBuilder.CreateReturnInstanceSetMethodBinding(dummyMethod);
OmsContext context = Oms.CreateContext();
Assert.That(delegate ()
{
IReadOnlyCollection<InstanceHandle> specifiedInstances = Oms.ExecuteStaticMethodReturningInstanceSet(context, dummyMethodRsmb);
}, Throws.InvalidOperationException);
}
[Test]
public void GetSpecifiedInstancesMethodTest()
{
InstanceHandle irTestClass = Oms.GetInstance(TEST_CLASS_GUID);
Assert.That(irTestClass, Is.Not.EqualTo(InstanceHandle.Empty));
InstanceHandle irTestClassInstance = Oms.CreateInstanceOf(irTestClass);
Assert.That(irTestClassInstance, Is.Not.EqualTo(InstanceHandle.Empty));
OmsMethodBuilder methodBuilder = new OmsMethodBuilder(Oms);
// create a Work Set to hold our data
WorkSet ws = Oms.CreateWorkSet("Test Work Set", true, new InstanceHandle[] { irTestClass });
GetSpecifiedInstancesMethod gsiMethod = methodBuilder.CreateGetSpecifiedInstancesMethod(irTestClass, "get", "Test Class Instance", null, true, ws, new InstanceHandle[] { irTestClassInstance });
string nom = Oms.GetInstanceText(gsiMethod);
// Method is: `Test Class@get Test Class Instance(GSI)*S`
ReturnInstanceSetMethodBinding gsiMethodRsmb = methodBuilder.CreateReturnInstanceSetMethodBinding(gsiMethod);
nom = Oms.GetInstanceText(gsiMethodRsmb);
OmsContext context = Oms.CreateContext();
IReadOnlyCollection<InstanceHandle> specifiedInstances = Oms.ExecuteStaticMethodReturningInstanceSet(context, gsiMethodRsmb);
Assert.That(specifiedInstances, Contains.Item(irTestClassInstance));
}
private Guid TEST_SYSTEM_ATTRIBUTE_ROUTINE_GUID = new Guid("{fd726a89-86b3-46ea-b65b-20681358ea92}");
private string TEST_SYSTEM_ATTRIBUTE_ROUTINE_VALUE = "Picadilly Circus";
[Test]
public void GetAttributeBySystemRoutineTest()
{
InstanceHandle irTestClass = Oms.GetInstance(TEST_CLASS_GUID);
OmsMethodBuilder methodBuilder = new OmsMethodBuilder(Oms);
OmsSystemRoutineBuilder systemRoutineBuilder = new OmsSystemRoutineBuilder(Oms);
SystemAttributeRoutine<string> testSystemAttributeRoutine = systemRoutineBuilder.CreateSystemAttributeRoutine(TEST_SYSTEM_ATTRIBUTE_ROUTINE_GUID, delegate()
{
return TEST_SYSTEM_ATTRIBUTE_ROUTINE_VALUE;
});
GetAttributeBySystemRoutineMethod gasMethod = methodBuilder.CreateGetAttributeBySystemRoutineMethod(irTestClass, "get", "Test System Routine Text Attribute", null, true, Oms.GetInstance(KnownAttributeGuids.Text.Value), testSystemAttributeRoutine);
ReturnAttributeMethodBinding gasMethodRamb = methodBuilder.CreateReturnAttributeMethodBinding(gasMethod);
OmsContext context = Oms.CreateContext();
string value = Oms.ExecuteReturningAttributeValue<string>(context, gasMethodRamb);
Assert.That(value, Is.EqualTo(TEST_SYSTEM_ATTRIBUTE_ROUTINE_VALUE));
}
[Test]
public void RuntimeVersionMatches()
{
InstanceHandle c_OMS = Oms.GetInstance(KnownInstanceGuids.Classes.OMS);
//*** Wow, this actually works!!! ***//
// ... but I wonder how long it would actually take to sift through 1000s of methods...
Method m = Oms.GetMethod(c_OMS, "get", "Runtime Version");
OmsContext context = Oms.CreateContext();
InstanceHandle workData = Oms.Execute(context, m);
object? value = context.GetWorkData(workData);
Assert.That(value is string);
Assert.That((string)value, Is.EqualTo(Oms.RuntimeVersion.ToString()));
}
[Test]
public void AssignAttributeMethodTest()
{
InstanceHandle irTestClass = Oms.GetInstance(TEST_CLASS_GUID);
InstanceHandle irTestClassInstance = Oms.CreateInstanceOf(irTestClass);
InstanceHandle a_Name = Oms.GetInstance(KnownAttributeGuids.Text.Name);
Oms.AddAttribute(irTestClass, a_Name);
string test_value = "Jackdaws love my big sphinx of quartz.";
string value = Oms.GetAttributeValue<string>(irTestClassInstance, a_Name);
Assert.That(value, Is.Not.EqualTo(test_value));
OmsMethodBuilder builder = new OmsMethodBuilder(Oms);
BuildAttributeMethod ih_BA = builder.CreateBuildAttributeMethod(irTestClass, "build", "Test Attribute", AccessModifier.Public, true, a_Name, test_value);
ReturnAttributeMethodBinding ramb1 = builder.CreateReturnAttributeMethodBinding(ih_BA);
AssignAttributeMethod ih_AA = builder.CreateAssignAttributeMethod(irTestClass, "set", "Test Attribute Value to `Jackdaws...`", AccessModifier.Public, true, ramb1, a_Name);
OmsContext context = Oms.CreateContext();
Oms.Execute(context, ih_AA, irTestClassInstance);
value = Oms.GetAttributeValue<string>(irTestClassInstance, a_Name);
Assert.That(value, Is.EqualTo(test_value));
}
}

37
mocha-dotnet/tests/Mocha.Core.Tests/MethodTests/AssignAttributeMethodTests.cs Normal file
View File

@ -0,0 +1,37 @@
using Mocha.Core.Oop;
using Mocha.Core.Oop.Methods;
namespace Mocha.Core.Tests.MethodTests;
public class AssignAttributeMethodTests : MethodTestsBase
{
[Test]
public void AssignAttributeMethodTest()
{
InstanceHandle irTestClass = Oms.GetInstance(TEST_CLASS_GUID);
InstanceHandle irTestClassInstance = Oms.CreateInstanceOf(irTestClass);
InstanceHandle a_Name = Oms.GetInstance(KnownAttributeGuids.Text.Name);
Oms.AddAttribute(irTestClass, a_Name);
string test_value = "Jackdaws love my big sphinx of quartz.";
string value = Oms.GetAttributeValue<string>(irTestClassInstance, a_Name);
Assert.That(value, Is.Not.EqualTo(test_value));
OmsMethodBuilder builder = new OmsMethodBuilder(Oms);
BuildAttributeMethod ih_BA = builder.CreateBuildAttributeMethod(irTestClass, "build", "Test Attribute", AccessModifier.Public, true, a_Name, test_value);
ReturnAttributeMethodBinding ramb1 = builder.CreateReturnAttributeMethodBinding(ih_BA);
AssignAttributeMethod ih_AA = builder.CreateAssignAttributeMethod(irTestClass, "set", "Test Attribute Value to `Jackdaws...`", AccessModifier.Public, true, ramb1, a_Name);
OmsContext context = Oms.CreateContext();
Oms.Execute(context, ih_AA, irTestClassInstance);
value = Oms.GetAttributeValue<string>(irTestClassInstance, a_Name);
Assert.That(value, Is.EqualTo(test_value));
}
}

28
mocha-dotnet/tests/Mocha.Core.Tests/MethodTests/BuildAttributeMethodTests.cs Normal file
View File

@ -0,0 +1,28 @@
using Mocha.Core.Oop;
using Mocha.Core.Oop.Methods;
namespace Mocha.Core.Tests.MethodTests
{
public class BuildAttributeMethodTests : MethodTestsBase
{
[Test]
public void BuildAttributeMethodTest()
{
InstanceHandle irTestClass = Oms.GetInstance(TEST_CLASS_GUID);
InstanceHandle irTestClassInstance = Oms.CreateInstanceOf(irTestClass);
string test_value = "Jackdaws love my big sphinx of quartz.";
OmsMethodBuilder builder = new OmsMethodBuilder(Oms);
BuildAttributeMethod ih_BA = builder.CreateBuildAttributeMethod(irTestClass, "build", "Test Attribute", AccessModifier.Public, true, Oms.GetInstance(KnownAttributeGuids.Text.Name), test_value);
OmsContext context = Oms.CreateContext();
InstanceHandle ih_test = Oms.Execute(context, ih_BA);
object value = context.GetWorkData(ih_test);
Assert.That(value, Is.EqualTo(test_value));
}
}
}

47
mocha-dotnet/tests/Mocha.Core.Tests/MethodTests/CommonTests.cs Normal file
View File

@ -0,0 +1,47 @@
using Mocha.Core.Oop;
using Mocha.Core.Oop.Methods;
namespace Mocha.Core.Tests.MethodTests;
public class CommonTests : MethodTestsBase
{
[Test]
public void NonStaticMethodInStaticContext()
{
InstanceHandle irTestClass = Oms.GetInstance(TEST_CLASS_GUID);
Assert.That(irTestClass, Is.Not.EqualTo(InstanceHandle.Empty));
// create a Work Set to hold our data
WorkSet ws = Oms.CreateWorkSet("Test Work Set");
OmsMethodBuilder methodBuilder = new OmsMethodBuilder(Oms);
GetSpecifiedInstancesMethod dummyMethod = methodBuilder.CreateGetSpecifiedInstancesMethod(irTestClass, "get", "Empty Set", null, false, ws, new InstanceHandle[0]);
ReturnInstanceSetMethodBinding dummyMethodRsmb = methodBuilder.CreateReturnInstanceSetMethodBinding(dummyMethod);
OmsContext context = Oms.CreateContext();
Assert.That(delegate ()
{
IReadOnlyCollection<InstanceHandle> specifiedInstances = Oms.ExecuteStaticMethodReturningInstanceSet(context, dummyMethodRsmb);
}, Throws.InvalidOperationException);
}
[Test]
public void RuntimeVersionMatches()
{
InstanceHandle c_OMS = Oms.GetInstance(KnownInstanceGuids.Classes.OMS);
//*** Wow, this actually works!!! ***//
// ... but I wonder how long it would actually take to sift through 1000s of methods...
Method m = Oms.GetMethod(c_OMS, "get", "Runtime Version");
OmsContext context = Oms.CreateContext();
InstanceHandle workData = Oms.Execute(context, m);
object? value = context.GetWorkData(workData);
Assert.That(value is string);
Assert.That((string?)value, Is.EqualTo(Oms.RuntimeVersion.ToString()));
}
}

85
mocha-dotnet/tests/Mocha.Core.Tests/MethodTests/ConditionalSelectAttributeMethodTests.cs Normal file
View File

@ -0,0 +1,85 @@
using Mocha.Core.Oop;
using Mocha.Core.Oop.Methods;
namespace Mocha.Core.Tests.MethodTests;
public class ConditionalSelectAttributeMethodTests : MethodTestsBase
{
[Test]
public void Test__Get_Method_Abbreviation__SAC()
{
InstanceHandle c_Method = Oms.GetInstance(KnownInstanceGuids.Classes.Method);
ConditionalSelectAttributeMethod sac = Oms.GetInstance<ConditionalSelectAttributeMethod>(KnownInstanceGuids.Methods.ConditionalSelectAttribute.Method__get__Method_Abbreviation);
ReturnAttributeMethodBinding ramb = sac.CreateMethodBinding(Oms);
OmsContext context = Oms.CreateContext();
context.SetWorkData(c_Method, sac);
InstanceHandle wd = Oms.Execute(context, ramb);
object? value = context.GetWorkData(wd);
Assert.That(value, Is.EqualTo("SAC"));
Assert.That(value, Is.Not.EqualTo("GR"));
}
[Test]
public void Test__Get_Method_Abbreviation__GR()
{
InstanceHandle c_Method = Oms.GetInstance(KnownInstanceGuids.Classes.Method);
ConditionalSelectAttributeMethod sac = Oms.GetInstance<ConditionalSelectAttributeMethod>(KnownInstanceGuids.Methods.ConditionalSelectAttribute.Method__get__Method_Abbreviation);
ReturnAttributeMethodBinding ramb = sac.CreateMethodBinding(Oms);
GetRelationshipMethod Instance__get__Class = Oms.GetInstance<GetRelationshipMethod>(KnownInstanceGuids.Methods.GetRelationship.Instance__get__Parent_Class);
OmsContext context = Oms.CreateContext();
context.SetWorkData(c_Method, Instance__get__Class);
InstanceHandle wd = Oms.Execute(context, ramb);
object? value = context.GetWorkData(wd);
Assert.That(value, Is.EqualTo("GR"));
Assert.That(value, Is.Not.EqualTo("SAC"));
}
[Test]
public void Test__Get_Method_Binding_Abbreviation__RAMB()
{
InstanceHandle c_MethodBinding = Oms.GetInstance(KnownInstanceGuids.Classes.MethodBinding);
ConditionalSelectAttributeMethod sac = Oms.GetInstance<ConditionalSelectAttributeMethod>(KnownInstanceGuids.Methods.ConditionalSelectAttribute.Method_Binding__get__Method_Binding_Abbreviation);
ReturnAttributeMethodBinding ramb = sac.CreateMethodBinding(Oms);
OmsContext context = Oms.CreateContext();
context.SetWorkData(c_MethodBinding, ramb);
InstanceHandle wd = Oms.Execute(context, ramb);
object? value = context.GetWorkData(wd);
Assert.That(value, Is.EqualTo("ramb"));
Assert.That(value, Is.Not.EqualTo("rsmb"));
}
[Test]
public void Test__Get_Method_Binding_Abbreviation__RSMB()
{
InstanceHandle c_MethodBinding = Oms.GetInstance(KnownInstanceGuids.Classes.MethodBinding);
ConditionalSelectAttributeMethod sac = Oms.GetInstance<ConditionalSelectAttributeMethod>(KnownInstanceGuids.Methods.ConditionalSelectAttribute.Method_Binding__get__Method_Binding_Abbreviation);
ReturnAttributeMethodBinding ramb = sac.CreateMethodBinding(Oms);
GetRelationshipMethod Instance__get__Class = Oms.GetInstance<GetRelationshipMethod>(KnownInstanceGuids.Methods.GetRelationship.Instance__get__Parent_Class);
ReturnInstanceSetMethodBinding rsmb = Instance__get__Class.CreateMethodBinding(Oms);
OmsContext context = Oms.CreateContext();
context.SetWorkData(c_MethodBinding, rsmb);
InstanceHandle wd = Oms.Execute(context, ramb);
object? value = context.GetWorkData(wd);
Assert.That(value, Is.EqualTo("rsmb"));
Assert.That(value, Is.Not.EqualTo("ramb"));
}
}

47
mocha-dotnet/tests/Mocha.Core.Tests/MethodTests/ConditionalSelectFromInstanceSetMethodTests.cs Normal file
View File

@ -0,0 +1,47 @@
using Mocha.Core.Oop;
using Mocha.Core.Oop.Methods;
namespace Mocha.Core.Tests.MethodTests;
public class ConditionalSelectFromInstanceSetMethodTests : MethodTestsBase
{
/*
[Test]
public void Test()
{
InstanceHandle c_AccessModifier = Oms.GetInstance(KnownInstanceGuids.Classes.AccessModifier);
// MethodReturningInstanceSet m_Access_Modifier__get__Most_Restrictive_from_Set = (MethodReturningInstanceSet) Oms.GetMethod(c_AccessModifier, "get", "Most Restrictive from Set");
InstanceHandle a_Order = Oms.GetInstance(KnownAttributeGuids.Text.Order);
WorkSet ws_Access_Modifier__Nonsingular = Oms.CreateWorkSet("Access Modifier [Nonsingular]", false);
WorkSet ws_Access_Modifier__Singular = Oms.CreateWorkSet("Access Modifier [Singular]", true);
OmsMethodBuilder methodBuilder = new OmsMethodBuilder(Oms);
GetAttributeMethod get_Order = methodBuilder.CreateGetAttributeMethod(c_AccessModifier, "get", "Order", a_Order);
SelectFromInstanceSetMethod m_Access_Modifier__get__Most_Restrictive_from_Set = methodBuilder.CreateSelectFromInstanceSetMethod(c_AccessModifier, "get", "Most Restrictive from Set", AccessModifier.Public, true, ws_Access_Modifier__Singular, ws_Access_Modifier__Nonsingular, null, Oms.GetInstance(KnownInstanceGuids.SelectionFunctions.Minimum), get_Order.Handle);
if (m_Access_Modifier__get__Most_Restrictive_from_Set != null)
{
ReturnInstanceSetMethodBinding rsmb = m_Access_Modifier__get__Most_Restrictive_from_Set.CreateMethodBinding(Oms);
OmsContext context = Oms.CreateContext();
context.SetWorkData(ws_Access_Modifier__Nonsingular, new InstanceWrapper[]
{
AccessModifier.Private,
AccessModifier.Protected,
AccessModifier.Public,
AccessModifier.RootA2
});
InstanceHandle workData = Oms.Execute(context, rsmb, null);
object? value = context.GetWorkData(workData);
Assert.That(value is InstanceHandle);
Assert.That((InstanceHandle?)value, Is.EqualTo(AccessModifier.Private.Handle));
}
}
*/
}

78
mocha-dotnet/tests/Mocha.Core.Tests/MethodTests/EvaluateBooleanExpressionMethodTests.cs Normal file
View File

@ -0,0 +1,78 @@
using Mocha.Core.Oop;
using Mocha.Core.Oop.Methods;
namespace Mocha.Core.Tests.MethodTests;
public class EvaluateBooleanExpressionMethodTests : MethodTestsBase
{
[Test]
public void Test_EBE_Returns_False_if_Method_is_NOT_Get_Attribute_Method()
{
InstanceHandle c_Instance = Oms.GetInstance(KnownInstanceGuids.Classes.Instance);
InstanceHandle c_Method = Oms.GetInstance(KnownInstanceGuids.Classes.Method);
OmsMethodBuilder methodBuilder = new OmsMethodBuilder(Oms);
GetRelationshipMethod Instance__get__Parent_Class = new GetRelationshipMethod(Oms.GetInstance(KnownInstanceGuids.Methods.GetRelationship.Instance__get__Parent_Class));
ReturnInstanceSetMethodBinding Instance__get__Parent_Class_rsmb = Instance__get__Parent_Class.CreateMethodBinding(Oms);
OmsContext context = Oms.CreateContext();
context.SetWorkData(c_Instance, Instance__get__Parent_Class);
InstanceHandle wsRet = Oms.Execute(context, Instance__get__Parent_Class);
// FIXME: this should be singular
InstanceHandle[] pclass = (InstanceHandle[])context.GetWorkData(wsRet);
Assert.That(pclass[0], Is.EqualTo(Oms.GetInstance(KnownInstanceGuids.MethodClasses.GetRelationshipMethod)));
EvaluateBooleanExpressionMethod Method__is__Conditional_Select_Attribute_Method = methodBuilder.CreateEvaluateBooleanExpressionMethod(c_Method, "is", "SAC", AccessModifier.Public, false, Oms.GetInstance(KnownAttributeGuids.Boolean.MethodIsOfTypeSpecified), Instance__get__Parent_Class_rsmb.Handle, RelationalOperator.InSelectionList, Oms.GetInstance(KnownInstanceGuids.MethodClasses.ConditionalSelectAttributeMethod));
ReturnAttributeMethodBinding Method__is__Conditional_Select_Attribute_Method_ramb = Method__is__Conditional_Select_Attribute_Method.CreateMethodBinding(Oms);
EvaluateBooleanExpressionMethod Method__is__Get_Relationship_Method = methodBuilder.CreateEvaluateBooleanExpressionMethod(c_Method, "is", "GR", AccessModifier.Public, false, Oms.GetInstance(KnownAttributeGuids.Boolean.MethodIsOfTypeSpecified), Instance__get__Parent_Class_rsmb.Handle, RelationalOperator.InSelectionList, Oms.GetInstance(KnownInstanceGuids.MethodClasses.GetRelationshipMethod));
ReturnAttributeMethodBinding Method__is__Get_Relationship_Method_ramb = Method__is__Get_Relationship_Method.CreateMethodBinding(Oms);
context.SetWorkData(Oms.GetInstance(KnownInstanceGuids.Classes.Method), Instance__get__Parent_Class.Handle);
InstanceHandle workData = Oms.Execute(context, Method__is__Conditional_Select_Attribute_Method_ramb);
object? value = context.GetWorkData(workData);
Assert.That(value, Is.EqualTo(false));
}
[Test]
public void Test_EBE_Returns_True_if_Method_is_Get_Attribute_Method()
{
InstanceHandle c_Instance = Oms.GetInstance(KnownInstanceGuids.Classes.Instance);
InstanceHandle c_Method = Oms.GetInstance(KnownInstanceGuids.Classes.Method);
OmsMethodBuilder methodBuilder = new OmsMethodBuilder(Oms);
GetRelationshipMethod Instance__get__Parent_Class = new GetRelationshipMethod(Oms.GetInstance(KnownInstanceGuids.Methods.GetRelationship.Instance__get__Parent_Class));
ReturnInstanceSetMethodBinding Instance__get__Parent_Class_rsmb = Instance__get__Parent_Class.CreateMethodBinding(Oms);
OmsContext context = Oms.CreateContext();
context.SetWorkData(c_Instance, Instance__get__Parent_Class);
InstanceHandle wsRet = Oms.Execute(context, Instance__get__Parent_Class);
// FIXME: this should be singular
InstanceHandle[] pclass = (InstanceHandle[]) context.GetWorkData(wsRet);
Assert.That(pclass[0], Is.EqualTo(Oms.GetInstance(KnownInstanceGuids.MethodClasses.GetRelationshipMethod)));
EvaluateBooleanExpressionMethod Method__is__Conditional_Select_Attribute_Method = methodBuilder.CreateEvaluateBooleanExpressionMethod(c_Method, "is", "SAC", AccessModifier.Public, false, Oms.GetInstance(KnownAttributeGuids.Boolean.MethodIsOfTypeSpecified), Instance__get__Parent_Class_rsmb.Handle, RelationalOperator.InSelectionList, Oms.GetInstance(KnownInstanceGuids.MethodClasses.ConditionalSelectAttributeMethod));
ReturnAttributeMethodBinding Method__is__Conditional_Select_Attribute_Method_ramb = Method__is__Conditional_Select_Attribute_Method.CreateMethodBinding(Oms);
EvaluateBooleanExpressionMethod Method__is__Get_Relationship_Method = methodBuilder.CreateEvaluateBooleanExpressionMethod(c_Method, "is", "GR", AccessModifier.Public, false, Oms.GetInstance(KnownAttributeGuids.Boolean.MethodIsOfTypeSpecified), Instance__get__Parent_Class_rsmb.Handle, RelationalOperator.InSelectionList, Oms.GetInstance(KnownInstanceGuids.MethodClasses.GetRelationshipMethod));
ReturnAttributeMethodBinding Method__is__Get_Relationship_Method_ramb = Method__is__Get_Relationship_Method.CreateMethodBinding(Oms);
context.SetWorkData(Oms.GetInstance(KnownInstanceGuids.Classes.Method), Instance__get__Parent_Class.Handle);
InstanceHandle workData = Oms.Execute(context, Method__is__Get_Relationship_Method_ramb);
object? value = context.GetWorkData(workData);
Assert.That(value, Is.EqualTo(true));
}
}

41
mocha-dotnet/tests/Mocha.Core.Tests/MethodTests/GetAttributeMethodTests.cs Normal file
View File

@ -0,0 +1,41 @@
using Mocha.Core.Oop;
using Mocha.Core.Oop.Methods;
namespace Mocha.Core.Tests.MethodTests
{
public class GetAttributeMethodTests : MethodTestsBase
{
[Test]
public void GetAttributeMethodTest()
{
InstanceHandle irTestClass = Oms.GetInstance(TEST_CLASS_GUID);
InstanceHandle irTestClassInstance = Oms.CreateInstanceOf(irTestClass);
InstanceHandle irTestAttribute = Oms.CreateInstanceOf(Oms.GetInstance(KnownInstanceGuids.Classes.TextAttribute), TEST_ATTR_GUID);
Assert.That(irTestAttribute, Is.Not.EqualTo(InstanceHandle.Empty));
Oms.AddAttribute(irTestClass, irTestAttribute);
Oms.SetAttributeValue(irTestClassInstance, irTestAttribute, TEST_ATTR_VALUE);
string testAttributeValue = Oms.GetAttributeValue<string>(irTestClassInstance, irTestAttribute);
Assert.That(testAttributeValue, Is.EqualTo(TEST_ATTR_VALUE));
// here, the test attribute has a particular value.
// let's make sure that calling a GA- Get Attribute method on TestClass returns the same
OmsMethodBuilder methodBuilder = new OmsMethodBuilder(Oms);
GetAttributeMethod gaMethod = methodBuilder.CreateGetAttributeMethod(irTestClass, "get", "Test Attribute", irTestAttribute);
// Method is: `Test Class@get Test Attribute(GA)`
ReturnAttributeMethodBinding gaMethodRamb = methodBuilder.CreateReturnAttributeMethodBinding(gaMethod);
OmsContext context = Oms.CreateContext();
object? testAttributeValue2 = Oms.ExecuteInstanceMethodReturningAttribute(context, irTestClassInstance, gaMethodRamb);
Assert.That(testAttributeValue2, Is.TypeOf<String>());
Assert.That(testAttributeValue2, Is.EqualTo(testAttributeValue));
}
}
}

166
mocha-dotnet/tests/Mocha.Core.Tests/MethodTests/GetReferencedAttributeTests.cs Normal file
View File

@ -0,0 +1,166 @@
using Mocha.Core.Oop;
using Mocha.Core.Oop.Methods;
namespace Mocha.Core.Tests.MethodTests;
public class GetReferencedAttributeTests : MethodTestsBase
{
protected InstanceHandle c_Nurse, c_Patient;
protected InstanceHandle a_Name, a_Acuity;
protected InstanceHandle r_Nurse__has__Patient, r_Patient__for__Nurse;
protected override void AfterSetup()
{
base.AfterSetup();
c_Nurse = Oms.GetInstance(TEST_CLASS_GUID);
c_Patient = Oms.GetInstance(TEST_CLASS2_GUID);
a_Name = Oms.GetInstance(KnownAttributeGuids.Text.Name);
a_Acuity = Oms.CreateInstanceOf(Oms.GetInstance(KnownInstanceGuids.Classes.NumericAttribute));
Oms.SetAttributeValue(a_Acuity, a_Name, "Acuity");
Oms.AddAttribute(c_Patient, a_Acuity);
Oms.SetAttributeValue(c_Nurse, a_Name, "Nurse");
Oms.SetAttributeValue(c_Patient, a_Name, "Patient");
r_Nurse__has__Patient = Oms.CreateRelationship(c_Nurse, "has", c_Patient, new Guid("{0558fc58-7504-4f6c-a63f-4a710ec0bbb9}"), false, "for", new Guid("{4a132262-0d5c-43d5-9308-5021dad070f8}"), out r_Patient__for__Nurse);
}
[Test]
public void GetReferencedAttributeTest()
{
OmsMethodBuilder builder = new OmsMethodBuilder(Oms);
InstanceHandle c_TestClass = Oms.GetInstance(TEST_CLASS_GUID);
InstanceHandle c_TestClass2 = Oms.GetInstance(TEST_CLASS2_GUID);
Oms.AddAttribute(c_TestClass, a_Name);
Oms.AddAttribute(c_TestClass2, a_Name);
GetAttributeMethod Test_Class__get__Name = builder.CreateGetAttributeMethod(c_TestClass, "get", "Name", a_Name);
GetRelationshipMethod Test_Class_2__get__Test_Class_2__for__Test_Class = builder.CreateGetRelationshipMethod(c_TestClass2, "get", "Test Class 2.for Test Class", AccessModifier.Public, false, r_Test_Class_2__for__Test_Class);
ReturnInstanceSetMethodBinding Test_Class_2__get__parent_Test_Class__ramb = Test_Class_2__get__Test_Class_2__for__Test_Class.CreateMethodBinding(Oms);
GetReferencedAttributeMethod ih_GRA = builder.CreateGetReferencedAttributeMethod(c_TestClass2, "get", "Test Attribute from parent Test Class", AccessModifier.Public, false, a_Name, Test_Class_2__get__parent_Test_Class__ramb, Test_Class__get__Name);
ReturnAttributeMethodBinding ramb = ih_GRA.CreateMethodBinding(Oms);
InstanceHandle i_TestClass_inst1 = Oms.CreateInstanceOf(c_TestClass);
Oms.SetAttributeValue(i_TestClass_inst1, a_Name, "This is Test Name");
InstanceHandle i_TestClass2_inst1 = Oms.CreateInstanceOf(c_TestClass2);
Oms.AssignRelationship(i_TestClass_inst1, r_Test_Class__has__Test_Class_2, i_TestClass2_inst1);
OmsContext context = Oms.CreateContext();
// Get Referenced Attribute
// From a given instance (e.g. Test Class 2 Instance 1)
// Test Class 2@get Test Attribute from parent Test Class
// looks at the Test Class 2@get Test Class 2.for Test Class (loop on instance set)
// and then on THAT instance, gets teh attribute value and puts it into the returnsAttribute
InstanceHandle valueWD = Oms.Execute(context, ih_GRA, i_TestClass2_inst1);
string value = context.GetWorkData<string>(valueWD);
Assert.That(value, Is.EqualTo("This is Test Name"));
}
[Test]
public void GetReferencedAttributeAccumulationSumTest()
{
OmsMethodBuilder builder = new OmsMethodBuilder(Oms);
InstanceHandle i_Nurse1 = Oms.CreateInstanceOf(c_Nurse);
InstanceHandle i_Patient1 = Oms.CreateInstanceOf(c_Patient);
Oms.SetAttributeValue(i_Patient1, a_Acuity, (decimal)10);
InstanceHandle i_Patient2 = Oms.CreateInstanceOf(c_Patient);
Oms.SetAttributeValue(i_Patient2, a_Acuity, (decimal)20);
InstanceHandle i_Patient3 = Oms.CreateInstanceOf(c_Patient);
Oms.SetAttributeValue(i_Patient3, a_Acuity, (decimal)30);
decimal expectedValue = 60;
// Patient@get Acuity(GA)*P*S
GetAttributeMethod Patient__get__Acuity = builder.CreateGetAttributeMethod(c_Patient, "get", "Acuity", a_Acuity);
ReturnAttributeMethodBinding Patient__get__Acuity_ramb = Patient__get__Acuity.CreateMethodBinding(Oms);
Oms.AssignRelationship(i_Nurse1, r_Nurse__has__Patient, new InstanceHandle[] { i_Patient1, i_Patient2, i_Patient3 });
GetRelationshipMethod Nurse__get__Patients = builder.CreateGetRelationshipMethod(c_Nurse, "get", "Nurse.has Patient", AccessModifier.Public, false, r_Nurse__has__Patient);
ReturnInstanceSetMethodBinding Nurse__get__Patients_rsmb = Nurse__get__Patients.CreateMethodBinding(Oms);
GetReferencedAttributeMethod ih_GRA = builder.CreateGetReferencedAttributeMethod(c_Nurse, "get", "Patient Acuity Levels Sum", AccessModifier.Public, false, a_Acuity, Nurse__get__Patients_rsmb, Patient__get__Acuity_ramb, Oms.GetInstance(KnownInstanceGuids.AccumulationFunctions.Sum));
ReturnAttributeMethodBinding ramb = ih_GRA.CreateMethodBinding(Oms);
OmsContext context = Oms.CreateContext();
InstanceHandle valueWD = Oms.Execute(context, ih_GRA, i_Nurse1);
decimal value = context.GetWorkData<decimal>(valueWD);
Assert.That(value, Is.EqualTo(expectedValue));
}
[Test]
public void GetReferencedAttributeAccumulationSumTestNative()
{
decimal expectedValue = 60;
decimal[] values = new decimal[] { 10, 20, 30 };
decimal sum = values.Sum();
Assert.That(sum, Is.EqualTo(expectedValue));
}
[Test]
public void GetReferencedAttributeAccumulationAverageTestNative()
{
decimal expectedValue = 20;
decimal[] values = new decimal[] { 10, 20, 30 };
decimal sum = values.Average();
Assert.That(sum, Is.EqualTo(expectedValue));
}
[Test]
public void GetReferencedAttributeAccumulationAverageTest()
{
OmsMethodBuilder builder = new OmsMethodBuilder(Oms);
InstanceHandle i_Nurse1 = Oms.CreateInstanceOf(c_Nurse);
InstanceHandle i_Patient1 = Oms.CreateInstanceOf(c_Patient);
Oms.SetAttributeValue(i_Patient1, a_Acuity, (decimal)10);
InstanceHandle i_Patient2 = Oms.CreateInstanceOf(c_Patient);
Oms.SetAttributeValue(i_Patient2, a_Acuity, (decimal)20);
InstanceHandle i_Patient3 = Oms.CreateInstanceOf(c_Patient);
Oms.SetAttributeValue(i_Patient3, a_Acuity, (decimal)30);
decimal expectedValue = 20;
// Patient@get Acuity(GA)*P*S
GetAttributeMethod Patient__get__Acuity = builder.CreateGetAttributeMethod(c_Patient, "get", "Acuity", a_Acuity);
ReturnAttributeMethodBinding Patient__get__Acuity_ramb = Patient__get__Acuity.CreateMethodBinding(Oms);
Oms.AssignRelationship(i_Nurse1, r_Nurse__has__Patient, new InstanceHandle[] { i_Patient1, i_Patient2, i_Patient3 });
GetRelationshipMethod Nurse__get__Patients = builder.CreateGetRelationshipMethod(c_Nurse, "get", "Nurse.has Patient", AccessModifier.Public, false, r_Nurse__has__Patient);
ReturnInstanceSetMethodBinding Nurse__get__Patients_rsmb = Nurse__get__Patients.CreateMethodBinding(Oms);
GetReferencedAttributeMethod ih_GRA = builder.CreateGetReferencedAttributeMethod(c_Nurse, "get", "Patient Acuity Levels Average", AccessModifier.Public, false, a_Acuity, Nurse__get__Patients_rsmb, Patient__get__Acuity_ramb, Oms.GetInstance(KnownInstanceGuids.AccumulationFunctions.Average));
ReturnAttributeMethodBinding ramb = ih_GRA.CreateMethodBinding(Oms);
OmsContext context = Oms.CreateContext();
InstanceHandle valueWD = Oms.Execute(context, ih_GRA, i_Nurse1);
decimal value = context.GetWorkData<decimal>(valueWD);
Assert.That(value, Is.EqualTo(expectedValue));
}
}

47
mocha-dotnet/tests/Mocha.Core.Tests/MethodTests/GetRelationshipTests.cs Normal file
View File

@ -0,0 +1,47 @@
using Mocha.Core.Oop;
using Mocha.Core.Oop.Methods;
namespace Mocha.Core.Tests.MethodTests;
public class GetRelationshipTests : MethodTestsBase
{
[Test]
public void GetRelationshipTest()
{
InstanceHandle c_TestClass = Oms.GetInstance(TEST_CLASS_GUID);
InstanceHandle c_TestClass2 = Oms.GetInstance(TEST_CLASS2_GUID);
OmsMethodBuilder builder = new OmsMethodBuilder(Oms);
GetRelationshipMethod method = builder.CreateGetRelationshipMethod(c_TestClass, "get", "Test Class.has Test Class 2", AccessModifier.Public, true, r_Test_Class__has__Test_Class_2);
ReturnInstanceSetMethodBinding rsmb = builder.CreateReturnInstanceSetMethodBinding(method);
OmsContext context = Oms.CreateContext();
object? value = Oms.Execute(context, rsmb);
Assert.That(value, Is.EqualTo(r_Test_Class__has__Test_Class_2));
}
[Test]
public void GetParentClassMatchesActualParentClass()
{
InstanceHandle c_Instance = Oms.GetInstance(KnownInstanceGuids.Classes.Instance);
InstanceHandle c_TestClass = Oms.GetInstance(TEST_CLASS_GUID);
InstanceHandle c_TestClassInstance = Oms.CreateInstanceOf(c_TestClass);
OmsMethodBuilder methodBuilder = new OmsMethodBuilder(Oms);
GetRelationshipMethod Instance__get__Parent_Class = methodBuilder.CreateGetRelationshipMethod(c_Instance, "get", "Parent Class", AccessModifier.Public, false, Oms.GetInstance(KnownRelationshipGuids.Instance__for__Class));
Oms.SetAttributeValue(Instance__get__Parent_Class.Handle, Oms.GetInstance(KnownAttributeGuids.Boolean.Singular), true);
ReturnInstanceSetMethodBinding Instance__get__Parent_Class_rsmb = Instance__get__Parent_Class.CreateMethodBinding(Oms);
OmsContext context = Oms.CreateContext();
context.SetWorkData(c_Instance, c_TestClassInstance);
InstanceHandle workSet = Oms.Execute(context, Instance__get__Parent_Class_rsmb);
object? value = context.GetWorkData(workSet);
Assert.That(value, Is.EqualTo(c_TestClass));
}
}

34
mocha-dotnet/tests/Mocha.Core.Tests/MethodTests/GetSpecifiedInstancesMethodTests.cs Normal file
View File

@ -0,0 +1,34 @@
using Mocha.Core.Oop;
using Mocha.Core.Oop.Methods;
namespace Mocha.Core.Tests.MethodTests;
public class GetSpecifiedInstancesMethodTests : MethodTestsBase
{
[Test]
public void GetSpecifiedInstancesMethodTest()
{
InstanceHandle irTestClass = Oms.GetInstance(TEST_CLASS_GUID);
Assert.That(irTestClass, Is.Not.EqualTo(InstanceHandle.Empty));
InstanceHandle irTestClassInstance = Oms.CreateInstanceOf(irTestClass);
Assert.That(irTestClassInstance, Is.Not.EqualTo(InstanceHandle.Empty));
OmsMethodBuilder methodBuilder = new OmsMethodBuilder(Oms);
// create a Work Set to hold our data
WorkSet ws = Oms.CreateWorkSet("Test Work Set", true, new InstanceHandle[] { irTestClass });
GetSpecifiedInstancesMethod gsiMethod = methodBuilder.CreateGetSpecifiedInstancesMethod(irTestClass, "get", "Test Class Instance", AccessModifier.Public, true, ws, new InstanceHandle[] { irTestClassInstance });
string nom = Oms.GetInstanceText(gsiMethod);
// Method is: `Test Class@get Test Class Instance(GSI)*S`
ReturnInstanceSetMethodBinding gsiMethodRsmb = methodBuilder.CreateReturnInstanceSetMethodBinding(gsiMethod);
nom = Oms.GetInstanceText(gsiMethodRsmb);
OmsContext context = Oms.CreateContext();
IReadOnlyCollection<InstanceHandle> specifiedInstances = Oms.ExecuteStaticMethodReturningInstanceSet(context, gsiMethodRsmb);
Assert.That(specifiedInstances, Contains.Item(irTestClassInstance));
}
}

45
mocha-dotnet/tests/Mocha.Core.Tests/MethodTests/SelectFromInstanceSetMethodTests.cs Normal file
View File

@ -0,0 +1,45 @@
using Mocha.Core.Oop;
using Mocha.Core.Oop.Methods;
namespace Mocha.Core.Tests.MethodTests;
public class SelectFromInstanceSetMethodTests : MethodTestsBase
{
[Test]
public void Access_Modifier__get__Most_Restrictive_from_Set()
{
InstanceHandle c_AccessModifier = Oms.GetInstance(KnownInstanceGuids.Classes.AccessModifier);
// MethodReturningInstanceSet m_Access_Modifier__get__Most_Restrictive_from_Set = (MethodReturningInstanceSet) Oms.GetMethod(c_AccessModifier, "get", "Most Restrictive from Set");
InstanceHandle a_Order = Oms.GetInstance(KnownAttributeGuids.Text.Order);
WorkSet ws_Access_Modifier__Nonsingular = Oms.CreateWorkSet("Access Modifier [Nonsingular]", false);
WorkSet ws_Access_Modifier__Singular = Oms.CreateWorkSet("Access Modifier [Singular]", true);
OmsMethodBuilder methodBuilder = new OmsMethodBuilder(Oms);
GetAttributeMethod get_Order = methodBuilder.CreateGetAttributeMethod(c_AccessModifier, "get", "Order", a_Order);
SelectFromInstanceSetMethod m_Access_Modifier__get__Most_Restrictive_from_Set = methodBuilder.CreateSelectFromInstanceSetMethod(c_AccessModifier, "get", "Most Restrictive from Set", AccessModifier.Public, true, ws_Access_Modifier__Singular, ws_Access_Modifier__Nonsingular, null, Oms.GetInstance(KnownInstanceGuids.SelectionFunctions.Minimum), get_Order.Handle);
if (m_Access_Modifier__get__Most_Restrictive_from_Set != null)
{
ReturnInstanceSetMethodBinding rsmb = m_Access_Modifier__get__Most_Restrictive_from_Set.CreateMethodBinding(Oms);
OmsContext context = Oms.CreateContext();
context.SetWorkData(ws_Access_Modifier__Nonsingular, new InstanceWrapper[]
{
AccessModifier.Private,
AccessModifier.Protected,
AccessModifier.Public,
AccessModifier.RootA2
});
InstanceHandle workData = Oms.Execute(context, rsmb, null);
object? value = context.GetWorkData(workData);
Assert.That(value is InstanceHandle);
Assert.That((InstanceHandle?)value, Is.EqualTo(AccessModifier.Private.Handle));
}
}
}

31
mocha-dotnet/tests/Mocha.Core.Tests/MethodTests/SystemRoutineTests.cs Normal file
View File

@ -0,0 +1,31 @@
using Mocha.Core.Oop;
using Mocha.Core.Oop.Methods;
namespace Mocha.Core.Tests.MethodTests;
public class SystemRoutineTests : MethodTestsBase
{
private Guid TEST_SYSTEM_ATTRIBUTE_ROUTINE_GUID = new Guid("{fd726a89-86b3-46ea-b65b-20681358ea92}");
private string TEST_SYSTEM_ATTRIBUTE_ROUTINE_VALUE = "Picadilly Circus";
[Test]
public void GetAttributeBySystemRoutineTest()
{
InstanceHandle irTestClass = Oms.GetInstance(TEST_CLASS_GUID);
OmsMethodBuilder methodBuilder = new OmsMethodBuilder(Oms);
OmsSystemRoutineBuilder systemRoutineBuilder = new OmsSystemRoutineBuilder(Oms);
SystemAttributeRoutine<string> testSystemAttributeRoutine = systemRoutineBuilder.CreateSystemAttributeRoutine(TEST_SYSTEM_ATTRIBUTE_ROUTINE_GUID, delegate ()
{
return TEST_SYSTEM_ATTRIBUTE_ROUTINE_VALUE;
});
GetAttributeBySystemRoutineMethod gasMethod = methodBuilder.CreateGetAttributeBySystemRoutineMethod(irTestClass, "get", "Test System Routine Text Attribute", AccessModifier.Public, true, Oms.GetInstance(KnownAttributeGuids.Text.Value), testSystemAttributeRoutine);
ReturnAttributeMethodBinding gasMethodRamb = methodBuilder.CreateReturnAttributeMethodBinding(gasMethod);
OmsContext context = Oms.CreateContext();
string value = Oms.ExecuteReturningAttributeValue<string>(context, gasMethodRamb);
Assert.That(value, Is.EqualTo(TEST_SYSTEM_ATTRIBUTE_ROUTINE_VALUE));
}
}

26
mocha-dotnet/tests/Mocha.Core.Tests/MethodTestsBase.cs Normal file
View File

@ -0,0 +1,26 @@
using System.ComponentModel.DataAnnotations;
using System.Security.Principal;
using Mocha.Core.OmsImplementations.Mini;
using Mocha.Core.Oop;
using Mocha.Core.Oop.Methods;
namespace Mocha.Core.Tests;
public abstract class MethodTestsBase : OmsTestsBase
{
Guid gid_r_Test_Class__has__Test_Class_2 = new Guid("{a5b67aad-e46f-4673-b339-77417396b2fe}");
Guid gid_r_Test_Class_2__for__Test_Class = new Guid("{2864dfd9-0313-4801-96bf-b9be99ea172d}");
protected InstanceHandle c_TestClass, c_TestClass2;
protected InstanceHandle r_Test_Class__has__Test_Class_2, r_Test_Class_2__for__Test_Class;
protected override void AfterSetup()
{
base.AfterSetup();
c_TestClass = Oms.GetInstance(TEST_CLASS_GUID);
c_TestClass2 = Oms.GetInstance(TEST_CLASS2_GUID);
r_Test_Class__has__Test_Class_2 = Oms.CreateRelationship(c_TestClass, "has", c_TestClass2, gid_r_Test_Class__has__Test_Class_2, true, "for", gid_r_Test_Class_2__for__Test_Class, out r_Test_Class_2__for__Test_Class);
}
}