private void ProcessParameters(ParameteriseNode parent, IEnumerable <Parameter> parameters)
{
foreach (Parameter parameter in parameters)
{
ParameterNode parameterNode = BuildParameterNode(parameter);
AddParameter(parameterNode, parent);
}
}
private void AddParameter(ParameterNode parameterNode, ParameteriseNode node)
{
if (!CheckIfParameterIsValid(parameterNode, node))
{
return;
}
node.Parameters.Add(parameterNode);
}
private bool CheckIfParameterIsValid(ParameterNode parameterNode, ParameteriseNode node)
{
Parameter newParameter = parameterNode.Parameter;
if (NeedsTemplate(newParameter) &&
!IsValidTemplate(newParameter.ArgumentTemplate))
{
logger.Error("Any optional or repeateble parameter needs to have a valid template.", GetContextFromNode(node), newParameter);
return(false);
}
if (node.Parameters.Count < 1)
{
return(true);
}
Parameter lastParameter = node.Parameters[node.Parameters.Count - 1].Parameter;
if (lastParameter.IsRepeatable)
{
logger.Error("A repeateble parameter needs to be the last parameter.", GetContextFromNode(node), lastParameter, newParameter);
return(false);
}
if (!newParameter.IsOptional &&
lastParameter.IsOptional)
{
logger.Error("Required parameters need to be defined before optional.", GetContextFromNode(node), newParameter);
return(false);
}
if (node.Type == NodeTypeEnum.Option &&
node.Parameters.Count >= 2)
{
logger.Warn("An option shouldn't have more than two parameters.", ((OptionNode)node).Option);
}
else if (node.Type == NodeTypeEnum.Query &&
node.Parameters.Count >= 3)
{
logger.Warn("An option shouldn't have more than three parameters.", ((QueryNode)node).Query);
}
return(true);
}
private void EvaluateParameters(ParameteriseNode statement, IDictionary <string, ParameterContext> context)
{
parameterIndex = 0;
AnalysedToken token = null;
ParameterContext.Builder repetableParameter = null;
while (!wrongInput &&
parameterIndex < statement.Parameters.Count &&
tokenStack.Count > 0)
{
token = tokenStack.Peek();
ParameterNode parameter = statement.Parameters[parameterIndex];
if (token.IsEndOfParameterList)
{
if (parameter.Parameter.IsRepeatable || parameter.Parameter.IsOptional)
{
AddTokenToResult(TokenTypeEnum.EndOfParameterList, token.RawInput);
tokenStack.Pop();
break;
}
AddWrongTokenToResult(token.RawInput);
return;
}
if (parameter.Parameter.IsOptional)
{
if (!IsParameterMatch(parameter, token))
{
parameterIndex++;
continue;
}
AddTokenToResult(TokenTypeEnum.Parameter, token.RawInput, token.Value);
tokenStack.Pop();
if (parameter.Parameter.IsRepeatable)
{
if (repetableParameter == null)
{
repetableParameter = ParameterContext.Empty.ToBuilder();
repetableParameter.Key = parameter.Parameter.Key;
}
repetableParameter.Values.Add(token.Value);
}
else
{
context[parameter.Parameter.Key] = ParameterContext.Build(parameter.Parameter.Key, token.Value);
parameterIndex++;
}
}
else
{
if (!IsParameterMatch(parameter, token))
{
if (repetableParameter == null)
{
AddWrongTokenToResult(token.RawInput);
return;
}
break;
}
AddTokenToResult(TokenTypeEnum.Parameter, token.RawInput, token.Value);
tokenStack.Pop();
if (parameter.Parameter.IsRepeatable)
{
if (repetableParameter == null)
{
repetableParameter = ParameterContext.Empty.ToBuilder();
repetableParameter.Key = parameter.Parameter.Key;
}
repetableParameter.Values.Add(token.Value);
}
else
{
context[parameter.Parameter.Key] = ParameterContext.Build(parameter.Parameter.Key, token.Value);
parameterIndex++;
}
}
}
if (repetableParameter != null)
{
context[repetableParameter.Key] = repetableParameter.ToImmutable();
}
if (!wrongInput &&
statement.Type == NodeTypeEnum.Query)
{
if (tokenStack.Peek().IsEndOfInput)
{
tokenStack.Pop();
}
if (tokenStack.Count > 0)
{
if (token != null &&
!token.IsEndOfParameterList)
{
AddWrongTokenToResult(token.RawInput);
}
if (statement.Parameters.Count < 1)
{
AddWrongTokenToResult(tokenStack.Peek().RawInput);
}
}
}
}
