private bool ParseTypePathGenerics(ref TypeLookup retn) { if (tokenStream.Current != ExpressionTokenType.LessThan) { return(false); } int advance = tokenStream.FindMatchingIndex(ExpressionTokenType.LessThan, ExpressionTokenType.GreaterThan); if (advance == -1) { // Abort(); return(false); } tokenStream.Save(); ExpressionParser subParser = CreateSubParser(advance); bool valid = subParser.ParseTypePathGenericStep(ref retn); subParser.Release(); if (!valid) { Abort(); } //tokenStream.Advance(); return(true); }
public RegisteredType( TypeSystemObjectBase type, bool isInferred, TypeRegistry typeRegistry, TypeLookup typeLookup, IDescriptorContext descriptorContext, ITypeInterceptor typeInterceptor, string?scope) { Type = type; _typeRegistry = typeRegistry; _typeLookup = typeLookup; IsInferred = isInferred; DescriptorContext = descriptorContext; TypeInterceptor = typeInterceptor; IsExtension = Type is INamedTypeExtensionMerger; IsSchema = Type is ISchema; Scope = scope; if (type is INamedType nt) { IsNamedType = true; IsIntrospectionType = nt.IsIntrospectionType(); Kind = nt.Kind; } else if (type is DirectiveType) { IsDirectiveType = true; Kind = TypeKind.Directive; } }
public void Partition_sequence_returns_sequence_with_duplicates() { // Fixture setup var expectedSequence = new[] { new KeyValuePair <string, IEnumerable <string> >("i", new[] { "10", "10", "30", "40" }) }; var specs = new[] { new OptionSpecification(string.Empty, "stringvalue", false, string.Empty, Maybe.Nothing <int>(), Maybe.Nothing <int>(), '\0', null, string.Empty, string.Empty, new List <string>(), typeof(string), TargetType.Scalar, string.Empty, flagCounter: false, hidden: false), new OptionSpecification("i", string.Empty, false, string.Empty, Maybe.Just(3), Maybe.Just(4), '\0', null, string.Empty, string.Empty, new List <string>(), typeof(IEnumerable <int>), TargetType.Sequence, string.Empty, flagCounter: false, hidden: false) }; // Exercize system var result = TokenPartitioner.Partition( new[] { Token.Name("i"), Token.Value("10"), Token.Value("10"), Token.Value("30"), Token.Value("40") }, name => TypeLookup.FindTypeDescriptorAndSibling(name, specs, StringComparer.Ordinal) ); // Verify outcome var options = result.Item1; Assert.True(expectedSequence.All(a => options.Any(r => a.Key.Equals(r.Key) && a.Value.SequenceEqual(r.Value)))); // Teardown }
public PostgreSQLDbGenerator(TypeLookup typeLookup, EntityUtils entityUtils, PostgreSQLExecutor sqlExecutorMaster, PostgreSQLExecutor sqlExecutor) : base(entityUtils, sqlExecutorMaster, sqlExecutor) { _typeLookup = typeLookup; _sqlExecutor = sqlExecutor; _entityTypes = _entityUtils.GetEntityTypes(); }
public override void VisitCastCPPModel(CastCPPModel model) { var type = TypeLookup.LookupCPPTypeName(model.Type); var expression = Invoke <ExpressionBuilder>(model.Expression).Expression; Expression = $"({type}){expression}"; }
private bool ParseNewExpression(ref ASTNode retn) { if (tokenStream.Current != ExpressionTokenType.New) { return(false); } tokenStream.Save(); tokenStream.Advance(); TypeLookup typeLookup = new TypeLookup(); // todo -- allocates a list :( bool valid = ParseTypePath(ref typeLookup); if (!valid || tokenStream.Current != ExpressionTokenType.ParenOpen) { typeLookup.Release(); tokenStream.Restore(); return(false); } LightList <ASTNode> parameters = null; if (!ParseListExpression(ref parameters, ExpressionTokenType.ParenOpen, ExpressionTokenType.ParenClose)) { Abort(); } retn = ASTNode.NewExpressionNode(typeLookup, parameters); return(true); }
public static Type ResolveType(TypeLookup typeLookup, IReadOnlyList <string> namespaces = null, Type scopeType = null) { if (typeLookup.resolvedType != null) { return(typeLookup.resolvedType); } FilterAssemblies(); // base type will valid or an exception will be thrown Type baseType = ResolveBaseTypePath(typeLookup, namespaces); if (typeLookup.generics != null && typeLookup.generics.Count != 0) { if (!baseType.IsGenericTypeDefinition) { throw new TypeResolutionException($"{baseType} is not a generic type definition but we are trying to resolve a generic type with it because generic arguments were provided"); } baseType = ReflectionUtil.CreateGenericType(baseType, ResolveGenericTypes(typeLookup, namespaces, scopeType)); } if (typeLookup.isArray) { baseType = baseType.MakeArrayType(); } return(baseType); }
/// <summary> /// Resolves a type /// </summary> /// <param name="type">The type to resolve</param> /// <returns>The TypeScript type definition</returns> protected virtual TsType OnResolve(ITypeSymbol type) { if (TypeLookup.TryGetValue(type, out var tsType)) { return(tsType); } if (IsGuid(type)) { return(TsPrimitive.String); } else if (TypeFilter != null && !TypeFilter(type)) // should this assembly be considered? { tsType = TsPrimitive.Any; } else if (type is INamedTypeSymbol namedType && namedType.IsGenericType) { if ($"{namedType.ContainingNamespace}.{namedType.MetadataName}" == typeof(Task <>).FullName) { //Ignore the type "Task" and use the type argument instead. tsType = Resolve(namedType.TypeArguments[0]); } else { var tsGenericType = new TsGenericType(new TsName(type.Name)); foreach (var argument in namedType.TypeArguments) { var tsArgType = Resolve(argument); tsGenericType.TypeArguments.Add(tsArgType); } tsType = tsGenericType; } }
private void ReadChunk(BinaryReader br, List <BaseChunk> chunks) { // no point parsing last 8 bytes as it's either padding or an empty chunk if (br.BaseStream.Length - br.BaseStream.Position <= 8) { return; } string tag = br.ReadString(4); if (TypeLookup.ContainsKey(tag)) { br.BaseStream.Position -= 4; var chunk = (BaseChunk)Activator.CreateInstance(TypeLookup[tag], br, Version); if (Version == 0 && chunk is VERS vers) { Version = vers.Version; } chunks.Add(chunk); } else { throw new Exception($"Unknown type {tag}"); } }
static unsafe MonoObject *LookupType(TypeLookup type) { Type rv = null; switch (type) { case TypeLookup.Foundation_NSNumber: rv = typeof(Foundation.NSNumber); break; case TypeLookup.Foundation_NSValue: rv = typeof(Foundation.NSValue); break; case TypeLookup.System_String: rv = typeof(string); break; default: throw new ArgumentOutOfRangeException(nameof(type)); } log_coreclr($"LookupType ({type}) => {rv}"); return((MonoObject *)GetMonoObject(rv)); }
public override void VisitMethodCPPModel(MethodCPPModel model) { Context.Method = model; var pars = string.Join(", ", model.Parameters.Select(arg => { var pass = ""; switch (arg.Pass) { case ArgumentPassCPPModel.Ref: pass = "******"; break; case ArgumentPassCPPModel.Pointer: pass = "******"; break; case ArgumentPassCPPModel.Raw: pass = "******"; break; } return($"{TypeLookup.LookupCPPTypeName(arg.ParameterType)}{pass}{arg.Name}"); })); AppendLine($"{TypeLookup.LookupCPPTypeName(model.ReturnType)} {Context.Class.Name}::{model.Name}({pars})"); OpenBlock(); VisitChildren(model.Members); CloseBlock(); }
public static ASTNode GenericTypePath(TypeLookup genericPath) { GenericTypePathNode node = s_GenericTypePathNode.Get(); node.genericPath = genericPath; return(node); }
public bool TryGetSearchParameter(string resourceType, string code, out SearchParameterInfo searchParameter) { searchParameter = null; return(TypeLookup.TryGetValue(resourceType, out ConcurrentDictionary <string, SearchParameterInfo> searchParameters) && searchParameters.TryGetValue(code, out searchParameter)); }
private bool ParseTypeOfExpression(ref ASTNode retn) { if (tokenStream.Current != ExpressionTokenType.TypeOf || tokenStream.Next != ExpressionTokenType.ParenOpen) { return(false); } tokenStream.Advance(); int advance = tokenStream.FindMatchingIndex(ExpressionTokenType.ParenOpen, ExpressionTokenType.ParenClose); if (advance == -1) { Abort(); return(false); } tokenStream.Save(); ExpressionParser subParser = CreateSubParser(advance); TypeLookup typeLookup = new TypeLookup(); bool valid = subParser.ParseTypePath(ref typeLookup); subParser.Release(); if (!valid) { Abort(); // hard fail since typeof token has no other paths to go tokenStream.Restore(); return(false); } retn = ASTNode.TypeOfNode(typeLookup); return(true); }
public override void VisitFieldCPPModel(FieldCPPModel model) { if (model.FieldType.IsArray) { var size = ""; switch (model.Initializer) { case ArrayCreationExpressionCPPModel ac: size = Invoke <ExpressionBuilder>(ac.Rank).Expression; break; default: Unsupported(model, "Array initializer not suported"); break; } AppendLine($"{TypeLookup.LookupCPPTypeName(model.FieldType.GetElementType())} {Context.Class.Name}::{model.Name}[{size}] = {{0}};"); } else { var initializer = Invoke <ExpressionBuilder>(model.Initializer).Expression; AppendLine($"{TypeLookup.LookupCPPTypeName(model.FieldType)} {Context.Class.Name}::{model.Name} = {initializer};"); } }
public async Task Interface_With_Fragments() { // arrange var path = HotChocolate.Path.New("root"); DocumentNode document = Utf8GraphQLParser.Parse( FileResource.Open("Multiple_Fragments_Query.graphql")); var operation = document.Definitions .OfType <OperationDefinitionNode>() .First(); var field = operation.SelectionSet.Selections .OfType <FieldNode>() .First(); var query = new QueryDescriptor( "Simple_Query", "Foo.Bar.Ns", "1234", "12345", new byte[] { 1, 2, 3 }, document); var schema = SchemaBuilder.New() .AddDocumentFromString(FileResource.Open("StarWars.graphql")) .Use(next => context => Task.CompletedTask) .Create(); var context = new ModelGeneratorContext( schema, query, "StarWarsClient", "Foo.Bar.Ns"); var character = schema.GetType <InterfaceType>("Character"); // act var generator = new InterfaceModelGenerator(); generator.Generate( context, operation, character, character, field, context.CollectFields(character, field.SelectionSet, path), path); // assert var typeLookup = new TypeLookup( LanguageVersion.CSharp_8_0, CollectFieldsVisitor.MockLookup(document, context.FieldTypes), "Foo.Bar"); string output = await WriteAllAsync(context.Descriptors, typeLookup); output.MatchSnapshot(); }
/// <summary> /// /// Tries to get the card list for a given dictionary key. Generic so that the key can be suited for any of the constructed dictionaries /// /// </summary> public List <CardData> GetDictionaryList <T>(T key, CardFilter listFilter = null) { var dictionaryList = new List <CardData>(); var type = typeof(T); switch (type) { case Type _ when type == typeof(Tags): TagLookup.TryGetValue((Tags)(object)key, out dictionaryList); break; case Type _ when type == typeof(Synergies): SynergyLookup.TryGetValue((Synergies)(object)key, out dictionaryList); break; case Type _ when type == typeof(Classes.ClassList): ClassLookup.TryGetValue((Classes.ClassList)(object) key, out dictionaryList); break; case Type _ when type == typeof(ClassResources): ClassPlayableLookup.TryGetValue((ClassResources)(object)key, out dictionaryList); break; case Type _ when type == typeof(CardResources): ResourceLookup.TryGetValue((CardResources)(object)key, out dictionaryList); break; case Type _ when type == typeof(Sets): SetLookup.TryGetValue((Sets)(object)key, out dictionaryList); break; case Type _ when type == typeof(Rarity): RarityLookup.TryGetValue((Rarity)(object)key, out dictionaryList); break; case Type _ when type == typeof(CardTypes): TypeLookup.TryGetValue((CardTypes)(object)key, out dictionaryList); break; default: throw new Exception("Not a valid Dictionary Type"); } if (dictionaryList != null) { if (listFilter != null) { return(FilterCardList(dictionaryList.OrderCardList(), listFilter)); } else { return(dictionaryList.OrderCardList()); } } else { return(new List <CardData>()); } }
public static TypeNode TypeOfNode(TypeLookup typeLookup) { TypeNode typeOfNode = s_TypeNodePool.Get(); typeOfNode.typeLookup = typeLookup; typeOfNode.type = ASTNodeType.TypeOf; return(typeOfNode); }
public static UnaryExpressionNode DirectCastNode(TypeLookup typeLookup, ASTNode expression) { UnaryExpressionNode unaryNode = s_UnaryNodePool.Get(); unaryNode.type = ASTNodeType.DirectCast; unaryNode.typeLookup = typeLookup; unaryNode.expression = expression; return(unaryNode); }
public IEnumerable <SearchParameterInfo> GetSearchParameters(string resourceType) { if (TypeLookup.TryGetValue(resourceType, out ConcurrentDictionary <string, SearchParameterInfo> value)) { return(value.Values); } throw new ResourceNotSupportedException(resourceType); }
public static NewExpressionNode NewExpressionNode(TypeLookup typeLookup, LightList <ASTNode> parameters) { NewExpressionNode retn = s_NewExpressionNodePool.Get(); retn.typeLookup = typeLookup; retn.parameters = parameters; retn.type = ASTNodeType.New; return(retn); }
public SearchParameterInfo GetSearchParameter(string resourceType, string code) { if (TypeLookup.TryGetValue(resourceType, out ConcurrentDictionary <string, SearchParameterInfo> lookup) && lookup.TryGetValue(code, out SearchParameterInfo searchParameter)) { return(searchParameter); } throw new SearchParameterNotSupportedException(resourceType, code); }
public void ResolveArrayType() { TypeLookup lookup = new TypeLookup(); lookup.typeName = "String"; lookup.namespaceName = "System"; lookup.isArray = true; Type t = TypeProcessor.ResolveType(lookup); Assert.AreEqual(typeof(string[]), t); }
private void AddAdditionalTypesAsKnown(params Tuple <Type, TsPrimitive>[] typesToBeAdded) { foreach (var type in typesToBeAdded) { var typeByMetadata = _compilation.GetTypeByMetadataName(type.Item1.FullName); if (typeByMetadata != null) { TypeLookup.Add(typeByMetadata, type.Item2); } } }
public XsdtPrimitiveDataType GetDataType(Type t) { if (TypeLookup.ContainsValue(t)) { return((from x in TypeLookup where x.Value == t select x.Key).FirstOrDefault()); } else { return(XsdtPrimitiveDataType.XsdtUnknown); } }
public override void VisitFieldCPPModel(FieldCPPModel model) { if (model.FieldType.IsArray) { AppendLine($"{CPPModelTools.Modifiers(model.Modifiers)} {TypeLookup.LookupCPPTypeName(model.FieldType.GetElementType())} {model.Name}[];"); } else { AppendLine($"{CPPModelTools.Modifiers(model.Modifiers)} {TypeLookup.LookupCPPTypeName(model.FieldType)} {model.Name};"); } }
private static CoreType GetUnderlyingType(Type type) { return(underlyingTypes.GetOrAdd(type, (t) => { if (!TypeLookup.CoreTypeLookup(Enum.GetUnderlyingType(t), out CoreType underlyingType)) { throw new NotImplementedException("Should not happen"); } return underlyingType; })); }
static bool IsClassOfType(Type type, TypeLookup match) { var rv = false; switch (match) { case TypeLookup.System_Array: rv = type.IsArray; break; case TypeLookup.System_String: rv = type == typeof(System.String); break; case TypeLookup.System_IntPtr: rv = type == typeof(System.IntPtr); break; case TypeLookup.Foundation_NSNumber: rv = typeof(Foundation.NSNumber).IsAssignableFrom(type); break; case TypeLookup.Foundation_NSObject: rv = typeof(Foundation.NSObject).IsAssignableFrom(type); break; case TypeLookup.Foundation_NSString: rv = typeof(Foundation.NSString).IsAssignableFrom(type); break; case TypeLookup.Foundation_NSValue: rv = typeof(Foundation.NSValue).IsAssignableFrom(type); break; case TypeLookup.ObjCRuntime_INativeObject: rv = typeof(ObjCRuntime.INativeObject).IsAssignableFrom(type); break; case TypeLookup.ObjCRuntime_NativeHandle: rv = typeof(ObjCRuntime.NativeHandle).IsAssignableFrom(type); break; default: throw new ArgumentOutOfRangeException(nameof(type)); } log_coreclr($"IsClassOfType ({type}, {match}) => {rv}"); return(rv); }
public static bool TryParseTypeName(string typeName, out TypeLookup typeLookup) { StructList <ExpressionToken> list = StructList <ExpressionToken> .Get(); ExpressionTokenizer.Tokenize(typeName, list); ExpressionParser parser = new ExpressionParser(new TokenStream(list)); typeLookup = default; bool valid = parser.ParseTypePath(ref typeLookup); parser.Release(); list.Release(); return(valid); }
protected StandardRepository(TypeLookup typeLookup, SQLConstants sqlConstants, EntityUtils entityUtils, ExpressionUtils expressionUtils, ISQLExecutor <TCommand, TConnection, TParameter> sqlExecutor, List <string> updateableFields = null) { _typeLookup = typeLookup; _sqlConstants = sqlConstants; _entityUtils = entityUtils; _expressionUtils = expressionUtils; SQLExecutor = sqlExecutor; UpdateableFields = updateableFields; var entityType = typeof(T); Fields = _entityUtils.GetProperties(entityType); BaseFields = _entityUtils.GetBaseProperties(); }