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);
}