private void checkActions(OnlineRoom receivedRoom)
{
if (receivedRoom.UserActionArgument != null)
{
argumentToSend = receivedRoom.UserActionArgument;
if (argumentToSend.Arguments.Count == 1)
{
argumentWithOneArgument(receivedRoom, argumentToSend.Type.ReturnType());
}
}
}
public static bool TryParse(string value, IFormatProvider formatProvider, out ArgumentParameter ordinalParameter)
{
var match = Pattern.Match(value);
if (match.Success)
{
var prototype = value;
var rest = match.Groups["rest"].Value;
var param = ArgumentParameter.Parse(rest, formatProvider);
ordinalParameter = new ArgumentParameter(prototype, param.Aliases, param.Delimiter, int.Parse(match.Groups["ord"].Value, formatProvider));
return true;
}
ordinalParameter = null;
return false;
}
/// <summary>
/// Note: this may accept invalid patterns.
/// </summary>
/// <param name="value"></param>
/// <param name="optionParameter"></param>
/// <returns></returns>
public static bool TryParse(string value, out ArgumentParameter optionParameter)
{
if (value.Contains("|"))
{
var prototype = value;
var names = prototype.TrimEnd('=', ':').Split('|');
string delimiter = null;
var last = prototype.Last();
switch (last)
{
case '=':
case ':':
delimiter = last.ToString();
break;
default:
break;
}
optionParameter = new ArgumentParameter(prototype, names, delimiter);
return true;
}
optionParameter = null;
return false;
}
public static bool TryParse(string value, out ArgumentParameter visualStudioParameter)
{
//TODO: need to do some cleaning here
var match = VisualStudioArgPattern.Match(value);
if (match.Success)
{
var aliases = new List<string>();
string val;
if (match.Groups["prefix"].Length > 0)
{
val = value.Replace("&", "");
if (match.Groups["alias"].Length > 0)
aliases.Add(match.Groups["alias"].Value);
}
else
{
val = value;
}
string delimiter;
if (match.Groups["equals"].Length > 0)
{
delimiter = match.Groups["equals"].Value;
val = val.Replace(delimiter, "");
}
else delimiter = null;
aliases.Add(val);
visualStudioParameter = new ArgumentParameter(
prototype:value,
names:aliases.ToArray(),
delimiter:delimiter);
return true;
}
visualStudioParameter = null;
return false;
}
/**
* Update missing tokens in expression related
* to iterative operators.
*
* @param index Index parameter of the iterative operator
* @param iterParams Parameters list of the iterative operator
*/
private void updateMissingTokens(ArgumentParameter index, IterativeOperatorParameters iterParams)
{
if (index.presence == Argument.NOT_FOUND) {
updateMissingTokens(iterParams.indexParam.tokens, iterParams.indexParam.paramStr, index.index, Argument.TYPE_ID);
updateMissingTokens(iterParams.fromParam.tokens, iterParams.indexParam.paramStr, index.index, Argument.TYPE_ID);
updateMissingTokens(iterParams.toParam.tokens, iterParams.indexParam.paramStr, index.index, Argument.TYPE_ID);
updateMissingTokens(iterParams.funParam.tokens, iterParams.indexParam.paramStr, index.index, Argument.TYPE_ID);
}
}
/**
* Gets / returns argument representing given argument name. If
* argument name exists on the list of known arguments
* the the initial status of the found argument is remembered, otherwise new
* argument will be created.
*
* @param argumentName the argument name
*
* @return Argument parameter representing given argument name:
*
*
* @see ArgumentParameter
* @see Argument
*/
private ArgumentParameter getParamArgument(String argumentName)
{
ArgumentParameter argParam = new ArgumentParameter();
argParam.index = getArgumentIndex(argumentName);
argParam.argument = getArgument(argParam.index);
argParam.presence = FOUND;
if (argParam.argument == null) {
argParam.argument = new Argument(argumentName);
argumentsList.Add(argParam.argument);
argParam.index = argumentsList.Count-1;
argParam.presence = NOT_FOUND;
} else {
argParam.initialValue = argParam.argument.argumentValue;
argParam.initialType = argParam.argument.argumentType;
argParam.argument.argumentValue = argParam.argument.getArgumentValue();
argParam.argument.argumentType = Argument.FREE_ARGUMENT;
}
return argParam;
}
/**
* Evaluates ranges 'from', 'to', 'delta' for the iterative operator
*
* @param index Index parameter of the iterative operator
* @param iterParams Parameters list of the iterative operator
*/
private void evalFromToDeltaParameters(ArgumentParameter index, IterativeOperatorParameters iterParams)
{
/*
* Create from, to, fun expression
* based on the from string
* expressions will use the same arguments list
* as used in the main expression (this.argumentsList)
*/
iterParams.fromExp = new Expression(iterParams.fromParam.paramStr, iterParams.fromParam.tokens, argumentsList, functionsList, constantsList, KEEP_ULP_ROUNDING_SETTINGS);
iterParams.toExp = new Expression(iterParams.toParam.paramStr, iterParams.toParam.tokens, argumentsList, functionsList, constantsList, KEEP_ULP_ROUNDING_SETTINGS);
iterParams.funExp = new Expression(iterParams.funParam.paramStr, iterParams.funParam.tokens, argumentsList, functionsList, constantsList, DISABLE_ULP_ROUNDING);
iterParams.deltaExp = null;
if (verboseMode == true) {
iterParams.fromExp.setVerboseMode();
iterParams.toExp.setVerboseMode();
iterParams.funExp.setVerboseMode();
}
/*
* Evaluate range
*/
iterParams.from = iterParams.fromExp.calculate();
iterParams.to = iterParams.toExp.calculate();
iterParams.delta = 1;
if (iterParams.to < iterParams.from) iterParams.delta = -1;
if (iterParams.withDelta == true) {
iterParams.deltaExp = new Expression(iterParams.deltaParam.paramStr, iterParams.deltaParam.tokens, argumentsList, functionsList, constantsList, DISABLE_ULP_ROUNDING);
if (index.presence == Argument.NOT_FOUND) {
updateMissingTokens(iterParams.deltaParam.tokens, iterParams.indexParam.paramStr, index.index, Argument.TYPE_ID);
}
if (verboseMode == true)
iterParams.deltaExp.setVerboseMode();
iterParams.delta = iterParams.deltaExp.calculate();
}
}
/**
* Clears argument parameter.
*
* @param argParam the argument parameter.
*/
private void clearParamArgument(ArgumentParameter argParam)
{
if (argParam.presence == NOT_FOUND)
argumentsList.RemoveAt(argParam.index);
else {
argParam.argument.argumentValue = argParam.initialValue;
argParam.argument.argumentType = argParam.initialType;
}
}
