/// <summary> /// Initializes a new instance of the <see cref="NancyEngine"/> class. /// </summary> /// <param name="resolver">An <see cref="IRouteResolver"/> instance that will be used to resolve a route, from the modules, that matches the incoming <see cref="Request"/>.</param> /// <param name="routeCache">Cache of all available routes</param> /// <param name="contextFactory">A factory for creating contexts</param> /// <param name="errorHandler">Error handler</param> public NancyEngine(IRouteResolver resolver, IRouteCache routeCache, INancyContextFactory contextFactory, IErrorHandler errorHandler) { if (resolver == null) { throw new ArgumentNullException("resolver", "The resolver parameter cannot be null."); } if (routeCache == null) { throw new ArgumentNullException("routeCache", "The routeCache parameter cannot be null."); } if (contextFactory == null) { throw new ArgumentNullException("contextFactory"); } if (errorHandler == null) { throw new ArgumentNullException("errorHandler"); } this.resolver = resolver; this.routeCache = routeCache; this.contextFactory = contextFactory; this.errorHandler = errorHandler; }
public MetadataImporter(CompilerOptions options, IErrorHandler errorHandler) { Debug.Assert(options != null); Debug.Assert(errorHandler != null); _options = options; _errorHandler = errorHandler; }
bool IParseNodeValidator.Validate(ParseNode node, CompilerOptions options, IErrorHandler errorHandler) { CompilationUnitNode compilationUnitNode = (CompilationUnitNode)node; foreach (AttributeBlockNode attribBlock in compilationUnitNode.Attributes) { AttributeNode scriptNamespaceNode = AttributeNode.FindAttribute(attribBlock.Attributes, "ScriptNamespace"); if (scriptNamespaceNode != null) { string scriptNamespace = (string)((LiteralNode)scriptNamespaceNode.Arguments[0]).Value; if (Utility.IsValidScriptNamespace(scriptNamespace) == false) { errorHandler.ReportError("A script namespace must be a valid script identifier.", scriptNamespaceNode.Token.Location); } } } foreach (ParseNode childNode in compilationUnitNode.Members) { if (!(childNode is NamespaceNode)) { errorHandler.ReportError("Non-namespaced types are not supported.", childNode.Token.Location); return false; } } return true; }
public virtual void Parse(string code, IErrorHandler errorHandler) { this._engine.Reset(); this._errorHandler = errorHandler; this._codeBlock.SourceText = code; this._engine.CheckForErrors(); }
public NancyEngineFixture() { this.resolver = A.Fake<IRouteResolver>(); this.response = new Response(); this.route = new FakeRoute(response); this.context = new NancyContext(); this.errorHandler = A.Fake<IErrorHandler>(); this.requestDispatcher = A.Fake<IRequestDispatcher>(); A.CallTo(() => this.requestDispatcher.Dispatch(A<NancyContext>._)).Invokes(x => this.context.Response = new Response()); A.CallTo(() => errorHandler.HandlesStatusCode(A<HttpStatusCode>.Ignored, A<NancyContext>.Ignored)).Returns(false); contextFactory = A.Fake<INancyContextFactory>(); A.CallTo(() => contextFactory.Create()).Returns(context); A.CallTo(() => resolver.Resolve(A<NancyContext>.Ignored)).Returns(new ResolveResult(route, DynamicDictionary.Empty, null, null, null)); var applicationPipelines = new Pipelines(); this.routeInvoker = A.Fake<IRouteInvoker>(); A.CallTo(() => this.routeInvoker.Invoke(A<Route>._, A<DynamicDictionary>._, A<NancyContext>._)).ReturnsLazily(arg => { return (Response)((Route)arg.Arguments[0]).Action.Invoke((DynamicDictionary)arg.Arguments[1]); }); this.engine = new NancyEngine(this.requestDispatcher, contextFactory, new[] { this.errorHandler }, A.Fake<IRequestTracing>()) { RequestPipelinesFactory = ctx => applicationPipelines }; }
/// <summary> /// Constructor /// </summary> /// <param name="writer">the writer to actually write to</param> /// <param name="errorHandler">the error handler to report error to</param> /// <remarks> /// <para> /// Create a new QuietTextWriter using a writer and error handler /// </para> /// </remarks> public QuietTextWriter(TextWriter writer, IErrorHandler errorHandler) : base(writer) { if (errorHandler == null) { throw new ArgumentNullException("errorHandler"); } ErrorHandler = errorHandler; }
bool IParseNodeValidator.Validate(ParseNode node, CompilerOptions options, IErrorHandler errorHandler) { NewNode newNode = (NewNode)node; // TODO: This is somewhat hacky - it only looks for any type named Dictionary // rather than resolving the type and checking if its actually // System.Dictionary. // This is because validators don't have a reference to the SymbolSet. NameNode typeNode = newNode.TypeReference as NameNode; if ((typeNode != null) && (typeNode.Name.Equals("Dictionary"))) { if (newNode.Arguments != null) { Debug.Assert(newNode.Arguments is ExpressionListNode); ParseNodeList arguments = ((ExpressionListNode)newNode.Arguments).Expressions; if (arguments.Count != 0) { if (arguments.Count % 2 != 0) { errorHandler.ReportError("Missing value parameter for the last name parameter in Dictionary instantiation.", newNode.Token.Location); } for (int i = 0; i < arguments.Count; i += 2) { ParseNode nameArgumentNode = arguments[i]; if ((nameArgumentNode.NodeType != ParseNodeType.Literal) || (((LiteralNode)nameArgumentNode).Literal.LiteralType != LiteralTokenType.String)) { errorHandler.ReportError("Name parameters in Dictionary instantiation must be string literals.", nameArgumentNode.Token.Location); } } } } } return true; }
/// <summary> /// create a new <see cref="ErrorHandlingTaskExecutor"/> with <paramref name="taskExecutor"/> and /// <paramref name="errorHandler"/> /// </summary> /// <param name="taskExecutor">the task executor</param> /// <param name="errorHandler">the error handler in case of an exception</param> public ErrorHandlingTaskExecutor(IExecutor taskExecutor, IErrorHandler errorHandler) { AssertUtils.ArgumentNotNull(taskExecutor, "taskExecutor must not be null"); AssertUtils.ArgumentNotNull(errorHandler, "errorHandler must not be null"); _taskExecutor = taskExecutor; _errorHandler = errorHandler; }
public Database(ILogger logger, IErrorHandler handler) { m_logger = logger; m_handler = handler; Console.WriteLine("In Database .ctor"); }
protected override void OnStart(string[] args) { try { base.OnStart(args); int delay = 0; lock (lockShutdown) { hasShutteddown = false; errorHandler = new ErrorHandler(serviceEventLog, lockLog); setInstallationWorkingDirectory(); config = CallSelectorFactory.loadISelectorConfig(new FileInfo("CallSelectorConfig.xml")); delay = config.HostRequestDelayMilliseconds(); processingThread = new Thread(new ThreadStart(RunProcessing)); processingThread.Start(); } lock (lockLog) { serviceEventLog.WriteEntry("Start. delay=" + delay + "; " + (config.LogDebug() ? "debug=true" : "debug=false")); } } catch (ThreadAbortException) { /*ignore*/} catch (Exception e) { if (null != errorHandler) errorHandler.handle(e); } }
public WorkbenchRefresher(WorkbenchViewModel viewModel, IAdministrationComponent component, IErrorHandler errorHandler) { this.ViewModel = viewModel; this.Component = component; this.Handle = errorHandler; this.Scheduler = viewModel.Scheduler; Thread.CurrentThread.CurrentUICulture = this.ViewModel.Culture; }
public NoneBlockingReceiver( IQueueEndpointProvider queueEndpointProvider, RabbitMqFactory rabbitMqFactory, ChannelConfigurator channelConfigurator, IErrorHandler errorHandler) : this(queueEndpointProvider, rabbitMqFactory, channelConfigurator, errorHandler, RabbitMqLogger.NullLogger) { }
public StaffingResourcePhoneListViewModel(IDomainUnitOfWorkManager<IDomainUnitOfWork> unitOfWorkManager, IPartFactory<ItemSelectorViewModel> phoneTypeSelectorFactory, IErrorHandler errorHandler, IDialogManager dialogManager) : base(unitOfWorkManager, errorHandler) { _phoneTypeSelectorFactory = phoneTypeSelectorFactory; _dialogManager = dialogManager; }
public ErrorClientBehavior(IErrorHandler errorHandler) { if (errorHandler == null) { throw new ArgumentNullException(); } _errorHandler = errorHandler; }
public ExternalThread(string name, IRuntime runtime, IActorLogger logger, IErrorHandler errorHandler, Action<Action> dispatchMethod) { _name = name; _runtime = runtime; _logger = logger; _errorHandler = errorHandler; _dispatcher = dispatchMethod; }
/// <summary>Creates a new instance of the RequestLifeCycleHandler class.</summary> /// <param name="webContext">The web context wrapper.</param> public RequestLifecycleHandler(IWebContext webContext, EventBroker broker, InstallationManager installer, IRequestDispatcher dispatcher, IErrorHandler errors, AdminSection editConfig, HostSection hostConfig) : this(webContext, broker, installer, dispatcher, errors) { checkInstallation = editConfig.Installer.CheckInstallationStatus; //installerUrl = editConfig.Installer.InstallUrl; rewriteMethod = hostConfig.Web.Rewrite; _adminConfig = editConfig; }
public StaffingResourceSummaryViewModel(IDomainUnitOfWorkManager<IDomainUnitOfWork> unitOfWorkManager, IPartFactory<StaffingResourceNameEditorViewModel> nameEditorFactory, IErrorHandler errorHandler, IDialogManager dialogManager) : base(unitOfWorkManager, errorHandler) { _nameEditorFactory = nameEditorFactory; _dialogManager = dialogManager; }
public StatementBuilder(ILocalSymbolTable symbolTable, CodeMemberSymbol memberContext, IErrorHandler errorHandler, CompilerOptions options) { _symbolTable = symbolTable; _memberContext = memberContext; _symbolSet = memberContext.SymbolSet; _errorHandler = errorHandler; _expressionBuilder = new ExpressionBuilder(symbolTable, memberContext, errorHandler, options); }
public ExpressionBuilder(ILocalSymbolTable symbolTable, FieldSymbol fieldContext, IErrorHandler errorHandler, CompilerOptions options) { _symbolTable = symbolTable; _symbolContext = fieldContext; _classContext = ((ClassSymbol)fieldContext.Parent).PrimaryPartialClass; _symbolSet = fieldContext.SymbolSet; _errorHandler = errorHandler; _options = options; }
bool IParseNodeValidator.Validate(ParseNode node, CompilerOptions options, IErrorHandler errorHandler) { MethodDeclarationNode methodNode = (MethodDeclarationNode)node; if (((methodNode.Modifiers & Modifiers.Static) == 0) && ((methodNode.Modifiers & Modifiers.New) != 0)) { errorHandler.ReportError("The new modifier is not supported on instance members.", methodNode.Token.Location); return false; } if ((methodNode.Modifiers & Modifiers.Extern) != 0) { AttributeNode altSigAttribute = AttributeNode.FindAttribute(methodNode.Attributes, "AlternateSignature"); if (altSigAttribute == null) { errorHandler.ReportError("Extern methods should only be used to declare alternate signatures and marked with [AlternateSignature].", methodNode.Token.Location); return false; } CustomTypeNode typeNode = (CustomTypeNode)methodNode.Parent; MethodDeclarationNode implMethodNode = null; if (methodNode.NodeType == ParseNodeType.MethodDeclaration) { foreach (MemberNode memberNode in typeNode.Members) { if ((memberNode.NodeType == ParseNodeType.MethodDeclaration) && ((memberNode.Modifiers & Modifiers.Extern) == 0) && memberNode.Name.Equals(methodNode.Name, StringComparison.Ordinal)) { implMethodNode = (MethodDeclarationNode)memberNode; break; } } } else if (methodNode.NodeType == ParseNodeType.ConstructorDeclaration) { foreach (MemberNode memberNode in typeNode.Members) { if ((memberNode.NodeType == ParseNodeType.ConstructorDeclaration) && ((memberNode.Modifiers & Modifiers.Extern) == 0)) { implMethodNode = (MethodDeclarationNode)memberNode; break; } } } if (implMethodNode == null) { errorHandler.ReportError("Extern methods used to declare alternate signatures should have a corresponding non-extern implementation as well.", methodNode.Token.Location); return false; } if ((methodNode.Modifiers & (Modifiers.Static | Modifiers.AccessMask)) != (implMethodNode.Modifiers & (Modifiers.Static | Modifiers.AccessMask))) { errorHandler.ReportError("The implemenation method and associated alternate signature methods should have the same access type.", methodNode.Token.Location); } } return true; }
public Scheduler(IEngine engine, IPluginFinder plugins, IHeart heart, IWorker worker, IWebContext context, IErrorHandler errorHandler) { this.engine = engine; actions = new List<ScheduledAction>(InstantiateActions(plugins)); this.heart = heart; this.worker = worker; this.context = context; this.errorHandler = errorHandler; }
// ────────────────────────── Constructors ────────────────────────── public ErrorHandlerBehavior(Type type, string unhandledErrorMessage, bool returnRawException) { _errorHandler = (IErrorHandler)Activator.CreateInstance(type); UnhandledErrorMessage = unhandledErrorMessage; ReturnRawException = returnRawException; }
public CommunicationHandler(TcpClient serverCon, IErrorHandler error, IInvokable invoke, INotifiable notify, ILobby lobby) { _errorHandler = error; _tcpClient = serverCon; _tcpClient.DataReceived += TcpClient_DataReceived; _tcpClient.Disconnected += TcpClient_Disconnnected; _tcpClient.Start(); _processor = new DataProcessor(invoke, notify, lobby); }
public ReceiveListener( IQueueEndpointProvider queueEndpointProvider, RabbitMqFactory rabbitMqFactory, ChannelConfigurator channelConfigurator, IErrorHandler errorHandler, RabbitMqLogger logger) : base(queueEndpointProvider, rabbitMqFactory, channelConfigurator, errorHandler, logger) { }
public ScriptGenerator(TextWriter writer, CompilerOptions options, IErrorHandler errorHandler) { Debug.Assert(writer != null); _writer = new ScriptTextWriter(writer, options); _options = options; _errorHandler = errorHandler; _classes = new List<ClassSymbol>(); }
/// <summary>Creates a new instance of the RequestLifeCycleHandler class.</summary> /// <param name="webContext">The web context wrapper.</param> public RequestLifecycleHandler(IWebContext webContext, EventBroker broker, InstallationManager installer, IRequestDispatcher dispatcher, IErrorHandler errors) { this.webContext = webContext; this.broker = broker; this.errors = errors; this.installer = installer; this.dispatcher = dispatcher; _adminConfig = null; }
public DedicatedThread(string name, IRuntime runtime, IActorLogger logger, IErrorHandler errorHandler, int actorId, IActor actor) { _actor = actor; _actorId = actorId; _name = name; _runtime = runtime; _logger = logger; _errorHandler = errorHandler; }
public ImportStep(IDataTransferService transferService, ITransferStatisticsFactory statisticsFactory, IErrorHandler errorHandler, IDataTransferModel transferModel) : base(transferModel) { this.transferService = transferService; this.statisticsFactory = statisticsFactory; this.errorHandler = errorHandler; transferModel.Subscribe(m => m.HasImportStarted, OnImportStateChanged); }
public StaffingResourceAddressListViewModel(IDomainUnitOfWorkManager<IDomainUnitOfWork> unitOfWorkManager, IPartFactory<ItemSelectorViewModel> addressTypeSelectorFactory, IErrorHandler errorHandler, IDialogManager dialogManager) : base(unitOfWorkManager, errorHandler) { _unitOfWorkManager = unitOfWorkManager; _addressTypeSelectorFactory = addressTypeSelectorFactory; _dialogManager = dialogManager; }
/// <summary> /// Constructs the step, using the given transport and settings /// </summary> public SimpleRetryStrategyStep(SimpleRetryStrategySettings simpleRetryStrategySettings, IErrorTracker errorTracker, IErrorHandler errorHandler) { if (simpleRetryStrategySettings == null) throw new ArgumentNullException(nameof(simpleRetryStrategySettings)); if (errorTracker == null) throw new ArgumentNullException(nameof(errorTracker)); if (errorHandler == null) throw new ArgumentNullException(nameof(errorHandler)); _simpleRetryStrategySettings = simpleRetryStrategySettings; _errorTracker = errorTracker; _errorHandler = errorHandler; }
protected BaseExecutingCommand(IErrorHandler errorHandler, IAnalyticsService analyticsService) { ErrorHandler = errorHandler; AnalyticsService = analyticsService; }
public ShopController(IShopRepository shopRepository, IErrorHandler errorHandler) { _shopRepository = shopRepository; _errorHandler = errorHandler; }
static CsLox() { _error_handler = new ConsoleErrorHandler(); _interpreter = new Interpreter(_error_handler); }
internal RequestObjectHandlerFake(Method method, string path, IErrorHandler errorHandler, RequestHandler0.ObjectHandler0 handler) : base(method, path, new List <IParameterResolver>()) { _executor = (request, mediaTypeMapper1, errorHandler1, logger1) => RequestObjectExecutor.ExecuteRequest(request, mediaTypeMapper1, handler.Invoke, errorHandler1, logger1); _errorHandler = errorHandler; }
public AsyncExecutingCommand(IErrorHandler errorHandler, IAnalyticsService analyticsService) : base(errorHandler, analyticsService) { }
bool IParseNodeValidator.Validate(ParseNode node, CompilerOptions options, IErrorHandler errorHandler) { string featureName = string.Empty; switch (node.NodeType) { case ParseNodeType.PointerType: featureName = "Pointer types"; break; case ParseNodeType.OperatorDeclaration: featureName = "Operator overloads"; break; case ParseNodeType.DestructorDeclaration: featureName = "Type destructors"; break; case ParseNodeType.Goto: featureName = "Goto statements"; break; case ParseNodeType.Lock: featureName = "Lock statements"; break; case ParseNodeType.UnsafeStatement: featureName = "Unsafe statements"; break; case ParseNodeType.LabeledStatement: featureName = "Labeled statements"; break; case ParseNodeType.YieldReturn: featureName = "Yield return statements"; break; case ParseNodeType.YieldBreak: featureName = "Yield break statements"; break; case ParseNodeType.Checked: featureName = "Checked expressions"; break; case ParseNodeType.Unchecked: featureName = "Unchecked expressions"; break; case ParseNodeType.Sizeof: featureName = "Sizeof expressions"; break; case ParseNodeType.Fixed: featureName = "Fixed expressions"; break; case ParseNodeType.StackAlloc: featureName = "Stackalloc expressions"; break; case ParseNodeType.DefaultValueExpression: featureName = "Default value expressions"; break; case ParseNodeType.ExternAlias: featureName = "Extern aliases"; break; case ParseNodeType.AliasQualifiedName: featureName = "Alias-qualified identifiers"; break; case ParseNodeType.ConstraintClause: featureName = "Generic type constraints"; break; case ParseNodeType.GenericName: featureName = "Generic types"; break; } errorHandler.ReportUnsupportedFeatureError(featureName, node); return(false); }
public EncryptCountingQuietTextWriter(string key, TextWriter writer, IErrorHandler errorHandler) : base(writer, errorHandler) { _key = key; }
/// <summary> /// Initializes a new instance of the <see cref="BaseViewModel"/> class. /// </summary> /// <param name="error">Error Handler.</param> /// <param name="navigation">Navigation Handler.</param> public BaseViewModel(IErrorHandler error, INavigationHandler navigation) { this.Error = error; this.Navigation = navigation; }
/// <summary> /// Constructor /// </summary> /// <param name="writer">The <see cref="TextWriter" /> to actually write to.</param> /// <param name="errorHandler">The <see cref="IErrorHandler" /> to report errors to.</param> /// <remarks> /// <para> /// Creates a new instance of the <see cref="CountingQuietTextWriter" /> class /// with the specified <see cref="TextWriter" /> and <see cref="IErrorHandler" />. /// </para> /// </remarks> public CountingQuietTextWriter(TextWriter writer, IErrorHandler errorHandler) : base(writer, errorHandler) { m_countBytes = 0; }
public static void ReportAssemblyError(this IErrorHandler errorHandler, string assemblyName, string message) { CompilerError error = new CompilerError((ushort)CompilerErrorCode.AssemblyError, message, assemblyName); errorHandler.ReportError(error); }
public ErrorBehaviorBase(IErrorHandler errorHandler) { _errorHandler = errorHandler; }
public ProductService(IRepository <TContext, ProductVariation> productVariationRepo, IErrorHandler errorHandler) { _productVariationRepo = productVariationRepo; _errorHandler = errorHandler; }
/// <summary> /// Initializes a new instance of the <see cref="RelayCommand" /> class. /// </summary> /// <param name="execute">The execute.</param> /// <param name="canExecute">The can execute.</param> /// <param name="errorHandler">The error handler for the asynchronous command.</param> /// <exception cref="ArgumentNullException">execute</exception> public RelayCommandAsync(Func <Task> execute, Predicate <object> canExecute = null, IErrorHandler errorHandler = null) { if (execute == null) { throw new ArgumentNullException(nameof(execute)); } _execute = execute; _canExecute = canExecute; _errorHandler = errorHandler; }
public ScriptPreprocessor(IStreamResolver includeResolver, IErrorHandler errorHandler) { _includeResolver = includeResolver; _errorHandler = errorHandler; }
public ScriptCompiler(IErrorHandler errorHandler) { _errorHandler = errorHandler; }
public EventTreeInfo(string expr, IErrorHandler errorHandler) : base(new[] { new ExprInfo(expr, null, ParserMode.Event) }, errorHandler) { }
public AsyncCommand(Func <Task> command, IAsyncOperationStatusManager asyncOperationStatusManager, IErrorHandler errorHandler) { this.errorHandler = errorHandler; this.asyncOperationStatusManager = asyncOperationStatusManager ?? throw new ArgumentNullException(nameof(asyncOperationStatusManager)); this.command = new WeakFunc <Task>(command ?? throw new ArgumentNullException(nameof(command))); }
public FileRepositoryStore(IErrorHandler errorHandler) { _errorHandler = errorHandler; }
internal ICompletes <Response> Execute(Request request, IErrorHandler errorHandler, ILogger logger) => _executor.Invoke(request, null, errorHandler, logger);
public ShareButtonViewModel(IErrorHandler errorHandler) { _errorHandler = errorHandler; ShareCodeCommand = new Command(ShareCode); }
public T UsingErrorHandler(Action <ActorSystem, Exception> generalErrorHandler, Action <ActorSystem, Pid, IMessage, Exception> processErrorHandler) { _errorHandler = new ErrorHandlerAction(generalErrorHandler, processErrorHandler); return((T)this); }
public AsyncCommand(Func <Task> execute, Func <bool> canExecute = null, IErrorHandler errorHandler = null) { this.execute = execute; this.canExecute = canExecute; this.errorHandler = errorHandler; }
public T UsingErrorHandler(IErrorHandler errorHandler) { _errorHandler = errorHandler; return((T)this); }
bool Initialize(JobSettings settings, IErrorHandler errorHandler) { this.settings = settings; var auditColumns = settings.AuditColumns.AuditColumnNames().Select(c => c.ToLowerInvariant()).ToList(); if (settings.UseAuditColumnsOnImport ?? false) { foreach (var field in Fields) { if (auditColumns.Contains(field.CanonicalName)) { field.IsAuditingColumn = true; } } } if (!Fields.Any()) { errorHandler.Error($"Could not find any information for table {Name}. Make sure it exists in the target database"); return(false); } var data = Fields.Select(f => f.Name.ToLowerInvariant()); if (PrimaryKey == null) { var primaryKeys = Fields.Where(f => f.IsPrimaryKey).ToList(); if (primaryKeys.Count == 0) { //errorHandler.Warning($"No primary key set for table {Name}, trying to infer from name"); primaryKeys = Fields.Where(f => f.Name.ToLowerInvariant() == "id" || f.Name.ToLowerInvariant() == BasicName.ToLowerInvariant() + "id").ToList(); } if (primaryKeys.Count > 1) { errorHandler.Error($"Multiple primary keys found for table {Name} ({string.Join(", ", primaryKeys.Select(pk => pk.Name))}). Please specify one manually."); return(false); } if (!primaryKeys.Any()) { errorHandler.Error($"No primary key could be found for table {Name}. Please specify one manually"); return(false); } PrimaryKey = primaryKeys.Single().Name; } PrimaryKey = PrimaryKey.ToLowerInvariant(); data = data.Where(f => f != PrimaryKey); if (settings.UseAuditColumnsOnImport ?? false) { data = data.Where(f => !settings.AuditColumns.AuditColumnNames().Select(a => a.ToLowerInvariant()).Contains(f)); } if (IsEnvironmentSpecific) { data = data.Where(f => f != "isenvironmentspecific"); } DataFields = data.ToList(); return(true); }
public static void ReportExpressionError(this IErrorHandler errorHandler, string message, ParseNode node) { CompilerError error = new CompilerError((ushort)CompilerErrorCode.ExpressionError, message, node.Token.SourcePath, node.Token.Position.Line, node.Token.Position.Column); errorHandler.ReportError(error); }
public DeclarationStartModel(IApiHttpClient apiHttpClient, IErrorHandler errorHandler) { this.apiHttpClient = apiHttpClient; this.errorHandler = errorHandler; }
public StockQuote(ILogger logger, IErrorHandler handler, IDatabase database) { _logger = logger; _handler = handler; _database = database; }
public ExecutingObservableCommand(IErrorHandler errorHandler, IAnalyticsService analyticsService) : base(errorHandler, analyticsService) { }
void Handle_Clicked_1(object sender, System.EventArgs e) { IErrorHandler errorHandler = null; viewModel.CommandSave.ExecuteAsync().FireAndForgetSafeAsync(errorHandler); }
public RequestHandler2 <T, TR> OnError(IErrorHandler errorHandler) { ErrorHandler = errorHandler; return(this); }