protected virtual FileSystemSearch CreateSearch()
{
var filter = new FileSystemFilter(
name: Options.NameFilter,
part: Options.NamePart,
extension: Options.ExtensionFilter,
content: Options.ContentFilter,
properties: Options.FilePropertyFilter,
attributes: Options.Attributes,
attributesToSkip: Options.AttributesToSkip,
emptyOption: Options.EmptyOption);
NameFilter?directoryFilter = null;
if (Options.DirectoryFilter != null)
{
directoryFilter = new NameFilter(
name: Options.DirectoryFilter,
part: Options.DirectoryNamePart);
}
var options = new FileSystemSearchOptions(
searchTarget: Options.SearchTarget,
recurseSubdirectories: Options.RecurseSubdirectories,
defaultEncoding: Options.DefaultEncoding);
return(new FileSystemSearch(
filter: filter,
directoryFilter: directoryFilter,
searchProgress: ProgressReporter,
options: options));
}
internal sealed override IEnumerable <PropertyInfo> SpecializeProperties(NameFilter?filter, Type reflectedType, RoInstantiationProviderType declaringType)
{
MetadataReader reader = Reader;
foreach (PropertyDefinitionHandle handle in TypeDefinition.GetProperties())
{
if (filter == null || filter.Matches(handle.GetPropertyDefinition(reader).Name, reader))
{
yield return(new EcmaProperty(declaringType, handle, reflectedType));
}
}
}
internal sealed override IEnumerable <RoType> GetNestedTypesCore(NameFilter?filter)
{
MetadataReader reader = Reader;
foreach (TypeDefinitionHandle handle in TypeDefinition.GetNestedTypes())
{
TypeDefinition nestedTypeDefinition = handle.GetTypeDefinition(reader);
if (filter == null || filter.Matches(nestedTypeDefinition.Name, reader))
{
yield return(handle.ResolveTypeDef(GetEcmaModule()));
}
}
}
internal sealed override IEnumerable <MethodInfo> SpecializeMethods(NameFilter?filter, Type reflectedType, RoInstantiationProviderType declaringType)
{
MetadataReader reader = Reader;
foreach (MethodDefinitionHandle handle in TypeDefinition.GetMethods())
{
MethodDefinition methodDefinition = handle.GetMethodDefinition(reader);
if (filter == null || filter.Matches(methodDefinition.Name, reader))
{
if (!methodDefinition.IsConstructor(reader))
{
yield return(new RoDefinitionMethod <EcmaMethodDecoder>(declaringType, reflectedType, new EcmaMethodDecoder(handle, GetEcmaModule())));
}
}
}
}
public FileSystemSearch(
FileSystemFilter filter,
NameFilter?directoryFilter = null,
IProgress <SearchProgress>?searchProgress = null,
FileSystemSearchOptions?options = null)
{
Filter = filter ?? throw new ArgumentNullException(nameof(filter));
if (directoryFilter?.Part == FileNamePart.Extension)
{
throw new ArgumentException($"Directory filter has invalid part '{FileNamePart.Extension}'.", nameof(directoryFilter));
}
DirectoryFilter = directoryFilter;
SearchProgress = searchProgress;
Options = options ?? FileSystemSearchOptions.Default;
}
internal sealed override IEnumerable <MethodInfo> GetMethodsCore(NameFilter?filter, Type reflectedType)
{
int rank = _rank;
int uniquifier = 0;
RoType systemInt32 = Loader.GetCoreType(CoreType.Int32);
RoType elementType = GetRoElementType();
RoType systemVoid = Loader.GetCoreType(CoreType.Void);
if (filter == null || filter.Matches("Get"))
{
RoType[] getParameters = new RoType[rank];
for (int i = 0; i < rank; i++)
{
getParameters[i] = systemInt32;
}
yield return(new RoSyntheticMethod(this, uniquifier++, "Get", elementType, getParameters));
}
if (filter == null || filter.Matches("Set"))
{
RoType[] setParameters = new RoType[rank + 1];
for (int i = 0; i < rank; i++)
{
setParameters[i] = systemInt32;
}
setParameters[rank] = elementType;
yield return(new RoSyntheticMethod(this, uniquifier++, "Set", systemVoid, setParameters));
}
if (filter == null || filter.Matches("Address"))
{
RoType[] addressParameters = new RoType[rank];
for (int i = 0; i < rank; i++)
{
addressParameters[i] = systemInt32;
}
yield return(new RoSyntheticMethod(this, uniquifier++, "Address", elementType.GetUniqueByRefType(), addressParameters));
}
}
internal abstract IEnumerable <FieldInfo> GetFieldsCore(NameFilter?filter, Type reflectedType);
internal abstract IEnumerable <MethodInfo> GetMethodsCore(NameFilter?filter, Type reflectedType);
internal abstract IEnumerable <EventInfo> GetEventsCore(NameFilter?filter, Type reflectedType);
// // Returns all of the directly declared members on the given TypeInfo whose name matches filter. If filter is null, // returns all directly declared members. // public abstract IEnumerable <M> CoreGetDeclaredMembers(RuntimeTypeInfo type, NameFilter?filter, RuntimeTypeInfo reflectedType);
// Low level support for the BindingFlag-driven enumerator apis. These return members declared (not inherited) on the current // type, possibly doing case-sensitive/case-insensitive filtering on a supplied name. internal abstract IEnumerable <ConstructorInfo> GetConstructorsCore(NameFilter?filter);
public sealed override IEnumerable <ConstructorInfo> CoreGetDeclaredMembers(RuntimeTypeInfo type, NameFilter?filter, RuntimeTypeInfo reflectedType)
{
Debug.Assert(reflectedType.Equals(type)); // Constructor queries are always performed as if BindingFlags.DeclaredOnly are set so the reflectedType should always be the declaring type.
return(type.GetConstructorsCore(filter));
}
public sealed override IEnumerable <EventInfo> CoreGetDeclaredMembers(RuntimeTypeInfo type, NameFilter?filter, RuntimeTypeInfo reflectedType)
{
return(type.GetEventsCore(filter, reflectedType));
}
// Low level support for the BindingFlag-driven enumerator apis. internal sealed override IEnumerable <ConstructorInfo> GetConstructorsCore(NameFilter?filter) => _genericTypeDefinition.SpecializeConstructors(filter, this);
internal sealed override IEnumerable <PropertyInfo> GetPropertiesCore(NameFilter?filter, Type reflectedType) => _genericTypeDefinition.SpecializeProperties(filter, reflectedType, this);
internal sealed override IEnumerable <FieldInfo> GetFieldsCore(NameFilter?filter, Type reflectedType) => throw null !;
internal sealed override IEnumerable <PropertyInfo> GetPropertiesCore(NameFilter?filter, Type reflectedType) => throw null !;
internal sealed override IEnumerable <EventInfo> GetEventsCore(NameFilter?filter, Type reflectedType) => throw null !;
// Low level support for the BindingFlag-driven enumerator apis. internal sealed override IEnumerable <ConstructorInfo> GetConstructorsCore(NameFilter?filter) => throw null !;
internal sealed override IEnumerable <PropertyInfo> SpecializeProperties(NameFilter?filter, Type reflectedType, RoInstantiationProviderType declaringType) => throw null !;
internal abstract IEnumerable <PropertyInfo> GetPropertiesCore(NameFilter?filter, Type reflectedType);
internal sealed override IEnumerable <ConstructorInfo> SpecializeConstructors(NameFilter?filter, RoInstantiationProviderType declaringType) => throw null !;
internal abstract IEnumerable <RoType> GetNestedTypesCore(NameFilter?filter);
/// <summary>
/// Process schema-related options.
/// </summary>
/// <param name="options">All specified options.</param>
/// <param name="settings">Schema settings to configure.</param>
private static void ProcessSchemaOptions(Dictionary <CliOption, object?> options, Scaffold.SchemaOptions settings)
{
// objects to load
if (options.Remove(SchemaOptions.LoadedObjects, out var value))
{
var objects = SchemaObjects.None;
foreach (var strVal in (string[])value !)
{
switch (strVal)
{
case "table": objects |= SchemaObjects.Table; break;
case "view": objects |= SchemaObjects.View; break;
case "foreign-key": objects |= SchemaObjects.ForeignKey; break;
case "stored-procedure": objects |= SchemaObjects.StoredProcedure; break;
case "scalar-function": objects |= SchemaObjects.ScalarFunction; break;
case "table-function": objects |= SchemaObjects.TableFunction; break;
case "aggregate-function": objects |= SchemaObjects.AggregateFunction; break;
}
}
settings.LoadedObjects = objects;
}
// include/exclude schemas
if (options.Remove(SchemaOptions.IncludedSchemas, out value))
{
settings.IncludeSchemas = true;
foreach (var strVal in (string[])value !)
{
settings.Schemas.Add(strVal);
}
}
else if (options.Remove(SchemaOptions.ExcludedSchemas, out value))
{
settings.IncludeSchemas = false;
foreach (var strVal in (string[])value !)
{
settings.Schemas.Add(strVal);
}
}
// include/exclude catalogs
if (options.Remove(SchemaOptions.IncludedCatalogs, out value))
{
settings.IncludeCatalogs = true;
foreach (var strVal in (string[])value !)
{
settings.Catalogs.Add(strVal);
}
}
else if (options.Remove(SchemaOptions.ExcludedCatalogs, out value))
{
settings.IncludeCatalogs = false;
foreach (var strVal in (string[])value !)
{
settings.Catalogs.Add(strVal);
}
}
// simple flags
if (options.Remove(SchemaOptions.PreferProviderTypes, out value))
{
settings.PreferProviderSpecificTypes = (bool)value !;
}
if (options.Remove(SchemaOptions.IgnoreDuplicateFKs, out value))
{
settings.IgnoreDuplicateForeignKeys = (bool)value !;
}
if (options.Remove(SchemaOptions.UseSafeSchemaLoadOnly, out value))
{
settings.UseSafeSchemaLoad = (bool)value !;
}
if (options.Remove(SchemaOptions.LoadDatabaseName, out value))
{
settings.LoadDatabaseName = (bool)value !;
}
if (options.Remove(SchemaOptions.LoadProcedureSchema, out value))
{
settings.LoadProceduresSchema = (bool)value !;
}
if (options.Remove(SchemaOptions.EnableSqlServerReturnValue, out value))
{
settings.EnableSqlServerReturnValue = (bool)value !;
}
// table/view filter delegate
var includeTables = false;
var includeViews = false;
NameFilter?tableFilter = null;
NameFilter?viewFilter = null;
if (options.Remove(SchemaOptions.IncludedTables, out value))
{
includeTables = true;
tableFilter = (NameFilter)value !;
}
else if (options.Remove(SchemaOptions.ExcludedTables, out value))
{
includeTables = false;
tableFilter = (NameFilter)value !;
}
if (options.Remove(SchemaOptions.IncludedViews, out value))
{
includeViews = true;
viewFilter = (NameFilter)value !;
}
else if (options.Remove(SchemaOptions.ExcludedViews, out value))
{
includeViews = false;
viewFilter = (NameFilter)value !;
}
if (tableFilter != null || viewFilter != null)
{
settings.LoadTableOrView = (name, isView) =>
{
if (!isView && tableFilter != null)
{
return(tableFilter.ApplyTo(name.Schema, name.Name) == includeTables);
}
if (isView && viewFilter != null)
{
return(viewFilter.ApplyTo(name.Schema, name.Name) == includeViews);
}
return(true);
};
}
// procedure schema load filter
if (options.Remove(SchemaOptions.ProceduresWithSchema, out value))
{
var filter = (NameFilter)value !;
settings.LoadProcedureSchema = name => filter.ApplyTo(name.Schema, name.Name);
}
else if (options.Remove(SchemaOptions.ProceduresWithoutSchema, out value))
{
var filter = (NameFilter)value !;
settings.LoadProcedureSchema = name => !filter.ApplyTo(name.Schema, name.Name);
}
// table function filter
if (options.Remove(SchemaOptions.IncludedTableFunctions, out value))
{
var filter = (NameFilter)value !;
settings.LoadTableFunction = name => filter.ApplyTo(name.Schema, name.Name);
}
else if (options.Remove(SchemaOptions.ExcludedTableFunctions, out value))
{
var filter = (NameFilter)value !;
settings.LoadTableFunction = name => !filter.ApplyTo(name.Schema, name.Name);
}
}
internal sealed override IEnumerable <RoType> GetNestedTypesCore(NameFilter?filter) => throw null !;
public sealed override IEnumerable <PropertyInfo> CoreGetDeclaredMembers(RuntimeTypeInfo type, NameFilter?optionalNameFilter, RuntimeTypeInfo reflectedType)
{
return(type.CoreGetDeclaredProperties(optionalNameFilter, reflectedType));
}
internal sealed override IEnumerable <FieldInfo> GetFieldsCore(NameFilter?filter, Type reflectedType) => _genericTypeDefinition.SpecializeFields(filter, reflectedType, this);
internal sealed override IEnumerable <ConstructorInfo> GetConstructorsCore(NameFilter?filter) => Array.Empty <ConstructorInfo>();
internal sealed override IEnumerable <RoType> GetNestedTypesCore(NameFilter?filter) => _genericTypeDefinition.GetNestedTypesCore(filter);
internal sealed override IEnumerable <MethodInfo> GetMethodsCore(NameFilter?filter, Type reflectedType) => Array.Empty <MethodInfo>();
