public IStatus <EchoLocation> Update(ICoordinates coordinates) { var response = new Status <EchoLocation>(); if (!this.IsValid) { response.AddError("Can only update valid Echo Locations"); } foreach (var violation in CoordinatesRules. GetCoordinatesRuleViolations(coordinates)) { response.AddError(violation.Rule); } // if there wernt errors go ahead and update this location. if (response.IsSuccess()) { Lattitude = coordinates.Lattitude; Longitude = coordinates.Longitude; TimeStamp = DateTimeOffset.UtcNow; } response.RespondWithObject(this); return(response); }
static void TestStatus() { IStatus status = new Status(); status.AddError(Error.From(AuthError.RegistrationError, "some technical jargon", "An unexpected error has occurred")); status.AddError(Error.From(AuthError.UserAlreadyExists, new [] { "*****@*****.**" })); status.AddError(Error.From(AuthError.InvalidCredentials)); Console.WriteLine(status.ToString()); Console.WriteLine(); Console.WriteLine(status.ToUserFriendlyString()); }
private List <IValue> ArrayIndexAccess(ArrayClepsType expressionType, IList <ClepsParser.RightHandExpressionContext> arrayIndexExpression) { var indexValues = arrayIndexExpression.Select(i => { var indexValueRet = Visit(i); IValue indexValue = indexValueRet as IValue; if (indexValue.ExpressionType != CompilerConstants.ClepsByteType) { string errorMessage = String.Format("Array access {0} is not a byte type", i.GetText()); Status.AddError(new CompilerError(FileName, i.Start.Line, i.Start.Column, errorMessage)); //just use the first element access to avoid stalling indexValue = CodeGenerator.CreateByte(0); } return(indexValue); }).ToList(); if (indexValues.Count > expressionType.Dimensions.Length) { string errorMessage = String.Format("Accessing more dimensions than array has. Array has {0} dimensions, but accessing {1} dimensions", expressionType.Dimensions.Length, indexValues.Count); Status.AddError(new CompilerError(FileName, arrayIndexExpression[indexValues.Count - 1].Start.Line, arrayIndexExpression[indexValues.Count - 1].Start.Column, errorMessage)); //truncate array access to allowed access to avoid stopping the compilation indexValues = indexValues.Take(expressionType.Dimensions.Length).ToList(); } return(indexValues); }
private void SenderStreams_CloneStreams(object sender, RoutedEventArgs e) { if (RestApi == null && ApiToken == null) { Status.AddError("Not logged in"); return; } var cell = SenderStreams.CurrentCell.Item; if (cell.GetType() == typeof(Tuple <string, string>)) { string streamID = (cell as Tuple <string, string>).Item2; Task.Run(() => SpeckleStreamManager.CloneStream(RestApi, ApiToken, streamID)).ContinueWith(res => { Application.Current.Dispatcher.BeginInvoke( DispatcherPriority.Background, new Action(() => { try { Status.AddMessage("Cloned to: " + res.Result); } catch { Status.AddError("Could not clone " + streamID); } } )); }); } }
public override object VisitFunctionVariableDeclarationStatement([NotNull] ClepsParser.FunctionVariableDeclarationStatementContext context) { ClepsVariable variable = Visit(context.variableDeclaration()) as ClepsVariable; VariableManager variableManager = VariableManagers.Last(); if (!variableManager.IsVariableNameAvailable(variable.VariableName)) { string errorMessage = String.Format("Variable {0} is already defined", variable.VariableName); Status.AddError(new CompilerError(FileName, context.Start.Line, context.Start.Column, errorMessage)); //Use a different variable name to avoid stopping the compilation string newVariableName = variableManager.GetAvailableVariableName(variable.VariableName); variable = new ClepsVariable(newVariableName, variable.VariableType, variable.IsConstant); } IValue value = null; if (context.rightHandExpression() != null) { value = Visit(context.rightHandExpression()) as IValue; if (variable.VariableType != value.ExpressionType) { throw new NotImplementedException("Assignment for non identical types not supported yet"); } } IValueRegister variableRegister = CurrMethodGenerator.CreateNewVariable(variable, value); variableManager.AddLocalVariable(variable, variableRegister); return(variable); }
/// <summary> /// Login to a SpeckleServer /// </summary> private void Login(object sender, RoutedEventArgs e) { var signInWindow = new SpecklePopup.SignInWindow(true); var helper = new System.Windows.Interop.WindowInteropHelper(signInWindow) { Owner = new System.Windows.Interop.WindowInteropHelper(this).Handle }; this.IsEnabled = false; signInWindow.ShowDialog(); this.IsEnabled = true; if (signInWindow.AccountListBox.SelectedIndex != -1) { var account = signInWindow.accounts[signInWindow.AccountListBox.SelectedIndex]; EmailAddress = account.Email; RestApi = account.RestApi; ApiToken = account.Token; (SenderTab.Content as Grid).IsEnabled = FileOpened && LoggedIn; (ReceiverTab.Content as Grid).IsEnabled = FileOpened && LoggedIn; UpdateClientLists(); Status.AddMessage("Logged in to account at: " + RestApi); } else { Status.AddError("Failed to log in"); } }
/// <summary> /// Receive all streams in the account. /// </summary> private void UpdateStreamList(object sender, RoutedEventArgs e) { if (RestApi == null && ApiToken == null) { Status.AddError("Not logged in"); return; } Task.Run(() => SpeckleStreamManager.GetStreams(RestApi, ApiToken)).ContinueWith(res => { Application.Current.Dispatcher.BeginInvoke( DispatcherPriority.Background, new Action(() => { List <Tuple <string, string> > streams = res.Result; if (streams != null) { streams.Reverse(); StreamList.Items.Clear(); foreach (Tuple <string, string> t in streams) { StreamList.Items.Add(t); } } } )); }); }
/// <summary> /// Return an echo from a pulse this radar emited. /// </summary> /// <param name="returnedEcho">The echo to return.</param> /// <returns></returns> public IStatus <CruiseRadar> ReturnEcho(RadarEcho returnedEcho) { var response = new Status <CruiseRadar>(); try { if (_pulses.Contains(returnedEcho.OriginatingPulse)) { ContactOrClutter(returnedEcho); } else { response.AddError ("Echos can only be returned to the radars that " + "emited the original pulse. "); } } catch (Exception ex) { response.AddException(ex); } response.RespondWithObject(this); return(response); }
/// <summary> /// Removes a handkerchief from the hard no list if it was in it. /// </summary> /// <param name="handkerchief"></param> /// <returns></returns> public IStatus <Avatar> StopFlaggingHandkerchiefAsHardNo (Handkerchief handkerchief) { var response = new Status <Avatar>(); try { if (hardNoHandkerchiefs.Contains(handkerchief)) { hardNoHandkerchiefs.Remove(handkerchief); AddDomainEvent(new AvatarRemovedHardNoHandkerchiefDomainEvent (this, handkerchief)); CruiseRadar.ReEvaluateClutter(); } else { response.AddError ("specified handkerchief not found in hard no list."); } } catch (Exception ex) { response.AddException(ex); } return(AvatarValidationStatus(response)); }
/// <summary> /// Stop the currenly active cruise, if there is one. /// </summary> /// <returns></returns> public IStatus <Avatar> StopActiveCruise() { var response = new Status <Avatar>(); try { if (HasActiveCruise) { LastCruise.StoppedAt = DateTimeOffset.UtcNow; AddDomainEvent(new CruiseStoppedDomainEvent (LastCruise, this)); } else { response.AddError("No active cruise avalable to stop."); } } catch (Exception ex) { response.AddException(ex); } return(AvatarValidationStatus(response)); }
public override object VisitMemberDeclarationStatement([NotNull] ClepsParser.MemberDeclarationStatementContext context) { string memberName = context.FieldName.Name.Text; ClepsClassBuilder classBuilder = ClassManager.GetClassBuilder(FullyQualifiedClassName); if (classBuilder == null) { //This is probably because of some earlier error. Return gracefully return(false); } if (classBuilder.DoesClassContainMember(memberName)) { string errorMessage = String.Format("Class {0} has multiple definitions of member {1}", FullyQualifiedClassName, memberName); Status.AddError(new CompilerError(FileName, context.Start.Line, context.Start.Column, errorMessage)); //Don't process this member return(false); } bool isStatic = context.STATIC() != null; ClepsType memberType = Visit(context.typename()) as ClepsType; if (memberType.IsFunctionType) { CodeGenerator.CreateMethod(FullyQualifiedClassName, isStatic, memberType, memberName); } classBuilder.AddNewMember(isStatic, memberType, memberName); return(true); }
/// <summary> /// Emits a radar pulse via a PulseEmittedDomainEvent /// </summary> /// <param name="location">The center point of the pulse</param> /// <remarks> /// Emitting a pulse triggers a PulseEmittedDomainEvent. Higher layers /// in Hankies handle the PulseEmittedDomainEvent and return a /// IRadarPulse to the radar object before saving to the database /// context. /// </remarks> public IStatus <PulseEmitedDomainEvent> EmitPulse(ICoordinates location) { var resultStatus = new Status <PulseEmitedDomainEvent>(); var pulseEvent = new PulseEmitedDomainEvent(location.Lattitude, location.Longitude, Range, this); try { if (pulseEvent.IsValid) { Owner.AddDomainEvent(pulseEvent); } else { resultStatus.AddError("Invalid PulseEmitedDomainEvent, " + "could not add to domain events"); } } catch (Exception ex) { resultStatus.AddException(ex); } resultStatus.RespondWithObject(pulseEvent); return(resultStatus); }
public override object VisitNumericAssignments([NotNull] ClepsParser.NumericAssignmentsContext context) { IValue val; string numericValue = context.numeric().NumericValue.Text; string numericType = context.numeric().NumericType?.Text; if (numericType == "b") { byte byteVal; if (!byte.TryParse(numericValue, out byteVal)) { string errorMessage = String.Format("Value {0} is outside the range of values allowed for a byte. Allowed range is 0 to 255", numericValue); Status.AddError(new CompilerError(FileName, context.Start.Line, context.Start.Column, errorMessage)); //Use a different value to avoid stopping the compilation byteVal = 0; } val = CodeGenerator.CreateByte(byteVal); } else { throw new NotImplementedException("Other numeric types not supported yet"); } return(val); }
private Status <Avatar> IsCorrectSender(Status <Avatar> response, Avatar sender) { if (Avatar != sender) { response.AddError ("Only the owning avatar may modify its cruise."); } return(response); }
/// <summary> /// Adds an error to a Status if Is Blindfold rule is violated. /// </summary> /// <param name="response"></param> /// <returns></returns> private Status <Avatar> IsBlindfolded(Status <Avatar> response) { if (!Blindfolded) { response.AddError ("Cannot don or doff blindfold for an avatar if you are " + "not wearing a Blindfold."); } return(response); }
private Status <Avatar> IsHooded(Status <Avatar> response) { if (!Hooded) { response.AddError ("Cannot don or doff hood for an avatar if you are " + "not wearing a hood."); } return(response); }
/// <summary> /// Clear all receivers. /// </summary> private void ClearReceiver(object sender, RoutedEventArgs e) { GSA.ReceiverInfo.Clear(); if (!GSA.SetSpeckleClients(EmailAddress, RestApi)) { Status.AddError("Error in communicating GSA - please check if the GSA file has been closed down"); return; } UpdateClientLists(); }
public IStatus <IPattern> UpdateUri(Uri newUri) { Location = newUri; var updateStatus = new Status <IPattern>(true); if (!IsValid) { updateStatus.AddError("Updated uri had rule violations"); } updateStatus.RespondWithObject(this); return(updateStatus); }
public IStatus <IPattern> UpdateColor(NamedColor newColor) { Color = newColor; var updatePattern = new Status <IPattern>(true); if (!IsValid) { updatePattern.AddError("Updated color had rule violations"); } updatePattern.RespondWithObject(this); return(updatePattern); }
private IStatus <Avatar> AvatarValidationStatus(Status <Avatar> response) { // Add any validation errors. if (!IsValid) { foreach (var violation in GetRuleViolations()) { response.AddError(violation.Rule); } } response.RespondWithObject(this); return(response); }
public sealed override object VisitFunctionStatement([NotNull] ClepsParser.FunctionStatementContext context) { if (CurrentBlockStatus.Last().ReturnStatementReached) { string errorMessage = String.Format("Statement is dead code", FullyQualifiedClassName); Status.AddError(new CompilerError(FileName, context.Start.Line, context.Start.Column, errorMessage)); return(false); } else { VisitFunctionStatement_Ex(context); return(true); } }
public IStatus <IDomainEntity> AddDomainEvent(IDomainEvent eventItem) { var addEventStatus = new Status <IDomainEntity>(true); if (_domainEvents == null) { _domainEvents = new List <IDomainEvent>(); } if (eventItem == null) { addEventStatus.AddError("Domain event can't be null."); } if (_domainEvents.Contains(eventItem)) { addEventStatus.AddError("Can't contain duplicate events."); } _domainEvents.Add(eventItem); addEventStatus.RespondWithObject(this); return(addEventStatus); }
public IStatus <EchoLocation> Refresh() { var response = new Status <EchoLocation>(); if (!this.IsValid) { response.AddError("Can only refresh valid Echo Locations"); } TimeStamp = DateTimeOffset.UtcNow; response.RespondWithObject(this); return(response); }
public override object VisitClassDeclarationStatements_Ex([NotNull] ClepsParser.ClassDeclarationStatementsContext context) { //if this qualified name already exists, there is an error if (ClassManager.IsClassBuilderAvailable(FullyQualifiedClassName)) { string errorMessage = String.Format("Class {0} has multiple definitions", FullyQualifiedClassName); Status.AddError(new CompilerError(FileName, context.Start.Line, context.Start.Column, errorMessage)); //Don't process this class return(false); } ClassManager.AddNewClassDeclaration(FullyQualifiedClassName); CodeGenerator.CreateClass(FullyQualifiedClassName); return(true); }
private void ReceiverStreams_RemoveStream(object sender, RoutedEventArgs e) { var streamID = ReceiverStreams.CurrentCell.Item; if (streamID.GetType() == typeof(string)) { GSA.ReceiverInfo.Remove(GSA.ReceiverInfo.First(x => x.Item1 == (string)streamID)); if (!GSA.SetSpeckleClients(EmailAddress, RestApi)) { Status.AddError("Error in communicating GSA - please check if the GSA file has been closed down"); return; } UpdateClientLists(); } }
public override object VisitValueAtOnExpression([NotNull] ClepsParser.ValueAtOnExpressionContext context) { IValue target = Visit(context.addressOfOrValueAtTargetExpression()) as IValue; if (!(target.ExpressionType is PointerClepsType)) { string errorMessage = String.Format("Cannot derefernce object of type {0}.", target.ExpressionType.GetClepsTypeString()); Status.AddError(new CompilerError(FileName, context.Start.Line, context.Start.Column, errorMessage)); //Just return something to avoid stalling compilation return(target); } IValue ret = CodeGenerator.GetDereferencedValueFromPtr(target); return(ret); }
/// <summary> /// Add a new receiver. /// </summary> private void AddReceiver(object sender, RoutedEventArgs e) { if (ReceiverTextbox.Text != "") { var streamId = ReceiverTextbox.Text.Trim(); GSA.ReceiverInfo.Add(new Tuple <string, string>(streamId, null)); if (!GSA.SetSpeckleClients(EmailAddress, RestApi)) { Status.AddError("Error in communicating GSA - please check if the GSA file has been closed down"); return; } UpdateClientLists(); ReceiverTextbox.Clear(); } }
public override object VisitThisAssignment([NotNull] ClepsParser.ThisAssignmentContext context) { if (CurrMemberIsStatic) { string errorMessage = "Cannot use the this keyword in a static member"; Status.AddError(new CompilerError(FileName, context.Start.Line, context.Start.Column, errorMessage)); //just return something to avoid stalling return(CodeGenerator.CreateByte(0)); } BasicClepsType currentClassType = new BasicClepsType(FullyQualifiedClassName); IValue thisValue = CodeGenerator.GetThisInstanceValue(currentClassType); IValue thisPtr = CodeGenerator.GetPtrToValue(thisValue); return(thisPtr); }
/// <summary> /// Add receivers from clipboard. /// </summary> private void PasteClipboardReceiver(object sender, RoutedEventArgs e) { string[] paste = Clipboard.GetText(TextDataFormat.Text).Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries); foreach (string p in paste) { var streamId = p.Trim(); GSA.ReceiverInfo.Add(new Tuple <string, string>(streamId, null)); } if (!GSA.SetSpeckleClients(EmailAddress, RestApi)) { Status.AddError("Error in communicating GSA - please check if the GSA file has been closed down"); return; } UpdateClientLists(); }
private IValueRegister GetVariableRegisterOrNullWithError([NotNull] ClepsParser.VariableAssignmentContext context) { string variableName = Visit(context.variable()) as string; var variableManager = VariableManagers.Last(); IValueRegister register; if (!variableManager.IsVariableAvailable(variableName)) { string errorMessage = String.Format("Variable {0} does not exist", variableName); Status.AddError(new CompilerError(FileName, context.Start.Line, context.Start.Column, errorMessage)); register = null; } else { register = variableManager.GetVariableRegister(variableName); } return(register); }