// ======================================================================================= // CLASS INITIALISATION // ======================================================================================= /// <summary> /// A statement should be solely an expression with no return value or whose return value is ignored - eg. a function call. Tokens that /// represent a statement where the return value is used to set another variable's value should be described by a ValueSettingStatement. /// It is recommended to pass any tokens that are thought to be one Statement through the StatementHandler, which will break down the /// content into multiple Statements (if there are any AbstractEndOfStatementToken tokens). /// </summary> public Statement(IEnumerable <IToken> tokens, CallPrefixOptions callPrefix) { if (tokens == null) { throw new ArgumentNullException("tokens"); } if (!Enum.IsDefined(typeof(CallPrefixOptions), callPrefix)) { throw new ArgumentOutOfRangeException("callPrefix"); } Tokens = tokens.ToList().AsReadOnly(); if (!Tokens.Any()) { throw new ArgumentException("Statements must contain at least one token"); } if (!Tokens.Any()) { throw new ArgumentException("Empty tokens specified - invalid"); } if (Tokens.Any(t => t == null)) { throw new ArgumentException("Null token passed into Statement constructor"); } var firstTokenAsAtom = tokens.First() as AtomToken; if ((firstTokenAsAtom != null) && firstTokenAsAtom.Content.Equals("Call", StringComparison.InvariantCultureIgnoreCase)) { throw new ArgumentException("The first token may not be the Call keyword, that must be specified through the CallPrefixOption value where present"); } CallPrefix = callPrefix; }
public static bool NextTokenIs(object obj) { if (Tokens != null && Tokens.Any()) { return(Tokens.Peek().Equals(obj)); } return(false); }
public static Token NextToken() { if (Tokens != null && Tokens.Any()) { return(Tokens.Dequeue()); } return(null); }
private TokenOutput PeekToken() { if (Tokens.Any()) { return(Tokens.Peek()); } return(null); }
public void AddToken(Token token) { if (Tokens.Any(t => t.Colour == token.Colour)) { throw new ArgumentException($"This token is already on the board: { token.Colour }"); } token.Position = StartPosition; Tokens = Tokens.Union(new Token[] { token }); }
public override HashSet <Document> GetResults(IInvertedIndex index) { var results = new HashSet <Document>(); if (Tokens.Any()) { results.UnionWith(index.GetDocumentsOfToken(Tokens[0])); Tokens.ForEach(t => results.IntersectWith(index.GetDocumentsOfToken(t))); } return(results); }
public Node Parse() { if (!Tokens.Any()) { return(null); } if (Tokens.Last().TokenType != FilterTokenType.ExprEnd) { Tokens.Add(new Token(FilterTokenType.ExprEnd, null, null)); } return(ParseExpression()); }
/// <summary> /// Releases all resources consumed by the current <see cref="ConcurrencyControl" />. /// </summary> /// <param name="disposing"> /// A value indicating whether or not managed resources should be released. /// </param> protected virtual void Dispose(Boolean disposing) { if (disposing) { if (Tokens.Any()) { // Reject new entries and wait for pending exits. IsDisposed = true; SpinWait.SpinUntil(() => Tokens.Any() == false); } } IsDisposed = true; }
public PartialNumberContent(IEnumerable <IToken> tokens) { if (tokens == null) { throw new ArgumentNullException("tokens"); } Tokens = tokens.ToList().AsReadOnly(); if (Tokens.Any(t => t == null)) { throw new ArgumentException("Null reference encountered in tokens set"); } if (Tokens.Any(t => !IsValidToken(t))) { throw new ArgumentException("The only allowable tokens are minus sign OperatorTokens, numeric AtomTokens and MemberAccessorOrDecimalPointTokens"); } }
/// <summary> /// Evaluates formula /// </summary> /// <param name="argument">The argument to take variables values from</param> /// <returns></returns> /// <exception cref="MathException">Formula is not valid, cannot evaluate it</exception> /// <exception cref="UnknownEnumException{TEnum}"></exception> public double Evaluate(object argument = null) { if (!IsValid) { throw new MathException("Formula is not valid, cannot evaluate it"); } if (argument == null && Tokens.Any(x => x.Type == TokenType.Variable)) { throw new MathException("Encountered variable, yet argument is empty"); } var stack = new Stack <double>(); var negateNextStatement = false; var argumentProperties = argument?.GetType().GetTypeInfo().DeclaredProperties; foreach (var token in Tokens) { switch (token.Type) { case TokenType.Number: stack.Push(negateNextStatement ? -((NumberToken)token).Number : ((NumberToken)token).Number); negateNextStatement = false; break; case TokenType.Operator: stack.Push(Compute(stack.Pop(), stack.Pop(), ((OperatorToken)token).Operator)); break; case TokenType.Negation: negateNextStatement = true; break; case TokenType.Variable: var value = GetValueForVariable((VariableToken)token, argument, argumentProperties); stack.Push(negateNextStatement ? -value : value); negateNextStatement = false; break; default: throw new UnknownEnumException <TokenType>(token.Type); } } return(stack.Pop()); }
public Deck(bool isTemp) { if (isTemp) { return; } Cards.CollectionChanged += delegate(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs ne) { HasChanges = true; OnPropertyChanged(nameof(HasChanges)); OnPropertyChanged(nameof(CardCount)); if (ne.NewItems != null) { foreach (var i in ne.NewItems) { (i as DeckCard).PropertyChanged += delegate(object s, PropertyChangedEventArgs pe) { if (pe.PropertyName == "SelectPrint" || pe.PropertyName == "Count" || pe.PropertyName == "CanPrint") { HasChanges = true; OnPropertyChanged(nameof(HasChanges)); if (pe.PropertyName == "Count") { OnPropertyChanged(nameof(CardCount)); } } }; } } }; Tokens.CollectionChanged += delegate { HasTokens = Tokens.Any(); OnPropertyChanged(nameof(HasTokens)); }; }
public bool IsEmpty() { return(!Tokens.Any() && !TokensList.Any()); }
public void Parse(string markup) { // Prepare markup for parsing. // Replace multiply spaces and commas with a single space. markup = Regex.Replace(markup, "[ ]{2,}", " ", RegexOptions.None); markup = Regex.Replace(markup, "[,]", " ", RegexOptions.None); markup = markup.Trim(); // We will change current tokens collection only // after the parsing process finishes successful. var newTokens = new List <Token>(); // Markup is ready for parsing. Now we can // analyse the syntax and get tokens. try { for (int i = 0; i < markup.Length; i++) { // Parse markup and create token. Also we can get // start (s) and end (e) points of the token in given markup. char symbol = markup[i]; int s = 0, e = 0; if (symbol == 'M' || symbol == 'm') { // Create token and save it to the tokens collection. newTokens.Add(Move.Parse(markup.Substring(i), out s, out e)); } else if (symbol == 'L' || symbol == 'l') { newTokens.Add(Line.Parse(markup.Substring(i), out s, out e)); i += e; } else if (symbol == 'H' || symbol == 'h') { newTokens.Add(HLine.Parse(markup.Substring(i), out s, out e)); i += e; } else if (symbol == 'V' || symbol == 'v') { newTokens.Add(VLine.Parse(markup.Substring(i), out s, out e)); } else if (symbol == 'C' || symbol == 'c') { newTokens.Add(CubicBezierCurve.Parse(markup.Substring(i), out s, out e)); } else if (symbol == 'Q' || symbol == 'q') { newTokens.Add(QuadraticBezierCurve.Parse(markup.Substring(i), out s, out e)); } else if (symbol == 'S' || symbol == 's') { newTokens.Add(SmoothCubicBezierCurve.Parse(markup.Substring(i), out s, out e)); } else if (symbol == 'T' || symbol == 't') { newTokens.Add(SmoothQuadraticBezierCurve.Parse(markup.Substring(i), out s, out e)); } else if (symbol == 'A' || symbol == 'a') { newTokens.Add(EllipticalArc.Parse(markup.Substring(i), out s, out e)); } else if (symbol == 'Z' || symbol == 'z') { newTokens.Add(Close.Parse(markup.Substring(i), out s, out e)); } else if (symbol == ' ') { continue; } else { // TODO: Throw an exception or log error and finish parsing. } // Continue loop from the end point of the token. i += e; } // Parsing process finshed successful so we can update tokens collection. if (Tokens.Any()) { Tokens.Clear(); } foreach (var token in newTokens) { Tokens.Add(token); } } catch (Exception e) { // TODO: Log exception. // Left collection not changed. } }
public bool Contains(string contents) { return(Tokens.Any(tok => tok.Contents == contents)); }