public IReadOnlyList <INamedTypeSymbol> Scan(ITypeInfoProvider typeInfoProvider)
{
using (new DTimer(_diagnosticReporter, "Dpdt scan for types taken"))
{
return(_typeScanner.Scan(typeInfoProvider));
}
}
public Activity Parse(JsonElement node, ITypeInfoProvider typeInfoProvider,
CompositeActivityParser compositeParser)
{
var displayName = ActivityParseUtil.GetDisplayName(node);
var branchesNodeExists = node.TryGetProperty("branches", out var branchesNode);
node.TryGetProperty("completionCondition", out var completionConditionProperty);
var parallel = new Parallel()
{
DisplayName = displayName,
CompletionCondition = new CSharpValue <bool>(completionConditionProperty.GetString()),
};
foreach (var variable in ActivityParseUtil.ParseVariables(node, typeInfoProvider))
{
parallel.Variables.Add(variable);
}
if (branchesNodeExists)
{
foreach (var branchNode in branchesNode.EnumerateArray())
{
parallel.Branches.Add(compositeParser.Parse(branchNode));
}
}
return(parallel);
}
public BindFromResolutionProducer(
ITypeInfoProvider typeInfoProvider,
ClusterBindings clusterBindings,
ITypeSymbol bindFrom,
IReadOnlyList <InstanceProduct> instanceProducts
)
{
if (typeInfoProvider is null)
{
throw new ArgumentNullException(nameof(typeInfoProvider));
}
if (clusterBindings is null)
{
throw new ArgumentNullException(nameof(clusterBindings));
}
if (bindFrom is null)
{
throw new System.ArgumentNullException(nameof(bindFrom));
}
if (instanceProducts is null)
{
throw new ArgumentNullException(nameof(instanceProducts));
}
_typeInfoProvider = typeInfoProvider;
ClusterBindings = clusterBindings;
BindFrom = bindFrom;
InstanceProducts = instanceProducts;
}
public Activity Parse(JsonElement node, ITypeInfoProvider typeInfoProvider,
CompositeActivityParser compositeParser)
{
var activitiesNodeExists = node.TryGetProperty("activities", out var activitiesNode);
var sequence = new Sequence
{
DisplayName = ActivityParseUtil.GetDisplayName(node),
};
if (activitiesNodeExists)
{
var activities = activitiesNode.EnumerateArray()
.Select(compositeParser.Parse);
foreach (var activity in activities)
{
sequence.Activities.Add(activity);
}
}
foreach (var v in ActivityParseUtil.ParseVariables(node, typeInfoProvider))
{
sequence.Variables.Add(v);
}
return(sequence);
}
public static IEnumerable <(DpdtArgumentWrapperTypeEnum, ITypeSymbol)> GenerateWrapperTypes(
this ITypeSymbol type,
ITypeInfoProvider typeInfoProvider,
bool includeNone
)
{
foreach (DpdtArgumentWrapperTypeEnum wrapperType in Enum.GetValues(typeof(DpdtArgumentWrapperTypeEnum)))
{
ITypeSymbol wrapperSymbol;
switch (wrapperType)
{
case DpdtArgumentWrapperTypeEnum.None:
if (!includeNone)
{
continue;
}
wrapperSymbol = type;
break;
case DpdtArgumentWrapperTypeEnum.Func:
wrapperSymbol = typeInfoProvider.Func(type);
break;
default:
throw new ArgumentOutOfRangeException(wrapperType.ToString());
}
yield return(wrapperType, wrapperSymbol);
}
}
private static string GetTypeName(ITypeInfoProvider type)
{
try
{
var sb = new StringBuilder();
var name = type.Name ?? type.FullName;
if (type.IsGenericType)
{
int lastIndexOf = name.LastIndexOf('`');
if (lastIndexOf != -1)
{
name = name.Substring(0, lastIndexOf);
}
}
sb.Append(name);
if (type.IsGenericType || type.IsGenericTypeDefinition)
{
sb.Append("<");
sb.Append(string.Join(", ", type.GetGenericArguments().Select(a => GetTypeName(a))));
sb.Append(">");
}
return(Normalizer.Normalize(sb.ToString()));
}
catch
{
Console.WriteLine("Exception stringifying type. Type details: \r\n" + type);
throw;
}
}
internal AsyncRemoteQueryProvider(Func <Expressions.Expression, Task <TSource> > dataProvider, ITypeInfoProvider typeInfoProvider, IAsyncQueryResultMapper <TSource> resutMapper, Func <Expression, bool> canBeEvaluatedLocally)
{
_dataProvider = dataProvider ?? throw new ArgumentNullException(nameof(dataProvider));
_resultMapper = resutMapper;
_typeInfoProvider = typeInfoProvider;
_canBeEvaluatedLocally = canBeEvaluatedLocally;
}
public BeanContextFactory CreateChildContextFactory(IBeanContextInitializer beanContextInitializer, IServiceContext serviceContext)
{
IProxyFactory proxyFactory = serviceContext.GetService <IProxyFactory>();
ITypeInfoProvider typeInfoProvider = serviceContext.GetService <ITypeInfoProvider>(false);
IProperties props = serviceContext.GetService <IProperties>();
Properties newProps = new Properties(props);
return(new BeanContextFactory(linkController, beanContextInitializer, proxyFactory, typeInfoProvider, newProps, this));
}
public Activity Parse(JsonElement node, ITypeInfoProvider typeInfoProvider,
CompositeActivityParser compositeParser)
{
var typeName = node.GetProperty("type").GetString();
var type = typeInfoProvider.Find(typeName);
var coreMethod = _coreMethod !.MakeGenericMethod(type);
return((Activity)coreMethod.Invoke(this, new object[] { node }));
}
public ExcelPropertyMapFactory(ITypeInfoProvider propertiesExtractor,
IPropertyInfoExtractor propertyInfoExtractor,
IPropertyNameConvention conventionsApplier,
ILogger <ExcelPropertyMapFactory> logger)
{
_propertiesExtractor = propertiesExtractor ?? throw new ArgumentNullException(nameof(propertiesExtractor));
_propertyInfoExtractor =
propertyInfoExtractor ?? throw new ArgumentNullException(nameof(propertyInfoExtractor));
_conventionsApplier = conventionsApplier ?? throw new ArgumentNullException(nameof(conventionsApplier));
Log = logger ?? throw new ArgumentNullException(nameof(logger));
}
public Activity Parse(JsonElement machineNode, ITypeInfoProvider typeInfoProvider,
CompositeActivityParser compositeParser)
{
var machine = new StateMachine();
var results =
machineNode.GetProperty("states").EnumerateArray()
.Select(s => ParseState(s, typeInfoProvider, compositeParser))
.ToDictionary(p => p.Id, p => p);
var initialState = machineNode.GetProperty("initialState").GetString();
machine.InitialState = results[initialState !].State;
public static INamedTypeSymbol Void(
this ITypeInfoProvider typeInfoProvider
)
{
if (typeInfoProvider is null)
{
throw new ArgumentNullException(nameof(typeInfoProvider));
}
return(typeInfoProvider.GetTypeByMetadataName("System.Void") !);
}
public Activity Parse(JsonElement node, ITypeInfoProvider typeInfoProvider,
CompositeActivityParser compositeParser)
{
var trace = new Trace
{
DisplayName = ActivityParseUtil.GetDisplayName(node),
Text = new CSharpValue <string>(node.GetProperty("text").GetString())
};
return(trace);
}
public void Dispose()
{
beanConfigurations = null;
nameToBeanConfMap = null;
aliasToBeanNameMap = null;
beanNameToAliasesMap = null;
linkController = null;
parent = null;
beanContextInitializer = null;
typeInfoProvider = null;
props = null;
}
public Activity Parse(JsonElement node, ITypeInfoProvider typeInfoProvider, CompositeActivityParser compositeParser)
{
var mirrorBase = node.GetProperty("mirrorBase").GetString();
var tenantId = node.GetProperty("tenantId").GetString();
var modelKey = node.GetProperty("modelKey").GetString();
var filter = node.GetProperty("filter").GetString();
filter = MirrorExpressionHelper.BuildCSharpExpression(filter);
var result = node.GetProperty("result").GetString();
return((Activity)_methodInfo.Invoke(this, new object[] { mirrorBase, tenantId, modelKey, filter, result }));
}
public Activity Parse(JsonElement node, ITypeInfoProvider typeInfoProvider, CompositeActivityParser compositeParser)
{
var mirrorBase = node.GetProperty("mirrorBase").GetString();
var tenantId = node.GetProperty("tenantId").GetString();
var modelKey = node.GetProperty("modelKey").GetString();
var modelType = typeInfoProvider.Find(modelKey);
var model = node.GetProperty("model").GetString();
var result = node.GetProperty("result").GetString();
var methodInfo = _methodInfo !.MakeGenericMethod(modelType);
return((Activity)methodInfo.Invoke(this, new object[] { mirrorBase, tenantId, modelKey, model, result }));
}
public IReadOnlyList <INamedTypeSymbol> ScanForClusterTypes(
ITypeInfoProvider typeInfoProvider
)
{
if (typeInfoProvider is null)
{
throw new ArgumentNullException(nameof(typeInfoProvider));
}
var foundTypes = typeInfoProvider.GetClusterTypes(RoslynHelper.IsClusterType).ToList();
return(foundTypes);
}
public Activity Parse(JsonElement node, ITypeInfoProvider typeInfoProvider, CompositeActivityParser compositeParser)
{
var pick = new Pick {DisplayName = ActivityParseUtil. GetDisplayName(node)};
var branchesNodeExists = node.TryGetProperty("branches", out var branchesNode);
if (branchesNodeExists)
{
foreach (var branchNode in branchesNode.EnumerateArray())
{
pick.Branches.Add(ParsePickBranch(branchNode, typeInfoProvider, compositeParser));
}
}
return pick;
}
public Activity Parse(JsonElement node, ITypeInfoProvider typeInfoProvider,
CompositeActivityParser compositeParser)
{
var typeName = node.GetProperty("type").GetString();
var type = typeInfoProvider.Find(typeName);
if (type == null)
{
throw new Exception($"can not find type name {typeName}");
}
var coreMethod = _coreMethod !.MakeGenericMethod(type);
return((Activity)coreMethod !.Invoke(this, new object[] { node, compositeParser }));
}
public SystemToRemoteLinqTranslator(IExpressionToRemoteLinqContext expressionTranslatorContext)
{
expressionTranslatorContext.AssertNotNull(nameof(expressionTranslatorContext));
_canBeEvaluatedLocally = expressionTranslatorContext.CanBeEvaluatedLocally;
_needsMapping = expressionTranslatorContext.NeedsMapping;
_typeInfoProvider = expressionTranslatorContext.TypeInfoProvider
?? throw new ArgumentException($"{nameof(expressionTranslatorContext.TypeInfoProvider)} property must not be null.", nameof(expressionTranslatorContext));
_dynamicObjectMapper = expressionTranslatorContext.ValueMapper
?? throw new ArgumentException($"{nameof(expressionTranslatorContext.ValueMapper)} property must not be null.", nameof(expressionTranslatorContext));
}
public Activity Parse(JsonElement node, ITypeInfoProvider typeInfoProvider,
CompositeActivityParser compositeParser)
{
var inputType = typeInfoProvider.Find(node.GetProperty("inType").GetString());
var outputType = typeInfoProvider.Find(node.GetProperty("outType").GetString());
var argumentsExits = node.TryGetProperty("arguments", out var argumentsNode);
var arguments = argumentsExits ? argumentsNode.GetString() : null;
var code = node.GetProperty("code").GetString();
var displayName = ActivityParseUtil.GetDisplayName(node);
var result = node.GetProperty("result").GetString();
var methodInfo = _methodInfo !.MakeGenericMethod(inputType, outputType);
return((Activity)methodInfo.Invoke(this, new object[] { displayName, code, result, arguments }));
}
public static INamedTypeSymbol Func(
this ITypeInfoProvider typeInfoProvider,
params ITypeSymbol[] genericParameters
)
{
if (typeInfoProvider is null)
{
throw new ArgumentNullException(nameof(typeInfoProvider));
}
return
(typeInfoProvider.GetTypeByMetadataName("System.Func`" + genericParameters.Length) !
.Construct(genericParameters)
);
}
public BeanContextFactory(ILinkController linkController, IBeanContextInitializer beanContextInitializer, IProxyFactory proxyFactory, ITypeInfoProvider typeInfoProvider, Properties properties,
BeanContextFactory parent)
{
ParamChecker.AssertParamNotNull(linkController, "linkController");
ParamChecker.AssertParamNotNull(beanContextInitializer, "beanContextInitializer");
ParamChecker.AssertParamNotNull(proxyFactory, "proxyFactory");
ParamChecker.AssertParamNotNull(properties, "properties");
this.linkController = linkController;
this.beanContextInitializer = beanContextInitializer;
this.proxyFactory = proxyFactory;
this.typeInfoProvider = typeInfoProvider;
this.props = properties;
this.parent = parent;
}
public InfoCarrierQueryResultMapper(
QueryContext queryContext,
ITypeResolver typeResolver,
ITypeInfoProvider typeInfoProvider,
IReadOnlyDictionary <string, IEntityType> entityTypeMap = null)
: base(typeResolver, typeInfoProvider, new DynamicObjectMapperSettings {
FormatPrimitiveTypesAsString = true
})
{
this.queryContext = queryContext;
this.typeResolver = typeResolver;
this.entityTypeMap = entityTypeMap ?? BuildEntityTypeMap(queryContext.Context);
this.entityMaterializerSource = queryContext.Context.GetService <IEntityMaterializerSource>();
this.valueMappers = queryContext.Context.GetService <IEnumerable <IInfoCarrierValueMapper> >()
.Concat(StandardValueMappers.Mappers);
}
private PickBranch ParsePickBranch(JsonElement branchNode, ITypeInfoProvider typeInfoProvider, CompositeActivityParser compositeParser)
{
var displayName = ActivityParseUtil. GetDisplayName(branchNode);
var triggerNode = branchNode.GetProperty("trigger");
var actionNodeExists = branchNode.TryGetProperty("action", out var actionNode);
var branch = new PickBranch
{
DisplayName = displayName,
Trigger = compositeParser. Parse(triggerNode),
Action = actionNodeExists ? null : compositeParser. Parse(actionNode),
};
foreach (var variable in ActivityParseUtil.ParseVariables(branchNode, typeInfoProvider))
{
branch.Variables.Add(variable);
}
return branch;
}
public Activity Parse(JsonElement node, ITypeInfoProvider typeInfoProvider,
CompositeActivityParser compositeParser)
{
var resultExists = node.TryGetProperty("result", out var resultNode);
var userTask = new UserTask()
{
DisplayName = ActivityParseUtil.GetDisplayName(node),
Name = node.GetProperty("name").GetString(),
};
if (resultExists)
{
userTask.Result = new OutArgument <string>(new CSharpReference <string>(resultNode.GetString()));
}
return(userTask);
}
public ClusterProducer(
ITypeInfoProvider typeInfoProvider,
ClusterBindings clusterBindings
)
{
if (typeInfoProvider is null)
{
throw new ArgumentNullException(nameof(typeInfoProvider));
}
if (clusterBindings is null)
{
throw new ArgumentNullException(nameof(clusterBindings));
}
_typeInfoProvider = typeInfoProvider;
ClusterBindings = clusterBindings;
}
public static string GetFullyQualifiedTypeName(ITypeInfoProvider @type)
{
string typeName = GetTypeName(@type);
if (MethodNameNormalizer.IsLambdaMethod(typeName))
{
return(null);
}
string ns = @type.Namespace;
if (!string.IsNullOrEmpty(ns))
{
typeName = ns + "." + typeName;
}
return(typeName);
}
public EntityToDynamicObjectMapper(
DbContext dbContext,
ITypeResolver typeResolver,
ITypeInfoProvider typeInfoProvider,
IEnumerable <IInfoCarrierValueMapper> valueMappers)
: base(typeResolver, typeInfoProvider, new DynamicObjectMapperSettings {
FormatPrimitiveTypesAsString = true
})
{
this.valueMappers = valueMappers;
IServiceProvider serviceProvider = dbContext.GetInfrastructure();
this.stateManager = serviceProvider.GetRequiredService <IStateManager>();
this.detachedEntityTypeMap = dbContext.Model.GetEntityTypes()
.Where(et => et.ClrType != null)
.GroupBy(et => et.ClrType)
.ToDictionary(x => x.Key, x => x.First());
}
public ConstructorArgumentExtractor(
ITypeInfoProvider typeInfoProvider,
SemanticModel semanticModel
)
{
if (typeInfoProvider is null)
{
throw new ArgumentNullException(nameof(typeInfoProvider));
}
if (semanticModel is null)
{
throw new ArgumentNullException(nameof(semanticModel));
}
_typeInfoProvider = typeInfoProvider;
_semanticModel = semanticModel;
_constructorArguments = new List <DetectedConstructorArgument>();
}
public static void RegisterProvider(Type t, ITypeInfoProvider prov)
{
providers[t] = prov;
}
