#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(); }
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; }
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); }
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> /// 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); }
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; }