public NamesStorage(INameValidation nameValidation, INameConverter nameConverter, INameSorter nameSorter) { _nameValidation = nameValidation; _nameConverter = nameConverter; _names = new List <Name>(); _nameSorter = nameSorter; }
public ISchema build_schema(INameConverter converter = null, string argument = "Id") { var schema = new Schema { NameConverter = converter ?? CamelCaseNameConverter.Instance }; var person = new ObjectGraphType { Name = "Person" }; person.Field("Name", new StringGraphType()); var query = new ObjectGraphType { Name = "Query" }; query.Field( "PeRsoN", person, arguments: new QueryArguments(new QueryArgument <StringGraphType> { Name = argument }), resolve: ctx => new Person { Name = "Quinn" }); schema.Query = query; return(schema); }
private SchemaTypes(ISchema schema) { _introspectionTypes = CreateIntrospectionTypes(schema.Features.AppliedDirectives, schema.Features.RepeatableDirectives); _context = new TypeCollectionContext( type => BuildNamedType(type, t => _builtInScalars.TryGetValue(t, out var graphType) ? graphType : _introspectionTypes.TryGetValue(t, out graphType) ? graphType : (IGraphType)Activator.CreateInstance(t)), (name, type, ctx) => { lock (_lock) { SetGraphType(name, type); } ctx.AddType(name, type, null); }); // Add introspection types. Note that introspection types rely on the // CamelCaseNameConverter, as some fields are defined in pascal case - e.g. Field(x => x.Name) _nameConverter = CamelCaseNameConverter.Instance; foreach (var introspectionType in _introspectionTypes.Values) { AddType(introspectionType, _context); } // set the name converter properly _nameConverter = schema.NameConverter ?? CamelCaseNameConverter.Instance; }
public GraphTypesLookup(INameConverter nameConverter) { if (nameConverter == null) { throw new ArgumentNullException(nameof(nameConverter)); } _context = new TypeCollectionContext( type => BuildNamedType(type, t => _builtInScalars.TryGetValue(t, out var graphType) ? graphType : _introspectionTypes.TryGetValue(t, out graphType) ? graphType : (IGraphType)Activator.CreateInstance(t)), (name, type, ctx) => { string trimmed = name.TrimGraphQLTypes(); lock (_lock) { SetGraphType(trimmed, type); } ctx.AddType(trimmed, type, null); }); // Add introspection types. Note that introspection types rely on the // CamelCaseNameConverter, as some fields are defined in pascal case - e.g. Field(x => x.Name) NameConverter = CamelCaseNameConverter.Instance; foreach (var introspectionType in _introspectionTypes.Values) { AddType(introspectionType, _context); } // set the name converter properly NameConverter = nameConverter; }
/// <summary> /// Initalizes a new instance with the specified <see cref="INameConverter"/>. /// </summary> public GraphTypesLookup(INameConverter nameConverter) { #pragma warning disable IDE0016 // Use 'throw' expression; if this rule is applied here, then the null check is moved to the very end of the method - this is not what we want if (nameConverter == null) { throw new ArgumentNullException(nameof(nameConverter)); } #pragma warning restore IDE0016 _context = new TypeCollectionContext( type => BuildNamedType(type, t => _builtInScalars.TryGetValue(t, out var graphType) ? graphType : _introspectionTypes.TryGetValue(t, out graphType) ? graphType : (IGraphType)Activator.CreateInstance(t)), (name, type, ctx) => { string trimmed = name.TrimGraphQLTypes(); lock (_lock) { SetGraphType(trimmed, type); } ctx.AddType(trimmed, type, null); }); // Add introspection types. Note that introspection types rely on the // CamelCaseNameConverter, as some fields are defined in pascal case - e.g. Field(x => x.Name) NameConverter = CamelCaseNameConverter.Instance; foreach (var introspectionType in _introspectionTypes.Values) { AddType(introspectionType, _context); } // set the name converter properly NameConverter = nameConverter; }
public DictService(IDictFor dictFor, INameConverter nameConverter, DictSettings settings) { _dictFor = dictFor; _db = DBFactory.CreateDBHelper("Default"); _db.DbNameConverter = null; //不转换字典sql中输出的字段名 _nameConverter = nameConverter; _settings = settings; }
public ValueOperation( [NotNull] Expression expression, [NotNull] string name, [NotNull] ISqlDialect dialect, [NotNull] INameConverter nameConverter ) : base(name, dialect, nameConverter) { _expression = expression ?? throw new ArgumentNullException(nameof(expression)); }
public NotOperation( [NotNull] IAssigmentOperation assigmentOperation, [NotNull] string name, [NotNull] ISqlDialect dialect, [NotNull] INameConverter nameConverter ) : base(name, dialect, nameConverter) { _operation = assigmentOperation ?? throw new ArgumentNullException(nameof(assigmentOperation)); }
/// <summary> /// Initializes a new instance for the specified graph types and directives, and with the specified type resolver and name converter. /// </summary> /// <param name="types">A list of graph type instances to register in the lookup table.</param> /// <param name="directives">A list of directives to register.</param> /// <param name="resolveType">A delegate which returns an instance of a graph type from its .NET type.</param> /// <param name="nameConverter">A name converter to use for the specified graph types.</param> /// <param name="seal">Prevents additional types from being added to the lookup table.</param> public static GraphTypesLookup Create( IEnumerable <IGraphType> types, IEnumerable <DirectiveGraphType> directives, Func <Type, IGraphType> resolveType, INameConverter nameConverter, bool seal = false) { var lookup = nameConverter == null ? new GraphTypesLookup() : new GraphTypesLookup(nameConverter); var ctx = new TypeCollectionContext(t => lookup._builtInScalars.TryGetValue(t, out var graphType) ? graphType : resolveType(t), (name, graphType, context) => { if (lookup[name] == null) { lookup.AddType(graphType, context); } }); foreach (var type in types) { lookup.AddType(type, ctx); } // these fields must not have their field names translated by INameConverter; see HandleField lookup.HandleField(null, lookup.SchemaMetaFieldType, ctx, false); lookup.HandleField(null, lookup.TypeMetaFieldType, ctx, false); lookup.HandleField(null, lookup.TypeNameMetaFieldType, ctx, false); foreach (var directive in directives) { if (directive.Arguments == null) { continue; } foreach (var arg in directive.Arguments) { if (arg.ResolvedType != null) { lookup.AddTypeIfNotRegistered(arg.ResolvedType, ctx); arg.ResolvedType = lookup.ConvertTypeReference(directive, arg.ResolvedType); } else { lookup.AddTypeIfNotRegistered(arg.Type, ctx); arg.ResolvedType = lookup.BuildNamedType(arg.Type, ctx.ResolveType); } } } lookup.ApplyTypeReferences(); Debug.Assert(ctx.InFlightRegisteredTypes.Count == 0); lookup._sealed = seal; return(lookup); }
public ParameterRefOperation( [NotNull] MemberExpression expression, [NotNull] ISqlDialect dialect, [NotNull] INameConverter nameConverter ) : base(dialect) { _expression = expression ?? throw new ArgumentNullException(nameof(expression)); _nameConverter = nameConverter ?? throw new ArgumentNullException(nameof(nameConverter)); if (_expression.Expression.NodeType != ExpressionType.Parameter) { throw new ArgumentException($"Invalid expression type {_expression.Expression.NodeType}", nameof(expression)); } }
private static string ConvertDirectoryName(string path, INameConverter converter) { string parentDirPath = Path.GetDirectoryName(path); if (parentDirPath == null) { throw new Exception("Invalid path to convert!"); } string dirName = Path.GetFileName(path); return(Path.Combine(parentDirPath, converter.Convert(dirName))); }
/// <summary> /// Sincronizza la strutture delle directory di 2 folder. /// Specchio da sorgente --> destinazione. /// </summary> public static void SyncFolderStructure(string sourceFolderPath, string destinationFolderPath, bool canCreateDestination = false, INameConverter nameConverter = null) { INameConverter converter = nameConverter ?? new IdentityNameConverter(); if (Directory.Exists(sourceFolderPath) == false) { throw new Exception("Source directory not exist!"); } string destPath = ConvertDirectoryName(destinationFolderPath, converter); if (Directory.Exists(destPath) == false) { if (canCreateDestination == false) { throw new Exception("Destination directory not exist!"); } else { Directory.CreateDirectory(destPath); } } // Recurse into subdirectories of this directory. List <string> sourceDirectories = Directory.EnumerateDirectories(sourceFolderPath).ToList(); foreach (var dir in sourceDirectories) { string directoryName = Path.GetFileName(dir); if (directoryName == null) { continue; } SyncFolderStructure(dir, Path.Combine(destinationFolderPath, directoryName), true, converter); } // Dopo aver generato tutto elimino le cartelle che non centrano nulla List <string> newDirectories = Directory.EnumerateDirectories(destPath).ToList(); List <string> localFolderDirectoriesName = sourceDirectories.Select(Path.GetFileName).Select(name => converter.Convert(name)).ToList(); foreach (var dir in newDirectories) { bool exists = localFolderDirectoriesName.Contains(Path.GetFileName(dir)); if (exists == false) { Directory.Delete(dir); } } }
public NotOperation( [NotNull] UnaryExpression expression, [NotNull] string name, [NotNull] ISqlDialect dialect, [NotNull] INameConverter nameConverter, [NotNull] AssigmentParseHelpers assigmentParseHelpers ) : base(name, dialect, nameConverter) { if (expression == null) { throw new ArgumentNullException(nameof(expression)); } _operation = assigmentParseHelpers.ParseExpression(expression.Operand.UnwrapConvert(), name, true); }
public BinaryOperation( [NotNull] BinaryExpression expression, [NotNull] Expression originalExpression, [NotNull] string name, [NotNull] ISqlDialect dialect, [NotNull] AssigmentParseHelpers assigmentParseHelpers, [NotNull] INameConverter nameConverter, bool skipBrackets ) : base(name, dialect, nameConverter) { _expression = expression ?? throw new ArgumentNullException(nameof(expression)); _originalExpression = originalExpression ?? throw new ArgumentNullException(nameof(originalExpression)); _skipBrackets = skipBrackets; _left = assigmentParseHelpers.ParseExpression(_expression.Left, name); _right = assigmentParseHelpers.ParseExpression(_expression.Right, name); }
/// <inheritdoc /> public CustomColumnOperation( [NotNull] MethodCallExpression expression, [NotNull] ISqlDialect dialect, [NotNull] INameConverter nameConverter, [NotNull] AssigmentParseHelpers assigmentParseHelpers ) : base(null, dialect, nameConverter) { if (expression == null) { throw new ArgumentNullException(nameof(expression)); } Name = expression.Arguments[1].NodeType == ExpressionType.Constant ? ((ConstantExpression)expression.Arguments[1]).Value as string : throw new InvalidOperationException(); _operation = assigmentParseHelpers.ParseExpression(expression.Arguments[2], Name, true); }
public GraphTypesLookup(INameConverter nameConverter) { if (nameConverter == null) { throw new ArgumentNullException(nameof(nameConverter)); } // standard scalars https://graphql.github.io/graphql-spec/June2018/#sec-Scalars AddType <StringGraphType>(); AddType <BooleanGraphType>(); AddType <FloatGraphType>(); AddType <IntGraphType>(); AddType <IdGraphType>(); // .NET custom scalars AddType <DateGraphType>(); AddType <DateTimeGraphType>(); AddType <DateTimeOffsetGraphType>(); AddType <TimeSpanSecondsGraphType>(); AddType <TimeSpanMillisecondsGraphType>(); AddType <DecimalGraphType>(); AddType <UriGraphType>(); AddType <GuidGraphType>(); AddType <ShortGraphType>(); AddType <UShortGraphType>(); AddType <UIntGraphType>(); AddType <LongGraphType>(); AddType <BigIntGraphType>(); AddType <ULongGraphType>(); AddType <ByteGraphType>(); AddType <SByteGraphType>(); // Add introspection types. Note that introspection types rely on the // CamelCaseNameConverter, as some fields are defined in pascal case - e.g. Field(x => x.Name) NameConverter = CamelCaseNameConverter.Instance; AddType <__Schema>(); AddType <__Type>(); AddType <__Directive>(); AddType <__Field>(); AddType <__EnumValue>(); AddType <__InputValue>(); AddType <__TypeKind>(); // set the name converter properly NameConverter = nameConverter; }
public SqlGenerator( [NotNull] ISqlDialect dialect, [NotNull] INameConverter nameConverter, [CanBeNull] ILoggerFactory loggerFactory ) { if (dialect == null) { throw new ArgumentNullException(nameof(dialect)); } if (nameConverter == null) { throw new ArgumentNullException(nameof(nameConverter)); } _dialect = dialect; _logger = loggerFactory?.CreateLogger <SqlGenerator>(); _filterParseHelpers = new FilterParseHelpers(_dialect, nameConverter); _assigmentParseHelpers = new AssigmentParseHelpers(_dialect, nameConverter); }
/// <summary> /// Initializes a new instance for the specified schema, and with the specified type resolver. /// </summary> /// <param name="schema">A schema for which this instance is created.</param> /// <param name="serviceProvider">A service provider used to resolve graph types.</param> public SchemaTypes(ISchema schema, IServiceProvider serviceProvider) { if (schema == null) { throw new ArgumentNullException(nameof(schema)); } if (serviceProvider == null) { throw new ArgumentNullException(nameof(serviceProvider)); } var types = GetSchemaTypes(schema, serviceProvider); var typeMappingsEnumerable = schema.TypeMappings ?? throw new ArgumentNullException(nameof(schema) + "." + nameof(ISchema.TypeMappings)); var typeMappings = typeMappingsEnumerable is List <(Type, Type)> typeMappingsList ? typeMappingsList : typeMappingsEnumerable.ToList(); var directives = schema.Directives ?? throw new ArgumentNullException(nameof(schema) + "." + nameof(ISchema.Directives)); _typeDictionary = new Dictionary <Type, IGraphType>(); _introspectionTypes = CreateIntrospectionTypes(schema.Features.AppliedDirectives, schema.Features.RepeatableDirectives); _context = new TypeCollectionContext( type => BuildNamedType(type, t => _builtInScalars.TryGetValue(t, out var graphType) ? graphType : _introspectionTypes.TryGetValue(t, out graphType) ? graphType : (IGraphType)Activator.CreateInstance(t)), (name, type, ctx) => { SetGraphType(name, type); ctx.AddType(name, type, null); }, typeMappings); // Add manually-added scalar types. To allow overriding of built-in scalars, these must be added // prior to adding any other types (including introspection types). foreach (var type in types) { if (type is ScalarGraphType) { AddType(type, _context); } } // Add introspection types. Note that introspection types rely on the // CamelCaseNameConverter, as some fields are defined in pascal case - e.g. Field(x => x.Name) _nameConverter = CamelCaseNameConverter.Instance; foreach (var introspectionType in _introspectionTypes.Values) { AddType(introspectionType, _context); } // set the name converter properly _nameConverter = schema.NameConverter ?? CamelCaseNameConverter.Instance; var ctx = new TypeCollectionContext( t => _builtInScalars.TryGetValue(t, out var graphType) ? graphType : (IGraphType)serviceProvider.GetRequiredService(t), (name, graphType, context) => { if (this[name] == null) { AddType(graphType, context); } }, typeMappings); foreach (var type in types) { if (!(type is ScalarGraphType)) { AddType(type, ctx); } } // these fields must not have their field names translated by INameConverter; see HandleField HandleField(null, SchemaMetaFieldType, ctx, false); HandleField(null, TypeMetaFieldType, ctx, false); HandleField(null, TypeNameMetaFieldType, ctx, false); foreach (var directive in directives) { if (directive.Arguments?.Count > 0) { foreach (var arg in directive.Arguments.List) { if (arg.ResolvedType != null) { AddTypeIfNotRegistered(arg.ResolvedType, ctx); arg.ResolvedType = ConvertTypeReference(directive, arg.ResolvedType); } else { AddTypeIfNotRegistered(arg.Type, ctx); arg.ResolvedType = BuildNamedType(arg.Type, ctx.ResolveType); } } } } ApplyTypeReferences(); Debug.Assert(ctx.InFlightRegisteredTypes.Count == 0); _typeDictionary = null; }
public void Initialize() { _nameConverter = new DefaultNameConverter(); }
public ConditionConverter(INameConverter nameConverter, IValueConverter valueConverter) { NameConverter = nameConverter; ValueConverter = valueConverter; }
public ConditionConverter(INameConverter nameConvertor, IValueConverter valueConverter) : base(nameConvertor, valueConverter) { }
public CodeState(INameConverter inConverter, List <string> inUsingList) { _converter = inConverter; _usingList = inUsingList; }
public static SyncInfo SyncFolderStructureUsingNamespace(Assembly assembly, string destinationFolderPath, INameConverter nameConverter = null) { INameConverter converter = nameConverter ?? (INameConverter) new IdentityNameConverter(); string destPath = destinationFolderPath; if (Directory.Exists(destPath) == false) { Directory.CreateDirectory(destPath); } // Create a directory for each namespace List <string> namespaces = assembly.GetNamespaces().ToList(); // Mapping fra un tipo e la sua locazione nel disco Dictionary <Type, string> typeToFolder = new Dictionary <Type, string>(); // Mapping fra un path ed una lista di tipi Dictionary <string, List <Type> > folderToTypes = new Dictionary <string, List <Type> >(); List <string> allNewFolders = new List <string>(); char[] separator = { '.' }; StringBuilder pathBuilder = new StringBuilder(); foreach (string ns in namespaces) { string[] nsFolders = ns.Split(separator); pathBuilder.Clear(); pathBuilder.Append(destPath); foreach (string folder in nsFolders) { pathBuilder.Append(Path.DirectorySeparatorChar).Append(converter.Convert(folder)); } string path = pathBuilder.ToString(); // Calling Create() will not error if the path already exists. if (Directory.Exists(path) == false) { Directory.CreateDirectory(path); } // Add the path to the all folders list allNewFolders.Add(path); // Mappo i tipi con la cartella e viceversa List <Type> typesInFolder = assembly.GetTypesInNamespace(ns).ToList(); foreach (Type t in typesInFolder) { typeToFolder.Add(t, path); } folderToTypes.Add(path, typesInFolder); } // Dopo aver generato tutto elimino le cartelle che non centrano nulla List <string> newDirectories = GetAllSubfoldersPaths(destinationFolderPath); foreach (var dir in newDirectories) { bool exists = allNewFolders.Contains(dir) || allNewFolders.Any(f => f.StartsWith(dir)); if (exists == false) { Directory.Delete(dir); } } // Ritorno il risultato del mapping return(new SyncInfo(destPath, allNewFolders, folderToTypes, typeToFolder)); }
protected AssigmentOperationBase(string name, [NotNull] ISqlDialect dialect, [NotNull] INameConverter nameConverter) { Name = name; _nameConverter = nameConverter ?? throw new ArgumentNullException(nameof(nameConverter)); Dialect = dialect ?? throw new ArgumentNullException(nameof(dialect)); }
// ReSharper restore MemberCanBePrivate.Global public SqlConverter(INameConverter newNameConverter, IValueConverter newValueConverter, IConditionConverter newConditionConverter) { _nameConverter = newNameConverter; _valueConverter = newValueConverter; _conditionConverter = newConditionConverter; }
// ReSharper disable MemberCanBePrivate.Global protected SqlConverter(INameConverter nameConverter, IValueConverter valueConverter, IConditionConverter conditionConverter = null) // ReSharper restore MemberCanBePrivate.Global : base(nameConverter, valueConverter, conditionConverter) { }
protected SqlConverter(INameConverter nameConverter, IValueConverter valueConverter, IConditionConverter conditionConverter = null) : base(nameConverter, valueConverter, conditionConverter ?? new ConditionConverter(nameConverter, valueConverter)) { }
public IImmutableDictionary <string, object> GetUpdates(INameConverter nameConverter) => _set.ToImmutableDictionary( prop => nameConverter.GetName(prop), prop => Property.Get(prop, _proxy));