Unregister functions & constants

Jace.Tests/ConstantRegistryTests.cs

@@ -54,5 +54,16 @@ public void TestNotOverwritable()
                     registry.RegisterConstant("test", 26.3, false);
                 });
         }
+
+        [TestMethod]
+        public void TestRemoveConstant()
+        {
+            ConstantRegistry registry = new ConstantRegistry(false);
+
+            registry.RegisterConstant("test", 42.0);
+            bool result = registry.UnregisterConstant("test");
+
+            Assert.IsTrue(result);
+        }
     }
 }

Jace.Tests/FunctionRegistryTests.cs

@@ -61,5 +61,17 @@ public void TestNotOverwritable()
                     registry.RegisterFunction("test", testFunction2, false);
                 });
         }
+
+        [TestMethod]
+        public void TestRemoveFunc()
+        {
+            FunctionRegistry registry = new FunctionRegistry(false);
+
+            Func<double, double, double> testFunction = (a, b) => a * b;
+            registry.RegisterFunction("test", testFunction);
+            bool result = registry.UnregisterFunction("test");
+
+            Assert.IsTrue(result);
+        }
     }
 }

Jace.Tests/Mocks/MockFunctionRegistry.cs

@@ -44,5 +44,10 @@ public void RegisterFunction(string functionName, int numberOfParameters)
         {
             throw new NotImplementedException();
         }
+
+        public bool UnregisterFunction(string functionName)
+        {
+            throw new NotImplementedException();
+        }
     }
 }

Jace/CalculationEngine.cs

@@ -161,6 +161,7 @@ public Func<Dictionary<string, double>, double> Build(string formulaText)
             }
         }
 
+        #region Functions & constants
         /// <summary>
         /// Add a function to the calculation engine.
         /// </summary>
@@ -211,6 +212,16 @@ public void AddFunction(string functionName, Func<double, double, double, double
             FunctionRegistry.RegisterFunction(functionName, function);
         }
 
+        /// <summary>
+        /// Remove a function from the calculation engine.
+        /// </summary>
+        /// <param name="functionName">The name of the function</param>
+        /// <returns>TRUE if the function was successfully removed.</returns>
+        public bool RemoveFunction(string functionName)
+        {
+            return FunctionRegistry.UnregisterFunction(functionName);
+        }
+
 #if !WINDOWS_PHONE_7
         /// <summary>
         /// Add a function to the calculation engine.
@@ -243,6 +254,16 @@ public void AddConstant(string constantName, double value)
             ConstantRegistry.RegisterConstant(constantName, value);
         }
 
+        /// <summary>
+        /// Remove a constant from the calculation engine.
+        /// </summary>
+        /// <param name="constantName">The name of the constant</param>
+        /// <returns>TRUE if the constant was successfully removed.</returns>
+        public bool RemoveConstant(string constantName)
+        {
+            return ConstantRegistry.UnregisterConstant(constantName);
+        }
+
         private void RegisterDefaultFunctions()
         {
             FunctionRegistry.RegisterFunction("sin", (Func<double, double>)((a) => Math.Sin(a)), false);
@@ -278,6 +299,7 @@ private void RegisterDefaultConstants()
             ConstantRegistry.RegisterConstant("e", Math.E, false);
             ConstantRegistry.RegisterConstant("pi", Math.PI, false);
         }
+        #endregion
 
         /// <summary>
         /// Build the abstract syntax tree for a given formula. The formula string will

Jace/Execution/ConstantRegistry.cs

@@ -70,6 +70,16 @@ public void RegisterConstant(string constantName, double value, bool isOverWrita
                 constants.Add(constantName, constantInfo);
         }
 
+        public bool UnregisterConstant(string constantName)
+        {
+            if (string.IsNullOrEmpty(constantName))
+                throw new ArgumentNullException("constantName");
+
+            constantName = ConvertConstantName(constantName);
+
+            return this.constants.Remove(constantName);
+        }
+
         private string ConvertConstantName(string constantName)
         {
             return caseSensitive ? constantName : constantName.ToLowerInvariant();

Jace/Execution/FunctionRegistry.cs

@@ -88,6 +88,16 @@ public bool IsFunctionName(string functionName)
             return functions.ContainsKey(ConvertFunctionName(functionName));
         }
 
+        public bool UnregisterFunction(string functionName)
+        {
+            if (string.IsNullOrEmpty(functionName))
+                throw new ArgumentNullException("functionName");
+
+            functionName = ConvertFunctionName(functionName);
+
+            return this.functions.Remove(functionName);
+        }
+
         private string ConvertFunctionName(string functionName)
         {
             return caseSensitive ? functionName : functionName.ToLowerInvariant();

Jace/Execution/IConstantRegistry.cs

@@ -11,5 +11,6 @@ public interface IConstantRegistry : IEnumerable<ConstantInfo>
         bool IsConstantName(string constantName);
         void RegisterConstant(string constantName, double value);
         void RegisterConstant(string constantName, double value, bool isOverWritable);
+        bool UnregisterConstant(string constantName);
     }
 }

Jace/Execution/IFunctionRegistry.cs

@@ -8,5 +8,6 @@ public interface IFunctionRegistry
         bool IsFunctionName(string functionName);
         void RegisterFunction(string functionName, Delegate function);
         void RegisterFunction(string functionName, Delegate function, bool isOverWritable);
+        bool UnregisterFunction(string functionName);
     }
 }