#pragma warning restore 618
public void TestFixtureSetUp()
{
BossManager = MockRepository.GenerateStub <IBossManager>();
BulletManager = MockRepository.GenerateStub <IBulletManager>();
CollisionManager = MockRepository.GenerateStub <ICollisionManager>();
CommandManager = MockRepository.GenerateStub <ICommandManager>();
ConfigManager = MockRepository.GenerateStub <IConfigManager>();
ContentManager = MockRepository.GenerateStub <IContentManager>();
ControlManager = MockRepository.GenerateStub <IControlManager>();
DebugManager = MockRepository.GenerateStub <IDebugManager>();
DelayManager = MockRepository.GenerateStub <IDelayManager>();
DeviceManager = MockRepository.GenerateStub <IDeviceManager>();
EnemyManager = MockRepository.GenerateStub <IEnemyManager>();
EventManager = MockRepository.GenerateStub <IEventManager>();
ExplosionManager = MockRepository.GenerateStub <IExplosionManager>();
IconManager = MockRepository.GenerateStub <IIconManager>();
ImageManager = MockRepository.GenerateStub <IImageManager>();
InputManager = MockRepository.GenerateStub <IInputManager>();
LevelManager = MockRepository.GenerateStub <ILevelManager>();
MoverManager = MockRepository.GenerateStub <IMoverManager>();
RandomManager = MockRepository.GenerateStub <IRandomManager>();
RenderManager = MockRepository.GenerateStub <IRenderManager>();
ResolutionManager = MockRepository.GenerateStub <IResolutionManager>();
ScoreManager = MockRepository.GenerateStub <IScoreManager>();
ScreenManager = MockRepository.GenerateStub <IScreenManager>();
SoundManager = MockRepository.GenerateStub <ISoundManager>();
SpriteManager = MockRepository.GenerateStub <ISpriteManager>();
StateManager = MockRepository.GenerateStub <IStateManager>();
StopwatchManager = MockRepository.GenerateStub <IStopwatchManager>();
StorageManager = MockRepository.GenerateStub <IStorageManager>();
TextManager = MockRepository.GenerateStub <ITextManager>();
ThreadManager = MockRepository.GenerateStub <IThreadManager>();
FileManager = MockRepository.GenerateStub <IFileManager>();
Logger = MockRepository.GenerateStub <ILogger>();
}
private void Start()
{
_logger.Info("Starting...");
var url = this.UriTextBox.Text.Trim();
if (_threadManager == null)
{
_threadManager = new TaskThreadManager(10);
var crawler = CreateCrawler(_threadManager);
_crawlerCancellationTS = new CancellationTokenSource();
_products.Clear();
_crawlerTask = new Task(() =>
{
CrawlResult result = crawler.Crawl(new Uri(url), _crawlerCancellationTS);
OnCrawlerCompleted();
}, _crawlerCancellationTS.Token);
_crawlerTask.Start();
}
else
{
_threadManager.Resume();
}
NotifyUIOnStatusChange(true);
}
///<summary>
/// Constructs a new space for things to live in.
///</summary>
public Space()
{
NarrowPhaseHelper.CollisionManagers = NarrowPhaseHelper.CollisionManagers; //Forces the NarrowPhaseHelper to run the static constructor. Better to do it now instead of mid-simulation.
timeStepSettings = new TimeStepSettings();
#if !WINDOWS
threadManager = new SpecializedThreadManager();
#else
threadManager = new SpecializedThreadManager();
#endif
SpaceObjectBuffer = new SpaceObjectBuffer(this);
EntityStateWriteBuffer = new EntityStateWriteBuffer();
DeactivationManager = new DeactivationManager(TimeStepSettings, ThreadManager);
ForceUpdater = new ForceUpdater(TimeStepSettings, ThreadManager);
BoundingBoxUpdater = new BoundingBoxUpdater(TimeStepSettings, ThreadManager);
BroadPhase = new DynamicHierarchy(ThreadManager);
NarrowPhase = new NarrowPhase(TimeStepSettings, BroadPhase.Overlaps, ThreadManager);
Solver = new Solver(TimeStepSettings, DeactivationManager, ThreadManager);
NarrowPhase.Solver = Solver;
PositionUpdater = new ContinuousPositionUpdater(TimeStepSettings, ThreadManager);
BufferedStates = new BufferedStatesManager(ThreadManager);
DeferredEventDispatcher = new DeferredEventDispatcher();
DuringForcesUpdateables = new DuringForcesUpdateableManager(timeStepSettings, ThreadManager);
BeforeNarrowPhaseUpdateables = new BeforeNarrowPhaseUpdateableManager(timeStepSettings, ThreadManager);
BeforeSolverUpdateables = new BeforeSolverUpdateableManager(timeStepSettings, ThreadManager);
BeforePositionUpdateUpdateables = new BeforePositionUpdateUpdateableManager(timeStepSettings, ThreadManager);
EndOfTimeStepUpdateables = new EndOfTimeStepUpdateableManager(timeStepSettings, ThreadManager);
EndOfFrameUpdateables = new EndOfFrameUpdateableManager(timeStepSettings, ThreadManager);
}
public SearchWorker(SearchOptions searchOptions, IThreadManager threadManager, ICacheManager cache)
{
this.searchOptions = searchOptions;
this.cache = cache;
deterministicSearchUtils = new DeterministicSearchUtils(this, searchOptions, threadManager);
probabilisticSearchUtils = new ProbabilisticSearchUtils(threadManager, deterministicSearchUtils, searchOptions);
}
public StreamingAudioServer(IConnectionListener <AudioMessage, MessageType> connectionListener,
IThreadManager threadManager)
{
this.threadManager = threadManager;
this.connectionListener = Guard.IsNull(() => connectionListener);
connectionWorker = this.threadManager.StartNew(AcceptConnections);
}
/// <summary>
/// Constructor sets up queue and creates download folder if non-existing.
/// </summary>
public JobManager(IDatabaseManager databaseManager, IMessageManager messageManager, IThreadManager threadManager, ILogger logger, CrashManager crashManager)
{
_databaseManager = databaseManager;
_messageManager = messageManager;
_threadManager = threadManager;
_logger = logger;
_crashManager = crashManager;
// setup transfer queue
_queue = _jobs
.Do(job => _logger.Info("----- Added job {0} to active transfers.", job.File.Name))
.ObserveOn(Scheduler.Default)
.Select(job => Observable.DeferAsync(async token => Observable.Return(await ProcessDownload(job, token))))
.Merge(MaximalSimultaneousDownloads)
.Subscribe(job => {
_databaseManager.SaveJob(job);
if (job.Status != Job.JobStatus.Aborted)
{
_whenDownloaded.OnNext(job);
}
}, error => {
// todo treat error in ui
_logger.Error(error, "Error: {0}", error.Message);
});
// save job when status changes
_whenStatusChanged.Sample(TimeSpan.FromMilliseconds(200)).Subscribe(_databaseManager.SaveJob);
if (!Directory.Exists(_downloadPath))
{
_logger.Info("Creating non-existing download folder at {0}.", _downloadPath);
Directory.CreateDirectory(_downloadPath);
}
}
///<summary>
/// Constructs a new space for things to live in.
///</summary>
///<param name="threadManager">Thread manager to use with the space.</param>
public Space(IThreadManager threadManager)
{
timeStepSettings = new TimeStepSettings();
this.threadManager = threadManager;
SpaceObjectBuffer = new SpaceObjectBuffer(this);
EntityStateWriteBuffer = new EntityStateWriteBuffer();
DeactivationManager = new DeactivationManager(TimeStepSettings, ThreadManager);
ForceUpdater = new ForceUpdater(TimeStepSettings, ThreadManager);
BoundingBoxUpdater = new BoundingBoxUpdater(TimeStepSettings, ThreadManager);
BroadPhase = new DynamicHierarchy(ThreadManager);
NarrowPhase = new NarrowPhase(TimeStepSettings, BroadPhase.Overlaps, ThreadManager);
Solver = new Solver(TimeStepSettings, DeactivationManager, ThreadManager);
NarrowPhase.Solver = Solver;
PositionUpdater = new ContinuousPositionUpdater(TimeStepSettings, ThreadManager);
BufferedStates = new BufferedStatesManager(ThreadManager);
DeferredEventDispatcher = new DeferredEventDispatcher();
DuringForcesUpdateables = new DuringForcesUpdateableManager(timeStepSettings, ThreadManager);
BeforeNarrowPhaseUpdateables = new BeforeNarrowPhaseUpdateableManager(timeStepSettings, ThreadManager);
BeforeSolverUpdateables = new BeforeSolverUpdateableManager(timeStepSettings, ThreadManager);
BeforePositionUpdateUpdateables = new BeforePositionUpdateUpdateableManager(timeStepSettings, ThreadManager);
EndOfTimeStepUpdateables = new EndOfTimeStepUpdateableManager(timeStepSettings, ThreadManager);
EndOfFrameUpdateables = new EndOfFrameUpdateableManager(timeStepSettings, ThreadManager);
}
/// <summary>
/// Initializes a new instance of the <see cref="ToastPresenter"/> class.
/// </summary>
public ToastPresenter([NotNull] IThreadManager threadManager)
{
Should.NotBeNull(threadManager, "threadManager");
_threadManager = threadManager;
Background = Color.FromArgb(255, 105, 105, 105);
Foreground = Color.FromArgb(255, 247, 247, 247);
}
/// <summary>
/// Initializes a new instance of the <see cref="UnmanagedBitmapRenderer" /> class.
/// </summary>
/// <param name="threadManager">The thread manager.</param>
/// <param name="dispatcher">The dispatcher.</param>
public UnmanagedBitmapRenderer(IThreadManager threadManager, IDispatcher dispatcher)
: base(threadManager)
{
threadManager.Guard("threadManager");
dispatcher.Guard("dispatcher");
this.dispatcher = dispatcher;
}
/// <summary>
/// Initializes the current view model using the specified <see cref="IDataContext" />.
/// </summary>
/// <param name="context">
/// The specified <see cref="IDataContext" />.
/// </param>
void IViewModel.InitializeViewModel(IDataContext context)
{
EnsureNotDisposed();
Should.NotBeNull(context, "context");
if (Interlocked.CompareExchange(ref _state, InitializedState, DefaultState) != DefaultState)
{
Tracer.Warn(ExceptionManager.ObjectInitialized("ViewModel", this).Message);
return;
}
context.TryGetData(InitializationConstants.IsRestored, out _isRestored);
IocContainer = context.GetData(InitializationConstants.IocContainer, true);
_threadManager = _iocContainer.Get <IThreadManager>();
if (_viewModelProvider == null)
{
ViewModelProvider = _iocContainer.Get <IViewModelProvider>();
}
OnInitializing(context);
OnInitializedInternal();
OnInitialized();
var handler = Initialized;
if (handler != null)
{
handler(this, EventArgs.Empty);
Initialized = null;
}
OnPropertyChanged("IsInitialized");
Tracer.TraceViewModel(AuditAction.Initialized, this);
}
public NotificationService(ITranslationFactory translationFactory, IThreadManager threadManager, ICommandLocator commandLocator)
{
_translationFactory = translationFactory;
_threadManager = threadManager;
_openDocumentInExplorerCommand = commandLocator.GetCommand <QuickActionOpenExplorerLocationCommand>();
}
public FrmNewMessage(MessageDestination state, Employee sender, IMessageThread thread = null)
{
if (null == sender)
{
MessageBox.Show("Invalid employee, please relog and try again.");
Close();
return;
}
InitializeComponent();
//Cannot switch on object types, so here we are using a classic ElIf chain
if (thread is UserThreadView)
{
_defaultSubject = (thread as UserThreadView).OpeningSubject;
}
else if (thread is UserThread)
{
//get the subject from the oldest message sent
_defaultSubject = (thread as UserThread).Messages.OrderBy(t => t.DateTimeSent).First().Subject;
}
else
{
_defaultSubject = "";
}
_thread = thread;
_messageDestination = state;
_sender = sender;
_threadManager = new RealThreadManager(AppData.DataStoreType.msssql);
SetupWindow();
}
///<summary>
/// Constructs a new space for things to live in.
///</summary>
///<param name="threadManager">Thread manager to use with the space.</param>
public Space(IThreadManager threadManager)
{
timeStepSettings = new TimeStepSettings();
this.threadManager = threadManager;
SpaceObjectBuffer = new SpaceObjectBuffer(this);
EntityStateWriteBuffer = new EntityStateWriteBuffer();
DeactivationManager = new DeactivationManager(TimeStepSettings, ThreadManager);
ForceUpdater = new ForceUpdater(TimeStepSettings, ThreadManager);
BoundingBoxUpdater = new BoundingBoxUpdater(TimeStepSettings, ThreadManager);
BroadPhase = new DynamicHierarchy(ThreadManager);
NarrowPhase = new NarrowPhase(TimeStepSettings, BroadPhase.Overlaps, ThreadManager);
Solver = new Solver(TimeStepSettings, DeactivationManager, ThreadManager);
NarrowPhase.Solver = Solver;
PositionUpdater = new ContinuousPositionUpdater(TimeStepSettings, ThreadManager);
BufferedStates = new BufferedStatesManager(ThreadManager);
DeferredEventDispatcher = new DeferredEventDispatcher();
DuringForcesUpdateables = new DuringForcesUpdateableManager(timeStepSettings, ThreadManager);
BeforeNarrowPhaseUpdateables = new BeforeNarrowPhaseUpdateableManager(timeStepSettings, ThreadManager);
BeforeSolverUpdateables = new BeforeSolverUpdateableManager(timeStepSettings, ThreadManager);
BeforePositionUpdateUpdateables = new BeforePositionUpdateUpdateableManager(timeStepSettings, ThreadManager);
EndOfTimeStepUpdateables = new EndOfTimeStepUpdateableManager(timeStepSettings, ThreadManager);
EndOfFrameUpdateables = new EndOfFrameUpdateableManager(timeStepSettings, ThreadManager);
}
public GameManager
(
IConfigManager configManager,
IContentManager contentManager,
IDeviceManager deviceManager,
IInputManager inputManager,
IRandomManager randomManager,
IResolutionManager resolutionManager,
IScreenManager screenManager,
ITextManager textManager,
IThreadManager threadManager,
IFileManager fileManager,
ILogger logger
)
{
ConfigManager = configManager;
ContentManager = contentManager;
DeviceManager = deviceManager;
InputManager = inputManager;
RandomManager = randomManager;
ResolutionManager = resolutionManager;
ScreenManager = screenManager;
TextManager = textManager;
ThreadManager = threadManager;
FileManager = fileManager;
Logger = logger;
}
///<summary>
/// Constructs the position updater.
///</summary>
///<param name="timeStepSettings">Time step settings to use.</param>
/// <param name="threadManager">Thread manager to use.</param>
public ContinuousPositionUpdater(TimeStepSettings timeStepSettings, IThreadManager threadManager)
: base(timeStepSettings, threadManager)
{
preUpdate = PreUpdate;
updateTimeOfImpact = UpdateTimeOfImpact;
updateContinuous = UpdateContinuousItem;
}
/// <summary>
/// Constructs a new dynamic hierarchy broad phase.
/// </summary>
/// <param name="threadManager">Thread manager to use in the broad phase.</param>
public DynamicHierarchy(IThreadManager threadManager)
: base(threadManager)
{
multithreadedRefit = MultithreadedRefit;
multithreadedOverlap = MultithreadedOverlap;
QueryAccelerator = new DynamicHierarchyQueryAccelerator(this);
}
public CryptoConnectionListener(ISerializer <TMessage> serializer, IThreadManager threadManager, ILinkNegotiator linkNegotiator, ITimerService timerService)
{
this.timerService = Guard.IsNull(() => timerService);
this.serializer = Guard.IsNull(() => serializer);
this.threadManager = Guard.IsNull(() => threadManager);
this.linkNegotiator = Guard.IsNull(() => linkNegotiator);
}
public NavigationProvider([NotNull] INavigationService navigationService, [NotNull] IThreadManager threadManager, [NotNull] IViewMappingProvider mappingProvider, [NotNull] IViewManager viewManager,
[NotNull] IViewModelProvider viewModelProvider, [NotNull] INavigationDispatcher navigationDispatcher, IEventAggregator eventAggregator)
{
Should.NotBeNull(navigationService, nameof(navigationService));
Should.NotBeNull(threadManager, nameof(threadManager));
Should.NotBeNull(mappingProvider, nameof(mappingProvider));
Should.NotBeNull(viewManager, nameof(viewManager));
Should.NotBeNull(viewModelProvider, nameof(viewModelProvider));
Should.NotBeNull(navigationDispatcher, nameof(navigationDispatcher));
Should.NotBeNull(eventAggregator, nameof(eventAggregator));
NavigationService = navigationService;
ThreadManager = threadManager;
ViewMappingProvider = mappingProvider;
ViewManager = viewManager;
ViewModelProvider = viewModelProvider;
NavigationDispatcher = navigationDispatcher;
_vmReference = Empty.WeakReference;
NavigationService.Navigating += NavigationServiceOnNavigating;
NavigationService.Navigated += NavigationServiceOnNavigated;
eventAggregator.Subscribe(this);
#if WINDOWS_UWP
_openedViewModels = new Dictionary <Guid, IViewModel>();
#endif
}
public void Constructor_OverMax()
{
Assert.Throws <ArgumentException>(() =>
{
_unitUnderTest = GetInstance(101);
});
}
public Server(ILog log, Settings settings, IEndpointFactory endpointFactory, IThreadManager threadManager)
{
this.log = log;
this.settings = settings;
this.endpointFactory = endpointFactory;
this.threadManager = threadManager;
}
/// <summary>
/// Set thread manager.
/// </summary>
/// <param name="newManager">New manager.</param>
public static void SetThreadManager(IThreadManager newManager)
{
if (newManager != null)
{
threadManager = newManager;
}
}
///<summary>
/// Constructs the bounding box updater.
///</summary>
///<param name="timeStepSettings">Time step setttings to be used by the updater.</param>
/// <param name="threadManager">Thread manager to be used by the updater.</param>
public BoundingBoxUpdater(TimeStepSettings timeStepSettings, IThreadManager threadManager)
: this(timeStepSettings)
{
ThreadManager = threadManager;
AllowMultithreading = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="UnmanagedBitmapRenderer" /> class.
/// </summary>
/// <param name="threadManager">The thread manager.</param>
/// <param name="dispatcher">The dispatcher.</param>
public UnmanagedBitmapRenderer(IThreadManager threadManager, IDispatcher dispatcher)
: base(threadManager)
{
threadManager.Guard("threadManager");
dispatcher.Guard("dispatcher");
this.dispatcher = dispatcher;
}
public override void Dispose()
{
base.Dispose();
_threadManager = null;
_outgoingMessages.Clear();
_incomingMessages.Clear();
}
/// <summary>
/// Constructs a grid-based sort and sweep broad phase.
/// </summary>
/// <param name="threadManager">Thread manager to use for the broad phase.</param>
public Grid2DSortAndSweep(IThreadManager threadManager)
: base(threadManager)
{
updateEntry = UpdateEntry;
updateCell = UpdateCell;
QueryAccelerator = new Grid2DSortAndSweepQueryAccelerator(this);
}
///<summary>
/// Constructs the position updater.
///</summary>
///<param name="timeStepSettings">Time step settings to use.</param>
/// <param name="threadManager">Thread manager to use.</param>
public ContinuousPositionUpdater(TimeStepSettings timeStepSettings, IThreadManager threadManager)
: base(timeStepSettings, threadManager)
{
preUpdate = PreUpdate;
updateTimeOfImpact = UpdateTimeOfImpact;
updateContinuous = UpdateContinuousItem;
}
public void Constructor_BelowMinimum()
{
Assert.Throws <ArgumentException>(() =>
{
_unitUnderTest = GetInstance(0);
});
}
public ToastPresenter([NotNull] IThreadManager threadManager)
{
Should.NotBeNull(threadManager, nameof(threadManager));
_threadManager = threadManager;
Background = Color.FromArgb(255, 105, 105, 105);
Foreground = Color.FromArgb(255, 247, 247, 247);
}
/// <summary>
/// Constructs a grid-based sort and sweep broad phase.
/// </summary>
/// <param name="threadManager">Thread manager to use for the broad phase.</param>
public Grid2DSortAndSweep(IThreadManager threadManager)
:base(threadManager)
{
updateEntry = UpdateEntry;
updateCell = UpdateCell;
QueryAccelerator = new Grid2DSortAndSweepQueryAccelerator(this);
}
/// <summary>
/// Creates a crawler instance with custom settings or implementation. Passing in null for all params is the equivalent of the empty constructor.
/// </summary>
/// <param name="threadManager">Distributes http requests over multiple threads</param>
/// <param name="scheduler">Decides what link should be crawled next</param>
/// <param name="pageRequester">Makes the raw http requests</param>
/// <param name="htmlParser">Parses a crawled page for it's hyperlinks</param>
/// <param name="crawlDecisionMaker">Decides whether or not to crawl a page or that page's links</param>
/// <param name="crawlConfiguration">Configurable crawl values</param>
/// <param name="memoryManager">Checks the memory usage of the host process</param>
public WebCrawler(
CrawlConfiguration crawlConfiguration,
ICrawlDecisionMaker crawlDecisionMaker,
IThreadManager threadManager,
IScheduler scheduler,
IPageRequester pageRequester,
IHtmlParser htmlParser,
IMemoryManager memoryManager)
{
_crawlContext = new CrawlContext
{
CrawlConfiguration = crawlConfiguration ?? new CrawlConfiguration()
};
CrawlBag = _crawlContext.CrawlBag;
_threadManager = threadManager ?? new TaskThreadManager(_crawlContext.CrawlConfiguration.MaxConcurrentThreads > 0 ? _crawlContext.CrawlConfiguration.MaxConcurrentThreads : Environment.ProcessorCount);
_scheduler = scheduler ?? new Scheduler(_crawlContext.CrawlConfiguration.IsUriRecrawlingEnabled, null, null);
_pageRequester = pageRequester ?? new PageRequester(_crawlContext.CrawlConfiguration, new WebContentExtractor());
_crawlDecisionMaker = crawlDecisionMaker ?? new CrawlDecisionMaker();
if (_crawlContext.CrawlConfiguration.MaxMemoryUsageInMb > 0 ||
_crawlContext.CrawlConfiguration.MinAvailableMemoryRequiredInMb > 0)
{
_memoryManager = memoryManager ?? new MemoryManager(new CachedMemoryMonitor(new GcMemoryMonitor(), _crawlContext.CrawlConfiguration.MaxMemoryUsageCacheTimeInSeconds));
}
_htmlParser = htmlParser ?? new AngleSharpHyperlinkParser(_crawlContext.CrawlConfiguration, null);
_crawlContext.Scheduler = _scheduler;
}
/// <summary>
/// Creates a crawler instance with custom settings or implementation. Passing in null for all params is the equivalent of the empty constructor.
/// </summary>
/// <param name="threadManager">Distributes http requests over multiple threads</param>
/// <param name="scheduler">Decides what link should be crawled next</param>
/// <param name="httpRequester">Makes the raw http requests</param>
/// <param name="hyperLinkParser">Parses a crawled page for it's hyperlinks</param>
/// <param name="crawlDecisionMaker">Decides whether or not to crawl a page or that page's links</param>
/// <param name="crawlConfiguration">Configurable crawl values</param>
public WebCrawler(
CrawlConfiguration crawlConfiguration,
ICrawlDecisionMaker crawlDecisionMaker,
IThreadManager threadManager,
IScheduler scheduler,
IPageRequester httpRequester,
IHyperLinkParser hyperLinkParser,
IMemoryManager memoryManager)
{
_crawlContext = new CrawlContext();
_crawlContext.CrawlConfiguration = crawlConfiguration ?? GetCrawlConfigurationFromConfigFile() ?? new CrawlConfiguration();
CrawlBag = _crawlContext.CrawlBag;
_threadManager = threadManager ?? new ManualThreadManager(_crawlContext.CrawlConfiguration.MaxConcurrentThreads);
_scheduler = scheduler ?? new FifoScheduler(_crawlContext.CrawlConfiguration.IsUriRecrawlingEnabled);
_httpRequester = httpRequester ?? new PageRequester(_crawlContext.CrawlConfiguration);
_crawlDecisionMaker = crawlDecisionMaker ?? new CrawlDecisionMaker();
if (_crawlContext.CrawlConfiguration.MaxMemoryUsageInMb > 0 ||
_crawlContext.CrawlConfiguration.MinAvailableMemoryRequiredInMb > 0)
{
_memoryManager = memoryManager ?? new MemoryManager(new CachedMemoryMonitor(new GcMemoryMonitor(), _crawlContext.CrawlConfiguration.MaxMemoryUsageCacheTimeInSeconds));
}
_hyperLinkParser = hyperLinkParser ?? new HapHyperLinkParser();
_crawlContext.Scheduler = _scheduler;
}
#pragma warning restore 618
public void TestFixtureTearDown()
{
BossManager = null;
BulletManager = null;
CollisionManager = null;
CommandManager = null;
ConfigManager = null;
ContentManager = null;
ControlManager = null;
DebugManager = null;
DelayManager = null;
DeviceManager = null;
EnemyManager = null;
EventManager = null;
ExplosionManager = null;
IconManager = null;
ImageManager = null;
InputManager = null;
LevelManager = null;
MoverManager = null;
RandomManager = null;
RenderManager = null;
ResolutionManager = null;
ScoreManager = null;
ScreenManager = null;
SoundManager = null;
SpriteManager = null;
StateManager = null;
StopwatchManager = null;
StorageManager = null;
TextManager = null;
ThreadManager = null;
FileManager = null;
Logger = null;
}
/// <summary>
/// Initializes a new instance of the <see cref="MessagePresenter" /> class.
/// </summary>
public MessagePresenter(INavigationProvider navigationProvider, IThreadManager threadManager)
{
Should.NotBeNull(navigationProvider, "navigationProvider");
Should.NotBeNull(threadManager, "threadManager");
_navigationProvider = navigationProvider;
_threadManager = threadManager;
}
/// <summary>
/// Constructs a new dynamic hierarchy broad phase.
/// </summary>
/// <param name="threadManager">Thread manager to use in the broad phase.</param>
public DynamicHierarchy(IThreadManager threadManager)
: base(threadManager)
{
multithreadedRefit = MultithreadedRefit;
multithreadedOverlap = MultithreadedOverlap;
QueryAccelerator = new DynamicHierarchyQueryAccelerator(this);
}
/// <summary>
/// Creates a crawler instance with custom settings or implementation. Passing in null for all params is the equivalent of the empty constructor.
/// </summary>
/// <param name="threadManager">Distributes http requests over multiple threads</param>
/// <param name="scheduler">Decides what link should be crawled next</param>
/// <param name="pageRequester">Makes the raw http requests</param>
/// <param name="hyperLinkParser">Parses a crawled page for it's hyperlinks</param>
/// <param name="crawlDecisionMaker">Decides whether or not to crawl a page or that page's links</param>
/// <param name="crawlConfiguration">Configurable crawl values</param>
/// <param name="memoryManager">Checks the memory usage of the host process</param>
public WebCrawler(
CrawlConfiguration crawlConfiguration,
ICrawlDecisionMaker crawlDecisionMaker,
IThreadManager threadManager,
IScheduler scheduler,
IPageRequester pageRequester,
IHyperLinkParser hyperLinkParser,
IMemoryManager memoryManager)
{
_crawlContext = new CrawlContext();
_crawlContext.CrawlConfiguration = crawlConfiguration ?? GetCrawlConfigurationFromConfigFile();
CrawlBag = _crawlContext.CrawlBag;
_threadManager = threadManager ?? new TaskThreadManager(_crawlContext.CrawlConfiguration.MaxConcurrentThreads > 0 ? _crawlContext.CrawlConfiguration.MaxConcurrentThreads : Environment.ProcessorCount);
_scheduler = scheduler ?? new Scheduler(_crawlContext.CrawlConfiguration.IsUriRecrawlingEnabled, null, null);
_pageRequester = pageRequester ?? new PageRequester(_crawlContext.CrawlConfiguration);
_crawlDecisionMaker = crawlDecisionMaker ?? new CrawlDecisionMaker();
if (_crawlContext.CrawlConfiguration.MaxMemoryUsageInMb > 0 ||
_crawlContext.CrawlConfiguration.MinAvailableMemoryRequiredInMb > 0)
{
_memoryManager = memoryManager ?? new MemoryManager(new CachedMemoryMonitor(new GcMemoryMonitor(), _crawlContext.CrawlConfiguration.MaxMemoryUsageCacheTimeInSeconds));
}
_hyperLinkParser = hyperLinkParser ?? new HapHyperLinkParser(_crawlContext.CrawlConfiguration.IsRespectMetaRobotsNoFollowEnabled, _crawlContext.CrawlConfiguration.IsRespectAnchorRelNoFollowEnabled);
_crawlContext.Scheduler = _scheduler;
}
public AutoUpdateLauncher(ITranslator translator, IInteractionInvoker interactionInvoker, IHashUtil hashUtil, IThreadManager threadManager)
{
_translator = translator;
_interactionInvoker = interactionInvoker;
_hashUtil = hashUtil;
_threadManager = threadManager;
}
public MainWindowStart(IThreadManager threadManager, IMaybePipedApplicationStarter maybePipedApplicationStarter, IPdfArchitectCheck pdfArchitectCheck, IMainWindowThreadLauncher mainWindowThreadLauncher)
: base(maybePipedApplicationStarter)
{
_threadManager = threadManager;
_pdfArchitectCheck = pdfArchitectCheck;
_mainWindowThreadLauncher = mainWindowThreadLauncher;
}
///<summary>
/// Constructs a read buffer manager.
///</summary>
///<param name="manager">Owning buffered states manager.</param>
///<param name="threadManager">Thread manager to use.</param>
public StateReadBuffers(BufferedStatesManager manager, IThreadManager threadManager)
{
this.manager = manager;
multithreadedStateUpdateDelegate = MultithreadedStateUpdate;
FlipLocker = new object();
ThreadManager = threadManager;
AllowMultithreading = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="ToastPresenter" /> class.
/// </summary>
public ToastPresenter([NotNull] INavigationProvider navigationProvider,
[NotNull] IThreadManager threadManager)
{
Should.NotBeNull(navigationProvider, "navigationProvider");
Should.NotBeNull(threadManager, "threadManager");
_navigationProvider = navigationProvider;
_threadManager = threadManager;
}
public Endpoint(ILog log, EndpointSettings settings, IFileSystem fileSystem, IListener listener, IHandlerFactory handlerFactory, IThreadManager threadManager)
{
this.log = log;
this.settings = settings;
this.fileSystem = fileSystem;
this.listener = listener;
this.handlerFactory = handlerFactory;
this.threadManager = threadManager;
}
public Handler(ILog log, EndpointSettings settings, ISessionStore sessionStore, IThreadManager threadManager, IContext context, IFileSystem fileSystem)
{
this.log = log;
this.settings = settings;
this.sessionStore = sessionStore;
this.threadManager = threadManager;
this.context = context;
this.fileSystem = fileSystem;
}
public ViewManager([NotNull] IThreadManager threadManager,
[NotNull] IViewMappingProvider viewMappingProvider, [NotNull] IWrapperManager wrapperManager)
{
Should.NotBeNull(threadManager, "threadManager");
Should.NotBeNull(viewMappingProvider, "viewMappingProvider");
Should.NotBeNull(viewMappingProvider, "wrapperManager");
_threadManager = threadManager;
_viewMappingProvider = viewMappingProvider;
_wrapperManager = wrapperManager;
}
public NavigationService([NotNull] IThreadManager threadManager)
{
Should.NotBeNull(threadManager, "threadManager");
_threadManager = threadManager;
XamarinFormsExtensions.BackButtonPressed += ReflectionExtensions
.CreateWeakDelegate<NavigationService, CancelEventArgs, EventHandler<Page, CancelEventArgs>>(this,
(service, o, arg3) => service.OnBackButtonPressed((Page)o, arg3),
(o, handler) => XamarinFormsExtensions.BackButtonPressed -= handler, handler => handler.Handle);
UseAnimations = true;
}
public override void SetThreadManager(IThreadManager paramThreadManager)
{
// base.SetThreadManager first.
base.SetThreadManager(paramThreadManager);
// Now spin up callback thread
List<Object> threadList = new List<Object>();
threadList.Add(new KeyValuePair<String, Delegate>(CallbackThreadActionStrings.customAction1String, new VoidObjectDelegate(this.ExecuteCustomAction1)));
threadList.Add(new KeyValuePair<String, Delegate>(CallbackThreadActionStrings.fullScreenString, new VoidVoidDelegate(this.ToggleFullScreen)));
threadManager.StartCallbackThread(threadList);
}
static ThreadTracer()
{
try {
_threadMgr = new ManagedThread ();
} catch {
try {
_threadMgr = new LinuxThread ();
} catch {
_threadMgr = null;
return;
}
}
_threads = new Dictionary<int, ThreadInfo> ();
}
public PoliteWebCrawler(
CrawlConfiguration crawlConfiguration,
ICrawlDecisionMaker crawlDecisionMaker,
IThreadManager threadManager,
IScheduler scheduler,
IPageRequester pageRequester,
IHyperLinkParser hyperLinkParser,
IMemoryManager memoryManager,
IDomainRateLimiter domainRateLimiter,
IRobotsDotTextFinder robotsDotTextFinder)
: base(crawlConfiguration, crawlDecisionMaker, threadManager, scheduler, pageRequester, hyperLinkParser, memoryManager)
{
_domainRateLimiter = domainRateLimiter ?? new DomainRateLimiter(_crawlContext.CrawlConfiguration.MinCrawlDelayPerDomainMilliSeconds);
_robotsDotTextFinder = robotsDotTextFinder ?? new RobotsDotTextFinder(new PageRequester(_crawlContext.CrawlConfiguration));
}
public void DoWork_SingleThreaded_WorkIsCompletedSynchronously()
{
_unitUnderTest = GetInstance(1);
int count = 0;
for (int i = 0; i < MAXTHREADS; i++)
{
_unitUnderTest.DoWork(() =>
{
System.Threading.Thread.Sleep(5);
Interlocked.Increment(ref count);
});
}
Assert.AreEqual(MAXTHREADS, count);
}
/// <summary>
/// Creates a fluid volume.
/// </summary>
/// <param name="upVector">Up vector of the fluid volume.</param>
/// <param name="gravity">Strength of gravity for the purposes of the fluid volume.</param>
/// <param name="surfaceTriangles">List of triangles composing the surface of the fluid. Set up as a list of length 3 arrays of Vector3's.</param>
/// <param name="depth">Depth of the fluid back along the surface normal.</param>
/// <param name="fluidDensity">Density of the fluid represented in the volume.</param>
/// <param name="linearDamping">Fraction by which to reduce the linear momentum of floating objects each update, in addition to any of the body's own damping.</param>
/// <param name="angularDamping">Fraction by which to reduce the angular momentum of floating objects each update, in addition to any of the body's own damping.</param>
/// <param name="queryAccelerator">System to accelerate queries to find nearby entities.</param>
/// <param name="threadManager">Thread manager used by the fluid volume.</param>
public CustomFluidVolume(Vector3 upVector, float gravity, List<Vector3[]> surfaceTriangles, float depth, float fluidDensity, float linearDamping, float angularDamping,
IQueryAccelerator queryAccelerator, IThreadManager threadManager)
{
Gravity = gravity;
SurfaceTriangles = surfaceTriangles;
MaxDepth = depth;
Density = fluidDensity;
LinearDamping = linearDamping;
AngularDamping = angularDamping;
UpVector = upVector;
QueryAccelerator = queryAccelerator;
ThreadManager = threadManager;
analyzeCollisionEntryDelegate = AnalyzeCollisionEntry;
}
public MultiProxyPoliteWebCrawler(
MultiProxyCrawlConfiguration crawlConfiguration,
ICrawlDecisionMaker crawlDecisionMaker,
IThreadManager threadManager,
IScheduler scheduler,
IPageRequester pageRequester,
IHyperLinkParser hyperLinkParser,
IMemoryManager memoryManager,
IMultiProxyDomainRateLimiter domainRateLimiter,
IRobotsDotTextFinder robotsDotTextFinder)
: base(crawlConfiguration, crawlDecisionMaker, threadManager, scheduler, pageRequester, hyperLinkParser, memoryManager)
{
if ((pageRequester as MultiProxyPageRequester) == null)
_pageRequester = new MultiProxyPageRequester(crawlConfiguration);
_domainRateLimiter = domainRateLimiter ?? new MultiProxyDomainRateLimiter(_crawlContext.CrawlConfiguration.MinCrawlDelayPerDomainMilliSeconds);
_robotsDotTextFinder = robotsDotTextFinder ?? new RobotsDotTextFinder(_pageRequester);
}
public PlatformManager(IMenuManager menuManager, IThreadManager threadManager, ILogger logger, IDependencyResolver resolver)
{
_menuManager = menuManager;
_threadManager = threadManager;
_resolver = resolver;
_logger = logger;
var systems = _menuManager.Systems;
// populate platforms when system change
systems.Changed
.Skip(1)
.ObserveOn(Scheduler.Default)
.Subscribe(UpdatePlatforms);
// populate platform when games change
systems.Changed
.ObserveOn(Scheduler.Default)
.SelectMany(_ => systems
.Select(system => system.Games.Changed.Select(__ => system))
.Merge())
.Subscribe(UpdatePlatform);
}
public ImageAltTextChecker(CrawlConfiguration crawlConfiguration, ICrawlDecisionMaker crawlDecisionMaker, IThreadManager threadManager, IScheduler scheduler, IPageRequester pageRequester, IHyperLinkParser hyperLinkParser, IMemoryManager memoryManager, IDomainRateLimiter domainRateLimiter, IRobotsDotTextFinder robotsDotTextFinder)
: base(crawlConfiguration, crawlDecisionMaker, threadManager, scheduler, pageRequester, hyperLinkParser, memoryManager, domainRateLimiter, robotsDotTextFinder)
{
}
public void Constructor_OverMax()
{
_unitUnderTest = GetInstance(101);
}
/// <summary>
/// Creates a crawler instance with custom settings or implementation. Passing in null for all params is the equivalent of the empty constructor.
/// </summary>
/// <param name="threadManager">Distributes http requests over multiple threads</param>
/// <param name="scheduler">Decides what link should be crawled next</param>
/// <param name="httpRequester">Makes the raw http requests</param>
/// <param name="hyperLinkParser">Parses a crawled page for it's hyperlinks</param>
/// <param name="crawlDecisionMaker">Decides whether or not to crawl a page or that page's links</param>
/// <param name="crawlConfiguration">Configurable crawl values</param>
public WebCrawler(
CrawlConfiguration crawlConfiguration,
ICrawlDecisionMaker crawlDecisionMaker,
IThreadManager threadManager,
IScheduler scheduler,
IPageRequester httpRequester,
IHyperLinkParser hyperLinkParser,
IMemoryManager memoryManager)
{
_crawlContext = new CrawlContext();
_crawlContext.CrawlConfiguration = crawlConfiguration ?? GetCrawlConfigurationFromConfigFile() ?? new CrawlConfiguration();
CrawlBag = _crawlContext.CrawlBag;
_threadManager = threadManager ?? new ManualThreadManager(_crawlContext.CrawlConfiguration.MaxConcurrentThreads);
_scheduler = scheduler ?? new FifoScheduler(_crawlContext.CrawlConfiguration.IsUriRecrawlingEnabled);
_httpRequester = httpRequester ?? new PageRequester(_crawlContext.CrawlConfiguration);
_crawlDecisionMaker = crawlDecisionMaker ?? new CrawlDecisionMaker();
if(_crawlContext.CrawlConfiguration.MaxMemoryUsageInMb > 0
|| _crawlContext.CrawlConfiguration.MinAvailableMemoryRequiredInMb > 0)
_memoryManager = memoryManager ?? new MemoryManager(new CachedMemoryMonitor(new GcMemoryMonitor(), _crawlContext.CrawlConfiguration.MaxMemoryUsageCacheTimeInSeconds));
_hyperLinkParser = hyperLinkParser ?? new HapHyperLinkParser();
_crawlContext.Scheduler = _scheduler;
}
public void SetUp()
{
_unitUnderTest = GetInstance(MAXTHREADS);
}
public void Constructor_BelowMinimum()
{
_unitUnderTest = GetInstance(0);
}
///<summary>
/// Constructs a read buffer manager.
///</summary>
///<param name="manager">Owning buffered states manager.</param>
///<param name="threadManager">Thread manager to use.</param>
public StateReadBuffers(BufferedStatesManager manager, IThreadManager threadManager)
{
this.manager = manager;
multithreadedStateUpdateDelegate = MultithreadedStateUpdate;
FlipLocker = new object();
ThreadManager = threadManager;
AllowMultithreading = true;
}
public MessagePresenter(IThreadManager threadManager)
{
Should.NotBeNull(threadManager, nameof(threadManager));
_threadManager = threadManager;
}
protected BroadPhase(IThreadManager threadManager)
: this()
{
ThreadManager = threadManager;
AllowMultithreading = true;
}
///<summary>
/// Constructs a Solver.
///</summary>
///<param name="timeStepSettings">Time step settings used by the solver.</param>
///<param name="deactivationManager">Deactivation manager used by the solver.</param>
/// <param name="threadManager">Thread manager used by the solver.</param>
public Solver(TimeStepSettings timeStepSettings, DeactivationManager deactivationManager, IThreadManager threadManager)
: this(timeStepSettings, deactivationManager)
{
ThreadManager = threadManager;
AllowMultithreading = true;
}
double RunTest(IThreadManager threadManager, Func<Space, int> simulationBuilder)
{
Space space = new Space(threadManager);
var timeStepCount = simulationBuilder(space);
//Perform one starter frame to warm things up.
space.Update();
var startTime = Stopwatch.GetTimestamp() / (double)Stopwatch.Frequency;
for (int i = 0; i < timeStepCount; i++)
{
space.Update();
}
var endTime = Stopwatch.GetTimestamp() / (double)Stopwatch.Frequency;
return endTime - startTime;
}
