public void TestNumericLiteralEquals() { NumericLiteral first = new NumericLiteral() { Value = 3 }; NumericLiteral firstClone = new NumericLiteral() { Value = 3 }; NumericLiteral second = new NumericLiteral() { Value = 17 }; //Equals Assert.IsTrue(Equals(first, firstClone)); Assert.IsFalse(Equals(first, null)); Assert.IsFalse(Equals(first, "test")); Assert.IsFalse(Equals(first, second)); //Hash code Assert.AreEqual(first.GetHashCode(), firstClone.GetHashCode()); Assert.AreNotEqual(first.GetHashCode(), second.GetHashCode()); }
/// <summary> /// Returns the object value of the literal. /// </summary> /// <param name="lit"></param> /// <returns></returns> public object GitLiteralValue(Literal lit) { // Support string literals. StringLiteral stringLit = null; NumericLiteral numberLiteral = null; stringLit = lit as StringLiteral; if (stringLit != null) { return(ParseStringLiteralValue(stringLit)); } numberLiteral = lit as NumericLiteral; if (numberLiteral != null) { return(ParseNumericLiteralValue(numberLiteral)); } var nullLiteral = lit as NullLiteral; if (nullLiteral != null) { return(null); } throw new NotSupportedException("Unknown Literal"); }
protected override void VisitNumericLiteral(NumericLiteral item) { var sqlValue = ParseNumericLiteralValue(item); var attName = GetColumnLogicalAttributeName(this.CurrentColumn); this.EntityBuilder.WithAttribute(attName).SetValueWithTypeCoersion(sqlValue); }
/// <summary> /// Returns the object value of the numeric literal. /// </summary> /// <param name="literal"></param> /// <returns></returns> public object ParseNumericLiteralValue(NumericLiteral literal) { // cast down from double to int if possible.. checked { try { if ((literal.Value % 1) == 0) { int intValue = (int)literal.Value; if (intValue == literal.Value) { return(intValue); } } // can we return a decimal instead? var decVal = Convert.ToDecimal(literal.Value); return(decVal); } catch (OverflowException) { // can't down cast to int so remain as double. return(literal.Value); } } }
private Field Numeric(NumericLiteral number) { return(new Field() { Value = number.Number }); }
public void TestNumericLiteralAccept() { Mock <KoraliumSqlVisitor> mock = new Mock <KoraliumSqlVisitor>(); NumericLiteral numericLiteral = new NumericLiteral(); numericLiteral.Accept(mock.Object); mock.Verify(x => x.VisitNumericLiteral(numericLiteral)); }
/// <summary> /// Gets the numeric properties. /// </summary> /// <param name="numericValue">The numeric value.</param> /// <returns></returns> protected static NumericProperties GetNumericProperties(NumericLiteral numericValue) { return(new NumericProperties { Precision = numericValue.Value.Length, Scale = numericValue.Value.Length - numericValue.Value.IndexOf('.') }); }
public void TestNumericLiteralGetValue() { NumericLiteral numericLiteral = new NumericLiteral() { Value = 17 }; Assert.AreEqual(17m, numericLiteral.GetValue()); }
public void TestNumericLiteralWithDecimal() { var actual = new NumericLiteral() { Value = 12.3M }.Print(); var expected = "12.3"; actual.Should().Be(expected); }
public void TestVisitNumericLiteral() { NumericLiteral numericLiteral = new NumericLiteral(); KoraliumSqlVisitor koraliumSqlVisitor = new KoraliumSqlVisitor(); koraliumSqlVisitor.Visit(numericLiteral); //Nothing to verify yet, only that no exceptions are thrown Assert.Pass(); }
public CSharpSyntaxNode Convert(NumericLiteral node) { string text = node.Text; if (Zeroize(node)) { text += ".0"; } return(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(text, double.Parse(text)))); }
/// <summary> /// Generates the text for a NumericLiteral builder. /// </summary> /// <param name="item">The NumericLiteral builder to generate the text for.</param> protected internal override void VisitNumericLiteral(NumericLiteral item) { if (item.Format == null) { writer.Write(item.Value.ToString(CultureInfo.InvariantCulture)); } else { writer.Write(item.Value.ToString(item.Format, CultureInfo.InvariantCulture)); } }
public void TestCloneNumericLiteral() { NumericLiteral numericLiteral = new NumericLiteral() { Value = 3 }; var clone = numericLiteral.Clone() as NumericLiteral; Assert.AreEqual(numericLiteral, clone); Assert.IsFalse(ReferenceEquals(numericLiteral, clone)); }
protected override void VisitNumericLiteral(NumericLiteral item) { var sqlValue = ParseNumericLiteralValue(item); if (IsVisitingFilterItem) { IdFilterValue = sqlValue; } else { throw new NotSupportedException(); } }
public void Decimals(string input, decimal result, int length) { List <Token> tokens = Lexer.Lex(input); Assert.NotNull(tokens); NumericLiteral token = Assert.IsType <NumericLiteral>(tokens[0]); Assert.Equal(0, token.Start); Assert.Equal(length, token.End); Assert.Equal(result, token.Number); Assert.Equal(input, string.Join("", tokens)); }
private bool Zeroize(NumericLiteral node) { BinaryExpression expr = node.Parent == null ? null : node.Parent as BinaryExpression; if (expr != null && expr.OperatorToken.Kind == NodeKind.SlashToken && expr.Left.Kind == NodeKind.NumericLiteral && expr.Right.Kind == NodeKind.NumericLiteral && node.Text.IndexOf(".") == -1) { return(true); } return(false); }
protected override void VisitNumericLiteral(NumericLiteral item) { var sqlValue = ParseNumericLiteralValue(item); if (CurrentUpdateStatementPart == UpdateStatementPart.WhereClause) { IdFilterValue = sqlValue; } else { var attName = GetColumnLogicalAttributeName(this.CurrentSetterColumn); EntityBuilder.WithAttribute(attName).SetValueWithTypeCoersion(sqlValue); } }
public abstract T Visit(NumericLiteral node);
/// <summary> /// Gets the data type of the value. /// </summary> /// <param name="value">The value.</param> /// <returns></returns> protected static string GetDataType(NumericLiteral value) { return(value.LiteralType.ToString()); }
private void visitBoundFrame(BoundFrame item) { IVisitableBuilder literal = new NumericLiteral(item.RowCount); literal.Accept(forSubCommand()); }
private LinkedList <Token> GenerateTokens() { string[] lines = sourceString.SplitAndKeep(new[] { '\r', '\n' }).ToArray(); string[] temp; List <string> list = new List <string>(); foreach (string line in lines) { list.AddRange(line.Split('\t', ' ')); } temp = list.ToArray(); temp = temp.Where(x => !String.IsNullOrEmpty(x)).ToArray(); tokenStrings = new LinkedList <string>(temp); currentTokenString = tokenStrings.First; nextTokenString = currentTokenString.Next; previousTokenString = currentTokenString.Previous; while (currentTokenString != null) { Token token = new GenericToken(currentTokenString.Value); if (token.isOperator()) { Operator op = new Operator(currentTokenString.Value); op.Type = op.DetectType(); tokens.AddLast(new LinkedListNode <Token>(op)); } else if (token.isKeyword()) { Keyword keyword = new Keyword(currentTokenString.Value); keyword.Type = keyword.DetectType(); tokens.AddLast(new LinkedListNode <Token>(keyword)); } else if (token.isType()) { Typename typename = new Typename(currentTokenString.Value); typename.Type = typename.DetectType(); tokens.AddLast(new LinkedListNode <Token>(typename)); } else { token.Type = token.DetectType(); if ((EnumTokenType)token.Type == EnumTokenType.STRING) { StringLiteral literal = new StringLiteral(currentTokenString.Value); literal.Type = EnumTokenType.STRING_LITERAL; while (!literal.Value.EndsWith("\"")) { currentTokenString = nextTokenString; nextTokenString = currentTokenString.Next; if (currentTokenString.Value == null) { ThrowError(EnumErrorCodes.STRING_NOT_TETMINATED, "\""); return(null); } literal.Value += " " + currentTokenString.Value; } tokens.AddLast(new LinkedListNode <Token>(literal)); } else if ((EnumTokenType)token.Type == EnumTokenType.NUMBER) { NumericLiteral literal = new NumericLiteral(currentTokenString.Value); literal.Type = EnumTokenType.NUMERIC_LITERAL; tokens.AddLast(new LinkedListNode <Token>(literal)); } else { tokens.AddLast(new LinkedListNode <Token>(token)); } } currentTokenString = nextTokenString; if (nextTokenString != null) { nextTokenString = currentTokenString.Next; } if (previousTokenString != null) { previousTokenString = currentTokenString.Previous; } } return(tokens); }
public Constant VisitNumericLiteral(NumericLiteral number) { return(Constant.Create(PrimitiveType.Int64, number.Value)); }
public virtual void VisitNumericLiteral(NumericLiteral numericLiteral) { //NOP }
public override object?Visit(NumericLiteral node) { AddNodeInfo(node.Value.ToString(CultureInfo.InvariantCulture)); return(null); }
public override void ExplicitVisit(NumericLiteral fragment) { _fragments.Add(fragment); }
public override void ExplicitVisit(NumericLiteral node) { node.Value = "0.1"; base.ExplicitVisit(node); }
public NumericExpression(IScope scope, Expression value, NumericLiteral fallback) : base(GlobalFunction.NUMB, scope, value) { _fallback = fallback; }
protected override void VisitNumericLiteral(NumericLiteral item) { this.ColumnSize = System.Convert.ToInt32(item.Value); base.VisitNumericLiteral(item); }
protected override void VisitNumericLiteral(NumericLiteral item) { this.CurrentNumericLiteralValue = item.Value; // base.VisitNumericLiteral(item); }
public override void Visit(NumericLiteral node) { this.action(node); }
public SerializedType VisitNumericLiteral(NumericLiteral number) { throw new NotImplementedException(); }
public override void ExplicitVisit(NumericLiteral node) { base.ExplicitVisit(node); }