public void Write(ITreeWriter writer) { writer.WriteStartObject(); writer.Write(Names.Indices, _indices); writer.Write(Names.Values, _values); writer.WriteEndObject(); }
public void Write(ITreeWriter writer) { writer.WriteStartObject(); if (DefaultValue == false && Count == 0) { // If all values are default false, only write Capacity; Count defaults back to zero on read writer.Write(Names.Capacity, Capacity); } else if (DefaultValue == true && Count == Capacity) { // If all values are default true, only write Count+Capacity (Array will be re-created with all default) writer.Write(Names.Count, Count); writer.Write(Names.Capacity, Capacity); } else if (Capacity > 0) { writer.Write(Names.Count, Count); writer.Write(Names.Capacity, Capacity); writer.WritePropertyName(Names.Array); writer.WriteBlockArray(Array, 0, Math.Min(Array.Length, (Capacity + 31) >> 5)); } writer.WriteEndObject(); }
public void Write(ITreeWriter writer) { writer.WriteStartObject(); writer.Write(Names.Count, Count); writer.WriteBlockArray(Names.Array, _array, 0, UsedArrayLength); writer.WriteEndObject(); }
public void Write(ITreeWriter writer) { // Merge changed small values under cutoff into SmallValueArray Trim(); writer.WriteStartObject(); if (_smallValueArray?.Length > 0) { // If there are any non-empty values, write the text and end positions writer.WriteBlockArray(Names.ValueEnd, _valueEndInPage); writer.WriteBlockArray(Names.SmallValues, _smallValueArray); // If there is more than one page, write page starts int pages = (Count / PageRowCount) + 1; if (pages > 1) { writer.WriteBlockArray(Names.PageStart, _pageStartInChapter); } } else if (Count > 0) { // If there is no text but a non-zero count, we must preserve the count writer.Write(Names.Count, Count); } // If there are any large values, write them if (_largeValueDictionary?.Count > 0) { writer.WritePropertyName(Names.LargeValues); writer.WriteDictionary(_largeValueDictionary); } writer.WriteEndObject(); }
public static void Save(this ITreeSerializable item, Stream stream, TreeFormat format, TreeSerializationSettings settings = null) { using (ITreeWriter writer = TreeSerializer.Writer(format, stream, settings)) { item.Write(writer); } }
public void Write(ITreeWriter writer) { Trim(); writer.WriteStartObject(); if (Count > 0) { int nullValueCount = IsNull.CountTrue; if (nullValueCount == Count) { // If all null, write IsNull only (default is already all null) writer.Write(Names.IsNull, IsNull); } else if (nullValueCount == 0) { // If no nulls, write values only (will infer situation on read) writer.Write(Names.Values, Values); } else { // If there are some nulls and some values, we must write both writer.Write(Names.IsNull, IsNull); writer.Write(Names.Values, Values); } } writer.WriteEndObject(); }
// Write item, then read back and return size diagnostics instead of round-tripped instance public static TreeDiagnostics Diagnostics <T>(T value, Func <T> buildT, TreeFormat format) where T : ITreeSerializable { TreeSerializationSettings settings = new TreeSerializationSettings() { LeaveStreamOpen = true }; using (MemoryStream stream = new MemoryStream()) { using (ITreeWriter writer = Writer(format, stream, settings)) { value.Write(writer); } stream.Seek(0, SeekOrigin.Begin); using (TreeDiagnosticsReader reader = new TreeDiagnosticsReader(Reader(format, stream, settings))) { T roundTripped = buildT(); roundTripped.Read(reader); // Test double dispose reader.Dispose(); return(reader.Tree); } } }
// WriteObject supports writing a subcomponent with name and value in one call. public static void WriteObject(this ITreeWriter writer, string name, ITreeSerializable component) { if (component != null) { writer.WritePropertyName(name); component.Write(writer); } }
public void Write(ITreeWriter writer) { writer.WriteStartObject(); writer.Write(Names.Keys, _keys); writer.Write(Names.Values, _values); writer.Write(Names.Pairs, _pairs); writer.WriteEndObject(); }
public static void Write(this ITreeWriter writer, string name, ITreeSerializable value) { if (value != null) { writer.WritePropertyName(name); value.Write(writer); } }
/// <summary>Creates array at current writer level.</summary> public static void SerializeTo(this IEnumerable obj, string elementName, ITreeWriter writer) { // Write start element tag writer.WriteStartArrayElement(elementName); // Iterate over sequence elements foreach (var item in obj) { // Write array item start tag writer.WriteStartArrayItem(); // Serialize based on type of the item switch (item) { case null: case string stringItem: case double doubleItem: case bool boolItem: case int intItem: case long longItem: // Write item as is for these types writer.WriteStartValue(); writer.WriteValue(item); writer.WriteEndValue(); break; case IEnumerable enumerableItem: throw new Exception($"Serialization is not supported for element {elementName} " + $"which is collection containing another collection."); case Data dataItem: if (dataItem is Key) { // Write key as serialized delimited string writer.WriteStartValue(); writer.WriteValue(dataItem.AsString()); writer.WriteEndValue(); } else { // Embedded data element dataItem.SerializeTo(writer); } break; default: // Argument type is unsupported, error message throw new Exception( $"Element type {item.GetType()} is not supported for tree serialization."); } // Write array item end tag writer.WriteEndArrayItem(); } // Write matching end element tag writer.WriteEndArrayElement(elementName); }
/// <summary>Write a single array item.</summary> public static void WriteArrayItem(this ITreeWriter obj, object value) { // Will serialize null or empty value obj.WriteStartArrayItem(); obj.WriteStartValue(); obj.WriteValue(value); obj.WriteEndValue(); obj.WriteEndArrayItem(); }
/// <summary>Write an array of elements with no inner nodes. /// Element type is inferred by calling obj.GetType().</summary> public static void WriteValueArray(this ITreeWriter obj, string elementName, IEnumerable <object> values) { obj.WriteStartArrayElement(elementName); foreach (object value in values) { obj.WriteArrayItem(value); } obj.WriteEndArrayElement(elementName); }
/// <summary>Write an array item with no inner nodes. /// Element type is inferred by calling obj.GetType().</summary> public static void WriteValueArrayItem(this ITreeWriter obj, object value) { // Writes null or empty value as BSON null obj.WriteStartArrayItem(); obj.WriteStartValue(); obj.WriteValue(value); obj.WriteEndValue(); obj.WriteEndArrayItem(); }
public Sawyer(AddressQualityChecker addressQualityChecker, IGeocodeManager geocodeManager, ILocationCacheFactory locationCacheFactory, ILogger <Sawyer> logger, TreeParser treeParser, ITreeReader treeReader, ITreeWriter treeWriter) { this.addressQualityChecker = addressQualityChecker; this.geocodeManager = geocodeManager; this.locationCache = locationCacheFactory.Create(); this.logger = logger; this.treeParser = treeParser; this.treeReader = treeReader; this.treeWriter = treeWriter; }
public static void VerifySkip <T>(T value, TreeFormat format) where T : ITreeSerializable { // Test serialization details using (MemoryStream stream = new MemoryStream()) { TreeSerializationSettings settings = new TreeSerializationSettings() { LeaveStreamOpen = true }; using (ITreeWriter writer = Writer(format, stream, settings)) { value.Write(writer); } long bytesWritten = stream.Position; // Read tokens individually and verify 'None' returned at end stream.Seek(0, SeekOrigin.Begin); using (ITreeReader reader = Reader(format, stream, settings)) { while (reader.Read()) { // Verify each token type is coming back properly (no reading random bytes) Assert.True((byte)reader.TokenType <= (byte)TreeToken.BlockArray); } Assert.Equal(TreeToken.None, reader.TokenType); Assert.Equal(bytesWritten, stream.Position); } // Verify Skip once skips everything (each ITreeSerializable must be one value or one root array or object stream.Seek(0, SeekOrigin.Begin); using (ITreeReader reader = Reader(format, stream, settings)) { reader.Skip(); Assert.Equal(TreeToken.None, reader.TokenType); Assert.Equal(bytesWritten, stream.Position); } // For objects, verify each property can be skipped correctly // Each Skip should read the value, so that the next token is the next PropertyName stream.Seek(0, SeekOrigin.Begin); using (ITreeReader reader = Reader(format, stream, settings)) { if (reader.TokenType == TreeToken.StartObject) { Empty empty = new Empty(); empty.Read(reader); Assert.Equal(bytesWritten, stream.Position); } } } }
/// <summary>Write an element with no inner nodes. /// Element type is inferred by calling obj.GetType().</summary> public static void WriteValueElement(this ITreeWriter obj, string elementName, object value) { // Do not serialize null or empty value if (!value.IsEmpty()) { obj.WriteStartElement(elementName); obj.WriteStartValue(); obj.WriteValue(value); obj.WriteEndValue(); obj.WriteEndElement(elementName); } }
public void Write(ITreeWriter writer) { writer.WriteStartObject(); writer.Write(nameof(IsActive), IsActive); writer.Write(nameof(Name), Name); writer.Write(nameof(Position), Position); writer.Write(nameof(Age), Age); writer.Write(nameof(Type), Type); writer.Write(nameof(Count), Count); writer.Write(nameof(When), When); writer.Write(nameof(Guid), Guid); writer.WriteEndObject(); }
public void Write(ITreeWriter writer) { writer.WriteStartObject(); writer.WritePropertyName(nameof(List)); writer.WriteList(List); writer.WritePropertyName(nameof(StringDictionary)); writer.WriteDictionary(StringDictionary); writer.WritePropertyName(nameof(IntDictionary)); writer.WriteDictionary(IntDictionary); writer.WriteEndObject(); }
public static void WriteList <T>(this ITreeWriter writer, IReadOnlyList <T> list) where T : ITreeSerializable { if (list == null) { writer.WriteNull(); return; } writer.WriteStartArray(); foreach (T item in list) { item.Write(writer); } writer.WriteEndArray(); }
public void Write(ITreeWriter writer) { // Write non-empty tables only writer.WriteStartObject(); foreach (var pair in Tables) { if (pair.Value.Count > 0) { writer.WritePropertyName(pair.Key); pair.Value.Write(writer); } } writer.WriteEndObject(); }
public static void WriteDictionary <T>(this ITreeWriter writer, IReadOnlyDictionary <string, T> dictionary) where T : ITreeSerializable { if (dictionary == null) { writer.WriteNull(); return; } writer.WriteStartObject(); foreach (var item in dictionary) { writer.WritePropertyName(item.Key); item.Value.Write(writer); } writer.WriteEndObject(); }
private static void TestIntegers(TreeFormat format) { TreeSerializationSettings settings = new TreeSerializationSettings() { LeaveStreamOpen = true }; using (MemoryStream stream = new MemoryStream()) { using (ITreeWriter writer = Writer(format, stream, settings)) { writer.WriteStartArray(); for (int i = -1; i < 300; i += 7) { writer.WriteValue(i); } writer.WriteEndArray(); } long bytesWritten = stream.Position; stream.Seek(0, SeekOrigin.Begin); using (ITreeReader reader = Reader(format, stream, settings)) { Assert.Equal(TreeToken.StartArray, reader.TokenType); for (int i = -1; i < 300; i += 7) { Assert.True(reader.Read()); Assert.Equal(TreeToken.Integer, reader.TokenType); Assert.Equal(i, reader.ReadAsInt32()); } Assert.True(reader.Read()); Assert.Equal(TreeToken.EndArray, reader.TokenType); Assert.False(reader.Read()); } Assert.Equal(bytesWritten, stream.Position); } }
public void Write(ITreeWriter writer) { writer.WriteStartObject(); writer.Write(Names.Count, Count); // Write non-empty columns only writer.WritePropertyName(Names.Columns); writer.WriteStartObject(); foreach (var pair in Columns) { if (pair.Value.Count > 0) { writer.Write(pair.Key, pair.Value); } } writer.WriteEndObject(); writer.WriteEndObject(); }
public static void WriteDictionary <T>(this ITreeWriter writer, IReadOnlyDictionary <int, T> dictionary) where T : ITreeSerializable { if (dictionary == null) { writer.WriteNull(); return; } writer.WriteStartArray(); int[] keys = dictionary.Keys.ToArray(); writer.WriteBlockArray(keys); writer.WriteStartArray(); for (int i = 0; i < keys.Length; ++i) { dictionary[keys[i]].Write(writer); } writer.WriteEndArray(); writer.WriteEndArray(); }
// RoundTrip with all verification public static T RoundTrip_NullSettings <T>(T value, TreeFormat format) where T : ITreeSerializable, new() { T roundTripped = new T(); byte[] buffer = null; using (MemoryStream stream = new MemoryStream()) { using (ITreeWriter writer = Writer(format, stream, null)) { // Writer must initialize settings property even if constructed with null. Assert.NotNull(writer.Settings); value.Write(writer); } // Get bytes to read back from with reader buffer = stream.ToArray(); } using (MemoryStream stream = new MemoryStream(buffer)) { using (ITreeReader reader = Reader(format, stream, null)) { // Reader must initialize settings property even if constructed with null. Assert.NotNull(reader.Settings); roundTripped.Read(reader); // Verify everything read back Assert.Equal(buffer.Length, stream.Position); } } return(roundTripped); }
// Reference RoundTrip implementation - no extra verification private static T RoundTrip_Basic <T>(T value, Func <T> buildT, TreeFormat format) where T : ITreeSerializable { TreeSerializationSettings settings = new TreeSerializationSettings() { LeaveStreamOpen = true }; using (MemoryStream stream = new MemoryStream()) { using (ITreeWriter writer = Writer(format, stream, settings)) { value.Write(writer); } stream.Seek(0, SeekOrigin.Begin); using (ITreeReader reader = Reader(format, stream, settings)) { T roundTripped = buildT(); roundTripped.Read(reader); return(roundTripped); } } }
public void Write(ITreeWriter writer) { writer.WriteBlockArray(Array, Index, Count); }
public void Write(ITreeWriter writer) { writer.WriteList(_chapters); }
public void Write(ITreeWriter writer) { _vector.Write(writer); }