public Game(IOutputHandler outputHandler, INumberHandler numberHandler, INumberProvider numberProvider)
{
this.model = model;
this.outputHandler = outputHandler;
this.numberHandler = numberHandler;
this.numberProvider = numberProvider;
}
/// <summary>
/// Replace any undefined components with the standard component implementations
/// </summary>
public static void ComponentNullCheck()
{
if (inputHandler == null)
{
inputHandler = new FileReader();
Log("No InputHandler supplied, using standard implementation");
}
if (parameterHandler == null)
{
parameterHandler = new InternalParameterHandler();
Log("No ParameterHandler supplied, using standard implementation");
}
if (testExecutor == null)
{
testExecutor = new TestExecutor();
Log("No TestExecutor supplied, using standard implementation");
}
if (resultValidator == null)
{
resultValidator = new ResultValidator();
Log("No ResultValidator supplied, using standard implementation");
}
if (outputHandler == null)
{
outputHandler = new FileWriter();
Log("No OutputHandler supplied, using standard implementation");
}
}
public Withdraw(
IOutputHandler outputHandler,
IAccountRepository accountRepository)
{
_outputHandler = outputHandler;
_accountRepository = accountRepository;
}
public GetAllTodos(
ITodoRepository repo,
IOutputHandler handler)
{
repository = repo;
outputHandler = handler;
}
public Connection(
PipeReader input,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestProcessIdentifier requestProcessIdentifier,
IRequestRouter <IHandlerDescriptor> requestRouter,
IResponseRouter responseRouter,
ILoggerFactory loggerFactory,
Action <Exception> onUnhandledException,
Func <ServerError, string, Exception> getException,
TimeSpan requestTimeout,
bool supportContentModified,
int?concurrency)
{
_inputHandler = new InputHandler(
input,
outputHandler,
receiver,
requestProcessIdentifier,
requestRouter,
responseRouter,
loggerFactory,
onUnhandledException,
getException,
requestTimeout,
supportContentModified,
concurrency
);
}
public InputHandler(
Stream input,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestProcessIdentifier requestProcessIdentifier,
IRequestRouter <IHandlerDescriptor> requestRouter,
IResponseRouter responseRouter,
ILoggerFactory loggerFactory,
ISerializer serializer
)
{
if (!input.CanRead)
{
throw new ArgumentException($"must provide a readable stream for {nameof(input)}", nameof(input));
}
_input = input;
_outputHandler = outputHandler;
_receiver = receiver;
_requestProcessIdentifier = requestProcessIdentifier;
_requestRouter = requestRouter;
_responseRouter = responseRouter;
_serializer = serializer;
_logger = loggerFactory.CreateLogger <InputHandler>();
_scheduler = new ProcessScheduler(loggerFactory);
_inputThread = new Thread(ProcessInputStream)
{
IsBackground = true, Name = "ProcessInputStream"
};
}
private static InputHandler NewHandler(
Stream inputStream,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestProcessIdentifier requestProcessIdentifier,
IRequestRouter <IHandlerDescriptor> requestRouter,
IResponseRouter responseRouter,
Action <CancellationTokenSource> action)
{
var cts = new CancellationTokenSource();
if (!System.Diagnostics.Debugger.IsAttached)
{
cts.CancelAfter(TimeSpan.FromSeconds(5));
}
action(cts);
var handler = new InputHandler(
inputStream,
outputHandler,
receiver,
requestProcessIdentifier,
requestRouter,
responseRouter,
Substitute.For <ILoggerFactory>(),
new DapSerializer(),
null);
handler.Start();
cts.Wait();
Task.Delay(10).Wait();
return(handler);
}
public GetAccountDetails(
IOutputHandler outputHandler,
IAccountRepository accountRepository)
{
_outputHandler = outputHandler;
_accountRepository = accountRepository;
}
public void PruneEncryptedDirectory(EncryptOptions options, IOutputHandler outputHandler)
{
outputHandler.WriteVerboseLine();
outputHandler.WriteVerbose("Pruning files");
int count = 0;
var fileNames = CreateFileList(options.SourceDir, options.IgnoreFilePath);
var validFiles = EncryptOperationFactory.Build(options.SourceDir, fileNames, options.BinaryKey[0], options.Levels).Select(x => x.EncFileName);
var validHashes = new HashSet <string>(validFiles.Select(Path.GetFileName));
foreach (var file in _fileSource.GetFilesRecursive(options.DestinationDir))
{
var fileName = Path.GetFileName(file);
if (!string.IsNullOrWhiteSpace(fileName) && !validHashes.Contains(fileName))
{
if (count == 0)
{
outputHandler.WriteVerboseLine();
}
outputHandler.WriteVerboseLine("\t{0}", fileName);
File.Delete(file);
count++;
}
}
outputHandler.WriteVerboseLine(count == 0 ? " (no files found)" : "Pruned " + count + " files");
}
public ProgressLoader(IHttpContextAccessor httpContextAccessor, IOutputHandler outputhandler, ICharacterClassDataAccess characterClassDataAccess, IAbilityDataAccess abilityDataAccess)
{
_httpContextAccessor = httpContextAccessor;
_outputHandler = outputhandler;
_characterClassDataAccess = characterClassDataAccess;
_abilityDataAccess = abilityDataAccess;
}
public WeatherServiceApplication(IWeatherForecastProvider forecastProvider, IInputHandler inputHandler, IOutputHandler outputHandler, IConfigDisplayGenerator configDisplayGenerator)
{
_forecastProvider = forecastProvider;
_inputHandler = inputHandler;
_outputHandler = outputHandler;
_configDisplayGenerator = configDisplayGenerator;
}
static async Task RunHelloWorld(string apiBaseUrl, IOutputHandler outputHandler)
{
client.BaseAddress = new Uri(apiBaseUrl);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json"));
try
{
var apiResponse = await client.GetAsync("api/HelloWorld");
if (apiResponse.IsSuccessStatusCode)
{
var payload = await apiResponse.Content.ReadAsStringAsync();
outputHandler.ProcessOutput(payload);
}
else
{
System.Console.WriteLine($"The API returned an unsuccessful response code ({apiResponse.StatusCode}).");
}
}
catch (Exception e)
{
System.Console.WriteLine($"An error has occurred: {e.Message}");
}
System.Console.ReadLine();
}
public Connection(
PipeReader input,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestProcessIdentifier requestProcessIdentifier,
IRequestRouter <IHandlerDescriptor?> requestRouter,
IResponseRouter responseRouter,
ILoggerFactory loggerFactory,
OnUnhandledExceptionHandler onUnhandledException,
TimeSpan requestTimeout,
bool supportContentModified,
int concurrency,
IScheduler scheduler,
CreateResponseExceptionHandler?getException = null
) : this(
input,
outputHandler,
receiver,
requestRouter,
responseRouter,
new DefaultRequestInvoker(
requestRouter,
outputHandler,
requestProcessIdentifier,
new RequestInvokerOptions(
requestTimeout,
supportContentModified,
concurrency),
loggerFactory,
scheduler),
loggerFactory,
onUnhandledException,
getException)
{
}
public Deposit(
IOutputHandler outputHandler,
IAccountRepository accountRepository)
{
_outputHandler = outputHandler;
_accountRepository = accountRepository;
}
public AddTodoItem(
ITodoRepository repo,
IOutputHandler handler)
{
repository = repo;
outputHandler = handler;
}
private InputHandler NewHandler(
PipeReader inputStream,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestProcessIdentifier requestProcessIdentifier,
IRequestRouter <IHandlerDescriptor?> requestRouter,
ILoggerFactory loggerFactory,
IResponseRouter responseRouter,
IScheduler?scheduler = null
) =>
new InputHandler(
inputStream,
outputHandler,
receiver,
requestProcessIdentifier,
requestRouter,
responseRouter,
loggerFactory,
_unhandledException,
null,
TimeSpan.FromSeconds(30),
true,
null,
scheduler ?? TaskPoolScheduler.Default
);
public void ExtractData(IOutputHandler ex, IFetchableHandler ch)
{
ex.Start();
ch.Start();
string[] tab = new string[Lines.Length * 6];
int i = 0;
foreach (string line in Lines)
{
ch.Handle(new string[1] {
line + " pogoda"
});
tab[i] = String.Format("{0:yyyy/MM/dd HH:mm:ss}", DateTime.Now);
tab[i + 1] = line;
try
{
tab[i + 2] = ch.GetData("wob_tm").ToString();
tab[i + 3] = ch.GetData("wob_pp").ToString();
tab[i + 4] = ch.GetData("wob_ws").ToString();
tab[i + 5] = "Success";
}
catch (DataNotFoundException)
{
tab[i + 5] = "Fail";
}
i += 6;
}
ex.Handle(tab);
ex.Finish();
ch.Finish();
}
public void SetOutputHandler(IOutputHandler outputHandler)
{
if (outputHandler != null)
{
//We need to store a ref in order to prevent garbage collection.
WriteDataDelegate tmpWriteDataDelegate = new WriteDataDelegate(WriteDataCallback);
ImageDelegate tmpBeginImageDelegate = new ImageDelegate(ImageCallback);
IntPtr ptrWriteData = Marshal.GetFunctionPointerForDelegate(tmpWriteDataDelegate);
IntPtr ptrBeginImage = Marshal.GetFunctionPointerForDelegate(tmpBeginImageDelegate);
nvttSetOutputOptionsOutputHandler(options, ptrWriteData, ptrBeginImage);
writeDataDelegate = tmpWriteDataDelegate;
beginImageDelegate = tmpBeginImageDelegate;
currentOutputHandler = outputHandler;
}
else
{
nvttSetOutputOptionsOutputHandler(options, IntPtr.Zero, IntPtr.Zero);
writeDataDelegate = null;
beginImageDelegate = null;
currentOutputHandler = null;
}
}
public AuthService(IAppConfig config, IOutputHandler outputHandler, OAuthClient oAuthClient)
{
(_verifier, _challenge) = PKCEUtil.GenerateCodes();
_config = config;
_outputHandler = outputHandler;
var loginRequest = new LoginRequest(new Uri(_redirectUri), _config.ClientId, LoginRequest.ResponseType.Code)
{
CodeChallengeMethod = "S256",
CodeChallenge = _challenge,
Scope = new [] {
Scopes.AppRemoteControl,
Scopes.PlaylistModifyPrivate,
Scopes.PlaylistModifyPublic,
Scopes.PlaylistReadCollaborative,
Scopes.PlaylistReadPrivate,
Scopes.Streaming,
Scopes.UserFollowModify,
Scopes.UserFollowRead,
Scopes.UserLibraryModify,
Scopes.UserLibraryRead,
Scopes.UserModifyPlaybackState,
Scopes.UserReadCurrentlyPlaying,
Scopes.UserReadPlaybackPosition,
Scopes.UserReadPlaybackState,
Scopes.UserReadPrivate,
Scopes.UserReadRecentlyPlayed,
Scopes.UserTopRead,
}
};
_oAuthClient = oAuthClient;
_loginRequestUri = loginRequest.ToUri();
}
/// <summary>
/// add a handler with a set of filters to the pipeline
/// </summary>
/// <param name="pipeline"></param>
/// <param name="outputHandler"></param>
/// <param name="filters"></param>
public static void AddHandler(this IEventPipeline pipeline, IOutputHandler outputHandler, IEnumerable <string> filters)
{
var converter = filters.BuildDataFilter();
outputHandler = new DataFilterDecorator(converter, outputHandler);
pipeline.AddHandler(outputHandler);
}
public CoffeeMachine(ICoffeeMachineCommandProvider commands, ICoffeeMachineController controller, ICoffeeMachineLogger logger,
IOutputHandler outputHandler)
{
this.controller = controller;
this.logger = logger;
this.outputHandler = outputHandler;
this.commands = commands;
}
public Session(TcpClient tcpClient_, IInputHandler inputHandler_, IOutputHandler outputHandler_, ILogger logger_)
{
tcpClient = tcpClient_;
inputHandler = inputHandler_;
outputHandler = outputHandler_;
logger = logger_;
client = new Client();
}
public static void AddHandler(CEiffelCompiler compiler, IOutputHandler handler)
{
if (compiler != null && handler != null)
{
compiler.OutputError += new IEiffelCompilerEvents_OutputErrorEventHandler (handler.ProcessError);
compiler.OutputString += new IEiffelCompilerEvents_OutputStringEventHandler (handler.ProcessOutput);
}
}
static public void AddHandler(CEiffelCompiler compiler, IOutputHandler handler)
{
if (compiler != null && handler != null)
{
compiler.OutputError += new IEiffelCompilerEvents_OutputErrorEventHandler(handler.ProcessError);
compiler.OutputString += new IEiffelCompilerEvents_OutputStringEventHandler(handler.ProcessOutput);
}
}
public TestCoffeeMachine(ICoffeeMachineCommandProvider commands,
ICoffeeMachineController controller,
ICoffeeMachineLogger logger,
IOutputHandler outputHandler) : base(commands,
controller,
logger,
outputHandler) =>
this.controller = controller;
public GetCustomerDetails(
IOutputHandler outputHandler,
ICustomerRepository customerRepository,
IAccountRepository accountRepository)
{
_outputHandler = outputHandler;
_customerRepository = customerRepository;
_accountRepository = accountRepository;
}
public Deposit(
IOutputHandler outputHandler,
IAccountRepository accountRepository,
ILoginUserService loginUserService)
{
_outputHandler = outputHandler;
_accountRepository = accountRepository;
_loginUserService = loginUserService;
}
public Processor(
IInputHandler inputHandler,
IOutputHandler outputHandler,
IInputToOutputConverter inputToOutputConverter)
{
_inputHandler = inputHandler;
_outputHandler = outputHandler;
_inputToOutputConverter = inputToOutputConverter;
}
public Transfer(
IOutputHandler outputHandler,
IAccountRepository accountRepository,
IUnitOfWork unityOfWork)
{
_outputHandler = outputHandler;
_accountRepository = accountRepository;
_unityOfWork = unityOfWork;
}
public GameRunner(IOutputHandler outputHandler)
{
_outputHandler = outputHandler;
_worldHandler = new WorldHandler(new Random());
_character = new Character(new Inventory());
_currentWorld = _worldHandler.GenerateWorld();
}
public static void Encrypt(EncryptOptions options, IOutputHandler outputHandler)
{
var helper = new EncryptCommandHelper();
PerformCommand(options, outputHandler, "Encryption", () => helper.GenerateEncryptionFileList(options), helper.PerformEncryption);
if (options.Prune)
{
helper.PruneEncryptedDirectory(options, outputHandler);
}
}
public Bootstrapper(Context context, string buildProject)
{
_buildProject = buildProject;
_context = context;
_context.ChildWorkingDirectory("Bootstrap");
_context.AddHandler(new HtmlOutputHandler(Path.Combine(_context.WorkingDirectory, "Bootstrap.log")));
_console = new LineNumberingOutputHandler(Console.Out, Console.Error);
}
public ProcessWrapper(Command command, string workingDir, IOutputHandler outputHandlers)
{
_command = command;
_workingDir = workingDir;
_outputHandler = outputHandlers;
}
public static void CalculateAndWriteResults(IInputHandler inputHandler, IOutputHandler outputHandler, IFibonacciCalculator calculator)
{
var number = inputHandler.GetNumber();
var result = calculator.Calculate(number);
outputHandler.Write(result);
}
public FileOutputHandler(string logFile)
{
var fileWriter = new StreamWriter(logFile);
handler = new HtmlOutputHandler(fileWriter);
}
private void Prepare_HCS()
{
var uploader = new UploadManager(Config);
SelectedHandler = uploader;
}
private void Prepare_IIS()
{
SelectedHandler = new SmoothStream.ChunkTransformer(Config, true);
}
private void Prepare_Test()
{
SelectedHandler = new TestingOutputHandler();
}
