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