/// <summary>
/// Creates a new object.
/// </summary>
public DotNetUniversalPlugAndPlayManager()
{
Provider = new DefaultProvider();
var configurationStorage = Factory.Singleton.Resolve<IConfigurationStorage>().Singleton;
configurationStorage.ConfigurationChanged += ConfigurationStorage_ConfigurationChanged;
}
public void TestSlidingExpiration()
{
if (!SupportsSlidingExpiration)
{
Assert.Ignore("Provider does not support sliding expiration settings");
}
const int expirySeconds = 3;
const string key = "keyTestSlidingExpiration";
var obj = new SomeObject {
Id = 2
};
var props = GetPropertiesForExpiration(Cfg.Environment.CacheDefaultExpiration, expirySeconds.ToString());
props["cache.use_sliding_expiration"] = "true";
var cache = DefaultProvider.BuildCache("TestObjectExpiration", props);
cache.Put(key, obj);
// Wait up to 1 sec before expiration
Thread.Sleep(TimeSpan.FromSeconds(expirySeconds - 1));
Assert.That(cache.Get(key), Is.Not.Null, "Missing entry for key");
// Wait up to 1 sec before expiration again
Thread.Sleep(TimeSpan.FromSeconds(expirySeconds - 1));
Assert.That(cache.Get(key), Is.Not.Null, "Missing entry for key after get and wait less than expiration");
// Wait expiration
Thread.Sleep(TimeSpan.FromSeconds(expirySeconds + 1));
// Check it expired
Assert.That(cache.Get(key), Is.Null, "Unexpected entry for key after expiration");
}
public void TestExpiration()
{
var cache = DefaultProvider.BuildCache("foo", null) as SysCacheRegion;
Assert.That(cache, Is.Not.Null, "pre-configured foo cache not found");
Assert.That(RelativeExpirationField.GetValue(cache), Is.EqualTo(TimeSpan.FromSeconds(500)), "Unexpected expiration value for foo region");
// In the case of SysCache2, due to the SQL notification callbacks which may be set up for each configured region,
// the build provider handles a global region cache and guarantees uniqueness of yielded cache region per region name
// for the whole application.
cache = DefaultProvider.BuildCache("noExplicitExpiration1", null) as SysCacheRegion;
Assert.That(RelativeExpirationField.GetValue(cache), Is.EqualTo(TimeSpan.FromSeconds(300)),
"Unexpected expiration value for noExplicitExpiration1 region");
Assert.That(UseSlidingExpirationField.GetValue(cache), Is.True, "Unexpected sliding value for noExplicitExpiration1 region");
cache = DefaultProvider
.BuildCache("noExplicitExpiration2", new Dictionary <string, string> {
{ "expiration", "100" }
}) as SysCacheRegion;
Assert.That(RelativeExpirationField.GetValue(cache), Is.EqualTo(TimeSpan.FromSeconds(100)),
"Unexpected expiration value for noExplicitExpiration2 region with default expiration");
cache = DefaultProvider
.BuildCache("noExplicitExpiration3", new Dictionary <string, string> {
{ Cfg.Environment.CacheDefaultExpiration, "50" }
}) as SysCacheRegion;
Assert.That(RelativeExpirationField.GetValue(cache), Is.EqualTo(TimeSpan.FromSeconds(50)),
"Unexpected expiration value for noExplicitExpiration3 region with cache.default_expiration");
}
protected CacheBase GetDefaultCache()
{
var cache = (CacheBase)DefaultProvider.BuildCache(DefaultRegion, GetDefaultProperties());
Assert.That(cache, Is.Not.Null, "No default cache returned");
return(cache);
}
public void TestExpiration()
{
var cache = DefaultProvider.BuildCache("foo", null) as RedisCache;
Assert.That(cache, Is.Not.Null, "pre-configured foo cache not found");
var strategy = cache.RegionStrategy;
Assert.That(strategy, Is.Not.Null, "strategy was not set for the pre-configured foo cache");
Assert.That(strategy, Is.TypeOf <DefaultRegionStrategy>(), "unexpected strategy type for foo region");
Assert.That(strategy.Expiration, Is.EqualTo(TimeSpan.FromSeconds(500)), "unexpected expiration value for foo region");
cache = (RedisCache)DefaultProvider.BuildCache("noExplicitExpiration", null);
Assert.That(cache.RegionStrategy.Expiration, Is.EqualTo(TimeSpan.FromSeconds(300)),
"unexpected expiration value for noExplicitExpiration region");
Assert.That(cache.RegionStrategy.UseSlidingExpiration, Is.True, "unexpected sliding value for noExplicitExpiration region");
cache = (RedisCache)DefaultProvider
.BuildCache("noExplicitExpiration", new Dictionary <string, string> {
{ "expiration", "100" }
});
Assert.That(cache.RegionStrategy.Expiration, Is.EqualTo(TimeSpan.FromSeconds(100)),
"unexpected expiration value for noExplicitExpiration region with default expiration");
cache = (RedisCache)DefaultProvider
.BuildCache("noExplicitExpiration", new Dictionary <string, string> {
{ Cfg.Environment.CacheDefaultExpiration, "50" }
});
Assert.That(cache.RegionStrategy.Expiration, Is.EqualTo(TimeSpan.FromSeconds(50)),
"unexpected expiration value for noExplicitExpiration region with cache.default_expiration");
}
public void TestExpiration()
{
var cache = DefaultProvider.BuildCache("foo", null) as CoreDistributedCache;
Assert.That(cache, Is.Not.Null, "pre-configured foo cache not found");
Assert.That(cache.Expiration, Is.EqualTo(TimeSpan.FromSeconds(500)), "Unexpected expiration value for foo region");
cache = (CoreDistributedCache)DefaultProvider.BuildCache("noExplicitExpiration", null);
Assert.That(cache.Expiration, Is.EqualTo(TimeSpan.FromSeconds(300)),
"Unexpected expiration value for noExplicitExpiration region");
Assert.That(cache.UseSlidingExpiration, Is.True, "Unexpected sliding value for noExplicitExpiration region");
cache = (CoreDistributedCache)DefaultProvider
.BuildCache("noExplicitExpiration", new Dictionary <string, string> {
{ "expiration", "100" }
});
Assert.That(cache.Expiration, Is.EqualTo(TimeSpan.FromSeconds(100)),
"Unexpected expiration value for noExplicitExpiration region with default expiration");
cache = (CoreDistributedCache)DefaultProvider
.BuildCache("noExplicitExpiration",
new Dictionary <string, string> {
{ Cfg.Environment.CacheDefaultExpiration, "50" }
});
Assert.That(cache.Expiration, Is.EqualTo(TimeSpan.FromSeconds(50)),
"Unexpected expiration value for noExplicitExpiration region with cache.default_expiration");
}
/// <summary>
/// Creates a new object.
/// </summary>
public FlightSimulatorXPresenter()
{
Provider = new DefaultProvider();
_FlightSimulatorX = Factory.Singleton.Resolve <IFlightSimulatorX>();
Factory.Singleton.Resolve <IConfigurationStorage>().Singleton.ConfigurationChanged += ConfigurationStorage_ConfigurationChanged;
}
protected ICache GetCacheForExpiration(string cacheRegion, string expirationSetting, int expirySeconds)
{
var props = GetPropertiesForExpiration(expirationSetting, expirySeconds.ToString());
var cache = DefaultProvider.BuildCache(cacheRegion, props);
return(cache);
}
public void TestPriorityOutOfRange()
{
var props = GetDefaultProperties();
props["priority"] = 7.ToString();
Assert.That(() => DefaultProvider.BuildCache("TestPriorityOutOfRange", props),
Throws.TypeOf <IndexOutOfRangeException>());
}
/// <summary>
/// Creates a new object.
/// </summary>
public DotNetUniversalPlugAndPlayManager()
{
Provider = new DefaultProvider();
var configurationStorage = Factory.Singleton.Resolve <IConfigurationStorage>().Singleton;
configurationStorage.ConfigurationChanged += ConfigurationStorage_ConfigurationChanged;
}
public void TestNoExpiration()
{
var props = GetDefaultProperties();
props["expiration"] = "0";
Assert.Throws <CacheException>(() => DefaultProvider.BuildCache(DefaultRegion, props),
"default region strategy should not allow to have no expiration");
}
public static void PrintMessages()
{
var proxy = DefaultProvider.GetDefaultRepository();
var csvText = proxy.GetCsvMessages();
Console.WriteLine("CSV response");
Console.WriteLine(csvText);
}
/// <summary>
/// Creates a new object.
/// </summary>
public FlightSimulatorPresenter()
{
Provider = new DefaultProvider();
_FlightSimulatorX = Factory.Resolve <IFlightSimulator>();
_Clock = Factory.Resolve <IClock>();
Factory.ResolveSingleton <IConfigurationStorage>().ConfigurationChanged += ConfigurationStorage_ConfigurationChanged;
Factory.ResolveSingleton <IFeedManager>().FeedsChanged += FeedManager_FeedsChanged;
}
protected virtual void OnWindowManagerCheckToggled(object sender, System.EventArgs e)
{
if (window_manager_check.Active)
{
DefaultProvider.SetWindowManager();
}
WindowManager = window_manager_check.Active = DefaultProvider.IsWindowManager;
window_manager_check.Sensitive = !window_manager_check.Active;
}
private RedisCache GetDefaultRedisCache(Dictionary <string, string> properties = null)
{
var props = GetDefaultProperties();
foreach (var property in properties ?? new Dictionary <string, string>())
{
props[property.Key] = property.Value;
}
return((RedisCache)DefaultProvider.BuildCache(DefaultRegion, props));
}
private RedisCache GetFastRedisCache(Dictionary <string, string> properties = null)
{
var props = GetDefaultProperties();
foreach (var property in properties ?? new Dictionary <string, string>())
{
props[property.Key] = property.Value;
}
props["strategy"] = typeof(FastRegionStrategy).AssemblyQualifiedName;
return((RedisCache)DefaultProvider.BuildCache(DefaultRegion, props));
}
/// <summary>
/// Creates a new object.
/// </summary>
public StandingDataManager()
{
Lock = new object();
Provider = new DefaultProvider();
RouteStatus = Strings.NotLoaded;
var configurationStorage = Factory.ResolveSingleton <IConfigurationStorage>();
_DatabaseFileName = Path.Combine(configurationStorage.Folder, "StandingData.sqb");
_StateFileName = Path.Combine(configurationStorage.Folder, "FlightNumberCoverage.csv");
}
public static IAclProvider Deny(string resource, string verb, params string[] subjects)
{
List <AccessRule> acls = new List <AccessRule>();
resource = resource.ToLower();
verb = verb.ToLower();
foreach (string subject in subjects)
{
acls.Add(new Deny(resource, verb, subject.ToLower()));
}
return(DefaultProvider.SetAcls(acls.ToArray()));
}
protected async override Task <int> ExecuteInternalAsync()
{
string defaultProvider = DefaultProvider.Value();
if (string.IsNullOrEmpty(defaultProvider) && UseDefault.HasValue())
{
defaultProvider = Settings.DefaultProvider;
}
await CreateManifestAsync(defaultProvider, DefaultDestination.Value(), Settings, DefaultProvider.LongName, CancellationToken.None);
return(0);
}
/// <summary>
///
/// </summary>
/// <param name="resource"></param>
/// <param name="subjects"></param>
/// <returns><see cref="true"/> if the <paramref name="subjects"/> specified have at least one rule that allow them to do something within the resource hierarchy</returns>
public static bool CanBrowse(string resource, params string[] subjects)
{
resource = resource.ToLower();
foreach (AccessRule acl in DefaultProvider.GetAcls(resource, "*"))
{
if (acl.Type == AccessRules.Allow)
{
return(true);
}
}
return(false);
}
private ILibraryInstallationState SetDefaultProviderIfNeeded(LibraryInstallationState desiredState)
{
if (string.IsNullOrEmpty(DefaultProvider))
{
DefaultProvider = desiredState.ProviderId;
desiredState.IsUsingDefaultProvider = true;
}
else if (DefaultProvider.Equals(desiredState.ProviderId, StringComparison.OrdinalIgnoreCase))
{
desiredState.IsUsingDefaultProvider = true;
}
return(desiredState);
}
public void TestBadRelativeExpiration([ValueSource(nameof(ExpirationSettingNames))] string expirationSetting)
{
if (!SupportsDefaultExpiration)
{
Assert.Ignore("Provider does not support default expiration settings");
}
var props = GetPropertiesForExpiration(expirationSetting, "foobar");
Assert.That(
() => DefaultProvider.BuildCache("TestBadRelativeExpiration", props),
Throws.ArgumentException.Or.TypeOf <FormatException>(),
expirationSetting);
}
public void TestMaxAllowedVersion()
{
var cache = (RedisCache)GetDefaultCache();
var strategy = (DefaultRegionStrategy)cache.RegionStrategy;
var version = strategy.CurrentVersion;
var props = GetDefaultProperties();
props.Add("cache.region_strategy.default.max_allowed_version", version.ToString());
cache = (RedisCache)DefaultProvider.BuildCache(DefaultRegion, props);
strategy = (DefaultRegionStrategy)cache.RegionStrategy;
cache.Clear();
Assert.That(strategy.CurrentVersion, Is.EqualTo(1L), "the version was not reset to 1");
}
public void TestRegions()
{
const string key = "keyTestRegions";
var props = GetDefaultProperties();
var cache1 = DefaultProvider.BuildCache("TestRegions1", props);
var cache2 = DefaultProvider.BuildCache("TestRegions2", props);
const string s1 = "test1";
const string s2 = "test2";
cache1.Put(key, s1);
cache2.Put(key, s2);
var get1 = cache1.Get(key);
var get2 = cache2.Get(key);
Assert.That(get1, Is.EqualTo(s1), "Unexpected value in cache1");
Assert.That(get2, Is.EqualTo(s2), "Unexpected value in cache2");
}
public async Task TestRegionsAsync()
{
const string key = "keyTestRegions";
var props = GetDefaultProperties();
var cache1 = DefaultProvider.BuildCache("TestRegions1", props);
var cache2 = DefaultProvider.BuildCache("TestRegions2", props);
const string s1 = "test1";
const string s2 = "test2";
await(cache1.PutAsync(key, s1, CancellationToken.None));
await(cache2.PutAsync(key, s2, CancellationToken.None));
var get1 = await(cache1.GetAsync(key, CancellationToken.None));
var get2 = await(cache2.GetAsync(key, CancellationToken.None));
Assert.That(get1, Is.EqualTo(s1), "Unexpected value in cache1");
Assert.That(get2, Is.EqualTo(s2), "Unexpected value in cache2");
}
public static void SendDefaultMessage()
{
var proxy = DefaultProvider.GetDefaultRepository();
var csvText = proxy.GetCsvMessages();
Console.WriteLine(csvText);
var command = "/stock=APPL.US quote is $93.42 per share";
var result = proxy.AddMessage(command);
if (result.Status)
{
Console.WriteLine("Message sent successfully!");
}
else
{
Console.WriteLine("Message sent with errors: " + result.OutputMessage);
}
}
static AclManager()
{
Providers = new Dictionary <string, IAclProvider>();
#if !SILVERLIGHT
AclConfigurationSection configSection = (AclConfigurationSection)ConfigurationManager.GetSection("nacl");
if (configSection != null)
{
foreach (ProviderElement provider in configSection.Providers)
{
IAclProvider securityProvider = provider.Provider;
Providers.Add(provider.Name, securityProvider);
if (provider.Name == configSection.DefaultProviderName)
{
DefaultProvider = securityProvider;
}
}
foreach (Ace ace in configSection.Rights)
{
AccessRule privilege = null;
switch (ace.Type)
{
case AccessRules.Allow:
privilege = new Allow(ace.Resource, ace.Verb, ace.Subject);
break;
case AccessRules.Deny:
privilege = new Deny(ace.Resource, ace.Verb, ace.Subject);
break;
}
if (!string.IsNullOrEmpty(ace.TargetProvider))
{
Providers[ace.TargetProvider].SetAcls(privilege);
}
else
{
DefaultProvider.SetAcls(privilege);
}
}
}
else
#endif
DefaultProvider = new MemoryProvider();
}
static void Main(string[] args)
{
// Localization ======================================================
//I18N i18n = I18N.Load("lt");
// Does return prevent from finally block ============================
//try
//{
// Console.Out.WriteLineAsync($"This is a try catch block.");
// return;
//}
//finally
//{
// Console.Out.WriteLineAsync($"And this is a FINALLY block");
// Console.Read();
//}
// WebServices =======================================================
WebService ws = new WebService();
var dp = new DefaultProvider(ws);
var ats = Console.ReadLine()?.ToLower() == "t";
if (!dp.TestAlive(ats))
{
Console.Out.WriteLine("<cxml1.0>\r\n <status>error</status>\r\n <message type=\"error\">Couldn't connect</message>\r\n</cxml1.0>");
return;
}
MakeSpace(5);
string xmlEmployee = $"<cxml1.0>\n" +
$" <header>\n" +
$" <language>LT</language>\n" +
$" <function>GET_Employee</function>\n" +
$" <params>\n" +
$" <id>{Console.ReadLine()}</id>\n" +
$" </params>\n" +
$" </header>\n" +
$"</cxml1.0>\n";
Console.Out.WriteLineAsync(dp.GetEmployee(xmlEmployee));
MakeSpace(5);
Console.ReadLine();
}
public void TestAppendHashcodeToKey()
{
Assert.That(CoreDistributedCacheProvider.AppendHashcodeToKey, Is.True, "Default is not true");
var cache = DefaultProvider.BuildCache("foo", null) as CoreDistributedCache;
Assert.That(cache.AppendHashcodeToKey, Is.True, "First built cache not correctly set");
CoreDistributedCacheProvider.AppendHashcodeToKey = false;
try
{
cache = DefaultProvider.BuildCache("foo", null) as CoreDistributedCache;
Assert.That(cache.AppendHashcodeToKey, Is.False, "Second built cache not correctly set");
}
finally
{
CoreDistributedCacheProvider.AppendHashcodeToKey = true;
}
}
public void TestRemove144()
{
string key = "keyTestRemove144";
string value = "value";
//memcached 1.4+ drops support for expiration time specified for Delete operations
//therefore if you install memcached 1.4.4 this test will fail unless corresponding fix is implemented in MemCacheClient.cs
//the test will fail because Remove won't actually delete the item from the cache!
//the error you will see in the log is: "Error deleting key: nunit@key1. Server response: CLIENT_ERROR bad command line format. Usage: delete <key> [noreply]"
//Now, Memcached.ClientLibrary incorrectly divides expiration time for Delete operation by 1000
//(for Add and Set operations the expiration time is calculated correctly)
//that's why we need to set expiration to 20000, otherwise it will be treated as 20ms which is too small to be sent to server (the minimum value is 1 second)
var props = GetDefaultProperties();
props["expiration"] = "20000";
//disabling lingering delete will cause the item to get immediately deleted
//this parameter is NEW and the code to make it work is part of the proposed fix
props.Add("lingering_delete_disabled", "true");
var cache = DefaultProvider.BuildCache("TestRemove144", props);
Assert.That(cache, Is.Not.Null, "no cache returned");
// add the item
cache.Put(key, value);
Thread.Sleep(1000);
// make sure it's there
var item = cache.Get(key);
Assert.That(item, Is.Not.Null, "item just added is not there");
// remove it
cache.Remove(key);
// make sure it's not there
item = cache.Get(key);
Assert.That(item, Is.Null, "item still exists in cache");
}
public void TestClearWithMultipleClientsAndNoPubSub()
{
const string key = "keyTestClear";
const string value = "valueClear";
var props = GetDefaultProperties();
props.Add("cache.region_strategy.default.use_pubsub", "false");
var cache = (RedisCache)DefaultProvider.BuildCache(DefaultRegion, props);
var strategy = (DefaultRegionStrategy)cache.RegionStrategy;
var cache2 = (RedisCache)DefaultProvider.BuildCache(DefaultRegion, props);
var strategy2 = (DefaultRegionStrategy)cache2.RegionStrategy;
// add the item
cache.Put(key, value);
// make sure it's there
var item = cache.Get(key);
Assert.That(item, Is.Not.Null, "couldn't find item in cache");
item = cache2.Get(key);
Assert.That(item, Is.Not.Null, "couldn't find item in second cache");
var version = strategy.CurrentVersion;
// clear the cache
cache.Clear();
Assert.That(strategy.CurrentVersion, Is.EqualTo(version + 1), "the version has not been updated");
Thread.Sleep(TimeSpan.FromSeconds(2));
Assert.That(strategy2.CurrentVersion, Is.EqualTo(version), "the version should not be updated");
// make sure we don't get an item
item = cache.Get(key);
Assert.That(item, Is.Null, "item still exists in cache after clear");
item = cache2.Get(key);
Assert.That(item, Is.Null, "item still exists in the second cache after clear");
}
/// <summary>
/// Creates a new object.
/// </summary>
public PluginSettingsStorage()
{
Provider = new DefaultProvider();
}
#pragma warning restore 0067
public MonoUniversalPlugAndPlayManager()
{
Provider = new DefaultProvider();
}
public BaseStationDatabaseStub()
{
Provider = new DefaultProvider();
}
/// <summary>
/// Creates a new object.
/// </summary>
public InstallerSettingsStorage()
{
Provider = new DefaultProvider();
}
/// <summary>
/// Creates a new object.
/// </summary>
public WebServer()
{
Provider = new DefaultProvider();
Port = ExternalPort = 80;
}
/// <summary>
/// Creates a new object.
/// </summary>
public BackgroundDataDownloader()
{
Provider = new DefaultProvider();
}
/// <summary>
/// Creates a new object.
/// </summary>
public WebSite()
{
Provider = new DefaultProvider();
}
/// <summary>
/// Creates a new object.
/// </summary>
public Plugin()
{
Provider = new DefaultProvider();
Status = PluginStrings.Disabled;
}
/// <summary>
/// Creates a new object.
/// </summary>
public ConnectionClientLogPresenter()
{
Provider = new DefaultProvider();
}
/// <summary>
/// Creates a new object.
/// </summary>
public MainPresenter()
{
Provider = new DefaultProvider();
}
/// <summary>
/// Creates a new object.
/// </summary>
public OptionsPresenter()
{
Provider = new DefaultProvider();
}
/// <summary>
/// Creates a new object.
/// </summary>
public ExternalIPAddressService()
{
Provider = new DefaultProvider();
}
/// <summary>
/// Creates a new object.
/// </summary>
public BaseStationAircraftList()
{
Provider = new DefaultProvider();
_PictureManager = Factory.Singleton.Resolve<IAircraftPictureManager>().Singleton;
_PictureDirectoryCache = Factory.Singleton.Resolve<IAutoConfigPictureFolderCache>().Singleton.DirectoryCache;
_PictureDirectoryCache.CacheChanged += PictureDirectoryCache_CacheChanged;
_PictureLookupQueue.StartBackgroundThread(SearchForPicture, (ex) => { OnExceptionCaught(new EventArgs<Exception>(ex)); });
_DatabaseLookupQueue.StartBackgroundThread(LoadAircraftDetails, (ex) => { OnExceptionCaught(new EventArgs<Exception>(ex)); });
}
/// <summary>
/// Creates a new object.
/// </summary>
public StatisticsPresenter()
{
Provider = new DefaultProvider();
}
/// <summary>
/// Creates a new object.
/// </summary>
public Database()
{
Provider = new DefaultProvider();
_ConfigurationStorage = Factory.Singleton.Resolve<IConfigurationStorage>().Singleton;
_ConfigurationStorage.ConfigurationChanged += ConfigurationStorage_ConfigurationChanged;
}
/// <summary>
/// Creates a new object.
/// </summary>
public PluginManifestStorage()
{
Provider = new DefaultProvider();
}
/// <summary>
/// Creates a new object.
/// </summary>
public NewVersionChecker()
{
Provider = new DefaultProvider();
}
/// <summary>
/// Creates a new object.
/// </summary>
public PluginManager()
{
Provider = new DefaultProvider();
LoadedPlugins = new List<IPlugin>();
IgnoredPlugins = new Dictionary<string, string>();
}
/// <summary>
/// Creates a new object.
/// </summary>
public ConnectionLogger()
{
Provider = new DefaultProvider();
}
/// <summary>
/// Creates a new object.
/// </summary>
public RawMessageTranslator()
{
Provider = new DefaultProvider();
_StandingDataManager = Factory.Singleton.Resolve<IStandingDataManager>().Singleton;
_Statistics = Factory.Singleton.Resolve<IStatistics>().Singleton;
GlobalDecodeAirborneThresholdMilliseconds = 10000;
GlobalDecodeFastSurfaceThresholdMilliseconds = 25000;
GlobalDecodeSlowSurfaceThresholdMilliseconds = 50000;
LocalDecodeMaxSpeedAirborne = 15.0;
LocalDecodeMaxSpeedTransition = 5.0;
LocalDecodeMaxSpeedSurface = 3.0;
ReceiverRangeKilometres = 650;
TrackingTimeoutSeconds = 600;
AcceptIcaoInPI0Count = 1;
AcceptIcaoInPI0Milliseconds = 1000;
_CompactPositionReporting = Factory.Singleton.Resolve<ICompactPositionReporting>();
_HeartbeatService = Factory.Singleton.Resolve<IHeartbeatService>().Singleton;
_HeartbeatService.SlowTick += Heartbeat_SlowTick;
}
public LogDatabaseStub()
{
Provider = new DefaultProvider();
}
/// <summary>
/// Creates a new object.
/// </summary>
public StandingDataManager()
{
Lock = new object();
Provider = new DefaultProvider();
RouteStatus = Strings.NotLoaded;
var configurationStorage = Factory.Singleton.Resolve<IConfigurationStorage>().Singleton;
_DatabaseFileName = Path.Combine(configurationStorage.Folder, "StandingData.sqb");
_StateFileName = Path.Combine(configurationStorage.Folder, "FlightNumberCoverage.csv");
}
/// <summary>
/// Creates a new object.
/// </summary>
public SplashPresenter()
{
Provider = new DefaultProvider();
}
/// <summary>
/// Creates a new object.
/// </summary>
public Log()
{
Provider = new DefaultProvider();
}
/// <summary>
/// Creates a new object.
/// </summary>
public ConfigurationStorage()
{
Provider = new DefaultProvider();
}
/// <summary>
/// Creates a new object.
/// </summary>
public DirectoryCache()
{
Provider = new DefaultProvider();
Factory.Singleton.Resolve<IHeartbeatService>().Singleton.SlowTick += HeartbeatService_SlowTick;
}
/// <summary>
/// Creates a new object.
/// </summary>
public FlightSimulatorXPresenter()
{
Provider = new DefaultProvider();
_FlightSimulatorX = Factory.Singleton.Resolve<IFlightSimulatorX>();
Factory.Singleton.Resolve<IConfigurationStorage>().Singleton.ConfigurationChanged += ConfigurationStorage_ConfigurationChanged;
}
/// <summary>
/// Creates a new object.
/// </summary>
public Database()
{
Provider = new DefaultProvider();
}
