add dictionaries

Author: Elektryk-Andrzej

Code/MethodSystem/Methods/DictionaryMethods/Dict_AddMethod.cs

@@ -0,0 +1,25 @@
+using SER.Code.ArgumentSystem.Arguments;
+using SER.Code.ArgumentSystem.BaseArguments;
+using SER.Code.MethodSystem.BaseMethods.Synchronous;
+using SER.Code.MethodSystem.Methods.DictionaryMethods.Structures;
+
+namespace SER.Code.MethodSystem.Methods.DictionaryMethods;
+
+[UsedImplicitly]
+// ReSharper disable once InconsistentNaming
+public class Dict_AddMethod : SynchronousMethod
+{
+    public override string Description => "Adds a key-value pair to a dictionary.";
+
+    public override Argument[] ExpectedArguments { get; } =
+    [
+        new ReferenceArgument<Dict>("dictionary"),
+        new AnyValueArgument("key"),
+        new AnyValueArgument("value")
+    ];
+    
+    public override void Execute()
+    {
+        Args.GetReference<Dict>("dictionary").Add(Args.GetAnyValue("key"), Args.GetAnyValue("value"));
+    }
+}

Code/MethodSystem/Methods/DictionaryMethods/Dict_ContainsMethod.cs

@@ -0,0 +1,25 @@
+using SER.Code.ArgumentSystem.Arguments;
+using SER.Code.ArgumentSystem.BaseArguments;
+using SER.Code.MethodSystem.BaseMethods.Synchronous;
+using SER.Code.MethodSystem.Methods.DictionaryMethods.Structures;
+using SER.Code.ValueSystem;
+
+namespace SER.Code.MethodSystem.Methods.DictionaryMethods;
+
+[UsedImplicitly]
+// ReSharper disable once InconsistentNaming
+public class Dict_ContainsMethod : ReturningMethod<BoolValue>
+{
+    public override string Description => "Returns true if the dictionary contains the provided key";
+
+    public override Argument[] ExpectedArguments { get; } =
+    [
+        new ReferenceArgument<Dict>("dictionary"),
+        new AnyValueArgument("key")
+    ];
+    
+    public override void Execute()
+    {
+        ReturnValue = Args.GetReference<Dict>("dictionary").ContainsKey(Args.GetAnyValue("key"));
+    }
+}

Code/MethodSystem/Methods/DictionaryMethods/Dict_EmptyMethod.cs

@@ -0,0 +1,26 @@
+using SER.Code.ArgumentSystem.BaseArguments;
+using SER.Code.MethodSystem.BaseMethods.Synchronous;
+using SER.Code.MethodSystem.MethodDescriptors;
+using SER.Code.MethodSystem.Methods.DictionaryMethods.Structures;
+
+namespace SER.Code.MethodSystem.Methods.DictionaryMethods;
+
+[UsedImplicitly]
+// ReSharper disable once InconsistentNaming
+public class Dict_EmptyMethod : ReferenceReturningMethod<Dict>, IAdditionalDescription
+{
+    public override string Description => "Creates an empty dictionary.";
+
+    public string AdditionalDescription =>
+        "Dictionary is a collection of unique keys (values) mapped to specific values. " +
+        "Think of it like a real-world dictionary where the \"word\" is the key and the \"definition\" is the value. " +
+        "E.g. you can map the value \"hello\" to the \"world\" value. " +
+        "This data type is used by more experienced users, allowing for dynamic data storage.";
+
+    public override Argument[] ExpectedArguments { get; } = [];
+
+    public override void Execute()
+    {
+        ReturnValue = new Dict();
+    }
+}

Code/MethodSystem/Methods/DictionaryMethods/Dict_GetMethod.cs

@@ -0,0 +1,44 @@
+using SER.Code.ArgumentSystem.Arguments;
+using SER.Code.ArgumentSystem.BaseArguments;
+using SER.Code.Exceptions;
+using SER.Code.MethodSystem.BaseMethods.Synchronous;
+using SER.Code.MethodSystem.MethodDescriptors;
+using SER.Code.MethodSystem.Methods.DictionaryMethods.Structures;
+using SER.Code.ValueSystem.Other;
+
+namespace SER.Code.MethodSystem.Methods.DictionaryMethods;
+
+[UsedImplicitly]
+// ReSharper disable once InconsistentNaming
+public class Dict_GetMethod : ReturningMethod, ICanError
+{
+    public override string Description => "Gets a value associated with a key from a dictionary.";
+    
+    public override TypeOfValue Returns => new UnknownTypeOfValue();
+
+    public string[] ErrorReasons =>
+    [
+        "There is no key with the given name in the dictionary."
+    ];
+
+    public override Argument[] ExpectedArguments { get; } =
+    [
+        new ReferenceArgument<Dict>("dictionary"),
+        new AnyValueArgument("key")
+    ];
+    
+    public override void Execute()
+    {
+        var dictionary = Args.GetReference<Dict>("dictionary");
+        var key = Args.GetAnyValue("key");
+
+        if (dictionary.TryGetValue(key, out var value))
+        {
+            ReturnValue = value;
+        }
+        else
+        {
+            throw new ScriptRuntimeError(this, $"Provided key '{key}' is not in the dictionary.");
+        }
+    }
+}

Code/MethodSystem/Methods/DictionaryMethods/Dict_RemoveMethod.cs

@@ -0,0 +1,24 @@
+using SER.Code.ArgumentSystem.Arguments;
+using SER.Code.ArgumentSystem.BaseArguments;
+using SER.Code.MethodSystem.BaseMethods.Synchronous;
+using SER.Code.MethodSystem.Methods.DictionaryMethods.Structures;
+
+namespace SER.Code.MethodSystem.Methods.DictionaryMethods;
+
+[UsedImplicitly]
+// ReSharper disable once InconsistentNaming
+public class Dict_RemoveMethod : SynchronousMethod
+{
+    public override string Description => "Removes a key-value pair from a dictionary.";
+
+    public override Argument[] ExpectedArguments { get; } =
+    [
+        new ReferenceArgument<Dict>("dictionary"),
+        new AnyValueArgument("key to remove")
+    ];
+    
+    public override void Execute()
+    {
+        Args.GetReference<Dict>("dictionary").Remove(Args.GetAnyValue("key to remove"));
+    }
+}

Code/MethodSystem/Methods/DictionaryMethods/Structures/Dict.cs

@@ -0,0 +1,5 @@
+using SER.Code.ValueSystem;
+
+namespace SER.Code.MethodSystem.Methods.DictionaryMethods.Structures;
+
+public class Dict : Dictionary<Value, Value>;