protected AppendEntryBaseTest() { // Arrange var mocker = new AutoMocker(); ServerIdentifier = new ServerIdentifier(); mocker.Use(ServerIdentifier); mocker.Setup<ISubject<AppendEntryMessage>>(p => p.Subscribe(It.IsAny<IObserver<AppendEntryMessage>>())) .Callback<IObserver<AppendEntryMessage>>((o) => { AppendEntryCallback = o; }); AppendEntryCallback = mocker.Get<ISubject<AppendEntryMessage>>(); AppendEntryResult = new Subject<AppendEntryResultMessage>(); Election = new Election(); LogReplication = new LogReplication(); AppendEntry = new Rafting.AppendEntry(AppendEntryResult, mocker.Get<ISubject<AppendEntryMessage>>(), mocker.Get<IHartbeatTimer>(), LogReplication, Election, mocker.Get<ILoggerFactory>(), new RaftOptions(), mocker.Get<ServerIdentifier>(), null); }
public ConnectivityService() { updateSubject = new Subject<Unit>(); status = Observable.FromEventPattern<NetworkNotificationEventArgs>(h => DeviceNetworkInformation.NetworkAvailabilityChanged += h, h => DeviceNetworkInformation.NetworkAvailabilityChanged -= h) .Select(_ => 0L) .Merge(Observable.Interval(TimeSpan.FromSeconds(10), ThreadPoolScheduler.Instance)) .Merge(updateSubject.Select(_ => 0L)) .StartWith(0L) .Select(_ => { if (NetworkInterface.GetIsNetworkAvailable()) { var it = NetworkInterface.NetworkInterfaceType; if (it == NetworkInterfaceType.Wireless80211 || it == NetworkInterfaceType.Ethernet) return ConnectionStatus.Wifi; if (it == NetworkInterfaceType.MobileBroadbandGsm || it == NetworkInterfaceType.MobileBroadbandCdma) return ConnectionStatus.MobileBroadband; } return ConnectionStatus.None; }) .DistinctUntilChanged() .Replay(1) .RefCount(); }
public PriceGrabber(ISubject subject, double usaPrice, double israelPrice) { _subject = subject; _subject.Register(this); USAPrice = usaPrice; IsraelPrice = israelPrice; }
public Field(ISubject parent, string sourceName, string displayName, Type type) { Subject = parent; SourceName = sourceName; DisplayName = displayName; DataType = type; }
public void SetUp() { callback_ = new NopAuthCallbackHandler(); shared_ = new Dictionary<string, string>(); options_ = new Dictionary<string, string>(); module_ = Mock.Create<ILoginModule>(); Mock .Arrange( () => module_.Login(Arg.IsAny<IAuthCallbackHandler>(), subject_)) .Returns(AuthenticationInfos.Sucessful()); Mock .Arrange(() => module_.Commit(Arg.IsAny<IAuthenticationInfo>())) .Returns(true); Mock .Arrange(() => module_.ControlFlag) .Returns(LoginModuleControlFlag.Required); subject_ = Mock.Create<ISubject>(); Mock .Arrange(() => subject_.Permissions) .Returns(new HashSet<IPermission>()); Mock .Arrange(() => subject_.Principals) .Returns(new HashSet<IPrincipal>()); }
public CandidateBaseTests() { var mocker = new AutoMocker(); ServerIdentifier = new ServerIdentifier(); mocker.Use(ServerIdentifier); Election = new Election(); RequestVoteResult = new Subject<RequestVoteResultMessage>(); RequestVote = new Subject<RequestVoteMessage>(); MockVotingSystem = mocker.GetMock<IVotingSystem>(); Candidate = new Rafting.States.Candidate(mocker.Get<ServerIdentifier>(), mocker.Get<IElectionTimer>(), RequestVote, RequestVoteResult, MockVotingSystem.Object, Election, mocker.Get<ILogReplication>(), mocker.Get<Nodes>(), mocker.Get<ILoggerFactory>(), new RaftOptions()); }
private DenyResult[] GetDenyActions(ISubject subject, IAction[] actions, ISecurityObjectId objectId, ISecurityObjectProvider securityObjProvider) { var denyActions = new List<DenyResult>(); if (actions == null) actions = new IAction[0]; if (subject == null) { denyActions = actions.Select(a => new DenyResult(a, null, null)).ToList(); } else if (subject is ISystemAccount && subject.ID == Constants.CoreSystem.ID) { // allow all } else { ISubject denySubject = null; IAction denyAction = null; foreach (var action in actions) { var allow = azManager.CheckPermission(subject, action, objectId, securityObjProvider, out denySubject, out denyAction); if (!allow) { denyActions.Add(new DenyResult(action, denySubject, denyAction)); break; } } } return denyActions.ToArray(); }
public SettingsService( ICurrentProfile Profile, [Dispatcher] IScheduler Dispatcher, [ThreadPool] IScheduler ThreadPool ) { Contract.Requires(Profile != null); Contract.Requires(Dispatcher != null); Contract.Requires(ThreadPool != null); this.Profile = Profile; this.SettingsSerializer = new XmlSerializer(typeof(AppSettings)); _SettingsReplay = _SettingsOut .ObserveOn(Dispatcher) .Replay(1) .RefCount(); _SettingsIn = new Subject<AppSettings>(); _SettingsIn .ObserveOn(ThreadPool) .Select(PersistSettings) .ObserveOn(Dispatcher) .Subscribe(_SettingsOut); Profile .CurrentProfilePathObservable() .Select(ProfileToSettingsPath) .ObserveOn(ThreadPool) .Select(LoadSettingsFromFile) .ObserveOn(Dispatcher) .Subscribe(_SettingsOut); }
public RulerBase(IModifierBus bus, IRules rules, ISubject<IInfo> infoChannel) { _bus = bus; _rules = rules; _infoChannel = infoChannel; }
public void Initializing_a_dynamic_object_implementation() { _subject = (ISubject)typeof(ISubject).InitializeProxy(new { Value = _stringValue, }); }
public void AddSubject(ISubject s) { if (!IsSubjectListened(s)) { subjectList.Add(s); } }
public FriendObserver(ListBox displayBox, ISubject friendSubject) { status = ""; this.friendSubject = friendSubject; this.displayBox = displayBox; friendSubject.addObserver(this); }
public MacroPlayer() { _iterationStartedSubject = new ScheduledSubject<int>(RxApp.DeferredScheduler); _stepCompletedSubject = new ScheduledSubject<int>(RxApp.DeferredScheduler); _stepStartedSubject = new ScheduledSubject<StepStartedInfo>(RxApp.DeferredScheduler); _stepProgressUpdatedSubject = new ScheduledSubject<int>(RxApp.DeferredScheduler); }
public void RemoveSubject(ISubject s) { if (IsSubjectListened(s)) { subjectList.Remove(s); } }
public void Add(ISubject subject) { if(this.DoesNotContain(subject) || subject == null) { this.subjects.Add(subject); } }
public VirtualListVewModel(SynchronizationContext bindingContext, DataService service) { _virtualRequest = new BehaviorSubject<VirtualRequest>(new VirtualRequest(0,10)); Items = new BindingList<Poco>(); var sharedDataSource = service .DataStream .Do(x => Trace.WriteLine($"Service -> {x}")) .ToObservableChangeSet() .Publish(); var binding = sharedDataSource .Virtualise(_virtualRequest) .ObserveOn(bindingContext) .Bind(Items) .Subscribe(); //the problem was because Virtualise should fire a noticiation if count changes, but it does not [BUG] //Therefore take the total count from the underlying data NB: Count is DD.Count() not Observable.Count() Count = sharedDataSource.Count().DistinctUntilChanged(); Count.Subscribe(x => Trace.WriteLine($"Count = {x}")); var connection = sharedDataSource.Connect(); _disposables = new CompositeDisposable(binding, connection); }
public ProcessManager() { var launched = new Subject<Tuple<ProcessStartInfo, int>>(); _launched = Subject.Synchronize(launched); Launched = _launched.AsObservable(); _subjects.Add(launched); var killed = new Subject<Tuple<ProcessStartInfo, int, TimeSpan, string>>(); _monitorKilled = Subject.Synchronize(killed); MonitorKilled = _monitorKilled.AsObservable(); _subjects.Add(killed); var started = new Subject<Tuple<ProcessStartInfo, int, string>>(); _monitorStarted = Subject.Synchronize(started); MonitorStarted = _monitorStarted.AsObservable(); _subjects.Add(started); var stopped = new Subject<Tuple<ProcessStartInfo, int, string>>(); _monitorStopped = Subject.Synchronize(stopped); MonitorStopped = _monitorStopped.AsObservable(); _subjects.Add(stopped); var terminated = new Subject<Tuple<ProcessStartInfo, int, int>>(); _terminated = Subject.Synchronize(terminated); Terminated = _terminated.AsObservable(); _subjects.Add(terminated); }
public void MyTestInitialize() { _pausingSubject = new Subject<bool>(); _scheduler = new TestScheduler(); _source = new SourceList<Person>(); _results = _source.Connect().BufferIf(_pausingSubject,TimeSpan.FromMinutes(1), _scheduler).AsAggregator(); }
public void UnSubscribe(ISubject<IObserver> topic, IObserver follower) { if (pushsubMapping.ContainsKey(topic.ToString())) { pushsubMapping[topic.ToString()].Remove(follower); } }
internal void Bind(IObservablePropertyBag target, PerspexProperty property, ISubject<object> subject) { var mode = BindingMode == BindingMode.Default ? property.DefaultBindingMode : BindingMode; switch (mode) { case BindingMode.Default: case BindingMode.OneWay: target.Bind(property, subject); break; case BindingMode.TwoWay: target.BindTwoWay(property, subject); break; case BindingMode.OneTime: target.GetObservable(Control.DataContextProperty).Subscribe(dataContext => { subject.Take(1).Subscribe(x => target.SetValue(property, x)); }); break; case BindingMode.OneWayToSource: target.GetObservable(property).Subscribe(subject); break; } }
public void MyTestInitialize() { _pausingSubject = new Subject<bool>(); _scheduler = new TestScheduler(); _source = new SourceCache<Person, string>(p => p.Key); _results = _source.Connect().BatchIf(_pausingSubject, _scheduler).AsAggregator(); }
public void YieldObservable() { coroutine = YieldObservableBlock().AsCoroutine<object>(); subject = new Subject<object>(); Subscribe(); expectedResults.Add(t1); expectedResults.Add(t2); AssertExpectedResults(); subject.OnNext(t3); // don't want to include results from observables yielded //expectedResults.Add(t3); AssertExpectedResults(); subject.OnCompleted(); expectedResults.Add(t4); AssertExpectedResults(); AssertExpectedErrors(); AssertCompleted(); }
public VideoService( Rectangle viewFinder, MediaElement player ) { // Initial State _State = PlayState.Paused; _CanRecord = false; _Record = new SwitchableCommand(OnRecord); _Play = new SwitchableCommand(OnPlay); _Stop = new SwitchableCommand(OnPause); _ViewFinder = viewFinder; _Player = player; _Player.MediaEnded += MediaEnded; _CaptureSource = new CaptureSource(); _CaptureSource.CaptureFailed += CaptureFailed; _FileSink = new FileSink(); _Brush = new VideoBrush(); _HasRecording = new BehaviorSubject<bool>(false); }
public ViewModel() { Users = new ObservableCollection<UserFullInfo>(); Countries = new ObservableCollection<Country>(countryService.GetCountries()); UserProvider userP = new UserProvider(); //AsyncUser = new AsyncVirtualizingCollection<UserFullInfo>(userP, 100, 30); AsyncUser = new AsyncVirtualizingCollection<UserFullInfo>(userP, 100, 30000); var usersObservable = userService.GetUsers().ToObservable(); usersObservable.SubscribeOn(ThreadPoolScheduler.Instance).ObserveOn(DispatcherScheduler.Current).Subscribe(userInfo => Users.Add(userInfo)); userSubject = new Subject<UserFullInfo>(); userSubject.Subscribe(x => { if (x == null) return; x.CountrySubject.OnNext(x.Country); x.SubdivisionSubject.OnNext(x.Subdivision); }); //var countrySubj = new Subject<UserFullInfo>(); currentUser = new UserFullInfo(); NewCommand = new RelayCommand(arg => NewMethod()); SaveCommand = new RelayCommand(arg => SaveMethod()); CloseComman = new RelayCommand(arg => CloseMethod()); }
/// <summary> /// Initializes a new instance of the <see cref="FantasyTeamPresenter"/> class. /// </summary> /// <param name="view">The view.</param> /// <param name="owningPerson">The owning person.</param> /// <param name="subject">The subject.</param> public FantasyTeamPresenter(IFantasyTeamView view, string owningPerson, ISubject subject) { _View = view; _View.Unsubscribing += Unsubscribing; FantasyTeam = owningPerson; _Subject = subject; }
/// <summary> /// Initializes a new instance of the <see cref="SuspensionService"/> class. /// Based on WinRTSuspensionHost in ReactiveUI.Mobile /// </summary> public SuspensionService(Application app, ISubject<LaunchActivatedEventArgs> launched) { var launchNew = new[] { ApplicationExecutionState.ClosedByUser, ApplicationExecutionState.NotRunning, }; this.IsLaunchingNew = launched .Where(x => launchNew.Contains(x.PreviousExecutionState)) .Select(x => x.Arguments); this.IsResuming = launched .Where(x => x.PreviousExecutionState == ApplicationExecutionState.Terminated) .Select(x => x.Arguments); var unpausing = new[] { ApplicationExecutionState.Suspended, ApplicationExecutionState.Running, }; this.IsUnpausing = launched .Where(x => unpausing.Contains(x.PreviousExecutionState)) .Select(x => x.Arguments); var shouldPersistState = new Subject<SuspendingEventArgs>(); app.Suspending += (o, e) => shouldPersistState.OnNext(e); this.ShouldPersistState = shouldPersistState.Select(x => { var deferral = x.SuspendingOperation.GetDeferral(); return Disposable.Create(deferral.Complete); }); var shouldInvalidateState = new Subject<Unit>(); app.UnhandledException += (o, e) => shouldInvalidateState.OnNext(Unit.Default); this.ShouldInvalidateState = shouldInvalidateState; }
internal static string FormatErrorMessage(ISubject subject, IAction[] actions, ISubject[] denySubjects, IAction[] denyActions) { if (subject == null) throw new ArgumentNullException("subject"); if (actions == null || actions.Length == 0) throw new ArgumentNullException("actions"); if (denySubjects == null || denySubjects.Length == 0) throw new ArgumentNullException("denySubjects"); if (denyActions == null || denyActions.Length == 0) throw new ArgumentNullException("denyActions"); if (actions.Length != denySubjects.Length || actions.Length != denyActions.Length) throw new ArgumentException(); string reasons = ""; for (int i = 0; i < actions.Length; i++) { string reason = ""; if (denySubjects[i] != null && denyActions[i] != null) reason = String.Format("{0}:{1} access denied {2}.", actions[i].Name, (denySubjects[i] is IRole ? "role:" : "") + denySubjects[i].Name, denyActions[i].Name ); else reason = String.Format("{0}: access denied.", actions[i].Name); if (i != actions.Length - 1) reason += ", "; reasons += reason; } string sactions = ""; Array.ForEach(actions, action => { sactions += action.ToString() + ", "; }); string message = String.Format( "\"{0}\" access denied \"{1}\". Cause: {2}.", (subject is IRole ? "role:" : "") + subject.Name, sactions, reasons ); return message; }
public IEnumerable<IRole> GetObjectRoles(ISubject account, ISecurityObjectId objectId, SecurityCallContext callContext) { // Constants.Everyone // if (_daoFactory.GetManagerDao().GetAll(false).Contains(ASC.Core.CoreContext.UserManager.GetUsers(account.ID))) // return new Action[] throw new NotImplementedException(); }
public void Update(ISubject subject) { var boxFight = (BoxFight)subject; if (boxFight.BoxerAScore < boxFight.BoxerBScore) BoxerToPutMoneyOn = "I put on boxer B, better be safe!"; else BoxerToPutMoneyOn = "I put on boxer A, better be safe!"; Console.WriteLine("CONSERVATIVEPLAYER:{0}", BoxerToPutMoneyOn); }
public GroupedObservable(TKey key, ISubject <TElement> subject, RefCountDisposable refCount) { this.key = key; this.subject = subject; this.refCount = refCount; }
/// <summary>Draw debug metadata to the screen.</summary> /// <param name="spriteBatch">The sprite batch being drawn.</param> public void Draw(SpriteBatch spriteBatch) { if (!this.Enabled) { return; } this.Monitor.InterceptErrors("drawing debug info", () => { // get location info GameLocation currentLocation = Game1.currentLocation; Vector2 cursorTile = Game1.currentCursorTile; Vector2 cursorPosition = GameHelper.GetScreenCoordinatesFromCursor(); // show 'debug enabled' warning + cursor position { string metadata = $"{this.WarningText} Cursor tile ({cursorTile.X}, {cursorTile.Y}), position ({cursorPosition.X}, {cursorPosition.Y})."; GameHelper.DrawHoverBox(spriteBatch, metadata, Vector2.Zero, Game1.viewport.Width); } // show cursor pixel spriteBatch.DrawLine(cursorPosition.X - 1, cursorPosition.Y - 1, new Vector2(Game1.pixelZoom, Game1.pixelZoom), Color.DarkRed); // show targets within detection radius Rectangle tileArea = GameHelper.GetScreenCoordinatesFromTile(Game1.currentCursorTile); IEnumerable <ITarget> targets = this.TargetFactory .GetNearbyTargets(currentLocation, cursorTile, includeMapTile: false) .OrderBy(p => p.Type == TargetType.Unknown ? 0 : 1); // if targets overlap, prioritise info on known targets foreach (ITarget target in targets) { // get metadata bool spriteAreaIntersects = target.GetSpriteArea().Intersects(tileArea); ISubject subject = this.TargetFactory.GetSubjectFrom(target); // draw tile { Rectangle tile = GameHelper.GetScreenCoordinatesFromTile(target.GetTile()); Color color = (subject != null ? Color.Green : Color.Red) * .5f; spriteBatch.DrawLine(tile.X, tile.Y, new Vector2(tile.Width, tile.Height), color); } // draw sprite box if (subject != null) { int borderSize = 3; Color borderColor = Color.Green; if (!spriteAreaIntersects) { borderSize = 1; borderColor *= 0.5f; } Rectangle spriteBox = target.GetSpriteArea(); spriteBatch.DrawLine(spriteBox.X, spriteBox.Y, new Vector2(spriteBox.Width, borderSize), borderColor); // top spriteBatch.DrawLine(spriteBox.X, spriteBox.Y, new Vector2(borderSize, spriteBox.Height), borderColor); // left spriteBatch.DrawLine(spriteBox.X + spriteBox.Width, spriteBox.Y, new Vector2(borderSize, spriteBox.Height), borderColor); // right spriteBatch.DrawLine(spriteBox.X, spriteBox.Y + spriteBox.Height, new Vector2(spriteBox.Width, borderSize), borderColor); // bottom } } // show current target name (if any) { ISubject subject = this.TargetFactory.GetSubjectFrom(Game1.player, currentLocation, LookupMode.Cursor, includeMapTile: false); if (subject != null) { GameHelper.DrawHoverBox(spriteBatch, subject.Name, new Vector2(Game1.getMouseX(), Game1.getMouseY()) + new Vector2(Game1.tileSize / 2f), Game1.viewport.Width / 4f); } } }, this.OnDrawError); }
/// <summary> /// Creates an observable progress that uses the specified subject. /// </summary> /// <param name="subject">The subject used for progress updates.</param> public ObservableProgress(ISubject <T> subject) { _subject = subject; }
public ReactiveEventBus() { _bus = new Subject <object>(); }
public SimpleRating(IRater rater, ISubject subject, double value) { Rater = rater; Subject = subject; Value = value; }
public RelationField(ISubject parent, string sourceName, string displayName) : this(parent, sourceName, displayName, null) { }
public void DetachFrom(ISubject subject) { subject.Attach(this); }
public WrappedSubject(ISubject <T> inner, IDisposable disposable) { this.inner = inner; this.disposable = disposable; }
public StatisticsDisplay(ISubject weatherData) { _weatherData = weatherData; _weatherData.RegisterObserver(this); }
public bool Update(ISubject sender, string data, short objState) { _newData.Add(data); return(true); }
public StatisticsDisplay() { _subject = new WeatherData(); }
public SubscriptionService() { _subject = new Subject <Object>(); _publisherSubscriptions = new List <IDisposable>(); }
public void Update(ISubject subject) { throw new System.NotImplementedException(); }
public RelationField(ISubject parent, string sourceName, string displayName, ISubject linkedSubject) : this(parent, sourceName, displayName, typeof(object), linkedSubject) { }
public Observer(string userName, ISubject subject) { UserName = userName; subject.RegisterObserver(this); }
public Proxy(ISubject subject, bool condition) { this.subject = subject; this.condition = condition; }
public void AttachTo(ISubject subject) { subject.Attach(this); }
public FilterControllerFixtureWithClearAndReplace() { _source = new SourceList <Person>(); _filter = new BehaviorSubject <Func <Person, bool> >(p => p.Age > 20); _results = _source.Connect().Filter(_filter).AsAggregator(); }
public IBuilder BuildSubject() { _subject = new Subject(); return(this); }
public ForcastDisplay(ISubject weatherData) { this.weatherData = weatherData; weatherData.RegisterObserver(this); }
public WebSocketController(IRepository repository, Action <string> logger, ISubject <string> mesgChain) { _repository = repository; _log = logger; _messageChain = mesgChain; }
public void Update(ISubject subject) { Count += subject.Count; }
public TimeSeriesController(ISubject <IEnumerable <KeyValuePair <DateTime, double> > > observable, Dispatcher dis) { Buttons = VMFactory.BuildButtons(observable); TimeValueSeries = observable.Select(_ => new CollectionViewModel <KeyValuePair <DateTime, double> >(_, dis)); }
public override void OnNext(TSource value) { var key = default(TKey); try { key = parent.keySelector(value); } catch (Exception exception) { Error(exception); return; } var fireNewMapEntry = false; var writer = default(ISubject <TElement>); try { if (key == null) { if (nullKeySubject == null) { nullKeySubject = new Subject <TElement>(); fireNewMapEntry = true; } writer = nullKeySubject; } else { if (!map.TryGetValue(key, out writer)) { writer = new Subject <TElement>(); map.Add(key, writer); fireNewMapEntry = true; } } } catch (Exception exception) { Error(exception); return; } if (fireNewMapEntry) { var group = new GroupedObservable <TKey, TElement>(key, writer, refCountDisposable); observer.OnNext(group); } var element = default(TElement); try { element = parent.elementSelector(value); } catch (Exception exception) { Error(exception); return; } writer.OnNext(element); }
public CurrentConditions(ISubject newWeatherData) { this.weatherData = newWeatherData; this.weatherData.Register(this); }
public MainViewModel() { _currentViewChanged = new Subject <Context>(); _receivedPlaySignal = new Subject <Uri>(); }
public Statistics(ISubject newWeatherData) { this.weatherData = newWeatherData; this.weatherData.Register(this); }
public CurrentConditionsDisplay(ISubject weatherData) { this.weatherData = weatherData; weatherData.registerObserver(this); }
public Forecast(ISubject newWeatherData) { this.weatherData = newWeatherData; this.weatherData.Register(this); }
// TODO: Lock? ISubject <PropertyChangingInfo, PropertyChangingInfo> GetChangingSubject() => _changingSubject ?? (_changingSubject = Subject.Synchronize(new Subject <PropertyChangingInfo>()));
public LeaderBaseTests() { var mocker = new AutoMocker(); ServerIdentifier = new ServerIdentifier(); mocker.Use(ServerIdentifier); Election = new Election(); AppendEntryResult = new Subject<AppendEntryResultMessage>(); AppendEntry = new Subject<AppendEntryMessage>(); LogReplication = new LogReplication(); Nodes = new Nodes(); Leader = new Rafting.States.Leader( Election, mocker.Get<IHartbeatTimer>(), AppendEntryResult, AppendEntry, mocker.Get<IObserver<ClientResultMessage>>(), mocker.Get<IObservable<ClientMessage>>(), LogReplication, Nodes, mocker.Get<ILoggerFactory>(), new RaftOptions(), mocker.Get<ServerIdentifier>()); }