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; } }