static IParameter MakeParameter(ITypeReference type, string name) { DefaultParameter p = new DefaultParameter(type, name); p.Freeze(); return(p); }
void ConvertParameters(IList <IParameter> outputList, IEnumerable <ParameterDeclaration> parameters) { foreach (ParameterDeclaration pd in parameters) { DefaultParameter p = new DefaultParameter(ConvertType(pd.Type), pd.Name); p.Region = MakeRegion(pd); ConvertAttributes(p.Attributes, pd.Attributes); switch (pd.ParameterModifier) { case ParameterModifier.Ref: p.IsRef = true; p.Type = ByReferenceTypeReference.Create(p.Type); break; case ParameterModifier.Out: p.IsOut = true; p.Type = ByReferenceTypeReference.Create(p.Type); break; case ParameterModifier.Params: p.IsParams = true; break; } if (!pd.DefaultExpression.IsNull) { p.DefaultValue = ConvertConstantValue(p.Type, pd.DefaultExpression); } outputList.Add(p); } }
public async Task <string> GetGlobalParamAsync(bool usetokencode, string userTokenOrCode, string key) { Dictionary <string, string> header = null; if (usetokencode) { header = GetTokenHeader(userTokenOrCode); } else { header = GetCodeHeader(userTokenOrCode); } var back = await AutoRetry.RunAsync <ResponseMessage <CmParam> >(() => { DefaultParameter param = new DefaultParameter() { tool = "DEFAULT", paramname = key, system = "INGEST" }; return(PostAsync <ResponseMessage <CmParam> >( string.Format("{0}/CMApi/api/basic/config/getsysparam", CmServerUrl), param, header)); }).ConfigureAwait(true); if (back != null) { return(back.Ext?.paramvalue); } return(string.Empty); }
public KubeMQConfigurationExtension(IServiceCollection services, IConfiguration configuration, Action <DefaultParameter> options) { _services = services; _configuration = configuration; _defaultParameter = new DefaultParameter(); options.Invoke(_defaultParameter); }
public KubeMQConfigurationExtension(IServiceCollection services, IConfiguration configuration) { _services = services; _configuration = configuration; _defaultParameter = new DefaultParameter(); configuration.Bind("KubeMQ:Default", _defaultParameter); }
public async Task <int> GetUserParamTemplateIDAsync(bool usetokencode, string userTokenOrCode) { Dictionary <string, string> header = null; if (usetokencode) { header = GetTokenHeader(userTokenOrCode); } else { header = GetCodeHeader(userTokenOrCode); } var back = await AutoRetry.RunAsync <ResponseMessage <CmParam> >(() => { DefaultParameter param = new DefaultParameter() { tool = "DEFAULT", paramname = "HIGH_RESOLUTION", system = "INGEST" }; return(PostAsync <ResponseMessage <CmParam> >( string.Format("{0}/CMApi/api/basic/config/getuserparam", CmServerUrl), param, header)); }).ConfigureAwait(true); if (back != null) { return(int.Parse(back.Ext?.paramvalue)); } return(0); }
internal static IParameter CreateParameter(AST.ParameterDeclarationExpression par, IMethod method, IClass currentClass, ICompilationUnit cu) { IReturnType parType = CreateReturnType(par.TypeReference, method, currentClass, cu, TypeVisitor.ReturnTypeOptions.None); DefaultParameter p = new DefaultParameter(par.ParameterName, parType, GetRegion(par.StartLocation, par.EndLocation)); p.Modifiers = (ParameterModifiers)par.ParamModifier; return(p); }
/// <summary> /// Converts from Ruby AST expressions to parameters. /// </summary> IParameter[] ConvertParameters(Parameters parameters) { List <IParameter> convertedParameters = new List <IParameter>(); foreach (LocalVariable variable in GetParameterVariables(parameters)) { DefaultParameter parameter = new DefaultParameter(variable.Name, null, new DomRegion()); convertedParameters.Add(parameter); } return(convertedParameters.ToArray()); }
public MockImplicitLambda(IType[] expectedParameterTypes, IType inferredReturnType) { this.expectedParameterTypes = expectedParameterTypes; this.inferredReturnType = inferredReturnType; this.parameters = new IParameter[expectedParameterTypes.Length]; for (int i = 0; i < parameters.Length; i++) { // UnknownType because this lambda is implicitly typed parameters[i] = new DefaultParameter(SpecialType.UnknownType, "X" + i); } }
public void ParameterComparisonTest() { DefaultParameter p1 = new DefaultParameter("a", mscorlib.GetClass("System.String", 0).DefaultReturnType, DomRegion.Empty); DefaultParameter p2 = new DefaultParameter("b", new GetClassReturnType(mscorlib, "System.String", 0), DomRegion.Empty); IList <IParameter> a1 = new List <IParameter>(); IList <IParameter> a2 = new List <IParameter>(); a1.Add(p1); a2.Add(p2); Assert.AreEqual(0, DiffUtility.Compare(a1, a2)); }
IParameter[] ConvertParameters(IList <Parameter> parameters, int startingIndex) { List <IParameter> convertedParameters = new List <IParameter>(); for (int i = startingIndex; i < parameters.Count; ++i) { DefaultParameter parameter = new DefaultParameter(parameters[i].Name, null, new DomRegion()); convertedParameters.Add(parameter); } return(convertedParameters.ToArray()); }
public static bool Require(IStatus s, List <string> list) { bool isLack = false; foreach (var item in list) { if (s[item] == null) { isLack = true; s[item] = new DefaultParameter(item, 0); //kokoyabai } } return(isLack); }
/// <summary> /// Copies methods from one class to another. /// </summary> /// <param name="oldClass">Source class</param> /// <param name="newClass">Target class</param> private void copyMethods(IClass oldClass, IClass newClass) { foreach (IMethod element in oldClass.Methods) { DefaultMethod newMethod = new DefaultMethod(element.Name, element.ReturnType, element.Modifiers, element.Region, element.BodyRegion, newClass); foreach (IParameter param in element.Parameters) { DefaultParameter newParam = new DefaultParameter(param); newMethod.Parameters.Add(newParam); } newMethod.BodyRegion = new DomRegion(element.BodyRegion.BeginLine, element.BodyRegion.BeginColumn, element.BodyRegion.EndLine, element.BodyRegion.EndColumn); newClass.Methods.Add(newMethod); } }
public void DefaultParameterTest() { var intParameter = new DefaultParameter <int>(); var stringParameter = new DefaultParameter <string>(); var dynamicParameter = new DefaultParameter <dynamic>(); var objectParameter = new DefaultParameter <object>(); intParameter.GetParamType().Should().BeAssignableTo <int>(); stringParameter.GetParamType().Should().BeAssignableTo <string>(); dynamicParameter.GetParamType().Should().BeAssignableTo <object>(); objectParameter.GetParamType().Should().BeAssignableTo <object>(); intParameter.GetValue().Should().BeAssignableTo <int>(); intParameter.GetValue().Should().Be(0); stringParameter.GetValue().Should().Be(null); dynamicParameter.GetValue().Should().Be(null); objectParameter.GetValue().Should().Be(null); }
internal static void AddParameters(AST.ParameterDeclarationCollection parameters, IList <IParameter> output, IMethodOrProperty method, IClass c) { if (c == null) { throw new ArgumentNullException("c"); } DefaultParameter p = null; foreach (AST.ParameterDeclaration par in parameters) { p = new DefaultParameter(par.Name, CreateReturnType(par.Type, c, method as IMethod, c.Region.BeginLine + 1, 1, c.ProjectContent), new DomRegion(par.LexicalInfo.Line, par.LexicalInfo.Column)); if (par.IsByRef) { p.Modifiers |= ParameterModifiers.Ref; } output.Add(p); } if (parameters.HasParamArray) { p.Modifiers |= ParameterModifiers.Params; } }
/// <summary> /// Create type predictor with defaul model file. /// </summary> public FullFeaturePredictor() { this.modelFile = (string)DefaultParameter.Get(DefaultParameter.Field.model_file); }
internal static IParameter CreateParameter(AST.ParameterDeclarationExpression par, IMethod method, IClass currentClass, ICompilationUnit cu) { IReturnType parType = CreateReturnType(par.TypeReference, method, currentClass, cu, TypeVisitor.ReturnTypeOptions.None); DefaultParameter p = new DefaultParameter(par.ParameterName, parType, GetRegion(par.StartLocation, par.EndLocation)); p.Modifiers = (ParameterModifiers)par.ParamModifier; return p; }
private string GetTypeName(DefaultParameter param) { return((param.Type as DefaultResolvedTypeDefinition).GetTypeName(usedNamespaces)); }