public static void FlatScalar(IIonReader reader) { //a flat struct of scalar values: //boolean:true //str:"yes" //integer:123456 //longInt:int.Max*2 //bigInt:long.Max*10 //double:2213.1267567f reader.MoveNext(); Assert.AreEqual(IonType.Struct, reader.CurrentType); reader.StepIn(); Assert.IsTrue(reader.IsInStruct); Assert.AreEqual(1, reader.CurrentDepth); reader.MoveNext(); Assert.AreEqual("boolean", reader.CurrentFieldName); Assert.AreEqual(IonType.Bool, reader.CurrentType); Assert.IsTrue(reader.BoolValue()); reader.MoveNext(); Assert.AreEqual("str", reader.CurrentFieldName); Assert.AreEqual(IonType.String, reader.CurrentType); Assert.AreEqual("yes", reader.StringValue()); reader.MoveNext(); Assert.AreEqual("integer", reader.CurrentFieldName); Assert.AreEqual(IonType.Int, reader.CurrentType); Assert.AreEqual(123456, reader.IntValue()); reader.MoveNext(); Assert.AreEqual("longInt", reader.CurrentFieldName); Assert.AreEqual(IonType.Int, reader.CurrentType); Assert.AreEqual((long)int.MaxValue * 2, reader.LongValue()); reader.MoveNext(); Assert.AreEqual("bigInt", reader.CurrentFieldName); Assert.AreEqual(IonType.Int, reader.CurrentType); Assert.AreEqual(BigInteger.Multiply(new BigInteger(long.MaxValue), 10), reader.BigIntegerValue()); reader.MoveNext(); Assert.AreEqual("double", reader.CurrentFieldName); Assert.AreEqual(IonType.Float, reader.CurrentType); Assert.AreEqual(2213.1267567, reader.DoubleValue()); Assert.AreEqual(IonType.None, reader.MoveNext()); reader.StepOut(); Assert.AreEqual(0, reader.CurrentDepth); }
private void WriteValueRecursively(IonType type, IIonReader reader) { this.TryWriteFieldName(reader); this.TryWriteAnnotationSymbols(reader); if (reader.CurrentIsNull) { this.WriteNull(type); return; } switch (type) { case IonType.Bool: this.WriteBool(reader.BoolValue()); break; case IonType.Int: switch (reader.GetIntegerSize()) { case IntegerSize.Int: this.WriteInt(reader.IntValue()); break; case IntegerSize.Long: this.WriteInt(reader.LongValue()); break; case IntegerSize.BigInteger: this.WriteInt(reader.BigIntegerValue()); break; default: throw new ArgumentOutOfRangeException(); } break; case IonType.Float: this.WriteFloat(reader.DoubleValue()); break; case IonType.Decimal: this.WriteDecimal(reader.DecimalValue()); break; case IonType.Timestamp: this.WriteTimestamp(reader.TimestampValue()); break; case IonType.Symbol: this.WriteSymbolToken(reader.SymbolValue()); break; case IonType.String: this.WriteString(reader.StringValue()); break; case IonType.Clob: this.WriteClob(reader.NewByteArray()); break; case IonType.Blob: this.WriteBlob(reader.NewByteArray()); break; case IonType.List: case IonType.Sexp: case IonType.Struct: this.WriteContainerRecursively(type, reader); break; } }
private static bool TryDeserializeScalar(IIonReader reader, Type type, IScalarConverter scalarConverter, ref object result) { if (type == typeof(string)) { if (reader.CurrentType != IonType.String && reader.CurrentType != IonType.Null) { return(false); } result = reader.CurrentIsNull ? null : reader.StringValue(); return(true); } if (reader.CurrentIsNull) { if (type.IsValueType) { return(false); } result = null; return(true); } //check for enum/symbol if (type.IsEnum) { if (reader.CurrentType != IonType.Symbol) { goto NoMatch; } var symbolText = reader.SymbolValue().Text; return(Enum.TryParse(type, symbolText, out result)); } if (type == typeof(bool)) { if (reader.CurrentType != IonType.Bool) { goto NoMatch; } result = reader.BoolValue(); return(true); } if (type == typeof(int)) { if (reader.CurrentType != IonType.Int) { goto NoMatch; } switch (reader.GetIntegerSize()) { case IntegerSize.Int: result = reader.IntValue(); return(true); case IntegerSize.Long: case IntegerSize.BigInteger: throw new OverflowException($"Encoded value is too big for int32"); default: throw new ArgumentOutOfRangeException(); } } if (type == typeof(long)) { if (reader.CurrentType != IonType.Int) { goto NoMatch; } switch (reader.GetIntegerSize()) { case IntegerSize.Int: result = (long)reader.IntValue(); return(true); case IntegerSize.Long: result = reader.LongValue(); return(true); case IntegerSize.BigInteger: throw new OverflowException($"Encoded value is too big for int32"); default: throw new ArgumentOutOfRangeException(); } } if (type == typeof(BigInteger)) { if (reader.CurrentType != IonType.Int) { goto NoMatch; } switch (reader.GetIntegerSize()) { case IntegerSize.Int: result = new BigInteger(reader.IntValue()); return(true); case IntegerSize.Long: result = new BigInteger(reader.LongValue()); return(true); case IntegerSize.BigInteger: result = reader.BigIntegerValue(); return(true); default: throw new ArgumentOutOfRangeException(); } } if (type == typeof(float)) { if (reader.CurrentType != IonType.Float) { goto NoMatch; } result = (float)reader.DoubleValue(); return(true); } if (type == typeof(double)) { if (reader.CurrentType != IonType.Float) { goto NoMatch; } result = reader.DoubleValue(); return(true); } if (type == typeof(decimal)) { if (reader.CurrentType != IonType.Decimal) { goto NoMatch; } result = reader.DecimalValue(); return(true); } if (type == typeof(DateTime)) { if (reader.CurrentType != IonType.Timestamp) { goto NoMatch; } result = reader.TimestampValue().DateTime; return(true); } if (type == typeof(DateTimeOffset)) { if (reader.CurrentType != IonType.Timestamp) { goto NoMatch; } result = reader.TimestampValue().AsDateTimeOffset(); return(true); } NoMatch: //here means we don't know , try the scalar converter return(scalarConverter != null && reader.TryConvertTo(type, scalarConverter, out result)); }
private static void CompareScalars(IonType t, bool isNull, IIonReader it1, IIonReader it2) { switch (t) { case IonType.Bool: { if (!isNull) { Assert.AreEqual(it1.BoolValue(), it2.BoolValue()); } break; } case IonType.Int: { if (!isNull) { Assert.AreEqual(it1.BigIntegerValue(), it2.BigIntegerValue()); } break; } case IonType.Float: { if (!isNull) { double v1 = it1.DoubleValue(); double v2 = it2.DoubleValue(); if (double.IsNaN(v1) && double.IsNaN(v2)) { Assert.AreEqual(v1, v2); } else if (double.IsNaN(v1) || double.IsNaN(v2)) { Assert.AreNotEqual(v1, v2, 0); } else { Assert.AreEqual(v1, v2, 0); // The last param is a delta, and we want exact match. } } break; } case IonType.Decimal: { if (!isNull) { BigDecimal bigDec1 = it1.DecimalValue(); BigDecimal bigDec2 = it2.DecimalValue(); AssertPreciselyEquals(bigDec1, bigDec2); try { decimal dec1 = bigDec1.ToDecimal(); decimal dec2 = bigDec2.ToDecimal(); Assert.AreEqual(dec1, dec2); Assert.AreEqual(decimal.ToDouble(dec1), decimal.ToDouble(dec2)); Assert.AreEqual(decimal.ToInt32(dec1), decimal.ToInt32(dec2)); Assert.AreEqual(decimal.ToInt64(dec1), decimal.ToInt64(dec2)); } catch (OverflowException) { // Certain Ion Decimals in test file exceed C# decmial range. Just AssertPreciselyEquals. } } break; } case IonType.Timestamp: { if (!isNull) { Timestamp t1 = it1.TimestampValue(); Timestamp t2 = it2.TimestampValue(); Assert.AreEqual(t1, t2); } break; } case IonType.String: { string s1 = it1.StringValue(); string s2 = it2.StringValue(); Assert.AreEqual(s1, s2); break; } case IonType.Symbol: { SymbolToken tok1 = it1.SymbolValue(); SymbolToken tok2 = it2.SymbolValue(); if (isNull) { Assert.IsNull(tok1.Text); Assert.IsNull(tok2.Text); } else if (tok1.Text == null || tok2.Text == null) { Assert.AreEqual(tok1.Sid, tok2.Sid, "sids"); } else { string s1 = tok1.Text; string s2 = tok2.Text; Assert.AreEqual(s1, s2); } break; } case IonType.Blob: case IonType.Clob: { if (!isNull) { byte[] b1 = it1.NewByteArray(); byte[] b2 = it2.NewByteArray(); Assert.IsTrue(b1 != null && b2 != null); Assert.IsTrue(b1.Length == b2.Length); for (int ii = 0; ii < b1.Length; ii++) { byte v1 = b1[ii]; byte v2 = b2[ii]; Assert.AreEqual(v1, v2); } } break; } default: throw new InvalidOperationException("iterated to a type that's not expected"); } }
private void InternalWriteValue(IIonReader reader, int depth = 0) { IonType type = reader.CurrentType; if (type == IonType.None) { return; } if (depth > 0) { string fieldName = reader.CurrentFieldName; if (fieldName != null) { this.SetFieldName(fieldName); } } foreach (var annotation in reader.GetTypeAnnotations()) { this.AddTypeAnnotationSymbol(annotation); } if (reader.CurrentIsNull) { this.WriteNull(type); } else { switch (type) { case IonType.Bool: this.WriteBool(reader.BoolValue()); break; case IonType.Int: this.WriteInt(reader.BigIntegerValue()); break; case IonType.Float: this.WriteFloat(reader.DoubleValue()); break; case IonType.Decimal: this.WriteDecimal(reader.DecimalValue()); break; case IonType.Timestamp: this.WriteTimestamp(reader.TimestampValue()); break; case IonType.Symbol: this.WriteSymbolToken(reader.SymbolValue()); break; case IonType.String: this.WriteString(reader.StringValue()); break; case IonType.Clob: this.WriteClob(reader.NewByteArray()); break; case IonType.Blob: this.WriteBlob(reader.NewByteArray()); break; case IonType.List: this.StepIn(IonType.List); break; case IonType.Sexp: this.StepIn(IonType.Sexp); break; case IonType.Struct: this.StepIn(IonType.Struct); break; default: throw new InvalidOperationException("Unexpected type '" + type + "'"); } if (type.IsContainer()) { reader.StepIn(); this.InternalWriteValues(reader, depth + 1); this.StepOut(); reader.StepOut(); } } }