public OptionsForm()
{
_provider = OptionsProviderRegistry.CurrentOptionsProvider;
_options = _provider.GetOptions();
InitializeComponent();
optionsUI.SetOptions(_options);
}
public void Add(IServiceCollection services, IOptionsProvider optionsProvider)
{
var options = optionsProvider.GetForExtension <CorsOptions>(Name);
services.AddCors(cors =>
{
var allowedHeaders = options.AllowedHeaders ?? Enumerable.Empty <string>();
var allowedMethods = options.AllowedMethods ?? Enumerable.Empty <string>();
var allowedOrigins = options.AllowedOrigins ?? Enumerable.Empty <string>();
var exposedHeaders = options.ExposedHeaders ?? Enumerable.Empty <string>();
cors.AddPolicy("CorsPolicy", builder =>
{
var origins = allowedOrigins.ToArray();
if (options.AllowCredentials && origins.FirstOrDefault() != "*")
{
builder.AllowCredentials();
}
else
{
builder.DisallowCredentials();
}
builder.WithHeaders(allowedHeaders.ToArray())
.WithMethods(allowedMethods.ToArray())
.WithOrigins(origins.ToArray())
.WithExposedHeaders(exposedHeaders.ToArray());
});
});
}
public IIndexSearcher CreateSearcher(IOptionsProvider searchOptions)
{
var searcher = new LuceneIndexSearcher(mIndex);
searcher.ApplyOptions(searchOptions);
return(searcher);
}
public Vector2 Deserialize(IOptionsProvider provider, XElement value)
{
float x, y;
try
{
x = Single.Parse(value.Attribute("X").Value);
y = Single.Parse(value.Attribute("Y").Value);
}
catch (NullReferenceException ex)
{
string message = "The given XElement is not a serialized Vector2.";
Log.Error(message);
throw new InvalidSerializedValueException(message, ex);
}
catch (FormatException ex)
{
string message = "Error parsing the value of the serialized Vector2 setting.";
Log.Error(message);
throw new InvalidSerializedValueException(message, ex);
}
return(new Vector2(x, y));
}
public OptionsForm()
{
_provider = OptionsProviderRegistry.CurrentOptionsProvider;
_options = _provider.GetOptions();
InitializeComponent();
optionsUI.SetOptions(_options);
}
public XElement Serialize(IOptionsProvider provider, Vector3 setting)
{
return(new XElement("Vector3",
new XAttribute("X", setting.x),
new XAttribute("Y", setting.y),
new XAttribute("Z", setting.z)));
}
public IOptionsProvider Update(IOptionsProvider provider, string value, uint?priority)
{
IOptionsProvider res = null;
if (priority.HasValue)
{
if (!Priority.HasValue || priority.Value >= Priority.Value)
{
Priority = priority;
if (Value != value && Provider != provider)
{
res = Provider;
}
Value = value;
Provider = provider;
}
}
else if (!Priority.HasValue)
{
Priority = priority;
if (Value != value && Provider != provider)
{
res = Provider;
}
Value = value;
Provider = provider;
}
else if (provider != Provider && value != Value)
{
res = provider;
}
return(res);
}
public void Use(IApplicationBuilder app, IOptionsProvider optionsProvider)
{
var options = optionsProvider.GetForExtension <SwaggerOptions>(Name);
var routePrefix = string.IsNullOrWhiteSpace(options.RoutePrefix) ? "swagger" : options.RoutePrefix;
app.UseStaticFiles()
.UseSwagger(c => c.RouteTemplate = routePrefix + "/{documentName}/swagger.json");
if (options.ReDocEnabled)
{
app.UseReDoc(c =>
{
c.RoutePrefix = routePrefix;
c.SpecUrl = $"{options.Name}/swagger.json";
});
return;
}
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint($"/{routePrefix}/{options.Name}/swagger.json", options.Title);
c.RoutePrefix = routePrefix;
});
}
public void Add(IServiceCollection services, IOptionsProvider optionsProvider)
{
var options = optionsProvider.GetForExtension <CustomErrorsOptions>(Name);
services.AddSingleton(options);
services.AddScoped <ErrorHandlerMiddleware>();
}
public void Add(IServiceCollection services, IOptionsProvider optionsProvider)
{
var options = optionsProvider.GetForExtension <TracingOptions>("tracing");
services.AddOpenTracing();
services.AddSingleton(options);
if (options.UseEmptyTracer)
{
var defaultTracer = DefaultTracer.Create();
services.AddSingleton(defaultTracer);
return;
}
services.AddSingleton <ITracer>(sp =>
{
var loggerFactory = sp.GetRequiredService <ILoggerFactory>();
var reporter = new RemoteReporter.Builder()
.WithSender(new UdpSender(options.UdpHost, options.UdpPort, options.MaxPacketSize))
.WithLoggerFactory(loggerFactory)
.Build();
var sampler = GetSampler(options);
var tracer = new Tracer.Builder(options.ServiceName)
.WithLoggerFactory(loggerFactory)
.WithReporter(reporter)
.WithSampler(sampler)
.Build();
GlobalTracer.Register(tracer);
return(tracer);
});
}
public void Add(IServiceCollection services, IOptionsProvider optionsProvider)
{
var options = optionsProvider.GetForExtension <RabbitMqOptions>(Name);
services.AddSingleton(options);
services.AddSingleton(sp =>
{
var connectionFactory = new ConnectionFactory
{
HostName = options.HostName,
Port = options.Port,
VirtualHost = options.VirtualHost,
UserName = options.Username,
Password = options.Password,
RequestedConnectionTimeout = options.RequestedConnectionTimeout,
SocketReadTimeout = options.SocketReadTimeout,
SocketWriteTimeout = options.SocketWriteTimeout,
RequestedChannelMax = options.RequestedChannelMax,
RequestedFrameMax = options.RequestedFrameMax,
RequestedHeartbeat = options.RequestedHeartbeat,
UseBackgroundThreadsForIO = options.UseBackgroundThreadsForIO,
Ssl = options.Ssl is null
? new SslOption()
: new SslOption(options.Ssl.ServerName, options.Ssl.CertificatePath, options.Ssl.Enabled),
};
return(connectionFactory.CreateConnection());
});
services.AddTransient <IRabbitMqClient, RabbitMqClient>();
services.AddTransient <RabbitMqHandler>();
services.AddSingleton <IContextBuilder, NullContextBuilder>();
}
public Rect Deserialize(IOptionsProvider provider, XElement value)
{
float x, y, width, height;
try
{
x = Single.Parse(value.Attribute("X").Value);
y = Single.Parse(value.Attribute("Y").Value);
width = Single.Parse(value.Attribute("Width").Value);
height = Single.Parse(value.Attribute("Height").Value);
}
catch (NullReferenceException ex)
{
string message = "The given XElement is not a serialized Rect.";
Log.Error(message);
throw new InvalidSerializedValueException(message, ex);
}
catch (FormatException ex)
{
string message = "Error parsing the value of the serialized Rect setting.";
Log.Error(message);
throw new InvalidSerializedValueException(message, ex);
}
return(new Rect(x, y, width, height));
}
public void InitEntity(IOptionsProvider optionsProvider)
{
var defaultOptions = optionsProvider.GetDefaultOptions();
var options = GetSavedOptions(optionsProvider.Id.Value, defaultOptions, false);
optionsProvider.InitOptions(options);
}
public AggregateTypeCompletionProvider(IOptionsProvider optionsProvider, params ICompletionProvider[] completionProviders)
{
this.completionProviders = completionProviders;
triggerCompletions = completionProviders.OfType <ITriggerCompletions>().ToArray();
_optionsProvider = optionsProvider;
}
/// <summary>
/// Creates a new instance
/// </summary>
/// <param name="logger">Logger</param>
/// <param name="options">Options</param>
/// <param name="fileSystem">File system</param>
public FileSystemAdapter(ILogger logger
, IOptionsProvider options
, IFileSystem fileSystem)
{
_logger = logger;
_options = options;
_fileSystem = fileSystem;
}
/// <summary>
/// Handles change of search options.
/// </summary>
/// <param name="optionsProvider">Options provider, whose option has changed.</param>
/// <param name="option">Option, which has changed.</param>
void OnSearchOptionChanged(IOptionsProvider optionsProvider, IOption option)
{
if (ImmediateSearch)
{
StartSearch(mSearchType, mSearchQuery, mUseFileTypeFilter ? FileTypeFilter.AllowedFileTypes : null, mUseDirectoryFilter ? DirectoryFilter.AllowedDirectories : null);
}
OnPropertyChanged("SearchOptions." + option.Name);
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="optionsValidator">Options validator</param>
/// <param name="options">Options provider</param>
/// <param name="logger">Logger</param>
public ValidateOptionsTask(IOptionsValidator optionsValidator
, IOptionsProvider options
, ILogger logger)
{
_optionsValidator = optionsValidator;
_options = options;
_logger = logger;
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="logger">Logger</param>
/// <param name="symbolStores">Collection of symbol stores</param>
/// <param name="options">Options</param>
public ContentResolver(ILogger logger
, IEnumerable <ISymbolStore> symbolStores
, IOptionsProvider options)
{
_logger = logger;
_options = options;
_symbolStores = symbolStores.ToArray();
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="logger">Logger</param>
/// <param name="options">Options</param>
/// <param name="sequenceTasks">Sequence tasks.</param>
public TaskAggregator(ILogger logger
, IOptionsProvider options
, IEnumerable <ISequenceTask> sequenceTasks)
{
_logger = logger;
_options = options;
_sequenceTasks = sequenceTasks;
}
public XElement Serialize(IOptionsProvider provider, Rect setting)
{
return(new XElement("Rect",
new XAttribute("X", setting.x),
new XAttribute("Y", setting.y),
new XAttribute("Width", setting.width),
new XAttribute("Height", setting.height)));
}
public ResourceManager(GraphicsDevice graphics, IStorageSystem storageSystem, IOptionsProvider options)
{
Storage = storageSystem;
Graphics = graphics;
Atlas = new AtlasGenerator(Graphics);
Options = options;
}
public AggregateTypeCompletionProvider(IOptionsProvider optionsProvider, params ICompletionProvider[] completionProviders)
{
typeCompletionProviders = completionProviders.OfType <ITypeCompletionProvider>().ToList();
simpleCompletionProviders = completionProviders.OfType <ISimpleCompletionProvider>().ToList();
triggerCompletions = completionProviders.OfType <ITriggerCompletions>().ToList();
_optionsProvider = optionsProvider;
}
public SPWorldProvider(Alex alex, IWorldGenerator worldGenerator)
{
Alex = alex;
OptionsProvider = alex.Services.GetService <IOptionsProvider>();
_generator = worldGenerator;
ThreadCancellationTokenSource = new CancellationTokenSource();
}
protected virtual void InitializeDefaultProvider()
{
if (this.provider != null)
{
this.provider.Dispose();
this.provider = null;
}
this.provider = new XmlOptionsProvider(this);
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="fileSystemAdapter">File system</param>
/// <param name="contentResolver">Content resolver</param>
/// <param name="logger">Logger</param>
/// <param name="options">Options</param>
public ProcessTemplatesTask(IFileSystemAdapter fileSystemAdapter
, IContentResolver contentResolver
, ILogger logger
, IOptionsProvider options)
{
_fileSystemAdapter = fileSystemAdapter;
_contentResolver = contentResolver;
_logger = logger;
_options = options;
}
public Program(
IOptionsProvider optionsProvider,
IOutputWriter outputWriter,
IHackerNewsTopPostRetriever hackerNewsTopPostRetriever,
IJsonSerializer jsonSerializer)
{
_optionsProvider = optionsProvider;
_outputWriter = outputWriter;
_hackerNewsTopPostRetriever = hackerNewsTopPostRetriever;
_jsonSerializer = jsonSerializer;
}
public AuthenticationTicketProvider(
IAuthenticationManager authenticationManager,
IDateTimeOffsetProvider dateTimeOffsetProvider,
ITokenHttpClient tokenHttpClient,
IOptionsProvider <AspNetCoreAuthorizationCodeFlowOptions> optionsProvider)
{
this.authenticationManager = authenticationManager;
this.dateTimeOffsetProvider = dateTimeOffsetProvider;
this.tokenHttpClient = tokenHttpClient;
this.optionsProvider = optionsProvider;
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="options">Options.</param>
/// <param name="logger">Logger</param>
/// <param name="assemblyResolver">Assembly resolver</param>
/// <param name="fileSystemAdapter">File system adapter</param>
public CSharpCompiler(IOptionsProvider options
, ILogger logger
, IAssemblyResolver assemblyResolver
, IFileSystemAdapter fileSystemAdapter)
{
_options = options;
_logger = logger;
_assemblyResolver = assemblyResolver;
_fileSystemAdapter = fileSystemAdapter;
_lazyMetadataReferences = new Lazy <IList <MetadataReference> >(BuildReferences);
}
public CommandDispatcher(ICommandRegistry commandRegistry,
ICommandExecuter commandExecuter,
ICommandScopeManager commandScopeManager,
ICommandAuditPipeline auditPipeline,
IOptionsProvider optionsProvider)
{
_commandRegistry = commandRegistry;
_commandScopeManager = commandScopeManager;
_auditor = auditPipeline;
AssociatedExecuter = commandExecuter;
_collectMetrics = optionsProvider.Options.MetricCollectionEnabled;
}
public XmlWorker(ILogger logger,
IXmlDownloader xmlDownloader,
IXmlComparer xmlComparer,
IBackgroundDownloader backgroundDownloader,
IOptionsProvider optionsProvider)
{
this.logger = logger;
this.xmlDownloader = xmlDownloader;
this.xmlComparer = xmlComparer;
this.backgroundDownloader = backgroundDownloader;
this.optionsProvider = optionsProvider;
}
/// <summary>
/// Creates a new instance
/// </summary>
/// <param name="compiler">Compiler</param>
/// <param name="logger">Logger</param>
/// <param name="options">Options</param>
/// <param name="fileSystemAdapter">File system</param>
/// <param name="extensionTypeActivator">Extension type activator</param>
public ExtensionScriptSymbolStore(ICompiler compiler
, ILogger logger
, IOptionsProvider options
, IFileSystemAdapter fileSystemAdapter
, IExtensionTypeActivator extensionTypeActivator)
{
_compiler = compiler;
_logger = logger;
_options = options;
_fileSystemAdapter = fileSystemAdapter;
_extensionTypeActivator = extensionTypeActivator;
}
public static void PushOptionsProvider(IOptionsProvider provider)
{
_optionsProviders.Push(provider);
}
/// <summary>
/// Creates a new RunManager instance
/// </summary>
/// <param name="args">Commandline parameters</param>
public RunManager(string[] args)
{
_doRun = true;
InstallMultiplexer();
#if DEBUG
ShowConsole();
Thread.CurrentThread.Name = "Main";
ThreadHelper.Track(Thread.CurrentThread);
#endif
_opts = new Opts();
_files = new FileManager(this);
var test = _files.GetDir("");
_commands = new Commands.Executor(this);
_abortOnExit = new ManualResetEvent(false);
_notifyHandlers = new List<ValueChangedHandler>();
foreach (var arg in args)
{
switch(arg.Substring(0,1))
{
case "-":
var argparts = arg.Substring(1).Split(new[] {"="}, StringSplitOptions.None);
switch ( argparts[0].ToLower() )
{
case "runmode":
#region RunmodeSelector
RunMode runMode = RunMode.Play;
if (argparts.Length < 2)
{
Console.WriteLine("[Warning] No runmode supplied!");
break;
}
switch (argparts[1])
{
case "select":
var selectForm = new Form();
selectForm.Text = "Select Runmode";
selectForm.FormBorderStyle = FormBorderStyle.FixedToolWindow;
selectForm.Size = new Size(330, 75);
selectForm.StartPosition = FormStartPosition.CenterScreen;
selectForm.Controls.Add(new Button()
{
Text = "Game",
Location = new Point(5, 3),
Size = new Size(75, 44)
});
selectForm.Controls.Add(new Button()
{
Text = "Editor",
Location = new Point(84, 3),
Size = new Size(75, 44)
});
selectForm.Controls.Add(new Button()
{
Text = "Server",
Location = new Point(163, 3),
Size = new Size(75, 44)
});
selectForm.Controls.Add(new Button()
{
Text = "Collab Server",
Location = new Point(242, 3),
Size = new Size(75, 44)
});
selectForm.Controls[0].Click +=
delegate
{
runMode = RunMode.Play;
selectForm.Close();
};
selectForm.Controls[1].Click +=
delegate
{
runMode = RunMode.Edit;
selectForm.Close();
};
selectForm.Controls[2].Click +=
delegate
{
runMode = RunMode.GameServer;
selectForm.Close();
};
selectForm.Controls[3].Click +=
delegate
{
runMode = RunMode.CollabServer;
selectForm.Close();
};
selectForm.Show();
selectForm.Focus();
Application.Run(selectForm);
break;
case "game":
runMode = RunMode.Play;
break;
case "gameserver":
runMode = RunMode.ServerPlay;
break;
case "edit":
case "editor":
runMode = RunMode.Edit;
break;
case "server":
runMode = RunMode.GameServer;
break;
case "collabserver":
case "editserver":
runMode = RunMode.CollabServer;
break;
case "aioserver":
runMode = RunMode.AIOServer;
break;
default:
Console.WriteLine("[Warning] Unknown runMode: '"+argparts[0]+"'");
break;
}
Opts.Set("sys_runMode", runMode);
#endregion
break;
case "console":
#region ConsoleSection
#if !DEBUG
ShowConsole();
#else
Console.WriteLine("[Info] Commandline-parameter '-console' given, ignoring...");
#endif
#endregion
break;
}
break;
case "+":
if (arg.Length < 2)
continue;
_commands.Parse(arg.Substring(1));
break;
}
}
((Options.Options)_opts).LockDownReadonly();
_views = new List<Base.Abstract.View>();
#if DEBUG
ThreadHelper.Start(delegate
{
var dbgWnd = new DebugWindow(this);
Application.Run(dbgWnd);
}, "Dbg_Wnd");
#endif
Console.ForegroundColor = _opts.Get<ConsoleColor>("gui_consoleColor");
_notifyHandlers.Add(_opts.RegisterChangeNotification("gui_consoleColor",
delegate(string key, object value) { Console.ForegroundColor = (ConsoleColor)value; }));
}
public Client(IOptionsProvider optionProvider)
{
this.OptionsProvider = optionProvider;
}
