/// <summary> /// Attempts to get the argument of a given option. /// If the option allows for multiple options or the /// option is not present, then this method will return /// <c>false</c>. /// </summary> /// <param name="self"> /// The instance to interrogate. /// </param> /// <param name="option"> /// The option whose argument is to be retrieved. /// </param> /// <param name="argument"> /// The argument, if it exists; <c>null</c> otherwise. /// </param> /// <returns> /// <c>true</c> if the argument was found; <c>false</c> /// otherwise. /// </returns> /// <exception cref="System.ArgumentNullException"> /// <paramref name="option"/> is <c>null</c>. /// - or - /// <paramref name="self"/> is <c>null</c>. /// </exception> public static bool TryGetOptionArgument( this ProcessorOptions self, Option option, out string argument) { return(self.TryGetOptionArgument(option.Id, out argument)); }
/// <summary> /// Attempts to get the argument of a given option. /// If the option allows for multiple options or the /// option is not present, then this method will return /// <c>false</c>. /// </summary> /// <param name="self"> /// The instance to interrogate. /// </param> /// <param name="id"> /// The option whose argument is to be retrieved. /// </param> /// <param name="argument"> /// The argument, if it exists; <c>null</c> otherwise. /// </param> /// <returns> /// <c>true</c> if the argument was found; <c>false</c> /// otherwise. /// </returns> /// <exception cref="System.ArgumentNullException"> /// <paramref name="id"/> is <c>null</c>. /// - or - /// <paramref name="self"/> is <c>null</c>. /// </exception> public static bool TryGetOptionArgument( this ProcessorOptions self, object id, out string argument) { Guard.NotNull(self, nameof(self)); Guard.NotNull(id, nameof(id)); if (self.Options.TryGetOptionArguments(id, out IEnumerable <string> allArguments)) { var enumerator = allArguments.GetEnumerator(); if (enumerator.MoveNext()) { // save the first argument. argument = enumerator.Current; if (enumerator.MoveNext()) { // we have more than one argument, so fail. argument = null; } } else { // no arguments argument = null; } } else { // no arguments argument = null; } return(argument != null); }
/// <summary> /// Determines whether the given instance contains the /// given option. /// </summary> /// <param name="self"> /// The instance to interrogate. /// </param> /// <param name="id"> /// The flag to check. /// </param> /// <returns> /// <c>true</c> if <paramref name="id"/> is present in /// <paramref name="self"/>; <c>false</c> otherwise. /// </returns> /// <exception cref="System.ArgumentNullException"> /// <paramref name="self"/> is <c>null</c>. /// </exception> public static bool IsOptionPresent( this ProcessorOptions self, object id) { Guard.NotNull(self, nameof(self)); return(self.Options.Any(x => x.Id.Equals(id))); }
/// <summary> /// Determines whether the given instance contains the /// given option. /// </summary> /// <param name="self"> /// The instance to interrogate. /// </param> /// <param name="flag"> /// The flag to check. /// </param> /// <returns> /// <c>true</c> if <paramref name="flag"/> is present in /// <paramref name="self"/>; <c>false</c> otherwise. /// </returns> /// <exception cref="System.ArgumentNullException"> /// <paramref name="flag"/> is <c>null</c>. /// - or - /// <paramref name="self"/> is <c>null</c>. /// </exception> public static bool IsOptionPresent( this ProcessorOptions self, Option flag) { Guard.NotNull(flag, nameof(flag)); return(self.IsOptionPresent(flag.Id)); }
/// <summary> /// Attempts to get all of the arguments passed to a given /// option. /// </summary> /// <param name="self"> /// The instance to interrogate. /// </param> /// <param name="id"> /// The option whose arguments are to be retrieved. /// </param> /// <param name="arguments"> /// The arguments, if the option is found. If the option /// exists but there are no arguments, this method will still /// return <c>true</c> and this parameter will be set to /// the empty collection. /// </param> /// <returns> /// <c>true</c> if the option was found; <c>false</c> /// otherwise. /// </returns> /// <exception cref="System.ArgumentNullException"> /// <paramref name="self"/> is <c>null</c>. /// </exception> public static bool TryGetOptionArguments( this ProcessorOptions self, char id, out IEnumerable <string> arguments) { Guard.NotNull(self, nameof(self)); return(self.Options.TryGetOptionArguments(id, out arguments)); }
/// <inheritdoc /> public ICustomDataProcessor CreateProcessor( IDataSource dataSource, IProcessorEnvironment processorEnvironment, ProcessorOptions options) { Guard.NotNull(dataSource, nameof(dataSource)); return(this.CreateProcessor( new[] { dataSource, }, processorEnvironment, options)); }
/// <summary> /// This constructor will setup the data processor so that it can use the data extension framework - allowing /// table and data cookers both internally and external to this plug-in. /// </summary> /// <param name="sourceParser">The source data parser</param> /// <param name="options">Processor options</param> /// <param name="applicationEnvironment">Application environment</param> /// <param name="processorEnvironment">Processor environment</param> /// <param name="allTablesMapping">Maps table descriptors to possible build actions</param> /// <param name="metadataTables">Metadata tables</param> protected CustomDataProcessorBaseWithSourceParser( ISourceParser <T, TContext, TKey> sourceParser, ProcessorOptions options, IApplicationEnvironment applicationEnvironment, IProcessorEnvironment processorEnvironment, IReadOnlyDictionary <TableDescriptor, Action <ITableBuilder, IDataExtensionRetrieval> > allTablesMapping, IEnumerable <TableDescriptor> metadataTables) : base(options, applicationEnvironment, processorEnvironment, allTablesMapping, metadataTables) { Guard.NotNull(sourceParser, nameof(sourceParser)); this.SourceParser = sourceParser; this.SourceProcessingSession = this.ApplicationEnvironment.SourceSessionFactory.CreateSourceSession(this); this.extensibilitySupport = this.ProcessorEnvironment.CreateDataProcessorExtensibilitySupport(this); foreach (var metadataTable in metadataTables) { ProcessTableForExtensibility(metadataTable); } }
/// <summary> /// Initializes a new instance of the <see cref="CustomDataProcessorBase"/> /// class. /// </summary> protected CustomDataProcessorBase( ProcessorOptions options, IApplicationEnvironment applicationEnvironment, IProcessorEnvironment processorEnvironment, IReadOnlyDictionary <TableDescriptor, Action <ITableBuilder, IDataExtensionRetrieval> > allTablesMapping, IEnumerable <TableDescriptor> metadataTables) { Guard.NotNull(options, nameof(options)); Guard.NotNull(applicationEnvironment, nameof(applicationEnvironment)); Guard.NotNull(allTablesMapping, nameof(allTablesMapping)); Guard.NotNull(metadataTables, nameof(metadataTables)); Guard.NotNull(processorEnvironment, nameof(processorEnvironment)); this.enabledTables = new HashSet <TableDescriptor>(metadataTables); this.ApplicationEnvironment = applicationEnvironment; this.ProcessorEnvironment = processorEnvironment; this.EnabledTables = new ReadOnlyHashSet <TableDescriptor>(this.enabledTables); this.Options = options; this.TableDescriptorToBuildAction = allTablesMapping; this.Logger = processorEnvironment.CreateLogger(this.GetType()); }
/// <inheritdoc /> public ICustomDataProcessor CreateProcessor( IEnumerable <IDataSource> dataSources, IProcessorEnvironment processorEnvironment, ProcessorOptions options) { Guard.NotNull(dataSources, nameof(dataSources)); Guard.NotNull(processorEnvironment, nameof(processorEnvironment)); Guard.NotNull(options, nameof(options)); Guard.All(dataSources, x => x != null, nameof(dataSources)); var processor = this.CreateProcessorCore( dataSources, processorEnvironment, options); if (processor is null) { throw new InvalidOperationException("CreateProcessorCore is not allowed to return null."); } return(processor); }
/// <summary> /// When implemented in a derived class, creates a new /// instance implementing <see cref="ICustomDataProcessor"/> /// to process the specified data sources. /// </summary> /// <param name="dataSources"> /// The data sources to be processed by the processor. /// This parameter is guaranteed to be non-null, and all /// elements in the collection are guaranteed to be non-null. /// </param> /// <param name="processorEnvironment"> /// The environment for this specific processor instance. /// </param> /// <param name="options"> /// The options to pass to the processor. /// </param> /// <returns> /// A new <see cref="ICustomDataProcessor"/>. It is an error /// to return <c>null</c> from this method. /// </returns> protected abstract ICustomDataProcessor CreateProcessorCore( IEnumerable <IDataSource> dataSources, IProcessorEnvironment processorEnvironment, ProcessorOptions options);