public ImmutableSortedSet <T> ImmutableSortedSet()
{
ImmutableSortedSet <T> immutableSortedSet = ImmutableSortedSet <T> .Empty;
foreach (T value in _uniqueValues)
{
immutableSortedSet = immutableSortedSet.Add(value);
}
return(immutableSortedSet.Clear());
}
public void ToImmutableSortedSet()
{
ImmutableSortedSet <int> .Builder builder = ImmutableSortedSet.CreateBuilder <int>();
builder.Add(1);
builder.Add(5);
builder.Add(10);
var set = builder.ToImmutableSortedSet();
Assert.Equal(1, builder[0]);
Assert.Equal(5, builder[1]);
Assert.Equal(10, builder[2]);
builder.Remove(10);
Assert.False(builder.Contains(10));
Assert.True(set.Contains(10));
builder.Clear();
Assert.True(builder.ToImmutableSortedSet().IsEmpty);
Assert.False(set.IsEmpty);
ImmutableSortedSet <int> .Builder nullBuilder = null;
AssertExtensions.Throws <ArgumentNullException>("builder", () => nullBuilder.ToImmutableSortedSet());
}
public static ImmutableSortedSet <T> ResetContents <T>(this ImmutableSortedSet <T> set, IEnumerable <T> values)
{
return(set.SetEquals(values) ? set : set.Clear().Union(values));
}
/// <summary>
/// Asynchronously reads data into the current <see cref="SearchResult"/>.
/// </summary>
/// <param name="reader">
/// The <see cref="XmlReader"/> from which to read.
/// </param>
/// <returns>
/// A <see cref="Task"/> representing the operation.
/// </returns>
public async Task ReadXmlAsync(XmlReader reader)
{
Contract.Requires <ArgumentNullException>(reader != null, "reader");
reader.MoveToElement();
reader.EnsureMarkup(XmlNodeType.Element, "result");
this.Object = new Dictionary <string, object>();
var dictionary = (IDictionary <string, object>) this.Object;
this.tagsObject = new Dictionary <string, object>();
var tagsDictionary = (IDictionary <string, object>) this.tagsObject;
this.SegmentedRaw = null;
await reader.ReadEachDescendantAsync("field", async (r) =>
{
ImmutableSortedSet <string> .Builder tags = null;
var key = r.GetRequiredAttribute("k");
var values = new List <object>();
var fieldDepth = r.Depth;
while (await r.ReadAsync().ConfigureAwait(false))
{
if (r.Depth == fieldDepth)
{
break;
}
Debug.Assert(r.Depth > fieldDepth, "This loop should have exited earlier.");
r.EnsureMarkup(XmlNodeType.Element, "value", "v");
if (r.IsEmptyElement)
{
continue;
}
if (r.Name == "value")
{
await r.ReadAsync().ConfigureAwait(false);
string value = null;
while (r.NodeType == XmlNodeType.Element)
{
r.EnsureMarkup(XmlNodeType.Element, "text", "tag");
var elementName = r.Name;
string content = await r.ReadElementContentAsStringAsync().ConfigureAwait(false);
switch (elementName)
{
case "text":
value = content;
break;
case "tag":
if (tags == null)
{
tags = ImmutableSortedSet.CreateBuilder <string>();
}
tags.Add(content);
break;
}
}
r.EnsureMarkup(XmlNodeType.EndElement, "value");
if (tags != null && tags.Count > 0)
{
values.Add(new TaggedFieldValue(value ?? string.Empty, tags.ToImmutable()));
tags.Clear();
}
else
{
values.Add(value ?? string.Empty);
}
}
else
{
Debug.Assert(this.SegmentedRaw == null);
Debug.Assert(key == "_raw");
string value = await r.ReadOuterXmlAsync().ConfigureAwait(false);
this.SegmentedRaw = XElement.Parse(value);
values.Add(this.SegmentedRaw.Value);
}
}
if (key.StartsWith("tag::"))
{
var valueSet = ImmutableSortedSet.ToImmutableSortedSet <string>(values.Cast <string>());
tagsDictionary.Add(key.Substring("tag::".Length), valueSet);
dictionary.Add(key, valueSet);
}
else
{
switch (values.Count)
{
case 0:
dictionary.Add(key, string.Empty);
break;
case 1:
dictionary.Add(key, values[0]);
break;
default:
dictionary.Add(key, new ReadOnlyCollection <object>(values));
break;
}
}
}).ConfigureAwait(false);
}
protected override ImmutableSortedSet <T> Clear(ImmutableSortedSet <T> values, ISerializationContext context) => values.Clear();