private String thePath; // Path of this file // ------------------------------------------------------------------------------------------ /// <summary> /// Constructor /// </summary> /// <param name="path">Path of the file to be parsed</param> public AudioFileReader(String path) { thePath = path; theFactory = AudioReaderFactory.GetInstance(); audioData = theFactory.GetDataReader(path); metaData = theFactory.GetMetaReader(path, audioData); }
public UploadedFileRepository(IFileStore fileStore, IFileWriter fileWriter, IMetadataReader metadataReader, ILogger <UploadedFileRepository> logger) { this._fileStore = fileStore; this._logger = logger; this._metadataReader = metadataReader; this._fileWriter = fileWriter; }
#pragma warning restore IDE0032 public ModuleSupervisor(DirectoryInfo directory, IMetadataReader metadataReader, ILogger <ModuleSupervisor> logger = null) { if (directory == null) { throw new ArgumentNullException(nameof(directory)); } if (metadataReader == null) { throw new ArgumentNullException(nameof(metadataReader)); } Directory = directory; _metadataReader = metadataReader; _logger = logger; // Volatile write op (Is avtually not necessary here, because the CLR enforces thread-safety.) _state = ModuleSupervisorState.Initializing; _metadataLazy = new DisposableAsyncLazy <IModuleMetadata>( factory: LookupMetadataAsync, options: DisposableAsyncLazyOptions.Autostart | DisposableAsyncLazyOptions.ExecuteOnCallingThread | DisposableAsyncLazyOptions.RetryOnFailure); _supervisorProcess = new AsyncProcess(SupervisorProcessRoutine, start: true); _disposeHelper = new AsyncDisposeHelper(DisposeInternalAsync); }
private TypeSpec GetTypeSpec(Type type, IMetadataReader metadataReader) { if (!type.HasExportAttribute(metadataReader)) { throw new CoreException($"Type '{type.FullName}' should have an ExportAttribute attribute"); } var exportAttribute = metadataReader.GetAttributes(type).FirstOrDefault(a => a is ExportAttribute) as ExportAttribute; IEnumerable <Attribute> additionalAttributes = metadataReader.GetAttributes(type) .Where(a => !(a is ExportAttribute)) .OfType <Attribute>(); var typeSpec = new TypeSpec(exportAttribute); foreach (Attribute additionalAttribute in additionalAttributes) { typeSpec.AdditionalAttributes.Add(additionalAttribute); } foreach (MemberInfo memberInfo in type.GetTsExportableMembers(metadataReader, false)) { IEnumerable <Attribute> attributes = metadataReader .GetAttributes(memberInfo) .OfType <Attribute>(); typeSpec.MemberAttributes.Add(memberInfo.Name, attributes.ToList()); } return(typeSpec); }
private void connectBtnClicked(object sender, EventArgs e) { if (_currentConnection == null) { return; } toolStripStatusLabel1.Text = string.Format("Connecting to {0}...", _currentConnection.Name); statusStrip1.Refresh(); Cursor.Current = Cursors.WaitCursor; try { tablesListBox.DataSource = null; tablesListBox.DisplayMember = "Name"; sequencesComboBox.Items.Clear(); metadataReader = MetadataFactory.GetReader(_currentConnection.Type, _currentConnection.ConnectionString); toolStripStatusLabel1.Text = "Retrieving owners..."; statusStrip1.Refresh(); PopulateOwners(); toolStripStatusLabel1.Text = string.Empty; } catch (Exception ex) { toolStripStatusLabel1.Text = ex.Message; } finally { Cursor.Current = Cursors.Default; } }
public void AddMetadataReader(IMetadataReader reader) { lock (_metadataReadersSyncRoot) { var currentReader = MetadataReader; MetadataReader = currentReader == null ? reader : new MetadataReader(reader, currentReader); } }
public void ShouldCreateTheAppropriateMetadataReader() { IMetadataReader metadataReader = MetadataFactory.GetReader(ServerType.Oracle, "conn"); Assert.That(metadataReader, Is.TypeOf(typeof (OracleMetadataReader))); metadataReader = MetadataFactory.GetReader(ServerType.SqlServer, "conn"); Assert.That(metadataReader, Is.TypeOf(typeof (SqlServerMetadataReader))); }
internal CameraFileNameConverter( IMetadataReader metadataReader, CameraFileFactory cameraFileFactory, IFileSystem fileSystem) { _metadataReader = metadataReader; _cameraFileFactory = cameraFileFactory; _fileSystem = fileSystem; }
public MetadataAccessor(IMetadataReader metadataReader) { if (metadataReader == null) { throw new ArgumentNullException(nameof(metadataReader)); } _metadataReader = metadataReader; }
/// <summary> /// Checks if a type is marked with an ExportTs... attribute /// </summary> /// <param name="type"></param> /// <param name="reader"></param> /// <returns></returns> public static bool HasExportAttribute(this Type type, IMetadataReader reader) { Requires.NotNull(type, nameof(type)); Requires.NotNull(reader, nameof(reader)); return(reader.GetAttribute <ExportTsClassAttribute>(type) != null || reader.GetAttribute <ExportTsInterfaceAttribute>(type) != null || reader.GetAttribute <ExportTsEnumAttribute>(type) != null); }
/// <summary> /// Creates mapping schema using provided EF.Core data model and metadata provider. /// </summary> /// <param name="model">EF.Core data model.</param> /// <param name="metadataReader">Additional optional LINQ To DB database metadata provider.</param> /// <returns>Mapping schema for provided EF.Core model.</returns> public virtual MappingSchema GetMappingSchema(IModel model, IMetadataReader metadataReader) { var schema = new MappingSchema(); if (metadataReader != null) { schema.AddMetadataReader(metadataReader); } return(schema); }
public ModuleSupervisorFactory(IMetadataReader metadataReader, ILoggerFactory loggerFactory = null) { if (metadataReader == null) { throw new ArgumentNullException(nameof(metadataReader)); } _metadataReader = metadataReader; _loggerFactory = loggerFactory; }
internal void AddReader(IMetadataReader reader) { // creation of new list is cheaper than lock on each method call var newReaders = new List <IMetadataReader>(_readers.Count + 1) { reader }; newReaders.AddRange(_readers); Volatile.Write(ref _readers, newReaders); }
public MetadataListCommand( List <string> args, IMetadataReader metadataReader, IFile fileWrapper, IOutputWriter outputWriter) { _args = args; _metadataReader = metadataReader; _fileWrapper = fileWrapper; _outputWriter = outputWriter; }
public TsContentGenerator(ITypeDependencyService typeDependencyService, ITypeService typeService, ITemplateService templateService, ITsContentParser tsContentParser, IMetadataReader metadataReader) { _typeDependencyService = typeDependencyService; _typeService = typeService; _templateService = templateService; _tsContentParser = tsContentParser; _metadataReader = metadataReader; }
private async Task ConnectToInfoBase(object parameter) { TreeNodeViewModel treeNode = parameter as TreeNodeViewModel; if (treeNode == null) { return; } Server server = treeNode.NodePayload as Server; if (server == null) { return; } IMetadataReader metadataReader = _shell.GetService <IMetadataReader>(); List <Database> databases = metadataReader.GetDatabases(server); if (databases.Count == 0) { return; } SelectInfoBaseDialog dialog = new SelectInfoBaseDialog(databases); _ = dialog.ShowDialog(); if (dialog.Result == null) { return; } string databaseName = ((Database)dialog.Result).Name; Database database = (Database)server.Domains.Where(i => i.Name == databaseName).FirstOrDefault(); if (database != null) { return; } database = new Database() { Name = databaseName, Owner = server }; server.Domains.Add(database); await DoWorkAsync(database); IController controller = GetController <DatabaseController>(); controller.BuildTreeNode(database, out TreeNodeViewModel childNode); treeNode.TreeNodes.Add(childNode); //Persist(database); }
public LookupClient( IMetadataLocator locator, IMetadataProvider provider, IMetadataFetcher fetcher, IMetadataReader reader, ICertificateValidator validator) { this.locator = locator; this.provider = provider; this.fetcher = fetcher; this.reader = reader; this.validator = validator; }
public HomeController(ILogger <HomeController> logger, IConfiguration config, IFileUploader fileUploader, IChangeFeedReader changeFeedReader, IMetadataReader metadataReader) { _logger = logger; this.fileUploader = fileUploader; this.metadataReader = metadataReader; this.changeFeedReader = changeFeedReader; var value = config.GetSection("Configuration"); this.containerConnectionString = value.GetValue <string>(Constants.ConnectionStrings.ContainerPropertyName); }
public List<IMetadataReader> GetMetaData() { //GetItems(); //itemcount = FolderItemList.Count; int i = 0; foreach (Shell32.FolderItem2 item2 in _objFolder.Items()) { metadata = new MetadataReader.MetadataReader(i, Folderpath); _metaList.Add(metadata); i++; } return _metaList; }
public ModuleInstaller(IMetadataReader metadataReader, IServiceProvider serviceProvider) { if (metadataReader == null) { throw new ArgumentNullException(nameof(metadataReader)); } if (serviceProvider == null) { throw new ArgumentNullException(nameof(serviceProvider)); } _metadataReader = metadataReader; _serviceProvider = serviceProvider; }
public GenerateCommand( List <string> args, ITransformer transformer, IMetadataReader metadataReader, IDirectory directoryWrapper, IFile fileWrapper, IOutputWriter outputWriter) { _args = args; _transformer = transformer; _metadataReader = metadataReader; _directoryWrapper = directoryWrapper; _fileWrapper = fileWrapper; _outputWriter = outputWriter; }
public ModuleSearchEngine(IMetadataReader metadataReader, IEntityStorageEngine entityStorageEngine) { if (metadataReader == null) { throw new ArgumentNullException(nameof(metadataReader)); } if (entityStorageEngine == null) { throw new ArgumentNullException(nameof(entityStorageEngine)); } _metadataReader = metadataReader; _entityStorageEngine = entityStorageEngine; }
public static ValueTask <IModuleMetadata> GetMetadataAsync(this IModuleSource moduleSource, ModuleReleaseIdentifier moduleRelease, IMetadataReader moduleMetadataReader, CancellationToken cancellation = default) { if (moduleSource == null) { throw new ArgumentNullException(nameof(moduleSource)); } if (moduleRelease == default) { throw new ArgumentDefaultException(nameof(moduleRelease)); } return(moduleSource.GetMetadataAsync(moduleRelease.Module, moduleRelease.Version, moduleMetadataReader, cancellation)); }
private void ConnectToServer(object parameter) { InputStringDialog dialog = new InputStringDialog(); _ = dialog.ShowDialog(); if (dialog.Result == null) { return; } IMetadataReader metadataProvider = _shell.GetService <IMetadataReader>(); string serverName = (string)dialog.Result; Server server = new Server() { Address = serverName }; if (!metadataProvider.CheckServerConnection(server)) { _ = MessageBox.Show( "Unable to connect server!", ONE_C_SHARP, MessageBoxButton.OK, MessageBoxImage.Error); return; } var treeNode = new TreeNodeViewModel() { NodeText = server.Address, NodeIcon = new BitmapImage(new Uri(LOCAL_SERVER)), NodePayload = server }; treeNode.ContextMenuItems.Add(new MenuItemViewModel() { MenuItemHeader = "Connect to database...", MenuItemIcon = new BitmapImage(new Uri(CONNECT_TO_DATABASE)), MenuItemCommand = new AsyncCommand(ConnectToInfoBase, CanExecuteConnectToInfoBase), MenuItemPayload = treeNode }); _shell.AddTreeNode(treeNode); }
public CommandFactory( IDbSchemaReader dbSchemaReader, IAssemblyReader assemblyReader, IMetadataWriter <DbModel> dbModelMetadataWriter, IMetadataWriter <AssemblyModel> assemblyMetadataWriter, IMetadataReader metadataReader, ITransformer transformer, IOutputWriter outputWriter, IDirectory directoryWrapper, IFile fileWrapper, CommandContext context) { RegisterCommand("h", "help", () => new HelpCommand(outputWriter)); RegisterCommand("v", "version", () => new VersionCommand(outputWriter)); RegisterCommand("metadata-dotnet", () => new MetadataDotNetCommand( context.CommandArgs, assemblyReader, assemblyMetadataWriter, outputWriter)); RegisterCommand("metadata-sqlclient", () => new MetadataSqlClientCommand( context.CommandArgs, dbSchemaReader, dbModelMetadataWriter, outputWriter)); RegisterCommand("metadata-oledb", () => new MetadataOledbCommand()); RegisterCommand("metadata-list", () => new MetadataListCommand( context.CommandArgs, metadataReader, fileWrapper, outputWriter)); RegisterCommand("generate", () => new GenerateCommand( context.CommandArgs, transformer, metadataReader, directoryWrapper, fileWrapper, outputWriter)); }
private void generateMapclass() { var Mapclasssettings = new Connection(); string mapTempPath = Path.GetTempPath(); if (mapTempPath.EndsWith(@"\") == false) { mapTempPath += @"\"; } mapTempPath += @"Mapping\"; if (Directory.Exists(mapTempPath) == false) { Directory.CreateDirectory(mapTempPath); } Mapclasssettings.Domainfolderpath = mapTempPath; Mapclasssettings.ConnectionString = ConfigurationManager.AppSettings["ConnectionString"]; Mapclasssettings.EntityName = "Entity"; if ((RecoEngine_BI.Common.iDBType) == (int)Enums.DBType.Oracle) { Mapclasssettings.Type = ServerType.Oracle; } metadataReader = MetadataFactory.GetReader(Mapclasssettings.Type, Mapclasssettings.ConnectionString); var owners = metadataReader.GetOwners(); IList <Table> tblList = metadataReader.GetTables("RECOUSR"); int tableindex = 0; for (int i = 0; i < tblList.Count; i++) { if (tblList[i].Name == "OPPORTUNITY") { tableindex = i; break; } } Table table = tblList[tableindex]; table.PrimaryKey = metadataReader.DeterminePrimaryKeys(table); metadataReader.GetTableDetails(table, "RECOUSR"); var applicationPreferences = GetApplicationPreferences(table, false, Mapclasssettings); new ApplicationController(applicationPreferences, table).Generate(); }
private async Task DoWorkAsync(Database database) { IMetadataReader metadataReader = _shell.GetService <IMetadataReader>(); _shell.ShowStatusBarMessage(string.Empty); try { Progress <string> progress = new Progress <string>(ReportProgress); Stopwatch stopwatch = Stopwatch.StartNew(); await metadataReader.ReadMetadataAsync(database, progress); stopwatch.Stop(); _shell.ShowStatusBarMessage(stopwatch.ElapsedMilliseconds.ToString()); } catch (Exception error) { _ = MessageBox.Show($"{error.Message}", "ONE-C-SHARP", MessageBoxButton.OK, MessageBoxImage.Error); return; } }
public ModuleInstallationManager(IMetadataReader metadataReader, IModuleInstaller moduleInstaller, IModuleSupervisorFactory moduleSupervisorFactory, IServiceProvider serviceProvider, IOptions <ModuleManagementOptions> optionsAccessor) { if (metadataReader == null) { throw new ArgumentNullException(nameof(metadataReader)); } if (moduleInstaller == null) { throw new ArgumentNullException(nameof(moduleInstaller)); } if (moduleSupervisorFactory == null) { throw new ArgumentNullException(nameof(moduleSupervisorFactory)); } if (serviceProvider == null) { throw new ArgumentNullException(nameof(serviceProvider)); } if (optionsAccessor == null) { throw new ArgumentNullException(nameof(optionsAccessor)); } _metadataReader = metadataReader; _moduleInstaller = moduleInstaller; _moduleSupervisorFactory = moduleSupervisorFactory; _serviceProvider = serviceProvider; var options = optionsAccessor.Value ?? new ModuleManagementOptions(); _installationDirectory = new DirectoryInfo(options.ModuleInstallationDirectory); _initializationHelper = new AsyncInitializationHelper(InitializeInternalAsync); }
/// <summary> /// Reads attributes of <paramref name="memberInfo"/> and tries to create metadata for each one. /// </summary> /// <param name="memberInfo">Reflection source.</param> /// <returns>Collection of metadata values.</returns> protected virtual MetadataCollection BuildMetadata(MemberInfo memberInfo) { MetadataCollection collection = new MetadataCollection(); foreach (Attribute attribute in memberInfo.GetCustomAttributes(true)) { IMetadataReader reader = attribute as IMetadataReader; if (reader != null) { reader.Apply(collection); } else { IAttributeMetadataReader attributeReader; if (MetadataReaderCollection.TryGet(attribute.GetType(), out attributeReader)) { attributeReader.Apply(attribute, collection); } } } return(collection); }
public static MediaFile GetMediaFile(string filePath) { int duration, fps = 0, height = 0, width = 0; bool hasVideo, hasAudio; string audioCodec = "", videoCodec = ""; MultimediaFactory factory; IMetadataReader reader = null; try{ factory = new MultimediaFactory(); reader = factory.getMetadataReader(); reader.Open(filePath); duration = (int)reader.GetMetadata(MetadataType.Duration); hasVideo = (bool)reader.GetMetadata(MetadataType.HasVideo); hasAudio = (bool)reader.GetMetadata(MetadataType.HasAudio); if (hasAudio) { audioCodec = (string)reader.GetMetadata(MetadataType.AudioEncoderType); } if (hasVideo) { videoCodec = (string)reader.GetMetadata(MetadataType.VideoEncoderType); fps = (int)reader.GetMetadata(MetadataType.Fps); } height = (int)reader.GetMetadata(MetadataType.DimensionX); width = (int)reader.GetMetadata(MetadataType.DimensionY); return(new MediaFile(filePath, duration * 1000, (ushort)fps, hasAudio, hasVideo, videoCodec, audioCodec, (uint)height, (uint)width)); } catch (GLib.GException ex) { throw new Exception(Catalog.GetString("Invalid video file:") + "\n" + ex.Message); } finally { reader.Close(); reader.Dispose(); } }
private void connectBtnClicked(object sender, EventArgs e) { errorLabel.Text = string.Empty; Cursor.Current = Cursors.WaitCursor; try { tablesListBox.Items.Clear(); sequencesComboBox.Items.Clear(); metadataReader = MetadataFactory.GetReader((ServerType)serverTypeComboBox.SelectedItem, connStrTextBox.Text); PopulateOwners(); PopulateTablesAndSequences(); } catch (Exception ex) { errorLabel.Text = ex.Message; } finally { Cursor.Current = Cursors.Default; } }
private void connectBtnClicked(object sender, EventArgs e) { if (_currentConnection == null) return; toolStripStatusLabel.Text = string.Format("Connecting to {0}...", _currentConnection.Name); statusStrip1.Refresh(); Cursor.Current = Cursors.WaitCursor; try { tablesListBox.DataSource = null; tablesListBox.DisplayMember = "Name"; sequencesComboBox.Items.Clear(); metadataReader = MetadataFactory.GetReader(_currentConnection.Type, _currentConnection.ConnectionString); toolStripStatusLabel.Text = "Retrieving owners..."; statusStrip1.Refresh(); PopulateOwners(); toolStripStatusLabel.Text = string.Empty; } catch (Exception ex) { toolStripStatusLabel.Text = ex.Message; } finally { Cursor.Current = Cursors.Default; } }
/// <summary> /// Calls the Metadata.MetadataReader with the passed parameters, and places the returned data to /// the list _metaList /// </summary> /// <param name="folderPath">A path to the musicnumber</param> /// <param name="musicnumber">The musicnumber that are to be pased on to the metadataReader</param> private void GetFileMetaData(string folderPath, string musicnumber) { metadata = new Metadata.MetadataReader(folderPath, musicnumber); _metaList.Add(metadata); }