public void SetUniformValue(int uniformId, object value) { if (CurrentProgramId != 0 && CurrentProgramId != ProgramId) { throw new System.Exception("An other program is already loaded!"); } using (UseProgram()) { TypeSwitch.On(value) .Case((int x) => GL.Uniform1(uniformId, x)) .Case((uint x) => GL.Uniform1(uniformId, x)) .Case((float x) => GL.Uniform1(uniformId, x)) .Case((Vector2 x) => GL.Uniform2(uniformId, x)) .Case((Vector3 x) => GL.Uniform3(uniformId, x)) .Case((Vector4 x) => GL.Uniform4(uniformId, x)) .Case((Quaternion x) => GL.Uniform4(uniformId, x)) .Case((Color4 x) => GL.Uniform4(uniformId, x)) .Case((int[] x) => GL.Uniform1(uniformId, x.Length, x)) .Case((uint[] x) => GL.Uniform1(uniformId, x.Length, x)) .Case((float[] x) => GL.Uniform1(uniformId, x.Length, x)) .Case((Matrix4 x) => GL.UniformMatrix4(uniformId, false, ref x)) .Case((Color x) => GL.Uniform4(uniformId, x.R, x.G, x.B, x.A)) .Default(x => Throw("GLUniform type {0} is not is not implemented.", value.GetType())); } }
public virtual ExceptionModel Convert(Exception exception) { ExceptionModel model = null; TypeSwitch.On(exception) .Case <HttpStatusException>(ex => { exception = ex.InnerException; model = Convert(exception); }) .Case <ArgumentException>(ex => model = new ArgumentExceptionModel { ParamName = ex.ParamName, }) .Case <NotSupportedException>(ex => model = new NotSupportedExceptionModel()) .Case <InvalidOperationException>(ex => model = new InvalidOperationExceptionModel()) .Default(() => model = new ExceptionModel { Message = string.Format("[No exception serializer found for {0}].{1}", exception.GetType(), Environment.NewLine) }); model.Message = exception.Message; model.StackTrace = exception.StackTrace; return(model); }
/// <summary> /// Sets the uniform value. /// </summary> /// <param name="uniformId">Uniform identifier.</param> /// <param name="value">Value.</param> void SetUniformValue(int uniformId, object value) { // Check if another program is loaded if (CurrentProgramId != 0 && CurrentProgramId != programId) { // Throw an exception const string message = "Cannot set uniform {0} on program {1} because the current program is {2}."; this.Throw(message, uniformId, programId, CurrentProgramId); } // Set the uniform using (UseProgram()) { TypeSwitch.On(value) .Case((int x) => GL.Uniform1(uniformId, x)) .Case((uint x) => GL.Uniform1(uniformId, x)) .Case((float x) => GL.Uniform1(uniformId, x)) .Case((Vector2 x) => GL.Uniform2(uniformId, x)) .Case((Vector3 x) => GL.Uniform3(uniformId, x)) .Case((Vector4 x) => GL.Uniform4(uniformId, x)) .Case((Quaternion x) => GL.Uniform4(uniformId, x)) .Case((Color4 x) => GL.Uniform4(uniformId, x)) .Case((int[] x) => GL.Uniform1(uniformId, x.Length, x)) .Case((uint[] x) => GL.Uniform1(uniformId, x.Length, x)) .Case((float[] x) => GL.Uniform1(uniformId, x.Length, x)) .Case((Matrix4 x) => GL.UniformMatrix4(uniformId, false, ref x)) .Case((Color x) => GL.Uniform4(uniformId, x.R, x.G, x.B, x.A)) .Default(x => this.Throw("GlUniform type {0} is not (yet?) implemented.", value.GetType().FullName)); } }
protected override void OnReceive(AbstractMessage message) { TypeSwitch.On(message) .Case((ClearMessage clearMessage) => { // Reset partition and send sync message clear(); clearMessage.Sender.SendMe(new EstimateRefinedMessage(this)); }) .Case((RefineMessage refineMessage) => { // Perform local refine step refine(); refineMessage.Sender.SendMe(new EstimateRefinedMessage(this)); }) .Case((CountMessage countMessage) => { var blocks = new HashSet <int>(); foreach (var node in ownerInverted[this]) { if (!blocks.Contains(partition[node])) { blocks.Add(partition[node]); } } countMessage.Sender.SendMe(new CountedMessage(this, blocks)); }) .Case((ShareMessage shareMessage) => { // Share changes foreach (var worker in ownerInverted.Keys) { if (worker != this) { var changedNodesOfInterest = partition.Where(kvp => interestedIn[worker].Contains(kvp.Key) && changed[kvp.Key]); if (changedNodesOfInterest.Any()) { worker.SendMe(new UpdatePartitionMessage <TNode>(this, changedNodesOfInterest)); } } } shareMessage.Sender.SendMe(new SharedMessage(this)); }) .Case((UpdatePartitionMessage <TNode> updatePartitionMessage) => { foreach (var change in updatePartitionMessage.Changes) { partition[change.Key] = change.Value; } }) .Case((SegmentRequestMessage segmentRequestMessage) => { segmentRequestMessage.Sender.SendMe(new SegmentResponseMessage <TNode>(this, partition.Where(kvp => owner[kvp.Key] == this))); }); }
public object GetValueFromPath(Type entityType, PathComponent[] pathComponents, object entity) { try { if (entity == null) { throw new JsonPatchException("The root object is null."); } object previous = entity; for (int i = 0; i < pathComponents.Length; i++) { string parentPath = PathComponent.GetFullPath(pathComponents.Take(i)); var pathComponent = pathComponents[i]; TypeSwitch.On(pathComponent) .Case((PropertyPathComponent component) => { if (previous == null) { throw new JsonPatchException(string.Format( "Cannot get property \"{0}\" from null object at path \"{1}\".", component.Name, parentPath)); } previous = component.GetPropertyInfo(previous).GetValue(previous); }) .Case((CollectionIndexPathComponent component) => { try { var list = (IList)previous; previous = list[component.CollectionIndex]; } catch (Exception e) { throw new JsonPatchException(string.Format( "Cannot access index {0} from collection at path \"{1}\".", component.CollectionIndex, parentPath), e); } }); } return(previous); } catch (Exception e) { throw new JsonPatchException(string.Format( "Failed to get value from path \"{0}\": {1}", PathComponent.GetFullPath(pathComponents), e.Message), e); } }
/// <summary> /// Views the did load. /// </summary> public override void ViewDidLoad() { base.ViewDidLoad(); base.StyleNavigationBar(); _tilesCollectionView = new UICollectionView(new CGRect(), new TetrixLayout()) { TranslatesAutoresizingMaskIntoConstraints = false, BackgroundColor = UIColor.White }; _tilesCollectionView.RegisterClassForCell(typeof(TileCollectionViewCell), TileCollectionViewCell.Key); _tilesSource = new TetrixCollectionSource(_tilesCollectionView, TileCollectionViewCell.Key, (item, collectionView, indexPath) => { var cell = default(BaseCollectionViewCell); TypeSwitch.On(item) .Case((TileViewModel x) => cell = (BaseCollectionViewCell)collectionView.DequeueReusableCell(TileCollectionViewCell.Key, indexPath)); //cell.DataContext = item; return(cell); }); _tilesCollectionView.Source = _tilesSource; Add(_tilesCollectionView); var views = new DictionaryViews() { { "tilesCollectionView", _tilesCollectionView } }; View.AddConstraints(NSLayoutConstraint.FromVisualFormat("V:|-20-[tilesCollectionView]-20-|", NSLayoutFormatOptions.DirectionLeftToRight, null, views) .Concat(NSLayoutConstraint.FromVisualFormat("H:|-20-[tilesCollectionView]-20-|", NSLayoutFormatOptions.AlignAllTop, null, views)) .ToArray()); this.WhenActivated(d => { // We need to bind the ViewModel property to the DataContext in order to be able to // use WPF Bindings. Let's use WPF bindings for the UserName property. //this.Bind(ViewModel, vm => vm.Cells, v => v._tilesSource.ItemsSource); //set.Bind(_tilesSource).For(s => s.ItemsSource).To(vm => vm.Cells); //set.Bind(_tilesSource).For(cv => cv.SelectionChangedCommand) // .To(vm => vm.SelectCommand); //OnAppear(new Dictionary<string, object>()); }); }
private void MenuView_OnViewEvent(object sender, EventArgs e) { TypeSwitch.On(e.GetType()) // paging .Case <GoToFirstPageEventArgs>(() => this.OnGoToFirstPageEvent()) .Case <GoToPrevPageEventArgs>(() => this.OnGoToPrevPageEvent()) .Case <GoToNextPageEventArgs>(() => this.OnGoToNextPageEvent()) .Case <GoToLastPageEventArgs>(() => this.OnGoToLastPageEvent()) // sorting .Case <SortByPersonPropertiesEventArgs>(() => this.OnSortEvent( e.As <SortByPersonPropertiesEventArgs>().SortCriteria, e.As <SortByPersonPropertiesEventArgs>().SortDirection)) // exit .Case <ExitEventArgs>(() => this.OnExitEvent()) // unknwon .Case <UnknownCommandEventArgs>(() => this.OnUnknownEvent(e.As <UnknownCommandEventArgs>()?.Command)) .Evaluate(); }
private void AddEmitterToRoot(StatementSequenceEmitter rootEmitter, StatementSequenceNode astNode) { foreach (var astSubNode in astNode.SubNodes) { StatementSequenceEmitter emittedNode = new NoOpEmitter(); TypeSwitch.On(astSubNode) .Case((VariableDeclarationNode variableDeclarationNode) => { emittedNode = new VariableDeclarationNodeEmitter(variableDeclarationNode); }) .Case((ReturnStatementNode returnStatementNode) => { emittedNode = new ReturnStatementNodeEmitter(returnStatementNode); }); if (astSubNode is StatementSequenceNode) { AddEmitterToRoot(emittedNode, astSubNode as StatementSequenceNode); //Also copy subnodes } rootEmitter.SubNodes.Add(emittedNode); } }
public string Lookup <T>(T key, params string[] args) where T : struct, IConvertible { if (!typeof(T).IsEnum) { throw new ArgumentException("T must be an enumerated type"); } var returnValue = string.Empty; var lookup = (object)key; TypeSwitch.On <T> ( TypeSwitch.Case <StringApplicationTemplate>(() => { returnValue = Lookup((StringApplicationTemplate)lookup, args); }), TypeSwitch.Case <StringWarningTemplate>(() => { returnValue = Lookup((StringWarningTemplate)lookup, args); }), TypeSwitch.Case <StringErrorTemplate>(() => { returnValue = Lookup((StringErrorTemplate)lookup, args); }), TypeSwitch.Case <StringExceptionTemplate>(() => { returnValue = Lookup((StringExceptionTemplate)lookup, args); }), TypeSwitch.Case <StringCacheKeyTemplate>(() => { returnValue = Lookup((StringCacheKeyTemplate)lookup, args); }), TypeSwitch.Default(() => { returnValue = StringHelper.Current.Lookup(key, args); }) ); return(returnValue); }
public void SetValueFromPath(Type entityType, PathComponent[] pathComponents, object entity, object value, JsonPatchOperationType operationType) { try { PathComponent[] parent = pathComponents.Take(pathComponents.Length - 1).ToArray(); string parentPath = PathComponent.GetFullPath(parent); object previous = GetValueFromPath(entityType, parent, entity); if (previous == null) { throw new JsonPatchException(string.Format("Value at parent path \"{0}\" is null.", parentPath)); } var target = pathComponents.Last(); TypeSwitch.On(target) .Case((PropertyPathComponent component) => { switch (operationType) { case JsonPatchOperationType.add: case JsonPatchOperationType.replace: component.GetPropertyInfo(previous).SetValue(previous, ConvertValue(value, component.ComponentType)); break; case JsonPatchOperationType.remove: component.GetPropertyInfo(previous).SetValue(previous, null); break; default: throw new ArgumentOutOfRangeException("operationType"); } }) .Case((CollectionPathComponent component) => { var list = previous as IList; if (list == null) { throw new JsonPatchException(string.Format("Value at parent path \"{0}\" is not a valid collection.", parentPath)); } switch (operationType) { case JsonPatchOperationType.add: list.Add(ConvertValue(value, component.ComponentType)); break; default: throw new ArgumentOutOfRangeException("operationType"); } }) .Case((CollectionPathComponent component) => { var list = previous as IList; if (list == null) { throw new JsonPatchException(string.Format("Value at parent path \"{0}\" is not a valid collection.", parentPath)); } switch (operationType) { case JsonPatchOperationType.add: list.Add(ConvertValue(value, component.ComponentType)); break; default: throw new ArgumentOutOfRangeException("operationType"); } }) .Case((CollectionIndexPathComponent component) => { var list = previous as IList; if (list == null) { throw new JsonPatchException(string.Format("Value at parent path \"{0}\" is not a valid collection.", parentPath)); } switch (operationType) { case JsonPatchOperationType.add: list.Insert(component.CollectionIndex, ConvertValue(value, component.ComponentType)); break; case JsonPatchOperationType.remove: list.RemoveAt(component.CollectionIndex); break; case JsonPatchOperationType.replace: list[component.CollectionIndex] = ConvertValue(value, component.ComponentType); break; default: throw new ArgumentOutOfRangeException("operationType"); } }); } catch (Exception e) { throw new JsonPatchException(string.Format( "Failed to set value at path \"{0}\" while performing \"{1}\" operation: {2}", PathComponent.GetFullPath(pathComponents), operationType, e.Message), e); } }
/// <summary> /// Posts the load subscriptions. /// </summary> /// <returns>The load subscriptions.</returns> public override IEnumerable <IDisposable> LoadSubscriptions() { yield return(ViewModel.WhenAnyValue(vm => vm.Feedbacks).BindTo <FeedbackListItemViewModel, FeedbackListItemTableViewCell>(_feedbackTableView, 80, cell => cell.Initialize())); yield return(ViewModel.WhenAnyValue(vm => vm.Infos) .Select((IReactiveList <TetrixViewModelBase> list) => { return list.GroupBy(model => (float)model.Height) .Select(typeGroup => { var collection = new ReactiveList <TetrixViewModelBase>(); collection.AddRange(typeGroup); return new TableSectionInformation <TetrixViewModelBase, BaseTableViewCell>(collection, (model) => { var cellIndentifier = ""; TypeSwitch.On(model) .Case((HeaderListItemViewModel m) => cellIndentifier = HeaderTableViewCell.Key) .Case((ContactListItemViewModel m) => cellIndentifier = ContactTableViewCell.Key); return new NSString(cellIndentifier); }, typeGroup.Key, cell => cell.Initialize()); }).ToList(); }).BindTo(_infoTableView)); yield return(this.WhenAnyValue(v => v._tableSource.ElementSelected) .Subscribe(x => { // when ever this value is updated we want to make sure we only ever have // the latest subscription _serialDisposable.Disposable = x.Subscribe(vm => ViewModel.SelectFeedbackAsync()); })); yield return(this.WhenAnyValue(v => v._infoTableSource.ElementSelected) .Subscribe(x => { // when ever this value is updated we want to make sure we only ever have // the latest subscription _serialDisposable.Disposable = x.Subscribe(vm => ViewModel.SelectContactAsync()); })); yield return(Observable.FromEventPattern <PathUpdateEventArgs>(ViewModel, "PathUpdate") .Window(() => Observable.Interval(TimeSpan.FromSeconds(2))) .SelectMany(x => x.Take(1)) .SubscribeOn(ViewModel.Scheduler) .Subscribe(e => { var pathArgs = e.EventArgs; var latDif = pathArgs.StartCoordinate.Latitude - pathArgs.EndCoordinate.Latitude; var lonDif = pathArgs.StartCoordinate.Longitude - pathArgs.EndCoordinate.Longitude; var midLat = latDif / 2 + pathArgs.EndCoordinate.Latitude; var midLon = lonDif / 2 + pathArgs.EndCoordinate.Longitude; double dist = Math.Sqrt(latDif * latDif + lonDif * lonDif) * 90; var polyline = new List <CLLocationCoordinate2D>(); foreach (var pathPoint in pathArgs.Path) { polyline.Add(new CLLocationCoordinate2D(pathPoint.Latitude, pathPoint.Longitude)); } // Must update the UI on the main thread // set map center var mapCenter = new CLLocationCoordinate2D(midLat, midLon); var mapRegion = MKCoordinateRegion.FromDistance(mapCenter, dist * 2000, dist * 2000); // if _mkPolyLine not null, remove then recreate and re add if (_mkPolyLine != null) { _mapView.RemoveOverlay(_mkPolyLine); _mkPolyLine?.Dispose(); } _mkPolyLine = MKPolyline.FromCoordinates(polyline.ToArray()); _mapView.CenterCoordinate = mapCenter; _mapView.Region = mapRegion; // add map overlay for path _mapView.AddOverlay(_mkPolyLine); })); yield return(ViewModel.WhenAnyValue(vm => vm.LocationLoading) .SubscribeOn(ViewModel.Scheduler) .Subscribe(loading => { if (loading) { _progressView.StartAnimating(); } else { _progressView.StopAnimating(); } })); }
protected override void OnReceive(AbstractMessage message) { TypeSwitch.On(message) .Case((CoordinatorMessage coordinatorMessage) => { k_max = 0; partition = new Dictionary <TNode, int>(); oldNumBlocks = 0; blocks = new HashSet <int>(); workers = coordinatorMessage.Workers; state = new Dictionary <AbstractMachine, WorkerState>(); var comparer1 = EqualityComparer <TLabel> .Default; var comparer2 = new Utils.HashSetEqualityComparer <Tuple <TLabel, int> >(); var comparer = new Utils.PairEqualityComparer <TLabel, HashSet <Tuple <TLabel, int> > >(comparer1, comparer2); signatures = new Dictionary <Tuple <TLabel, HashSet <Tuple <TLabel, int> > >, int>(comparer); counter = 0; foreach (var worker in workers) { state.Add(worker, WorkerState.Refining); worker.SendMe(new ClearMessage(this)); } }) .Case((ExactRefinedMessage <TLabel> refinedMessage) => { state[refinedMessage.Sender] = WorkerState.Waiting; var remap = new Dictionary <int, int>(); foreach (var kvp in refinedMessage.PartitionMap) { if (!signatures.ContainsKey(kvp.Key)) { signatures.Add(kvp.Key, counter++); } remap.Add(kvp.Value, signatures[kvp.Key]); } refinedMessage.Sender.SendMe(new RemapPartitionMessage(this, remap)); if (workers.All(worker => state[worker] == WorkerState.Waiting)) { signatures.Clear(); // All workers have refined, now perform a share step foreach (var worker in workers) { state[worker] = WorkerState.Sharing; worker.SendMe(new ShareMessage(this)); } } }) .Case((SharedMessage sharedMessage) => { state[sharedMessage.Sender] = WorkerState.Waiting; if (workers.All(worker => state[worker] == WorkerState.Waiting)) { // All workers have shared, now count the number of unqiue blocks oldNumBlocks = blocks.Count; blocks.Clear(); foreach (var worker in workers) { state[worker] = WorkerState.Counting; worker.SendMe(new CountMessage(this)); } } }) .Case((CountedMessage countedMessage) => { state[countedMessage.Sender] = WorkerState.Waiting; blocks.UnionWith(countedMessage.Blocks); if (workers.All(worker => state[worker] == WorkerState.Waiting)) { if (blocks.Count > oldNumBlocks) { // There was a change, continue refining k_max += 1; foreach (var worker in workers) { state[worker] = WorkerState.Refining; worker.SendMe(new RefineMessage(this)); } } else { // We're done, collect global partition k_max -= 1; foreach (var worker in workers) { state[worker] = WorkerState.Collecting; worker.SendMe(new SegmentRequestMessage(this)); } } } }) .Case((SegmentResponseMessage <TNode> segmentResponseMessage) => { state[segmentResponseMessage.Sender] = WorkerState.Waiting; foreach (var pair in segmentResponseMessage.Pairs) { partition.Add(pair.Key, pair.Value); } if (workers.All(worker => state[worker] == WorkerState.Waiting)) { onComplete(k_max, partition); } }); }
protected override void OnReceive(AbstractMessage message) { TypeSwitch.On(message) .Case((CoordinatorMessage coordinatorMessage) => { k_max = 0; partition = new Dictionary <TNode, int>(); oldNumBlocks = 0; blocks = new HashSet <int>(); workers = coordinatorMessage.Workers; state = new Dictionary <AbstractMachine, WorkerState>(); foreach (var worker in workers) { state.Add(worker, WorkerState.Refining); worker.SendMe(new ClearMessage(this)); } }) .Case((EstimateRefinedMessage refinedMessage) => { state[refinedMessage.Sender] = WorkerState.Waiting; if (workers.All(worker => state[worker] == WorkerState.Waiting)) { // All workers have refined, now perform a share step foreach (var worker in workers) { state[worker] = WorkerState.Sharing; worker.SendMe(new ShareMessage(this)); } } }) .Case((SharedMessage sharedMessage) => { state[sharedMessage.Sender] = WorkerState.Waiting; if (workers.All(worker => state[worker] == WorkerState.Waiting)) { // All workers have shared, now count the number of unqiue blocks oldNumBlocks = blocks.Count; blocks.Clear(); foreach (var worker in workers) { state[worker] = WorkerState.Counting; worker.SendMe(new CountMessage(this)); } } }) .Case((CountedMessage countedMessage) => { state[countedMessage.Sender] = WorkerState.Waiting; blocks.UnionWith(countedMessage.Blocks); if (workers.All(worker => state[worker] == WorkerState.Waiting)) { if (blocks.Count > oldNumBlocks) { // There was a change, continue refining k_max += 1; foreach (var worker in workers) { state[worker] = WorkerState.Refining; worker.SendMe(new RefineMessage(this)); } } else { // We're done, collect global partition k_max -= 1; foreach (var worker in workers) { state[worker] = WorkerState.Collecting; worker.SendMe(new SegmentRequestMessage(this)); } } } }) .Case((SegmentResponseMessage <TNode> segmentResponseMessage) => { state[segmentResponseMessage.Sender] = WorkerState.Waiting; foreach (var pair in segmentResponseMessage.Pairs) { partition.Add(pair.Key, pair.Value); } if (workers.All(worker => state[worker] == WorkerState.Waiting)) { onComplete(k_max, partition); } }); }