Adds support for size function in domain expressions.

installer/Workbench.UI.Wix/Product.wxs

@@ -50,7 +50,6 @@
             <Component Id="DynaAppDependencies" Guid="EBB0BEDC-99EF-4F4F-9979-50383A91DD1D" Directory="INSTALLDIR">
               <File Id="DynaAppConfiguration" Source="$(var.APPPATH)\ConstraintWorkbench.exe.config" Checksum="yes"/>
               <File Id="Google.OrTools" Source="$(var.APPPATH)\Google.OrTools.dll" Checksum="yes"/>
-              <File Id="Sprache" Source="$(var.APPPATH)\Sprache.dll" Checksum="yes"/>
               <File Id="Caliburn.Micro" Source="$(var.APPPATH)\Caliburn.Micro.dll" Checksum="yes"/>
               <File Id="Caliburn.Micro.Platform" Source="$(var.APPPATH)\Caliburn.Micro.Platform.dll" Checksum="yes"/>
               <File Id="Castle.Core" Source="$(var.APPPATH)\Castle.Core.dll" Checksum="yes"/>

src/Workbench.Core/Grammars/ConstraintGrammar.cs

@@ -100,7 +100,7 @@ public ConstraintGrammar()
             Root = constraintExpression;
 
             MarkTransient(binaryOperators, infixOperators);
-            MarkPunctuation("|");
+            MarkPunctuation(PIPE);
         }
     }
 }

src/Workbench.Core/Grammars/DomainGrammarIrony.cs

@@ -0,0 +1,57 @@
+using Irony.Parsing;
+using Workbench.Core.Nodes;
+
+namespace Workbench.Core.Grammars
+{
+    /// <summary>
+    /// Grammar for shared domain expressions.
+    /// </summary>
+    [Language("Domain Expression Grammar", "0.1", "A grammar for shared domain expressions.")]
+    internal class DomainGrammarIrony : Grammar
+    {
+        private const string FunctionNamePattern = @"\b[A-Za-z]\w*\b";
+        private const string FunctionArgumentStringLiteralPattern = @"\b[A-Za-z]\w*\b";
+
+        public DomainGrammarIrony()
+            : base(caseSensitive: false)
+        {
+            LanguageFlags = LanguageFlags.CreateAst |
+                            LanguageFlags.NewLineBeforeEOF;
+
+            var RANGE = ToTerm("..", "range");
+            var FUNCTION_CALL_ARGUMENT_SEPERATOR = ToTerm(",");
+            var OPEN_ARG = ToTerm("(");
+            var CLOSE_ARG = ToTerm(")");
+
+            // Terminals
+            var numberLiteral = new NumberLiteral("number literal",
+                                                  NumberOptions.IntOnly,
+                                                  typeof(NumberLiteralNode));
+            var functionCallArgumentStringLiteral = new RegexBasedTerminal("function call argument string literal", FunctionArgumentStringLiteralPattern);
+            functionCallArgumentStringLiteral.AstConfig.NodeType = typeof(FunctionCallArgumentStringLiteralNode);
+            var functionName = new RegexBasedTerminal("function name", FunctionNamePattern);
+            functionName.AstConfig.NodeType = typeof(FunctionNameNode);
+
+            // Non-terminals
+            var domainExpression = new NonTerminal("domainExpression", typeof(DomainExpressionNode));
+            var bandExpression = new NonTerminal("expression", typeof(BandExpressionNode));
+            var functionCall = new NonTerminal("function call", typeof(FunctionCallXNode));
+            var functionCallArgumentList = new NonTerminal("function call arguments", typeof(FunctionArgumentListNode));
+            var functionCallArgument = new NonTerminal("function argument", typeof(FunctionCallArgumentNode));
+
+            // BNF rules
+            functionCallArgument.Rule = numberLiteral | functionCallArgumentStringLiteral;
+            functionCall.Rule = functionName + OPEN_ARG + functionCallArgumentList + CLOSE_ARG;
+            functionCallArgumentList.Rule = MakePlusRule(functionCallArgumentList, FUNCTION_CALL_ARGUMENT_SEPERATOR, functionCallArgument);
+            bandExpression.Rule = numberLiteral | functionCall;
+            domainExpression.Rule = bandExpression + RANGE + bandExpression;
+
+            Root = domainExpression;
+
+            MarkPunctuation(RANGE, FUNCTION_CALL_ARGUMENT_SEPERATOR);
+            MarkPunctuation(OPEN_ARG, CLOSE_ARG);
+
+            RegisterBracePair("(", ")");
+        }
+    }
+}

src/Workbench.Core/Grammars/VariableDomainGrammarIrony.cs

@@ -0,0 +1,62 @@
+using Irony.Parsing;
+using Workbench.Core.Nodes;
+
+namespace Workbench.Core.Grammars
+{
+    /// <summary>
+    /// Grammar for variable inline domain expressions.
+    /// </summary>
+    [Language("Variable Domain Expression Grammar", "0.1", "A grammar for variable inline domain expressions.")]
+    internal class VariableDomainGrammarIrony : Grammar
+    {
+        private const string FunctionNamePattern = @"\b[A-Za-z]\w*\b";
+        private const string FunctionArgumentStringLiteralPattern = @"\b[A-Za-z]\w*\b";
+        private const string VariableRegexPattern = @"\b[A-Za-z]\w*\b";
+
+        public VariableDomainGrammarIrony()
+            : base(caseSensitive: false)
+        {
+            LanguageFlags = LanguageFlags.CreateAst |
+                            LanguageFlags.NewLineBeforeEOF;
+
+            var RANGE = ToTerm("..", "range");
+            var FUNCTION_CALL_ARGUMENT_SEPERATOR = ToTerm(",");
+            var OPEN_ARG = ToTerm("(");
+            var CLOSE_ARG = ToTerm(")");
+
+            // Terminals
+            var numberLiteral = new NumberLiteral("number literal", NumberOptions.IntOnly, typeof (NumberLiteralNode));
+            var functionCallArgumentStringLiteral = new RegexBasedTerminal("function call argument string literal", FunctionArgumentStringLiteralPattern);
+            functionCallArgumentStringLiteral.AstConfig.NodeType = typeof (FunctionCallArgumentStringLiteralNode);
+            var functionName = new RegexBasedTerminal("function name", FunctionNamePattern);
+            functionName.AstConfig.NodeType = typeof (FunctionNameNode);
+            var domainName = new RegexBasedTerminal("domain name", VariableRegexPattern);
+            domainName.AstConfig.NodeType = typeof(DomainNameNode);
+
+            // Non-terminals
+            var domainExpression = new NonTerminal("domainExpression", typeof (DomainExpressionNode));
+            var bandExpression = new NonTerminal("expression", typeof (BandExpressionNode));
+            var functionCall = new NonTerminal("function call", typeof (FunctionCallXNode));
+            var functionCallArgumentList = new NonTerminal("function call arguments", typeof (FunctionArgumentListNode));
+            var functionCallArgument = new NonTerminal("function argument", typeof (FunctionCallArgumentNode));
+            var sharedDomainReference = new NonTerminal("shared domain reference", typeof(SharedDomainReferenceNode));
+            var variableDomainExpression = new NonTerminal("variable domain expression", typeof(VariableDomainExpressionNode));
+
+            // BNF rules
+            functionCallArgument.Rule = numberLiteral | functionCallArgumentStringLiteral;
+            functionCall.Rule = functionName + OPEN_ARG + functionCallArgumentList + CLOSE_ARG;
+            functionCallArgumentList.Rule = MakePlusRule(functionCallArgumentList, FUNCTION_CALL_ARGUMENT_SEPERATOR, functionCallArgument);
+            bandExpression.Rule = numberLiteral | functionCall;
+            domainExpression.Rule = bandExpression + RANGE + bandExpression;
+            sharedDomainReference.Rule = domainName;
+            variableDomainExpression.Rule = domainExpression | sharedDomainReference;
+
+            Root = variableDomainExpression;
+
+            MarkPunctuation(RANGE, FUNCTION_CALL_ARGUMENT_SEPERATOR);
+            MarkPunctuation(OPEN_ARG, CLOSE_ARG);
+
+            RegisterBracePair("(", ")");
+        }
+    }
+}

src/Workbench.Core/Models/AggregateVariableModel.cs

@@ -205,14 +205,25 @@ public void OverrideDomainTo(int variableIndex, VariableDomainExpressionModel ne
             Contract.Requires<ArgumentNullException>(newDomainExpression != null);
 
             var variableToOverride = GetVariableByIndex(variableIndex);
+#if false
             if (!variableToOverride.DomainExpression.IsEmpty)
             {
                 if (!variableToOverride.DomainExpression.Intersects(newDomainExpression))
                     throw new ArgumentException("newDomainExpression");
             }
+#endif
             variableToOverride.DomainExpression = newDomainExpression;
         }
 
+        /// <summary>
+        /// Get the size of the variable.
+        /// </summary>
+        /// <returns>Size of the variable.</returns>
+        public override long GetSize()
+        {
+            return AggregateCount;
+        }
+
         /// <summary>
         /// Create a new variable.
         /// </summary>