diff --git a/Src/Lib/NUnit/Compact/NUnitLite.dll b/Src/Lib/NUnit/Compact/NUnitLite.dll deleted file mode 100644 index 2bf15332..00000000 Binary files a/Src/Lib/NUnit/Compact/NUnitLite.dll and /dev/null differ diff --git a/Src/Lib/NUnit/Silverlight/nunit.framework.dll b/Src/Lib/NUnit/Silverlight/nunit.framework.dll deleted file mode 100644 index d4e0b72a..00000000 Binary files a/Src/Lib/NUnit/Silverlight/nunit.framework.dll and /dev/null differ diff --git a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net20.csproj b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net20.csproj index 685c9f27..4e1717e2 100644 --- a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net20.csproj +++ b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net20.csproj @@ -63,9 +63,9 @@ AllRules.ruleset - + False - ..\Lib\NUnit\DotNet\nunit.framework.dll + ..\packages\NUnit.2.6.2\lib\nunit.framework.dll @@ -96,6 +96,7 @@ + diff --git a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net35.csproj b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net35.csproj index fc27673e..1e4a6bbd 100644 --- a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net35.csproj +++ b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net35.csproj @@ -65,9 +65,9 @@ AllRules.ruleset - + False - ..\Lib\NUnit\DotNet\nunit.framework.dll + ..\packages\NUnit.2.6.2\lib\nunit.framework.dll @@ -138,6 +138,7 @@ + diff --git a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net40.csproj b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net40.csproj index 5278360a..644e137e 100644 --- a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net40.csproj +++ b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net40.csproj @@ -67,9 +67,9 @@ - + False - ..\Lib\NUnit\DotNet\nunit.framework.dll + ..\packages\NUnit.2.6.2\lib\nunit.framework.dll @@ -256,6 +256,7 @@ + diff --git a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Portable.csproj b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Portable.csproj index 96a96143..f7188a3a 100644 --- a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Portable.csproj +++ b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Portable.csproj @@ -68,11 +68,13 @@ - - False - ..\Lib\NUnit\DotNet\nunit.framework.dll + + ..\packages\NUnit.2.6.2\lib\nunit.framework.dll + + ..\packages\Microsoft.Bcl.Immutable.1.0.12-beta\lib\portable-net45+win8+wp8\System.Collections.Immutable.dll + 3.5 @@ -137,6 +139,7 @@ + @@ -149,9 +152,7 @@ - - Component - + diff --git a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Portable40.csproj b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Portable40.csproj index 53bd1940..4176c8b3 100644 --- a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Portable40.csproj +++ b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Portable40.csproj @@ -68,9 +68,9 @@ - + False - ..\Lib\NUnit\DotNet\nunit.framework.dll + ..\packages\NUnit.2.6.2\lib\nunit.framework.dll diff --git a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.csproj b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.csproj index 25baf467..79905512 100644 --- a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.csproj +++ b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.csproj @@ -30,10 +30,14 @@ 4 - - ..\Lib\NUnit\DotNet\nunit.framework.dll + + False + ..\packages\NUnit.2.6.2\lib\nunit.framework.dll + + ..\packages\Microsoft.Bcl.Immutable.1.0.12-beta\lib\portable-net45+win8+wp8\System.Collections.Immutable.dll + @@ -226,6 +230,7 @@ + @@ -355,6 +360,7 @@ LinqToSqlClasses.designer.cs Designer + Always diff --git a/Src/Newtonsoft.Json.Tests/Properties/AssemblyInfo.cs b/Src/Newtonsoft.Json.Tests/Properties/AssemblyInfo.cs index 71b35dec..fbd680f5 100644 --- a/Src/Newtonsoft.Json.Tests/Properties/AssemblyInfo.cs +++ b/Src/Newtonsoft.Json.Tests/Properties/AssemblyInfo.cs @@ -75,4 +75,4 @@ using System.Security; // You can specify all the values or you can default the Revision and Build Numbers // by using the '*' as shown below: [assembly: AssemblyVersion("4.5.0.0")] -[assembly: AssemblyFileVersion("5.0.6.16207")] +[assembly: AssemblyFileVersion("5.0.6.16308")] diff --git a/Src/Newtonsoft.Json.Tests/Serialization/ImmutableCollectionsTests.cs b/Src/Newtonsoft.Json.Tests/Serialization/ImmutableCollectionsTests.cs new file mode 100644 index 00000000..d3f189c5 --- /dev/null +++ b/Src/Newtonsoft.Json.Tests/Serialization/ImmutableCollectionsTests.cs @@ -0,0 +1,424 @@ +#region License +// Copyright (c) 2007 James Newton-King +// +// Permission is hereby granted, free of charge, to any person +// obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without +// restriction, including without limitation the rights to use, +// copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following +// conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +#endregion + +#if !(NET20 || NET35 || NET40 || PORTABLE40) +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using NUnit.Framework; +using Newtonsoft.Json.Linq; + +namespace Newtonsoft.Json.Tests.Serialization +{ + [TestFixture] + public class ImmutableCollectionsTests : TestFixtureBase + { + #region List + [Test] + public void SerializeList() + { + ImmutableList l = ImmutableList.From(new List + { + "One", + "II", + "3" + }); + + string json = JsonConvert.SerializeObject(l, Formatting.Indented); + Assert.AreEqual(@"[ + ""One"", + ""II"", + ""3"" +]", json); + } + + [Test] + public void DeserializeList() + { + string json = @"[ + ""One"", + ""II"", + ""3"" +]"; + + ImmutableList l = JsonConvert.DeserializeObject>(json); + + Assert.AreEqual(3, l.Count); + Assert.AreEqual("One", l[0]); + Assert.AreEqual("II", l[1]); + Assert.AreEqual("3", l[2]); + } + + [Test] + public void DeserializeListInterface() + { + string json = @"[ + ""One"", + ""II"", + ""3"" +]"; + + IImmutableList l = JsonConvert.DeserializeObject>(json); + + Assert.AreEqual(3, l.Count); + Assert.AreEqual("One", l[0]); + Assert.AreEqual("II", l[1]); + Assert.AreEqual("3", l[2]); + } + #endregion + + #region Array + [Test] + public void SerializeArray() + { + ImmutableArray l = ImmutableArray.From(new List + { + "One", + "II", + "3" + }); + + string json = JsonConvert.SerializeObject(l, Formatting.Indented); + Assert.AreEqual(@"[ + ""One"", + ""II"", + ""3"" +]", json); + } + + [Test] + public void DeserializeArray() + { + string json = @"[ + ""One"", + ""II"", + ""3"" +]"; + + ImmutableArray l = JsonConvert.DeserializeObject>(json); + + Assert.AreEqual(3, l.Length); + Assert.AreEqual("One", l[0]); + Assert.AreEqual("II", l[1]); + Assert.AreEqual("3", l[2]); + } + #endregion + + #region Queue + [Test] + public void SerializeQueue() + { + ImmutableQueue l = ImmutableQueue.From(new List + { + "One", + "II", + "3" + }); + + string json = JsonConvert.SerializeObject(l, Formatting.Indented); + Assert.AreEqual(@"[ + ""One"", + ""II"", + ""3"" +]", json); + } + + [Test] + public void DeserializeQueue() + { + string json = @"[ + ""One"", + ""II"", + ""3"" +]"; + + ImmutableQueue l = JsonConvert.DeserializeObject>(json); + + Assert.AreEqual(3, l.Count()); + Assert.AreEqual("One", l.ElementAt(0)); + Assert.AreEqual("II", l.ElementAt(1)); + Assert.AreEqual("3", l.ElementAt(2)); + } + + [Test] + public void DeserializeQueueInterface() + { + string json = @"[ + ""One"", + ""II"", + ""3"" +]"; + + IImmutableQueue l = JsonConvert.DeserializeObject>(json); + + Assert.AreEqual(3, l.Count()); + Assert.AreEqual("One", l.ElementAt(0)); + Assert.AreEqual("II", l.ElementAt(1)); + Assert.AreEqual("3", l.ElementAt(2)); + } + #endregion + + #region Stack + [Test] + public void SerializeStack() + { + ImmutableStack l = ImmutableStack.From(new List + { + "One", + "II", + "3" + }); + + string json = JsonConvert.SerializeObject(l, Formatting.Indented); + Assert.AreEqual(@"[ + ""3"", + ""II"", + ""One"" +]", json); + } + + [Test] + public void DeserializeStack() + { + string json = @"[ + ""One"", + ""II"", + ""3"" +]"; + + ImmutableStack l = JsonConvert.DeserializeObject>(json); + + Assert.AreEqual(3, l.Count()); + Assert.AreEqual("3", l.ElementAt(0)); + Assert.AreEqual("II", l.ElementAt(1)); + Assert.AreEqual("One", l.ElementAt(2)); + } + + [Test] + public void DeserializeStackInterface() + { + string json = @"[ + ""One"", + ""II"", + ""3"" +]"; + + IImmutableStack l = JsonConvert.DeserializeObject>(json); + + Assert.AreEqual(3, l.Count()); + Assert.AreEqual("3", l.ElementAt(0)); + Assert.AreEqual("II", l.ElementAt(1)); + Assert.AreEqual("One", l.ElementAt(2)); + } + #endregion + + #region HashSet + [Test] + public void SerializeHashSet() + { + ImmutableHashSet l = ImmutableHashSet.From(new List + { + "One", + "II", + "3" + }); + + string json = JsonConvert.SerializeObject(l, Formatting.Indented); + + JArray a = JArray.Parse(json); + Assert.AreEqual(3, a.Count); + Assert.IsTrue(a.Any(t => t.DeepEquals("One"))); + Assert.IsTrue(a.Any(t => t.DeepEquals("II"))); + Assert.IsTrue(a.Any(t => t.DeepEquals("3"))); + } + + [Test] + public void DeserializeHashSet() + { + string json = @"[ + ""One"", + ""II"", + ""3"" +]"; + + ImmutableHashSet l = JsonConvert.DeserializeObject>(json); + + Assert.AreEqual(3, l.Count()); + Assert.IsTrue(l.Contains("3")); + Assert.IsTrue(l.Contains("II")); + Assert.IsTrue(l.Contains("One")); + } + + [Test] + public void DeserializeHashSetInterface() + { + string json = @"[ + ""One"", + ""II"", + ""3"" +]"; + + IImmutableSet l = JsonConvert.DeserializeObject>(json); + + Assert.AreEqual(3, l.Count()); + Assert.IsTrue(l.Contains("3")); + Assert.IsTrue(l.Contains("II")); + Assert.IsTrue(l.Contains("One")); + } + #endregion + + #region SortedSet + [Test] + public void SerializeSortedSet() + { + ImmutableSortedSet l = ImmutableSortedSet.From(new List + { + "One", + "II", + "3" + }); + + string json = JsonConvert.SerializeObject(l, Formatting.Indented); + Assert.AreEqual(@"[ + ""3"", + ""II"", + ""One"" +]", json); + } + + [Test] + public void DeserializeSortedSet() + { + string json = @"[ + ""One"", + ""II"", + ""3"" +]"; + + ImmutableSortedSet l = JsonConvert.DeserializeObject>(json); + + Assert.AreEqual(3, l.Count()); + Assert.IsTrue(l.Contains("3")); + Assert.IsTrue(l.Contains("II")); + Assert.IsTrue(l.Contains("One")); + } + #endregion + + #region Dictionary + [Test] + public void SerializeDictionary() + { + ImmutableDictionary l = ImmutableDictionary.Create(new Dictionary + { + {1, "One"}, + {2, "II"}, + {3, "3"} + }); + + string json = JsonConvert.SerializeObject(l, Formatting.Indented); + JObject a = JObject.Parse(json); + Assert.AreEqual(3, a.Count); + Assert.AreEqual("One", (string)a["1"]); + Assert.AreEqual("II", (string)a["2"]); + Assert.AreEqual("3", (string)a["3"]); + } + + [Test] + public void DeserializeDictionary() + { + string json = @"{ + ""1"": ""One"", + ""2"": ""II"", + ""3"": ""3"" +}"; + + ImmutableDictionary l = JsonConvert.DeserializeObject>(json); + + Assert.AreEqual(3, l.Count); + Assert.AreEqual("One", l[1]); + Assert.AreEqual("II", l[2]); + Assert.AreEqual("3", l[3]); + } + + [Test] + public void DeserializeDictionaryInterface() + { + string json = @"{ + ""1"": ""One"", + ""2"": ""II"", + ""3"": ""3"" +}"; + + IImmutableDictionary l = JsonConvert.DeserializeObject>(json); + + Assert.AreEqual(3, l.Count); + Assert.AreEqual("One", l[1]); + Assert.AreEqual("II", l[2]); + Assert.AreEqual("3", l[3]); + } + #endregion + + #region SortedDictionary + [Test] + public void SerializeSortedDictionary() + { + ImmutableSortedDictionary l = ImmutableSortedDictionary.Create(new SortedDictionary + { + {1, "One"}, + {2, "II"}, + {3, "3"} + }); + + string json = JsonConvert.SerializeObject(l, Formatting.Indented); + Assert.AreEqual(@"{ + ""1"": ""One"", + ""2"": ""II"", + ""3"": ""3"" +}", json); + } + + [Test] + public void DeserializeSortedDictionary() + { + string json = @"{ + ""1"": ""One"", + ""2"": ""II"", + ""3"": ""3"" +}"; + + ImmutableSortedDictionary l = JsonConvert.DeserializeObject>(json); + + Assert.AreEqual(3, l.Count); + Assert.AreEqual("One", l[1]); + Assert.AreEqual("II", l[2]); + Assert.AreEqual("3", l[3]); + } + #endregion + } +} +#endif \ No newline at end of file diff --git a/Src/Newtonsoft.Json/Newtonsoft.Json.Net20.csproj b/Src/Newtonsoft.Json/Newtonsoft.Json.Net20.csproj index 99649409..5425fea1 100644 --- a/Src/Newtonsoft.Json/Newtonsoft.Json.Net20.csproj +++ b/Src/Newtonsoft.Json/Newtonsoft.Json.Net20.csproj @@ -122,6 +122,7 @@ + diff --git a/Src/Newtonsoft.Json/Newtonsoft.Json.Net35.csproj b/Src/Newtonsoft.Json/Newtonsoft.Json.Net35.csproj index f6c8d994..5ecceb04 100644 --- a/Src/Newtonsoft.Json/Newtonsoft.Json.Net35.csproj +++ b/Src/Newtonsoft.Json/Newtonsoft.Json.Net35.csproj @@ -5,7 +5,7 @@ AnyCPU 9.0.30729 2.0 - {B70AD007-4437-44C2-A25A-6D5AE41691F9} + {A9AE40FF-1A21-414A-9FE7-3BE13644CC6D} Library Properties Newtonsoft.Json @@ -232,6 +232,7 @@ + diff --git a/Src/Newtonsoft.Json/Newtonsoft.Json.Net40.csproj b/Src/Newtonsoft.Json/Newtonsoft.Json.Net40.csproj index 943b43de..5051da43 100644 --- a/Src/Newtonsoft.Json/Newtonsoft.Json.Net40.csproj +++ b/Src/Newtonsoft.Json/Newtonsoft.Json.Net40.csproj @@ -231,6 +231,7 @@ + diff --git a/Src/Newtonsoft.Json/Newtonsoft.Json.Portable.csproj b/Src/Newtonsoft.Json/Newtonsoft.Json.Portable.csproj index 20268cd6..bbe8d0cb 100644 --- a/Src/Newtonsoft.Json/Newtonsoft.Json.Portable.csproj +++ b/Src/Newtonsoft.Json/Newtonsoft.Json.Portable.csproj @@ -207,6 +207,7 @@ + diff --git a/Src/Newtonsoft.Json/Newtonsoft.Json.csproj b/Src/Newtonsoft.Json/Newtonsoft.Json.csproj index efa64569..9c579193 100644 --- a/Src/Newtonsoft.Json/Newtonsoft.Json.csproj +++ b/Src/Newtonsoft.Json/Newtonsoft.Json.csproj @@ -208,6 +208,7 @@ + diff --git a/Src/Newtonsoft.Json/Properties/AssemblyInfo.cs b/Src/Newtonsoft.Json/Properties/AssemblyInfo.cs index 8771a5ee..a977c2ab 100644 --- a/Src/Newtonsoft.Json/Properties/AssemblyInfo.cs +++ b/Src/Newtonsoft.Json/Properties/AssemblyInfo.cs @@ -92,6 +92,6 @@ using System.Security; // You can specify all the values or you can default the Revision and Build Numbers // by using the '*' as shown below: [assembly: AssemblyVersion("4.5.0.0")] -[assembly: AssemblyFileVersion("5.0.6.16207")] +[assembly: AssemblyFileVersion("5.0.6.16308")] [assembly: CLSCompliant(true)] diff --git a/Src/Newtonsoft.Json/Serialization/JsonArrayContract.cs b/Src/Newtonsoft.Json/Serialization/JsonArrayContract.cs index af7e4f79..dee86696 100644 --- a/Src/Newtonsoft.Json/Serialization/JsonArrayContract.cs +++ b/Src/Newtonsoft.Json/Serialization/JsonArrayContract.cs @@ -65,7 +65,7 @@ namespace Newtonsoft.Json.Serialization internal bool ShouldCreateWrapper { get; private set; } internal bool CanDeserialize { get; private set; } - internal ConstructorInfo ParametrizedConstructor { get; private set; } + internal MethodBase ParametrizedConstructor { get; private set; } /// /// Initializes a new instance of the class. @@ -95,8 +95,8 @@ namespace Newtonsoft.Json.Serialization else CollectionItemType = ReflectionUtils.GetCollectionItemType(underlyingType); - if (underlyingType == typeof (IList)) - CreatedType = typeof (List); + if (underlyingType == typeof(IList)) + CreatedType = typeof(List); if (CollectionItemType != null) ParametrizedConstructor = CollectionUtils.ResolveEnumableCollectionConstructor(underlyingType, CollectionItemType); @@ -122,12 +122,12 @@ namespace Newtonsoft.Json.Serialization ShouldCreateWrapper = true; } #if !(NET40 || NET35 || NET20 || SILVERLIGHT || WINDOWS_PHONE || PORTABLE40) - else if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof (IReadOnlyCollection<>), out tempCollectionType)) + else if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(IReadOnlyCollection<>), out tempCollectionType)) { CollectionItemType = underlyingType.GetGenericArguments()[0]; - if (ReflectionUtils.IsGenericDefinition(underlyingType, typeof (IReadOnlyCollection<>)) - || ReflectionUtils.IsGenericDefinition(underlyingType, typeof (IReadOnlyList<>))) + if (ReflectionUtils.IsGenericDefinition(underlyingType, typeof(IReadOnlyCollection<>)) + || ReflectionUtils.IsGenericDefinition(underlyingType, typeof(IReadOnlyList<>))) CreatedType = typeof(ReadOnlyCollection<>).MakeGenericType(CollectionItemType); _genericCollectionDefinitionType = typeof(List<>).MakeGenericType(CollectionItemType); @@ -136,7 +136,7 @@ namespace Newtonsoft.Json.Serialization canDeserialize = (ParametrizedConstructor != null); } #endif - else if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof (IEnumerable<>), out tempCollectionType)) + else if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(IEnumerable<>), out tempCollectionType)) { CollectionItemType = tempCollectionType.GetGenericArguments()[0]; @@ -184,6 +184,18 @@ namespace Newtonsoft.Json.Serialization ShouldCreateWrapper = true; } #endif + +#if !(NET20 || NET35 || NET40 || PORTABLE40) + Type immutableCreatedType; + MethodBase immutableParameterizedCreator; + if (ImmutableCollectionsUtils.TryBuildImmutableForArrayContract(underlyingType, CollectionItemType, out immutableCreatedType, out immutableParameterizedCreator)) + { + CreatedType = immutableCreatedType; + ParametrizedConstructor = immutableParameterizedCreator; + IsReadOnlyOrFixedSize = true; + CanDeserialize = true; + } +#endif } internal IWrappedCollection CreateWrapper(object list) @@ -203,8 +215,8 @@ namespace Newtonsoft.Json.Serialization ConstructorInfo genericWrapperConstructor = _genericWrapperType.GetConstructor(new[] { constructorArgument }); _genericWrapperCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall(genericWrapperConstructor); } - - return (IWrappedCollection) _genericWrapperCreator(null, list); + + return (IWrappedCollection)_genericWrapperCreator(null, list); } internal IList CreateTemporaryCollection() @@ -212,7 +224,7 @@ namespace Newtonsoft.Json.Serialization if (_genericTemporaryCollectionCreator == null) { // multidimensional array will also have array instances in it - Type collectionItemType = (IsMultidimensionalArray) ? typeof (object) : CollectionItemType; + Type collectionItemType = (IsMultidimensionalArray) ? typeof(object) : CollectionItemType; Type temporaryListType = typeof(List<>).MakeGenericType(collectionItemType); _genericTemporaryCollectionCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateDefaultConstructor(temporaryListType); } diff --git a/Src/Newtonsoft.Json/Serialization/JsonDictionaryContract.cs b/Src/Newtonsoft.Json/Serialization/JsonDictionaryContract.cs index 5d51aec4..1622ff9e 100644 --- a/Src/Newtonsoft.Json/Serialization/JsonDictionaryContract.cs +++ b/Src/Newtonsoft.Json/Serialization/JsonDictionaryContract.cs @@ -68,7 +68,7 @@ namespace Newtonsoft.Json.Serialization private Func _genericTemporaryDictionaryCreator; internal bool ShouldCreateWrapper { get; private set; } - internal ConstructorInfo ParametrizedConstructor { get; private set; } + internal MethodBase ParametrizedConstructor { get; private set; } /// /// Initializes a new instance of the class. @@ -117,7 +117,7 @@ namespace Newtonsoft.Json.Serialization if (keyType != null && valueType != null) ParametrizedConstructor = CollectionUtils.ResolveEnumableCollectionConstructor(CreatedType, typeof(KeyValuePair<,>).MakeGenericType(keyType, valueType)); - ShouldCreateWrapper = !typeof (IDictionary).IsAssignableFrom(CreatedType); + ShouldCreateWrapper = !typeof(IDictionary).IsAssignableFrom(CreatedType); DictionaryKeyType = keyType; DictionaryValueType = valueType; @@ -136,6 +136,17 @@ namespace Newtonsoft.Json.Serialization ShouldCreateWrapper = true; } #endif + +#if !(NET20 || NET35 || NET40 || PORTABLE40) + Type immutableCreatedType; + MethodBase immutableParameterizedCreator; + if (ImmutableCollectionsUtils.TryBuildImmutableForDictionaryContract(underlyingType, DictionaryKeyType, DictionaryValueType, out immutableCreatedType, out immutableParameterizedCreator)) + { + CreatedType = immutableCreatedType; + ParametrizedConstructor = immutableParameterizedCreator; + IsReadOnlyOrFixedSize = true; + } +#endif } internal IWrappedDictionary CreateWrapper(object dictionary) diff --git a/Src/Newtonsoft.Json/Serialization/JsonSerializerInternalReader.cs b/Src/Newtonsoft.Json/Serialization/JsonSerializerInternalReader.cs index b1a55097..bdfb686c 100644 --- a/Src/Newtonsoft.Json/Serialization/JsonSerializerInternalReader.cs +++ b/Src/Newtonsoft.Json/Serialization/JsonSerializerInternalReader.cs @@ -426,7 +426,11 @@ namespace Newtonsoft.Json.Serialization if (createdFromNonDefaultConstructor) { - return dictionaryContract.ParametrizedConstructor.Invoke(new object[] {dictionary}); + ConstructorInfo constructor = dictionaryContract.ParametrizedConstructor as ConstructorInfo; + if (constructor != null) + return constructor.Invoke(new object[] { dictionary }); + + return dictionaryContract.ParametrizedConstructor.Invoke(null, new object[] { dictionary }); } else if (dictionary is IWrappedDictionary) { @@ -644,7 +648,11 @@ To fix this error either change the JSON to a {1} or change the deserialized typ else { // call constructor that takes IEnumerable - return arrayContract.ParametrizedConstructor.Invoke(new object[] { list }); + ConstructorInfo constructor = arrayContract.ParametrizedConstructor as ConstructorInfo; + if (constructor != null) + return constructor.Invoke(new object[] { list }); + + return arrayContract.ParametrizedConstructor.Invoke(null, new object[] { list }); } } else if (list is IWrappedCollection) diff --git a/Src/Newtonsoft.Json/Utilities/ImmutableCollectionsUtils.cs b/Src/Newtonsoft.Json/Utilities/ImmutableCollectionsUtils.cs new file mode 100644 index 00000000..ad313075 --- /dev/null +++ b/Src/Newtonsoft.Json/Utilities/ImmutableCollectionsUtils.cs @@ -0,0 +1,166 @@ +#region License +// Copyright (c) 2007 James Newton-King +// +// Permission is hereby granted, free of charge, to any person +// obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without +// restriction, including without limitation the rights to use, +// copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following +// conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +#endregion + +#if !(NET20 || NET35 || NET40 || PORTABLE40) +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using System.Text; +using System.Threading.Tasks; + +namespace Newtonsoft.Json.Utilities +{ + internal static class ImmutableCollectionsUtils + { + internal class ImmutableCollectionTypeInfo + { + public ImmutableCollectionTypeInfo(string contractTypeName, string createdTypeName, string builderTypeName) + { + ContractTypeName = contractTypeName; + CreatedTypeName = createdTypeName; + BuilderTypeName = builderTypeName; + } + + public string ContractTypeName { get; set; } + public string CreatedTypeName { get; set; } + public string BuilderTypeName { get; set; } + } + + private const string ImmutableListGenericInterfaceTypeName = "System.Collections.Immutable.IImmutableList`1"; + private const string ImmutableQueueGenericInterfaceTypeName = "System.Collections.Immutable.IImmutableQueue`1"; + private const string ImmutableStackGenericInterfaceTypeName = "System.Collections.Immutable.IImmutableStack`1"; + private const string ImmutableSetGenericInterfaceTypeName = "System.Collections.Immutable.IImmutableSet`1"; + + private const string ImmutableArrayTypeName = "System.Collections.Immutable.ImmutableArray"; + private const string ImmutableArrayGenericTypeName = "System.Collections.Immutable.ImmutableArray`1"; + + private const string ImmutableListTypeName = "System.Collections.Immutable.ImmutableList"; + private const string ImmutableListGenericTypeName = "System.Collections.Immutable.ImmutableList`1"; + + private const string ImmutableQueueTypeName = "System.Collections.Immutable.ImmutableQueue"; + private const string ImmutableQueueGenericTypeName = "System.Collections.Immutable.ImmutableQueue`1"; + + private const string ImmutableStackTypeName = "System.Collections.Immutable.ImmutableStack"; + private const string ImmutableStackGenericTypeName = "System.Collections.Immutable.ImmutableStack`1"; + + private const string ImmutableSortedSetTypeName = "System.Collections.Immutable.ImmutableSortedSet"; + private const string ImmutableSortedSetGenericTypeName = "System.Collections.Immutable.ImmutableSortedSet`1"; + + private const string ImmutableHashSetTypeName = "System.Collections.Immutable.ImmutableHashSet"; + private const string ImmutableHashSetGenericTypeName = "System.Collections.Immutable.ImmutableHashSet`1"; + + private static readonly IList ArrayContractImmutableCollectionDefinitions = new List + { + new ImmutableCollectionTypeInfo(ImmutableListGenericInterfaceTypeName, ImmutableListGenericTypeName, ImmutableListTypeName), + new ImmutableCollectionTypeInfo(ImmutableListGenericTypeName, ImmutableListGenericTypeName, ImmutableListTypeName), + new ImmutableCollectionTypeInfo(ImmutableQueueGenericInterfaceTypeName, ImmutableQueueGenericTypeName, ImmutableQueueTypeName), + new ImmutableCollectionTypeInfo(ImmutableQueueGenericTypeName, ImmutableQueueGenericTypeName, ImmutableQueueTypeName), + new ImmutableCollectionTypeInfo(ImmutableStackGenericInterfaceTypeName, ImmutableStackGenericTypeName, ImmutableStackTypeName), + new ImmutableCollectionTypeInfo(ImmutableStackGenericTypeName, ImmutableStackGenericTypeName, ImmutableStackTypeName), + new ImmutableCollectionTypeInfo(ImmutableSetGenericInterfaceTypeName, ImmutableSortedSetGenericTypeName, ImmutableSortedSetTypeName), + new ImmutableCollectionTypeInfo(ImmutableSortedSetGenericTypeName, ImmutableSortedSetGenericTypeName, ImmutableSortedSetTypeName), + new ImmutableCollectionTypeInfo(ImmutableHashSetGenericTypeName, ImmutableHashSetGenericTypeName, ImmutableHashSetTypeName), + new ImmutableCollectionTypeInfo(ImmutableArrayGenericTypeName, ImmutableArrayGenericTypeName, ImmutableArrayTypeName) + }; + + private const string ImmutableDictionaryGenericInterfaceTypeName = "System.Collections.Immutable.IImmutableDictionary`2"; + + private const string ImmutableDictionaryTypeName = "System.Collections.Immutable.ImmutableDictionary"; + private const string ImmutableDictionaryGenericTypeName = "System.Collections.Immutable.ImmutableDictionary`2"; + + private const string ImmutableSortedDictionaryTypeName = "System.Collections.Immutable.ImmutableSortedDictionary"; + private const string ImmutableSortedDictionaryGenericTypeName = "System.Collections.Immutable.ImmutableSortedDictionary`2"; + + private static readonly IList DictionaryContractImmutableCollectionDefinitions = new List + { + new ImmutableCollectionTypeInfo(ImmutableDictionaryGenericInterfaceTypeName, ImmutableSortedDictionaryGenericTypeName, ImmutableSortedDictionaryTypeName), + new ImmutableCollectionTypeInfo(ImmutableSortedDictionaryGenericTypeName, ImmutableSortedDictionaryGenericTypeName, ImmutableSortedDictionaryTypeName), + new ImmutableCollectionTypeInfo(ImmutableDictionaryGenericTypeName, ImmutableDictionaryGenericTypeName, ImmutableDictionaryTypeName) + }; + + internal static bool TryBuildImmutableForArrayContract(Type underlyingType, Type collectionItemType, out Type createdType, out MethodBase parameterizedCreator) + { + if (underlyingType.IsGenericType()) + { + string name = underlyingType.GetGenericTypeDefinition().FullName; + ImmutableCollectionTypeInfo definition = ArrayContractImmutableCollectionDefinitions.FirstOrDefault(d => d.ContractTypeName == name); + if (definition != null) + { + Type createdTypeDefinition = Type.GetType(definition.CreatedTypeName + ", System.Collections.Immutable"); + Type builderTypeDefinition = Type.GetType(definition.BuilderTypeName + ", System.Collections.Immutable"); + if (createdTypeDefinition != null && builderTypeDefinition != null) + { + MethodInfo mb = builderTypeDefinition.GetMethods().FirstOrDefault(m => m.Name == "From" && m.GetParameters().Length == 1); + if (mb != null) + { + createdType = createdTypeDefinition.MakeGenericType(collectionItemType); + parameterizedCreator = mb.MakeGenericMethod(collectionItemType); + return true; + } + } + } + } + + createdType = null; + parameterizedCreator = null; + return false; + } + + internal static bool TryBuildImmutableForDictionaryContract(Type underlyingType, Type keyItemType, Type valueItemType, out Type createdType, out MethodBase parameterizedCreator) + { + if (underlyingType.IsGenericType()) + { + string name = underlyingType.GetGenericTypeDefinition().FullName; + ImmutableCollectionTypeInfo definition = DictionaryContractImmutableCollectionDefinitions.FirstOrDefault(d => d.ContractTypeName == name); + if (definition != null) + { + Type createdTypeDefinition = Type.GetType(definition.CreatedTypeName + ", System.Collections.Immutable"); + Type builderTypeDefinition = Type.GetType(definition.BuilderTypeName + ", System.Collections.Immutable"); + if (createdTypeDefinition != null && builderTypeDefinition != null) + { + MethodInfo mb = builderTypeDefinition.GetMethods().FirstOrDefault(m => + { + ParameterInfo[] parameters = m.GetParameters(); + + return m.Name == "Create" && parameters.Length == 1 && parameters[0].ParameterType.IsGenericType() && parameters[0].ParameterType.GetGenericTypeDefinition() == typeof(IEnumerable<>); + }); + if (mb != null) + { + createdType = createdTypeDefinition.MakeGenericType(keyItemType, valueItemType); + parameterizedCreator = mb.MakeGenericMethod(keyItemType, valueItemType); + return true; + } + } + } + } + + createdType = null; + parameterizedCreator = null; + return false; + } + } +} +#endif \ No newline at end of file diff --git a/Src/packages/Microsoft.Bcl.Immutable.1.0.12-beta/License.rtf b/Src/packages/Microsoft.Bcl.Immutable.1.0.12-beta/License.rtf new file mode 100644 index 00000000..b1136314 --- /dev/null +++ b/Src/packages/Microsoft.Bcl.Immutable.1.0.12-beta/License.rtf @@ -0,0 +1,440 @@ +{\rtf1\adeflang1025\ansi\ansicpg1252\uc1\adeff41\deff0\stshfdbch0\stshfloch31506\stshfhich31506\stshfbi31506\deflang1033\deflangfe1033\themelang1033\themelangfe0\themelangcs1025{\fonttbl{\f0\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f2\fbidi \fmodern\fcharset0\fprq1{\*\panose 02070309020205020404}Courier New;} +{\f3\fbidi \froman\fcharset2\fprq2{\*\panose 05050102010706020507}Symbol;}{\f10\fbidi \fnil\fcharset2\fprq2{\*\panose 05000000000000000000}Wingdings;} +{\f11\fbidi \fmodern\fcharset128\fprq1{\*\panose 00000000000000000000}MS Mincho{\*\falt ?l?r ??\'81\'66c};}{\f13\fbidi \fnil\fcharset134\fprq2{\*\panose 02010600030101010101}SimSun{\*\falt ??\'a8\'ac?};} +{\f34\fbidi \froman\fcharset0\fprq2{\*\panose 00000000000000000000}Cambria Math;}{\f41\fbidi \fswiss\fcharset0\fprq2{\*\panose 00000000000000000000}Tahoma;}{\f43\fbidi \fswiss\fcharset0\fprq2{\*\panose 00000000000000000000}Trebuchet MS{\*\falt Univers};} +{\f44\fbidi \fnil\fcharset134\fprq2{\*\panose 02010600030101010101}@SimSun;}{\f45\fbidi \fmodern\fcharset128\fprq1{\*\panose 02020609040205080304}@MS Mincho;}{\flomajor\f31500\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;} +{\fdbmajor\f31501\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fhimajor\f31502\fbidi \froman\fcharset0\fprq2{\*\panose 00000000000000000000}Cambria;} +{\fbimajor\f31503\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\flominor\f31504\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;} +{\fdbminor\f31505\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fhiminor\f31506\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;} +{\fbiminor\f31507\fbidi \fswiss\fcharset0\fprq2{\*\panose 020b0604020202020204}Arial;}{\f46\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\f47\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;} +{\f49\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\f50\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\f51\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\f52\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);} +{\f53\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\f54\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\f66\fbidi \fmodern\fcharset238\fprq1 Courier New CE;}{\f67\fbidi \fmodern\fcharset204\fprq1 Courier New Cyr;} +{\f69\fbidi \fmodern\fcharset161\fprq1 Courier New Greek;}{\f70\fbidi \fmodern\fcharset162\fprq1 Courier New Tur;}{\f71\fbidi \fmodern\fcharset177\fprq1 Courier New (Hebrew);}{\f72\fbidi \fmodern\fcharset178\fprq1 Courier New (Arabic);} +{\f73\fbidi \fmodern\fcharset186\fprq1 Courier New Baltic;}{\f74\fbidi \fmodern\fcharset163\fprq1 Courier New (Vietnamese);}{\f158\fbidi \fmodern\fcharset0\fprq1 MS Mincho Western{\*\falt ?l?r ??\'81\'66c};} +{\f156\fbidi \fmodern\fcharset238\fprq1 MS Mincho CE{\*\falt ?l?r ??\'81\'66c};}{\f157\fbidi \fmodern\fcharset204\fprq1 MS Mincho Cyr{\*\falt ?l?r ??\'81\'66c};}{\f159\fbidi \fmodern\fcharset161\fprq1 MS Mincho Greek{\*\falt ?l?r ??\'81\'66c};} +{\f160\fbidi \fmodern\fcharset162\fprq1 MS Mincho Tur{\*\falt ?l?r ??\'81\'66c};}{\f163\fbidi \fmodern\fcharset186\fprq1 MS Mincho Baltic{\*\falt ?l?r ??\'81\'66c};}{\f178\fbidi \fnil\fcharset0\fprq2 SimSun Western{\*\falt ??\'a8\'ac?};} +{\f386\fbidi \froman\fcharset238\fprq2 Cambria Math CE;}{\f387\fbidi \froman\fcharset204\fprq2 Cambria Math Cyr;}{\f389\fbidi \froman\fcharset161\fprq2 Cambria Math Greek;}{\f390\fbidi \froman\fcharset162\fprq2 Cambria Math Tur;} +{\f393\fbidi \froman\fcharset186\fprq2 Cambria Math Baltic;}{\f394\fbidi \froman\fcharset163\fprq2 Cambria Math (Vietnamese);}{\f456\fbidi \fswiss\fcharset238\fprq2 Tahoma CE;}{\f457\fbidi \fswiss\fcharset204\fprq2 Tahoma Cyr;} +{\f459\fbidi \fswiss\fcharset161\fprq2 Tahoma Greek;}{\f460\fbidi \fswiss\fcharset162\fprq2 Tahoma Tur;}{\f461\fbidi \fswiss\fcharset177\fprq2 Tahoma (Hebrew);}{\f462\fbidi \fswiss\fcharset178\fprq2 Tahoma (Arabic);} +{\f463\fbidi \fswiss\fcharset186\fprq2 Tahoma Baltic;}{\f464\fbidi \fswiss\fcharset163\fprq2 Tahoma (Vietnamese);}{\f465\fbidi \fswiss\fcharset222\fprq2 Tahoma (Thai);}{\f476\fbidi \fswiss\fcharset238\fprq2 Trebuchet MS CE{\*\falt Univers};} +{\f477\fbidi \fswiss\fcharset204\fprq2 Trebuchet MS Cyr{\*\falt Univers};}{\f479\fbidi \fswiss\fcharset161\fprq2 Trebuchet MS Greek{\*\falt Univers};}{\f480\fbidi \fswiss\fcharset162\fprq2 Trebuchet MS Tur{\*\falt Univers};} +{\f483\fbidi \fswiss\fcharset186\fprq2 Trebuchet MS Baltic{\*\falt Univers};}{\f488\fbidi \fnil\fcharset0\fprq2 @SimSun Western;}{\f498\fbidi \fmodern\fcharset0\fprq1 @MS Mincho Western;}{\f496\fbidi \fmodern\fcharset238\fprq1 @MS Mincho CE;} +{\f497\fbidi \fmodern\fcharset204\fprq1 @MS Mincho Cyr;}{\f499\fbidi \fmodern\fcharset161\fprq1 @MS Mincho Greek;}{\f500\fbidi \fmodern\fcharset162\fprq1 @MS Mincho Tur;}{\f503\fbidi \fmodern\fcharset186\fprq1 @MS Mincho Baltic;} +{\flomajor\f31508\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\flomajor\f31509\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\flomajor\f31511\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;} +{\flomajor\f31512\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\flomajor\f31513\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\flomajor\f31514\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);} +{\flomajor\f31515\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\flomajor\f31516\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fdbmajor\f31518\fbidi \froman\fcharset238\fprq2 Times New Roman CE;} +{\fdbmajor\f31519\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fdbmajor\f31521\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fdbmajor\f31522\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;} +{\fdbmajor\f31523\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fdbmajor\f31524\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fdbmajor\f31525\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;} +{\fdbmajor\f31526\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fhimajor\f31528\fbidi \froman\fcharset238\fprq2 Cambria CE;}{\fhimajor\f31529\fbidi \froman\fcharset204\fprq2 Cambria Cyr;} +{\fhimajor\f31531\fbidi \froman\fcharset161\fprq2 Cambria Greek;}{\fhimajor\f31532\fbidi \froman\fcharset162\fprq2 Cambria Tur;}{\fhimajor\f31535\fbidi \froman\fcharset186\fprq2 Cambria Baltic;} +{\fhimajor\f31536\fbidi \froman\fcharset163\fprq2 Cambria (Vietnamese);}{\fbimajor\f31538\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fbimajor\f31539\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;} +{\fbimajor\f31541\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fbimajor\f31542\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fbimajor\f31543\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);} +{\fbimajor\f31544\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fbimajor\f31545\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fbimajor\f31546\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);} +{\flominor\f31548\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\flominor\f31549\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\flominor\f31551\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;} +{\flominor\f31552\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\flominor\f31553\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\flominor\f31554\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);} +{\flominor\f31555\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\flominor\f31556\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fdbminor\f31558\fbidi \froman\fcharset238\fprq2 Times New Roman CE;} +{\fdbminor\f31559\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fdbminor\f31561\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fdbminor\f31562\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;} +{\fdbminor\f31563\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fdbminor\f31564\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fdbminor\f31565\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;} +{\fdbminor\f31566\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fhiminor\f31568\fbidi \fswiss\fcharset238\fprq2 Calibri CE;}{\fhiminor\f31569\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;} +{\fhiminor\f31571\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}{\fhiminor\f31572\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;}{\fhiminor\f31575\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;} +{\fhiminor\f31576\fbidi \fswiss\fcharset163\fprq2 Calibri (Vietnamese);}{\fbiminor\f31578\fbidi \fswiss\fcharset238\fprq2 Arial CE;}{\fbiminor\f31579\fbidi \fswiss\fcharset204\fprq2 Arial Cyr;} +{\fbiminor\f31581\fbidi \fswiss\fcharset161\fprq2 Arial Greek;}{\fbiminor\f31582\fbidi \fswiss\fcharset162\fprq2 Arial Tur;}{\fbiminor\f31583\fbidi \fswiss\fcharset177\fprq2 Arial (Hebrew);} +{\fbiminor\f31584\fbidi \fswiss\fcharset178\fprq2 Arial (Arabic);}{\fbiminor\f31585\fbidi \fswiss\fcharset186\fprq2 Arial Baltic;}{\fbiminor\f31586\fbidi \fswiss\fcharset163\fprq2 Arial (Vietnamese);}}{\colortbl;\red0\green0\blue0;\red0\green0\blue255; +\red0\green255\blue255;\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0;\red255\green255\blue255;\red0\green0\blue128;\red0\green128\blue128;\red0\green128\blue0;\red128\green0\blue128;\red128\green0\blue0; +\red128\green128\blue0;\red128\green128\blue128;\red192\green192\blue192;}{\*\defchp \f31506\fs22 }{\*\defpap \ql \li0\ri0\sa200\sl276\slmult1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 }\noqfpromote {\stylesheet{ +\ql \li0\ri0\sb120\sa120\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 \fs19\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 +\snext0 \sautoupd \sqformat \spriority0 \styrsid11363863 Normal;}{\s1\ql \fi-357\li357\ri0\sb120\sa120\widctlpar\jclisttab\tx360\wrapdefault\aspalpha\aspnum\faauto\ls3\outlinelevel0\adjustright\rin0\lin357\itap0 \rtlch\fcs1 \ab\af41\afs19\alang1025 +\ltrch\fcs0 \b\fs19\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext1 \slink15 \sqformat \styrsid11363863 heading 1;}{\s2\ql \fi-363\li720\ri0\sb120\sa120\widctlpar +\jclisttab\tx720\wrapdefault\aspalpha\aspnum\faauto\ls3\ilvl1\outlinelevel1\adjustright\rin0\lin720\itap0 \rtlch\fcs1 \ab\af41\afs19\alang1025 \ltrch\fcs0 \b\fs19\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 +\sbasedon0 \snext2 \slink16 \sqformat \styrsid11363863 heading 2;}{\s3\ql \fi-357\li1077\ri0\sb120\sa120\widctlpar\tx1077\jclisttab\tx1440\wrapdefault\aspalpha\aspnum\faauto\ls3\ilvl2\outlinelevel2\adjustright\rin0\lin1077\itap0 \rtlch\fcs1 +\af41\afs19\alang1025 \ltrch\fcs0 \fs19\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext3 \slink17 \sqformat \styrsid11363863 heading 3;}{\s4\ql \fi-358\li1435\ri0\sb120\sa120\widctlpar +\jclisttab\tx1437\wrapdefault\aspalpha\aspnum\faauto\ls3\ilvl3\outlinelevel3\adjustright\rin0\lin1435\itap0 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 \fs19\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 +\sbasedon0 \snext4 \slink18 \sqformat \styrsid11363863 heading 4;}{\s5\ql \fi-357\li1792\ri0\sb120\sa120\widctlpar\tx1792\jclisttab\tx2155\wrapdefault\aspalpha\aspnum\faauto\ls3\ilvl4\outlinelevel4\adjustright\rin0\lin1792\itap0 \rtlch\fcs1 +\af41\afs19\alang1025 \ltrch\fcs0 \fs19\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext5 \slink19 \sqformat \styrsid11363863 heading 5;}{\s6\ql \fi-357\li2149\ri0\sb120\sa120\widctlpar +\jclisttab\tx2152\wrapdefault\aspalpha\aspnum\faauto\ls3\ilvl5\outlinelevel5\adjustright\rin0\lin2149\itap0 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 \fs19\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 +\sbasedon0 \snext6 \slink20 \sqformat \styrsid11363863 heading 6;}{\s7\ql \fi-357\li2506\ri0\sb120\sa120\widctlpar\jclisttab\tx2509\wrapdefault\aspalpha\aspnum\faauto\ls3\ilvl6\outlinelevel6\adjustright\rin0\lin2506\itap0 \rtlch\fcs1 +\af41\afs19\alang1025 \ltrch\fcs0 \fs19\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext7 \slink21 \sqformat \styrsid11363863 heading 7;}{\s8\ql \fi-357\li2863\ri0\sb120\sa120\widctlpar +\jclisttab\tx2866\wrapdefault\aspalpha\aspnum\faauto\ls3\ilvl7\outlinelevel7\adjustright\rin0\lin2863\itap0 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 \fs19\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 +\sbasedon0 \snext8 \slink22 \sqformat \styrsid11363863 heading 8;}{\s9\ql \fi-358\li3221\ri0\sb120\sa120\widctlpar\jclisttab\tx3223\wrapdefault\aspalpha\aspnum\faauto\ls3\ilvl8\outlinelevel8\adjustright\rin0\lin3221\itap0 \rtlch\fcs1 +\af41\afs19\alang1025 \ltrch\fcs0 \fs19\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext9 \slink23 \sqformat \styrsid11363863 heading 9;}{\*\cs10 \additive \ssemihidden \sunhideused \spriority1 +Default Paragraph Font;}{\*\ts11\tsrowd\trftsWidthB3\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblind0\tblindtype3\tsvertalt\tsbrdrt\tsbrdrl\tsbrdrb\tsbrdrr\tsbrdrdgl\tsbrdrdgr\tsbrdrh\tsbrdrv \ql \li0\ri0\sa200\sl276\slmult1 +\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af31506\afs22\alang1025 \ltrch\fcs0 \f31506\fs22\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 \snext11 \ssemihidden \sunhideused Normal Table;}{\*\cs15 \additive +\rtlch\fcs1 \ab\af41\afs19 \ltrch\fcs0 \b\fs19\loch\f41\hich\af41\dbch\af11 \sbasedon10 \slink1 \slocked \styrsid11363863 Heading 1 Char;}{\*\cs16 \additive \rtlch\fcs1 \ab\af41\afs19 \ltrch\fcs0 \b\fs19\loch\f41\hich\af41\dbch\af11 +\sbasedon10 \slink2 \slocked \styrsid11363863 Heading 2 Char;}{\*\cs17 \additive \rtlch\fcs1 \af41\afs19 \ltrch\fcs0 \fs19\loch\f41\hich\af41\dbch\af11 \sbasedon10 \slink3 \slocked \styrsid11363863 Heading 3 Char;}{\*\cs18 \additive \rtlch\fcs1 +\af41\afs19 \ltrch\fcs0 \fs19\loch\f41\hich\af41\dbch\af11 \sbasedon10 \slink4 \slocked \styrsid11363863 Heading 4 Char;}{\*\cs19 \additive \rtlch\fcs1 \af41\afs19 \ltrch\fcs0 \fs19\loch\f41\hich\af41\dbch\af11 +\sbasedon10 \slink5 \slocked \styrsid11363863 Heading 5 Char;}{\*\cs20 \additive \rtlch\fcs1 \af41\afs19 \ltrch\fcs0 \fs19\loch\f41\hich\af41\dbch\af11 \sbasedon10 \slink6 \slocked \styrsid11363863 Heading 6 Char;}{\*\cs21 \additive \rtlch\fcs1 +\af41\afs19 \ltrch\fcs0 \fs19\loch\f41\hich\af41\dbch\af11 \sbasedon10 \slink7 \slocked \styrsid11363863 Heading 7 Char;}{\*\cs22 \additive \rtlch\fcs1 \af41\afs19 \ltrch\fcs0 \fs19\loch\f41\hich\af41\dbch\af11 +\sbasedon10 \slink8 \slocked \styrsid11363863 Heading 8 Char;}{\*\cs23 \additive \rtlch\fcs1 \af41\afs19 \ltrch\fcs0 \fs19\loch\f41\hich\af41\dbch\af11 \sbasedon10 \slink9 \slocked \styrsid11363863 Heading 9 Char;}{ +\s24\ql \li357\ri0\sb120\sa120\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin357\itap0 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 \fs19\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 +\sbasedon0 \snext24 \styrsid11363863 Body 1;}{\s25\ql \fi-363\li720\ri0\sb120\sa120\widctlpar\jclisttab\tx720\wrapdefault\aspalpha\aspnum\faauto\ls1\adjustright\rin0\lin720\itap0 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 +\fs19\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext25 \styrsid11363863 Bullet 2;}{\s26\ql \fi-357\li1077\ri0\sb120\sa120\widctlpar +\jclisttab\tx1080\wrapdefault\aspalpha\aspnum\faauto\ls2\adjustright\rin0\lin1077\itap0 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 \fs19\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 +\sbasedon0 \snext26 \slink34 \styrsid11363863 Bullet 3;}{\s27\ql \li0\ri0\sb120\sa120\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \ab\af41\afs28\alang1025 \ltrch\fcs0 +\b\fs28\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext0 \styrsid11363863 Heading EULA;}{\s28\ql \li0\ri0\sb120\sa120\widctlpar\brdrb\brdrs\brdrw10\brsp20 +\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \ab\af41\afs28\alang1025 \ltrch\fcs0 \b\fs28\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext0 \styrsid11363863 +Heading Software Title;}{\s29\ql \li0\ri0\sb120\sa120\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \ab\af41\afs19\alang1025 \ltrch\fcs0 +\b\fs19\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext29 \styrsid11363863 Preamble;}{\s30\ql \li0\ri0\sb120\sa120\widctlpar\brdrt\brdrs\brdrw10\brsp20 +\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \ab\af41\afs19\alang1025 \ltrch\fcs0 \b\fs19\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 \sbasedon29 \snext30 \styrsid11363863 +Preamble Border Above;}{\*\cs31 \additive \rtlch\fcs1 \af0 \ltrch\fcs0 \ul\cf2 \sbasedon10 \styrsid11363863 Hyperlink;}{\s32\ql \li0\ri0\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \ab\af41\afs19\alang1025 +\ltrch\fcs0 \b\fs19\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 \snext0 \styrsid11363863 Body 0 Bold;}{\s33\ql \li0\ri0\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 +\af41\afs19\alang1025 \ltrch\fcs0 \fs19\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 \snext0 \styrsid11363863 Body 0;}{\*\cs34 \additive \rtlch\fcs1 \af41\afs19 \ltrch\fcs0 \fs19\loch\f41\hich\af41\dbch\af11 +\sbasedon10 \slink26 \slocked \styrsid11363863 Bullet 3 Char1;}{\*\cs35 \additive \rtlch\fcs1 \af0\afs16 \ltrch\fcs0 \fs16 \sbasedon10 \ssemihidden \sunhideused \styrsid4544046 annotation reference;}{ +\s36\ql \li0\ri0\sb120\sa120\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af41\afs20\alang1025 \ltrch\fcs0 \fs20\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 +\sbasedon0 \snext36 \slink37 \ssemihidden \sunhideused \styrsid4544046 annotation text;}{\*\cs37 \additive \rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\loch\f41\hich\af41\dbch\af11 \sbasedon10 \slink36 \slocked \ssemihidden \styrsid4544046 +Comment Text Char;}{\s38\ql \li0\ri0\sb120\sa120\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \ab\af41\afs20\alang1025 \ltrch\fcs0 +\b\fs20\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 \sbasedon36 \snext36 \slink39 \ssemihidden \sunhideused \styrsid4544046 annotation subject;}{\*\cs39 \additive \rtlch\fcs1 \ab\af41\afs20 \ltrch\fcs0 +\b\fs20\loch\f41\hich\af41\dbch\af11 \sbasedon37 \slink38 \slocked \ssemihidden \styrsid4544046 Comment Subject Char;}{\s40\ql \li0\ri0\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af41\afs16\alang1025 \ltrch\fcs0 +\fs16\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext40 \slink41 \ssemihidden \sunhideused \styrsid4544046 Balloon Text;}{\*\cs41 \additive \rtlch\fcs1 \af41\afs16 \ltrch\fcs0 +\fs16\loch\f41\hich\af41\dbch\af11 \sbasedon10 \slink40 \slocked \ssemihidden \styrsid4544046 Balloon Text Char;}{\s42\ql \li0\ri0\widctlpar\tqc\tx4680\tqr\tx9360\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 +\af41\afs19\alang1025 \ltrch\fcs0 \fs19\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext42 \slink43 \sunhideused \styrsid160711 header;}{\*\cs43 \additive \rtlch\fcs1 \af41\afs19 \ltrch\fcs0 +\fs19\loch\f41\hich\af41\dbch\af11 \sbasedon10 \slink42 \slocked \styrsid160711 Header Char;}{\s44\ql \li0\ri0\widctlpar\tqc\tx4680\tqr\tx9360\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 +\fs19\lang1033\langfe1033\loch\f41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext44 \slink45 \sunhideused \styrsid160711 footer;}{\*\cs45 \additive \rtlch\fcs1 \af41\afs19 \ltrch\fcs0 \fs19\loch\f41\hich\af41\dbch\af11 +\sbasedon10 \slink44 \slocked \styrsid160711 Footer Char;}}{\*\listtable{\list\listtemplateid789093748\listhybrid{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\leveltemplateid-317712510 +\'01\u-3913 ?;}{\levelnumbers;}\f3\fbias0 \s25\fi-363\li720\jclisttab\tx720\lin720 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\leveltemplateid67698691\'01o;}{\levelnumbers;} +\f2\fbias0 \fi-360\li1440\jclisttab\tx1440\lin1440 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\leveltemplateid67698693\'01\u-3929 ?;}{\levelnumbers;}\f10\fbias0 \fi-360\li2160 +\jclisttab\tx2160\lin2160 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\leveltemplateid67698689\'01\u-3913 ?;}{\levelnumbers;}\f3\fbias0 \fi-360\li2880\jclisttab\tx2880\lin2880 } +{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\leveltemplateid67698691\'01o;}{\levelnumbers;}\f2\fbias0 \fi-360\li3600\jclisttab\tx3600\lin3600 }{\listlevel\levelnfc23\levelnfcn23 +\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\leveltemplateid67698693\'01\u-3929 ?;}{\levelnumbers;}\f10\fbias0 \fi-360\li4320\jclisttab\tx4320\lin4320 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0 +\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\leveltemplateid67698689\'01\u-3913 ?;}{\levelnumbers;}\f3\fbias0 \fi-360\li5040\jclisttab\tx5040\lin5040 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1 +\levelspace0\levelindent0{\leveltext\leveltemplateid67698691\'01o;}{\levelnumbers;}\f2\fbias0 \fi-360\li5760\jclisttab\tx5760\lin5760 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext +\leveltemplateid67698693\'01\u-3929 ?;}{\levelnumbers;}\f10\fbias0 \fi-360\li6480\jclisttab\tx6480\lin6480 }{\listname ;}\listid477573462}{\list\listtemplateid-1517670730{\listlevel\levelnfc0\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1 +\levelspace0\levelindent0{\leveltext\'02\'00.;}{\levelnumbers\'01;}\rtlch\fcs1 \ab\ai0\af41\afs20 \ltrch\fcs0 \b\i0\f41\fs20\cf0\fbias0 \s1\fi-357\li357\jclisttab\tx360\lin357 }{\listlevel\levelnfc4\levelnfcn4\leveljc0\leveljcn0\levelfollow0\levelstartat1 +\levelspace0\levelindent0{\leveltext\'02\'01.;}{\levelnumbers\'01;}\rtlch\fcs1 \ab\ai0\af41\afs20 \ltrch\fcs0 \b\i0\f41\fs20\fbias0 \s2\fi-363\li720\jclisttab\tx720\lin720 }{\listlevel\levelnfc2\levelnfcn2\leveljc0\leveljcn0\levelfollow0\levelstartat1 +\levelspace0\levelindent0{\leveltext\'02\'02.;}{\levelnumbers\'01;}\rtlch\fcs1 \ab\ai0\af41\afs20 \ltrch\fcs0 \b\i0\f41\fs20\fbias0 \s3\fi-357\li1077\jclisttab\tx1440\lin1077 }{\listlevel\levelnfc3\levelnfcn3\leveljc0\leveljcn0\levelfollow0\levelstartat1 +\levelspace0\levelindent0{\leveltext\'02\'03.;}{\levelnumbers\'01;}\rtlch\fcs1 \ab0\ai0\af43\afs20 \ltrch\fcs0 \b0\i0\strike0\f43\fs20\ulnone\fbias0 \s4\fi-358\li1435\jclisttab\tx1437\lin1435 }{\listlevel\levelnfc1\levelnfcn1\leveljc0\leveljcn0 +\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'02\'04.;}{\levelnumbers\'01;}\rtlch\fcs1 \ab0\ai0\af43\afs20 \ltrch\fcs0 \b0\i0\strike0\f43\fs20\ulnone\fbias0 \s5\fi-357\li1792\jclisttab\tx2155\lin1792 }{\listlevel\levelnfc0\levelnfcn0 +\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'02\'05.;}{\levelnumbers\'01;}\rtlch\fcs1 \ab0\ai0\af43\afs20 \ltrch\fcs0 \b0\i0\f43\fs20\fbias0 \s6\fi-357\li2149\jclisttab\tx2152\lin2149 }{\listlevel\levelnfc4 +\levelnfcn4\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'02\'06.;}{\levelnumbers\'01;}\rtlch\fcs1 \ab0\ai0\af43\afs20 \ltrch\fcs0 \b0\i0\f43\fs20\fbias0 \s7\fi-357\li2506\jclisttab\tx2509\lin2506 }{\listlevel +\levelnfc255\levelnfcn255\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'02i.;}{\levelnumbers;}\rtlch\fcs1 \ab0\ai0\af43\afs20 \ltrch\fcs0 \b0\i0\f43\fs20\fbias0 \s8\fi-357\li2863\jclisttab\tx2866\lin2863 }{\listlevel +\levelnfc255\levelnfcn255\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'02A.;}{\levelnumbers;}\rtlch\fcs1 \ab0\ai0\af43\afs20 \ltrch\fcs0 \b0\i0\f43\fs20\fbias0 \s9\fi-358\li3221\jclisttab\tx3223\lin3221 }{\listname +;}\listid752163927}{\list\listtemplateid-743794326\listhybrid{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\leveltemplateid2033377338\'01\u-3913 ?;}{\levelnumbers;}\f3\fbias0 \s26 +\fi-357\li1077\jclisttab\tx1080\lin1077 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\leveltemplateid67698691\'01o;}{\levelnumbers;}\f2\fbias0 \fi-360\li1440\jclisttab\tx1440\lin1440 +}{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\leveltemplateid67698693\'01\u-3929 ?;}{\levelnumbers;}\f10\fbias0 \fi-360\li2160\jclisttab\tx2160\lin2160 }{\listlevel\levelnfc23 +\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\leveltemplateid67698689\'01\u-3913 ?;}{\levelnumbers;}\f3\fbias0 \fi-360\li2880\jclisttab\tx2880\lin2880 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0 +\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\leveltemplateid67698691\'01o;}{\levelnumbers;}\f2\fbias0 \fi-360\li3600\jclisttab\tx3600\lin3600 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0 +\levelindent0{\leveltext\leveltemplateid67698693\'01\u-3929 ?;}{\levelnumbers;}\f10\fbias0 \fi-360\li4320\jclisttab\tx4320\lin4320 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext +\leveltemplateid67698689\'01\u-3913 ?;}{\levelnumbers;}\f3\fbias0 \fi-360\li5040\jclisttab\tx5040\lin5040 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\leveltemplateid67698691 +\'01o;}{\levelnumbers;}\f2\fbias0 \fi-360\li5760\jclisttab\tx5760\lin5760 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\leveltemplateid67698693\'01\u-3929 ?;}{\levelnumbers;} +\f10\fbias0 \fi-360\li6480\jclisttab\tx6480\lin6480 }{\listname ;}\listid1567649130}}{\*\listoverridetable{\listoverride\listid477573462\listoverridecount0\ls1}{\listoverride\listid1567649130\listoverridecount0\ls2}{\listoverride\listid752163927 +\listoverridecount0\ls3}}{\*\rsidtbl \rsid160711\rsid874403\rsid2693076\rsid2964340\rsid4000782\rsid4544046\rsid5065081\rsid5394699\rsid7043895\rsid10182339\rsid11363863\rsid11675240\rsid12077466}{\mmathPr\mmathFont34\mbrkBin0\mbrkBinSub0\msmallFrac0 +\mdispDef1\mlMargin0\mrMargin0\mdefJc1\mwrapIndent1440\mintLim0\mnaryLim1}{\info{\creatim\yr2012\mo12\dy17\hr15\min34}{\revtim\yr2012\mo12\dy17\hr15\min34}{\version1}{\edmins0}{\nofpages3}{\nofwords1169}{\nofchars6668}{\nofcharsws7822}{\vern57427}} +{\*\xmlnstbl {\xmlns1 http://schemas.microsoft.com/office/word/2003/wordml}}\paperw12240\paperh15840\margl1440\margr1440\margt1440\margb1440\gutter0\ltrsect +\widowctrl\ftnbj\aenddoc\trackmoves0\trackformatting1\donotembedsysfont1\relyonvml0\donotembedlingdata0\grfdocevents0\validatexml1\showplaceholdtext0\ignoremixedcontent0\saveinvalidxml0\showxmlerrors1\noxlattoyen +\expshrtn\noultrlspc\dntblnsbdb\nospaceforul\formshade\horzdoc\dgmargin\dghspace180\dgvspace180\dghorigin1440\dgvorigin1440\dghshow1\dgvshow1 +\jexpand\viewkind1\viewscale100\pgbrdrhead\pgbrdrfoot\splytwnine\ftnlytwnine\htmautsp\nolnhtadjtbl\useltbaln\alntblind\lytcalctblwd\lyttblrtgr\lnbrkrule\nobrkwrptbl\viewnobound1\snaptogridincell\rempersonalinfo +\allowfieldendsel\wrppunct\asianbrkrule\rsidroot11363863\newtblstyruls\nogrowautofit\remdttm\usenormstyforlist\noindnmbrts\felnbrelev\nocxsptable\indrlsweleven\noafcnsttbl\afelev\utinl\hwelev\spltpgpar +\notcvasp\notbrkcnstfrctbl\notvatxbx\krnprsnet\cachedcolbal \nouicompat \fet0{\*\wgrffmtfilter 2450}\nofeaturethrottle1\ilfomacatclnup0{\*\ftnsep \ltrpar \pard\plain \ltrpar +\ql \li0\ri0\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid160711 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 \fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af41 +\ltrch\fcs0 \insrsid11675240 \chftnsep +\par }}{\*\ftnsepc \ltrpar \pard\plain \ltrpar\ql \li0\ri0\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid160711 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 +\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af41 \ltrch\fcs0 \insrsid11675240 \chftnsepc +\par }}{\*\aftnsep \ltrpar \pard\plain \ltrpar\ql \li0\ri0\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid160711 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 +\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af41 \ltrch\fcs0 \insrsid11675240 \chftnsep +\par }}{\*\aftnsepc \ltrpar \pard\plain \ltrpar\ql \li0\ri0\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid160711 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 +\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af41 \ltrch\fcs0 \insrsid11675240 \chftnsepc +\par }}\ltrpar \sectd \ltrsect\linex0\endnhere\sectlinegrid360\sectdefaultcl\sftnbj {\headerl \ltrpar \pard\plain \ltrpar\s42\ql \li0\ri0\widctlpar\tqc\tx4680\tqr\tx9360\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 +\af41\afs19\alang1025 \ltrch\fcs0 \fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af41 \ltrch\fcs0 \insrsid160711 +\par }}{\headerr \ltrpar \pard\plain \ltrpar\s42\ql \li0\ri0\widctlpar\tqc\tx4680\tqr\tx9360\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 +\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af41 \ltrch\fcs0 \insrsid160711 +\par }}{\footerl \ltrpar \pard\plain \ltrpar\s44\ql \li0\ri0\widctlpar\tqc\tx4680\tqr\tx9360\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 +\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af41 \ltrch\fcs0 \insrsid160711 +\par }}{\footerr \ltrpar \pard\plain \ltrpar\s44\ql \li0\ri0\widctlpar\tqc\tx4680\tqr\tx9360\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 +\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af41 \ltrch\fcs0 \insrsid160711 +\par }}{\headerf \ltrpar \pard\plain \ltrpar\s42\ql \li0\ri0\widctlpar\tqc\tx4680\tqr\tx9360\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 +\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af41 \ltrch\fcs0 \insrsid160711 +\par }}{\footerf \ltrpar \pard\plain \ltrpar\s44\ql \li0\ri0\widctlpar\tqc\tx4680\tqr\tx9360\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 +\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af41 \ltrch\fcs0 \insrsid160711 +\par }}{\*\pnseclvl1\pnucrm\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl2\pnucltr\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl3\pndec\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl4\pnlcltr\pnstart1\pnindent720\pnhang {\pntxta )}} +{\*\pnseclvl5\pndec\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl6\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl7\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl8 +\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl9\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}\pard\plain \ltrpar +\s27\ql \li0\ri0\sb120\sa120\nowidctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid11363863 \rtlch\fcs1 \ab\af41\afs28\alang1025 \ltrch\fcs0 +\b\fs28\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 MICROSOFT PRE-RELEASE SOFTWARE LICENSE TERMS +\par }\pard \ltrpar\s27\ql \li0\ri0\sb120\sa120\nowidctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid10182339 {\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 MICROSOFT }{ +\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid5065081\charrsid5065081 \hich\af41\dbch\af13\loch\f41 S}{\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid10182339 \hich\af41\dbch\af13\loch\f41 YSTEM.COLLECTIONS.}{\rtlch\fcs1 +\af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid2964340 \hich\af41\dbch\af13\loch\f41 I}{\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid5065081 \hich\af41\dbch\af13\loch\f41 MMUTABLE}{\rtlch\fcs1 \af41\afs21 \ltrch\fcs0 +\fs21\dbch\af0\insrsid10182339\charrsid10182339 +\par }\pard\plain \ltrpar\s28\ql \li0\ri0\sb120\sa120\nowidctlpar\brdrb\brdrs\brdrw10\brsp20 \wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid5065081 \rtlch\fcs1 \ab\af41\afs28\alang1025 \ltrch\fcs0 +\b\fs28\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 +\par }\pard\plain \ltrpar\s29\ql \li0\ri0\sb120\sa120\nowidctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid11363863 \rtlch\fcs1 \ab\af41\afs19\alang1025 \ltrch\fcs0 +\b\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab0\af41\afs20 \ltrch\fcs0 \b0\fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 +These license terms are an agreement between Microsoft Corporation (or based on where you live, one of its affiliates) and you. Please read them. They apply to the pre-release software named above, which includes the media on which you received it, if any +.\hich\af41\dbch\af13\loch\f41 The terms also apply to any Microsoft +\par {\listtext\pard\plain\ltrpar \s25 \rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\loch\af3\hich\af3\dbch\af13\insrsid11363863 \loch\af3\dbch\af13\hich\f3 \'b7\tab}}\pard\plain \ltrpar\s25\ql \fi-360\li360\ri0\sb120\sa120\nowidctlpar +\jclisttab\tx360\wrapdefault\aspalpha\aspnum\faauto\ls1\adjustright\rin0\lin360\itap0\pararsid11363863 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 \fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 +\af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 updates, +\par {\listtext\pard\plain\ltrpar \s25 \rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\loch\af3\hich\af3\dbch\af13\insrsid11363863 \loch\af3\dbch\af13\hich\f3 \'b7\tab}\hich\af41\dbch\af13\loch\f41 supplements, +\par {\listtext\pard\plain\ltrpar \s25 \rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\loch\af3\hich\af3\dbch\af13\insrsid11363863 \loch\af3\dbch\af13\hich\f3 \'b7\tab}\hich\af41\dbch\af13\loch\f41 Internet-based services, and +\par {\listtext\pard\plain\ltrpar \s25 \rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\loch\af3\hich\af3\dbch\af13\insrsid11363863 \loch\af3\dbch\af13\hich\f3 \'b7\tab}\hich\af41\dbch\af13\loch\f41 support services +\par }\pard\plain \ltrpar\s29\ql \li0\ri0\sb120\sa120\nowidctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid11363863 \rtlch\fcs1 \ab\af41\afs19\alang1025 \ltrch\fcs0 +\b\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab0\af41\afs20 \ltrch\fcs0 \b0\fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 +for this software, unless other terms accompany those items. If so, those terms apply. +\par }{\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 BY USING THE SOFTWARE, YOU ACCEPT THESE TERMS. IF YOU \hich\af41\dbch\af13\loch\f41 DO NOT ACCEPT THEM, DO NOT USE THE SOFTWARE. +\par }\pard\plain \ltrpar\s30\ql \li0\ri0\sb120\sa120\nowidctlpar\brdrt\brdrs\brdrw10\brsp20 \wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid11363863 \rtlch\fcs1 \ab\af41\afs19\alang1025 \ltrch\fcs0 +\b\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 If you comply with these license terms, you have the rights below. + +\par {\listtext\pard\plain\ltrpar \s1 \rtlch\fcs1 \ab\af41\afs20 \ltrch\fcs0 \b\fs20\loch\af41\hich\af41\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 1.\tab}}\pard\plain \ltrpar\s1\ql \fi-357\li357\ri0\sb120\sa120\nowidctlpar +\jclisttab\tx360\wrapdefault\aspalpha\aspnum\faauto\ls3\outlinelevel0\adjustright\rin0\lin357\itap0\pararsid11363863 \rtlch\fcs1 \ab\af41\afs19\alang1025 \ltrch\fcs0 \b\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 { +\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 INSTALLATION AND USE RIGHTS. }{\rtlch\fcs1 \ab0\af41\afs20 \ltrch\fcs0 \b0\fs20\dbch\af13\insrsid11363863 +\par {\listtext\pard\plain\ltrpar \s26 \rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\loch\af3\hich\af3\dbch\af13\insrsid11363863 \loch\af3\dbch\af13\hich\f3 \'b7\tab}}\pard\plain \ltrpar\s26\ql \fi-357\li720\ri0\sb120\sa120\nowidctlpar +\jclisttab\tx720\wrapdefault\aspalpha\aspnum\faauto\ls2\adjustright\rin0\lin720\itap0\pararsid11363863 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 \fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 +\af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 You may install and use any number of copies of the software on your premises to design, develop and test you\hich\af41\dbch\af13\loch\f41 +r programs for use with the software. +\par {\listtext\pard\plain\ltrpar \s26 \rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\loch\af3\hich\af3\dbch\af13\insrsid5065081 \loch\af3\dbch\af13\hich\f3 \'b7\tab}}{\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid5065081 \hich\af41\dbch\af13\loch\f41 +Evaluation Only. }{\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 You may not test }{\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid5065081 \hich\af41\dbch\af13\loch\f41 or deploy }{ +\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 the software in a live operating environment unless Microsoft permits you to do so under another agreement. +\par {\listtext\pard\plain\ltrpar \s1 \rtlch\fcs1 \ab\af41\afs20 \ltrch\fcs0 \b\fs20\loch\af41\hich\af41\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 2.\tab}}\pard\plain \ltrpar\s1\ql \fi-357\li357\ri0\sb120\sa120\nowidctlpar +\jclisttab\tx360\wrapdefault\aspalpha\aspnum\faauto\ls3\outlinelevel0\adjustright\rin0\lin357\itap0\pararsid11363863 \rtlch\fcs1 \ab\af41\afs19\alang1025 \ltrch\fcs0 \b\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 { +\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 PRE-RELEASE SOFTWARE. }{\rtlch\fcs1 \ab0\af41\afs20 \ltrch\fcs0 \b0\fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 +This software is a pre-release versio\hich\af41\dbch\af13\loch\f41 n. It may not work the way a final version of the software will. We may change it for the final, commercial version. We also may not release a commercial version. +\par {\listtext\pard\plain\ltrpar \s1 \rtlch\fcs1 \ab\af41\afs20 \ltrch\fcs0 \b\fs20\loch\af41\hich\af41\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 3.\tab}}{\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 +\hich\af41\dbch\af13\loch\f41 FEEDBACK. }{\rtlch\fcs1 \ab0\af41\afs20 \ltrch\fcs0 \b0\fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 If you give feedback about the software to Microsoft, you give to Microsoft, wit +\hich\af41\dbch\af13\loch\f41 +hout charge, the right to use, share and commercialize your feedback in any way and for any purpose. You also give to third parties, without charge, any patent rights needed for their products, technologies and services to use or interface with any specif +\hich\af41\dbch\af13\loch\f41 i\hich\af41\dbch\af13\loch\f41 +c parts of a Microsoft software or service that includes the feedback. You will not give feedback that is subject to a license that requires Microsoft to license its software or documentation to third parties because we include your feedback in them. Thes +\hich\af41\dbch\af13\loch\f41 e\hich\af41\dbch\af13\loch\f41 rights survive this agreement. +\par {\listtext\pard\plain\ltrpar \s1 \rtlch\fcs1 \ab\af41\afs20 \ltrch\fcs0 \b\fs20\loch\af41\hich\af41\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 4.\tab}}{\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 +\hich\af41\dbch\af13\loch\f41 SCOPE OF LICENSE.}{\rtlch\fcs1 \ab0\af41\afs20 \ltrch\fcs0 \b0\fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 + The software is licensed, not sold. This agreement only gives you some rights to use the software. Microsoft reserves all other rights. Unless applicable law gives you more rights despite this limitation\hich\af41\dbch\af13\loch\f41 +, you may use the software only as expressly permitted in this agreement. In doing so, you must comply with any technical limitations in the software that only allow you to use it in certain ways. You may not +\par {\listtext\pard\plain\ltrpar \s25 \rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\loch\af3\hich\af3\dbch\af13\insrsid11363863 \loch\af3\dbch\af13\hich\f3 \'b7\tab}}\pard\plain \ltrpar\s25\ql \fi-363\li720\ri0\sb120\sa120\nowidctlpar +\jclisttab\tx720\wrapdefault\aspalpha\aspnum\faauto\ls1\adjustright\rin0\lin720\itap0\pararsid11363863 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 \fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 +\af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 work around any technical limitations in the \hich\af41\dbch\af13\loch\f41 software; +\par {\listtext\pard\plain\ltrpar \s25 \rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\loch\af3\hich\af3\dbch\af13\insrsid11363863 \loch\af3\dbch\af13\hich\f3 \'b7\tab}\hich\af41\dbch\af13\loch\f41 +reverse engineer, decompile or disassemble the software, except and only to the extent that applicable law expressly permits, despite this limitation; +\par {\listtext\pard\plain\ltrpar \s25 \rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\loch\af3\hich\af3\dbch\af13\insrsid11363863 \loch\af3\dbch\af13\hich\f3 \'b7\tab}\hich\af41\dbch\af13\loch\f41 make more copies of the softw\hich\af41\dbch\af13\loch\f41 +are than specified in this agreement or allowed by applicable law, despite this limitation; +\par {\listtext\pard\plain\ltrpar \s25 \rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\loch\af3\hich\af3\dbch\af13\insrsid11363863 \loch\af3\dbch\af13\hich\f3 \'b7\tab}\hich\af41\dbch\af13\loch\f41 publish the software for others to copy; +\par {\listtext\pard\plain\ltrpar \s25 \rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\loch\af3\hich\af3\dbch\af13\insrsid11363863 \loch\af3\dbch\af13\hich\f3 \'b7\tab}\hich\af41\dbch\af13\loch\f41 rent, lease or lend the software; +\par {\listtext\pard\plain\ltrpar \s25 \rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\loch\af3\hich\af3\dbch\af13\insrsid11363863 \loch\af3\dbch\af13\hich\f3 \'b7\tab}\hich\af41\dbch\af13\loch\f41 transfer the software or this agreement to any third party; or + +\par {\listtext\pard\plain\ltrpar \s25 \rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\loch\af3\hich\af3\dbch\af13\insrsid11363863 \loch\af3\dbch\af13\hich\f3 \'b7\tab}\hich\af41\dbch\af13\loch\f41 use\hich\af41\dbch\af13\loch\f41 + the software for commercial software hosting services. +\par {\listtext\pard\plain\ltrpar \s1 \rtlch\fcs1 \ab\af41\afs20 \ltrch\fcs0 \b\fs20\loch\af41\hich\af41\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 5.\tab}}\pard\plain \ltrpar\s1\ql \fi-357\li357\ri0\sb120\sa120\nowidctlpar +\jclisttab\tx360\wrapdefault\aspalpha\aspnum\faauto\ls3\outlinelevel0\adjustright\rin0\lin357\itap0\pararsid11363863 \rtlch\fcs1 \ab\af41\afs19\alang1025 \ltrch\fcs0 \b\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 { +\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 EXPORT RESTRICTIONS.}{\rtlch\fcs1 \ab0\af41\afs20 \ltrch\fcs0 \b0\fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 + The software is subject to United States export laws and regulations. You must comply with all domestic and international export laws and regulations that apply to the software\hich\af41\dbch\af13\loch\f41 +. These laws include restrictions on destinations, end users and end use. For additional information, see }{\rtlch\fcs1 \ab0\af0\afs20 \ltrch\fcs0 \cs31\b0\fs20\ul\cf2\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 www.microsoft.com/exporting}{ +\rtlch\fcs1 \ab0\af41\afs20 \ltrch\fcs0 \b0\fs20\dbch\af13\insrsid11363863 .}{\rtlch\fcs1 \ab0\af0\afs20 \ltrch\fcs0 \cs31\b0\fs20\ul\cf2\dbch\af13\insrsid11363863 +\par {\listtext\pard\plain\ltrpar \s1 \rtlch\fcs1 \ab\af41\afs20 \ltrch\fcs0 \b\fs20\loch\af41\hich\af41\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 6.\tab}}{\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 +\hich\af41\dbch\af13\loch\f41 SUPPORT SERVICES. }{\rtlch\fcs1 \ab0\af41\afs20 \ltrch\fcs0 \b0\fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 \hich\f41 Because this software is \'93\loch\f41 \hich\f41 as is,\'94\loch\f41 + we may not provide support services for it. +\par {\listtext\pard\plain\ltrpar \s1 \rtlch\fcs1 \ab\af41\afs20 \ltrch\fcs0 \b\fs20\loch\af41\hich\af41\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 7.\tab}}{\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 +\hich\af41\dbch\af13\loch\f41 ENTIRE AGREEMENT.}{\rtlch\fcs1 \ab0\af41\afs20 \ltrch\fcs0 \b0\fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 T\hich\af41\dbch\af13\loch\f41 +his agreement, and the terms for supplements, updates, Internet-based services and support services that you use, are the entire agreement for the software and support services. +\par {\listtext\pard\plain\ltrpar \s1 \rtlch\fcs1 \ab\af41\afs20 \ltrch\fcs0 \b\fs20\loch\af41\hich\af41\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 8.\tab}}\pard \ltrpar\s1\ql \fi-360\li360\ri0\sb120\sa120\nowidctlpar +\jclisttab\tx360\wrapdefault\aspalpha\aspnum\faauto\ls3\outlinelevel0\adjustright\rin0\lin360\itap0\pararsid11363863 {\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 APPLICABLE LAW. +\par {\listtext\pard\plain\ltrpar \s2 \rtlch\fcs1 \ab\af41\afs20 \ltrch\fcs0 \b\fs20\loch\af41\hich\af41\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 a.\tab}}\pard\plain \ltrpar\s2\ql \fi-363\li720\ri0\sb120\sa120\nowidctlpar +\jclisttab\tx720\wrapdefault\aspalpha\aspnum\faauto\ls3\ilvl1\outlinelevel1\adjustright\rin0\lin720\itap0\pararsid11363863 \rtlch\fcs1 \ab\af41\afs19\alang1025 \ltrch\fcs0 +\b\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 United States.}{\rtlch\fcs1 \ab0\af41\afs20 \ltrch\fcs0 +\b0\fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 If you acquired the software in the Unite\hich\af41\dbch\af13\loch\f41 +d States, Washington state law governs the interpretation of this agreement and applies to claims for breach of it, regardless of conflict of laws principles. The laws of the state where you live govern all other claims, including claims under state consu +\hich\af41\dbch\af13\loch\f41 m\hich\af41\dbch\af13\loch\f41 er protection laws, unfair competition laws, and in tort. +\par {\listtext\pard\plain\ltrpar \s2 \rtlch\fcs1 \ab\af41\afs20 \ltrch\fcs0 \b\fs20\loch\af41\hich\af41\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 b.\tab}}{\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 +\hich\af41\dbch\af13\loch\f41 Outside the United States.}{\rtlch\fcs1 \ab0\af41\afs20 \ltrch\fcs0 \b0\fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 If you acquired the software in any other country, the laws of that country apply. +\par {\listtext\pard\plain\ltrpar \s1 \rtlch\fcs1 \ab\af41\afs20 \ltrch\fcs0 \b\fs20\loch\af41\hich\af41\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 9.\tab}}\pard\plain \ltrpar\s1\ql \fi-357\li357\ri0\sb120\sa120\nowidctlpar +\jclisttab\tx360\wrapdefault\aspalpha\aspnum\faauto\ls3\outlinelevel0\adjustright\rin0\lin357\itap0\pararsid11363863 \rtlch\fcs1 \ab\af41\afs19\alang1025 \ltrch\fcs0 \b\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 { +\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 LEGAL EFFECT.}{\rtlch\fcs1 \ab0\af41\afs20 \ltrch\fcs0 \b0\fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 + This agreement describes certain legal rights. You may have other ri\hich\af41\dbch\af13\loch\f41 +ghts under the laws of your country. You may also have rights with respect to the party from whom you acquired the software. This agreement does not change your rights under the laws of your country if the laws of your country do not permit it to do so. + +\par {\listtext\pard\plain\ltrpar \s1 \rtlch\fcs1 \ab\af41\afs20 \ltrch\fcs0 \b\fs20\loch\af41\hich\af41\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 10.\tab}}\pard \ltrpar\s1\ql \fi-357\li357\ri0\sb120\sa120\widctlpar +\jclisttab\tx360\wrapdefault\aspalpha\aspnum\faauto\ls3\outlinelevel0\adjustright\rin0\lin357\itap0\pararsid11363863 {\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 \hich\f41 +DISCLAIMER OF WARRANTY. THE SOFTWARE IS LICENSED \'93\loch\f41 \hich\f41 AS-IS.\'94\loch\f41 + YOU BEAR THE RISK OF USING IT. MICROSOFT GIVES NO EXPRESS WARRANTIES, GUARANTEES OR CONDITIONS. YOU MAY HAVE ADDITIONAL CONSUMER RIGHTS UNDER YOUR LOCAL LAWS WHICH THIS AGREEMENT CANNOT CHANGE. TO\hich\af41\dbch\af13\loch\f41 + THE EXTENT PERMITTED UNDER YOUR LOCAL LAWS, MICROSOFT EXCLUDES THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. +\par }\pard \ltrpar\s1\ql \li357\ri0\sb120\sa120\widctlpar\wrapdefault\aspalpha\aspnum\faauto\outlinelevel0\adjustright\rin0\lin357\itap0\pararsid5065081 {\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid5065081 \hich\af41\dbch\af13\loch\f41 +FOR AUSTRALIA \hich\f41 \endash \loch\f41 YOU HAVE STATUTORY GUARANTEES UNDER THE AUSTRALIAN CONSUMER LAW AND NOTHING IN\hich\af41\dbch\af13\loch\f41 THESE TERMS IS INTENDED TO AFFECT THOSE RIGHTS. +\par {\listtext\pard\plain\ltrpar \s1 \rtlch\fcs1 \ab\af41\afs20 \ltrch\fcs0 \b\fs20\loch\af41\hich\af41\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 11.\tab}}\pard \ltrpar\s1\ql \fi-357\li357\ri0\sb120\sa120\widctlpar +\jclisttab\tx360\wrapdefault\aspalpha\aspnum\faauto\ls3\outlinelevel0\adjustright\rin0\lin357\itap0\pararsid11363863 {\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 +LIMITATION ON AND EXCLUSION OF REMEDIES AND DAMAGES}{\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\insrsid11363863 \hich\af41\dbch\af11\loch\f41 +. YOU CAN RECOVER FROM MICROSOFT AND ITS SUPPLIERS ONLY DIRECT DAMAGES UP TO U.S. $5.00. YOU CANNOT RECOVER ANY OTHER DAMAGES, INCLUDING CONSEQUENTIAL, \hich\af41\dbch\af11\loch\f41 LOST PROFITS, SPECIAL, INDIRECT OR INCIDENTAL DAMAGES. +\par }\pard\plain \ltrpar\s24\ql \li357\ri0\sb120\sa120\nowidctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin357\itap0\pararsid11363863 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 +\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 This limitation applies to +\par {\listtext\pard\plain\ltrpar \s25 \rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\loch\af3\hich\af3\dbch\af13\insrsid11363863 \loch\af3\dbch\af13\hich\f3 \'b7\tab}}\pard\plain \ltrpar\s25\ql \fi-363\li720\ri0\sb120\sa120\nowidctlpar +\jclisttab\tx720\wrapdefault\aspalpha\aspnum\faauto\ls1\adjustright\rin0\lin720\itap0\pararsid11363863 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 \fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 +\af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 anything related to the software, services, content (including code) on third party Internet sites, or third party programs; and +\par {\listtext\pard\plain\ltrpar \s25 \rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\loch\af3\hich\af3\dbch\af13\insrsid11363863 \loch\af3\dbch\af13\hich\f3 \'b7\tab}\hich\af41\dbch\af13\loch\f41 claims for breach of contract, breach of +\hich\af41\dbch\af13\loch\f41 warranty, guarantee or condition, strict liability, negligence, or other tort to the extent permitted by applicable law. +\par }\pard\plain \ltrpar\ql \li360\ri0\sb120\sa120\nowidctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin360\itap0\pararsid11363863 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 +\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 +It also applies even if Microsoft knew or should have known about the possibility of the damages. The above limitation or exclusion may\hich\af41\dbch\af13\loch\f41 + not apply to you because your country may not allow the exclusion or limitation of incidental, consequential or other damages. +\par }\pard\plain \ltrpar\s32\ql \li0\ri0\sb120\sa120\nowidctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid11363863 \rtlch\fcs1 \ab\af41\afs19\alang1025 \ltrch\fcs0 +\b\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 +Please note: As this software is distributed in Quebec, Canada, some of the clauses in this agreement are provided below in Fren\hich\af41\dbch\af13\loch\f41 ch. +\par }{\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\lang1036\langfe1033\dbch\af13\langnp1036\insrsid11363863 \hich\af41\dbch\af13\loch\f41 \hich\f41 Remarque : Ce logiciel \'e9\loch\f41 \hich\f41 tant distribu\'e9\loch\f41 \hich\f41 au Qu\'e9\loch\f41 \hich\f41 +bec, Canada, certaines des clauses dans ce contrat sont fournies ci-dessous en fran\'e7\loch\f41 ais. +\par }\pard\plain \ltrpar\s33\ql \li0\ri0\sb120\sa120\nowidctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid11363863 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 +\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af41\afs20 \ltrch\fcs0 \b\fs20\lang1036\langfe1033\dbch\af13\langnp1036\insrsid11363863 \hich\af41\dbch\af13\loch\f41 \hich\f41 EXON\'c9\loch\f41 +RATION DE GARANTIE.}{\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\lang1036\langfe1033\dbch\af13\langnp1036\insrsid11363863 \hich\af41\dbch\af13\loch\f41 \hich\f41 Le logiciel vis\'e9\loch\f41 \hich\f41 par une licence est offert \'ab\loch\f41 \hich\f41 + tel quel \'bb\loch\f41 . Toute utilisation de ce logiciel es\hich\af41\dbch\af13\loch\f41 \hich\f41 t \'e0\loch\f41 \hich\f41 votre seule risque et p\'e9\loch\f41 ril. Microsoft n\hich\f41 \rquote \loch\f41 \hich\f41 +accorde aucune autre garantie expresse. Vous pouvez b\'e9\loch\f41 \hich\f41 n\'e9\loch\f41 ficier de droits additionnels en vertu du droit local sur la protection des consommateurs, que ce contrat ne peut modifier. La ou elles sont permises par +\hich\af41\dbch\af13\loch\f41 l\hich\af41\dbch\af13\loch\f41 \hich\f41 e droit locale, les garanties implicites de qualit\'e9\loch\f41 marchande, d\hich\f41 \rquote \loch\f41 \hich\f41 ad\'e9\loch\f41 \hich\f41 quation \'e0\loch\f41 + un usage particulier et d\hich\f41 \rquote \loch\f41 \hich\f41 absence de contrefa\'e7\loch\f41 on sont exclues. +\par }{\rtlch\fcs1 \ab\af41\afs20 \ltrch\fcs0 \b\fs20\lang1036\langfe1033\dbch\af13\langnp1036\insrsid11363863 \hich\af41\dbch\af13\loch\f41 \hich\f41 LIMITATION DES DOMMAGES-INT\'c9\loch\f41 \hich\f41 R\'ca\loch\f41 \hich\f41 TS ET EXCLUSION DE RESPONSABILIT +\'c9\loch\f41 POUR LES DOMMAGES.}{\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\lang1036\langfe1033\dbch\af13\langnp1036\insrsid11363863 \hich\af41\dbch\af13\loch\f41 \hich\f41 + Vous pouvez obtenir de Microsoft et de ses fournisseurs une indemnisation en cas de dommages directs uniquement \'e0\loch\f41 \hich\f41 hauteur de 5,00 $ US. Vous ne pouvez pr\'e9\loch\f41 \hich\f41 tendre \'e0\loch\f41 \hich\f41 + aucune indemnisation pour les autres dommages, y compris les dommages sp\'e9\loch\f41 ciaux, indirects o\hich\af41\dbch\af13\loch\f41 u\hich\af41\dbch\af13\loch\f41 \hich\f41 accessoires et pertes de b\'e9\loch\f41 \hich\f41 n\'e9\loch\f41 fices. +\par }{\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\dbch\af13\insrsid11363863 \hich\af41\dbch\af13\loch\f41 Cette limitation concerne : +\par {\listtext\pard\plain\ltrpar \s25 \rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\lang1036\langfe1033\loch\af3\hich\af3\dbch\af13\langnp1036\insrsid11363863 \loch\af3\dbch\af13\hich\f3 \'b7\tab}}\pard\plain \ltrpar +\s25\ql \fi-360\li360\ri0\sb120\sa120\nowidctlpar\jclisttab\tx360\wrapdefault\aspalpha\aspnum\faauto\ls1\adjustright\rin0\lin360\itap0\pararsid11363863 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 +\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\lang1036\langfe1033\dbch\af13\langnp1036\insrsid11363863 \hich\af41\dbch\af13\loch\f41 \hich\f41 tout ce qui est reli\'e9 +\loch\f41 au logiciel, aux services ou au contenu (y compris le code) figurant sur des sites Internet tiers ou dans des programmes tiers ; et +\par {\listtext\pard\plain\ltrpar \s25 \rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\lang1036\langfe1033\loch\af3\hich\af3\dbch\af13\langnp1036\insrsid11363863 \loch\af3\dbch\af13\hich\f3 \'b7\tab}\hich\af41\dbch\af13\loch\f41 \hich\f41 les r\'e9 +\hich\af41\dbch\af13\loch\f41 \hich\f41 clamations au titre de violation de contrat ou de garantie, ou au titre de responsabilit\'e9\loch\f41 \hich\f41 stricte, de n\'e9\loch\f41 gligence ou d\hich\f41 \rquote \loch\f41 \hich\f41 +une autre faute dans la limite autoris\'e9\loch\f41 e par la loi en vigueur. +\par }\pard\plain \ltrpar\s33\ql \li0\ri0\sb120\sa120\nowidctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid11363863 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 +\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af41\afs20 \ltrch\fcs0 \fs20\lang1036\langfe1033\dbch\af13\langnp1036\insrsid11363863 \hich\af41\dbch\af13\loch\f41 Elle s\hich\f41 \rquote \loch\f41 +\hich\f41 applique \'e9\loch\f41 \hich\f41 galement, m\'ea\loch\f41 \hich\f41 me si Microsoft connaissait ou devrait conna\'ee\hich\af41\dbch\af13\loch\f41 tre l\hich\f41 \rquote \'e9\loch\f41 \hich\f41 ventualit\'e9\loch\f41 d\hich\f41 \rquote +\loch\f41 un tel dommage. Si votre pays n\hich\f41 \rquote \loch\f41 autorise pas l\hich\f41 \rquote \loch\f41 \hich\f41 exclusion ou la limitation de responsabilit\'e9\loch\f41 + pour les dommages indirects, accessoires ou de quelque nature que ce soit, il se peut que la limitation ou l\hich\f41 \rquote \loch\f41 exclusion ci-dessus ne s\hich\f41 \rquote \loch\f41 appliquer\hich\af41\dbch\af13\loch\f41 a +\hich\af41\dbch\af13\loch\f41 \hich\f41 pas \'e0\loch\f41 \hich\f41 votre \'e9\loch\f41 gard. +\par }\pard\plain \ltrpar\ql \li0\ri0\sb120\sa120\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid11363863 \rtlch\fcs1 \af41\afs19\alang1025 \ltrch\fcs0 +\fs19\lang1033\langfe1033\loch\af41\hich\af41\dbch\af11\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af41\afs20 \ltrch\fcs0 \b\fs20\lang1036\langfe1033\dbch\af13\langnp1036\insrsid11363863 \hich\af41\dbch\af13\loch\f41 EFFET JURIDIQUE.}{\rtlch\fcs1 +\af41\afs20 \ltrch\fcs0 \fs20\lang1036\langfe1033\dbch\af13\langnp1036\insrsid11363863 \hich\af41\dbch\af13\loch\f41 \hich\f41 Le pr\'e9\loch\f41 \hich\f41 sent contrat d\'e9\loch\f41 crit certains droits juridiques. Vous pourriez avoir d\hich\f41 +\rquote \loch\f41 \hich\f41 autres droits pr\'e9\loch\f41 \hich\f41 vus par les lois de votre pays. Le pr\'e9\loch\f41 \hich\f41 sent contrat ne modifie pas les droits que vous conf\'e8\loch\f41 rent les lois de votre pays si cell +\hich\af41\dbch\af13\loch\f41 es-ci ne le permettent pas.}{\rtlch\fcs1 \af41 \ltrch\fcs0 \insrsid4000782 +\par }{\*\themedata 504b030414000600080000002100e9de0fbfff0000001c020000130000005b436f6e74656e745f54797065735d2e786d6cac91cb4ec3301045f748fc83e52d4a +9cb2400825e982c78ec7a27cc0c8992416c9d8b2a755fbf74cd25442a820166c2cd933f79e3be372bd1f07b5c3989ca74aaff2422b24eb1b475da5df374fd9ad +5689811a183c61a50f98f4babebc2837878049899a52a57be670674cb23d8e90721f90a4d2fa3802cb35762680fd800ecd7551dc18eb899138e3c943d7e503b6 +b01d583deee5f99824e290b4ba3f364eac4a430883b3c092d4eca8f946c916422ecab927f52ea42b89a1cd59c254f919b0e85e6535d135a8de20f20b8c12c3b0 +0c895fcf6720192de6bf3b9e89ecdbd6596cbcdd8eb28e7c365ecc4ec1ff1460f53fe813d3cc7f5b7f020000ffff0300504b030414000600080000002100a5d6 +a7e7c0000000360100000b0000005f72656c732f2e72656c73848fcf6ac3300c87ef85bd83d17d51d2c31825762fa590432fa37d00e1287f68221bdb1bebdb4f +c7060abb0884a4eff7a93dfeae8bf9e194e720169aaa06c3e2433fcb68e1763dbf7f82c985a4a725085b787086a37bdbb55fbc50d1a33ccd311ba548b6309512 +0f88d94fbc52ae4264d1c910d24a45db3462247fa791715fd71f989e19e0364cd3f51652d73760ae8fa8c9ffb3c330cc9e4fc17faf2ce545046e37944c69e462 +a1a82fe353bd90a865aad41ed0b5b8f9d6fd010000ffff0300504b0304140006000800000021006b799616830000008a0000001c0000007468656d652f746865 +6d652f7468656d654d616e616765722e786d6c0ccc4d0ac3201040e17da17790d93763bb284562b2cbaebbf600439c1a41c7a0d29fdbd7e5e38337cedf14d59b +4b0d592c9c070d8a65cd2e88b7f07c2ca71ba8da481cc52c6ce1c715e6e97818c9b48d13df49c873517d23d59085adb5dd20d6b52bd521ef2cdd5eb9246a3d8b +4757e8d3f729e245eb2b260a0238fd010000ffff0300504b03041400060008000000210030dd4329a8060000a41b0000160000007468656d652f7468656d652f +7468656d65312e786d6cec594f6fdb3614bf0fd87720746f6327761a07758ad8b19b2d4d1bc46e871e698996d850a240d2497d1bdae38001c3ba618715d86d87 +615b8116d8a5fb34d93a6c1dd0afb0475292c5585e9236d88aad3e2412f9e3fbff1e1fa9abd7eec70c1d1221294fda5efd72cd4324f1794093b0eddd1ef62fad +79482a9c0498f184b4bd2991deb58df7dfbb8ad755446282607d22d771db8b944ad79796a40fc3585ee62949606ecc458c15bc8a702910f808e8c66c69b9565b +5d8a314d3c94e018c8de1a8fa94fd05093f43672e23d06af89927ac06762a049136785c10607758d9053d965021d62d6f6804fc08f86e4bef210c352c144dbab +999fb7b4717509af678b985ab0b6b4ae6f7ed9ba6c4170b06c788a705430adf71bad2b5b057d03606a1ed7ebf5babd7a41cf00b0ef83a6569632cd467faddec9 +699640f6719e76b7d6ac355c7c89feca9cccad4ea7d36c65b258a206641f1b73f8b5da6a6373d9c11b90c537e7f08dce66b7bbeae00dc8e257e7f0fd2badd586 +8b37a088d1e4600ead1ddaef67d40bc898b3ed4af81ac0d76a197c86826828a24bb318f3442d8ab518dfe3a20f000d6458d104a9694ac6d88728eee2782428d6 +0cf03ac1a5193be4cbb921cd0b495fd054b5bd0f530c1931a3f7eaf9f7af9e3f45c70f9e1d3ff8e9f8e1c3e3073f5a42ceaa6d9c84e5552fbffdeccfc71fa33f +9e7ef3f2d117d57859c6fffac327bffcfc793510d26726ce8b2f9ffcf6ecc98baf3efdfdbb4715f04d814765f890c644a29be408edf3181433567125272371be +15c308d3f28acd249438c19a4b05fd9e8a1cf4cd296699771c393ac4b5e01d01e5a30a787d72cf1178108989a2159c77a2d801ee72ce3a5c545a6147f32a9979 +3849c26ae66252c6ed637c58c5bb8b13c7bfbd490a75330f4b47f16e441c31f7184e140e494214d273fc80900aedee52ead87597fa824b3e56e82e451d4c2b4d +32a423279a668bb6690c7e9956e90cfe766cb37b077538abd27a8b1cba48c80acc2a841f12e698f13a9e281c57911ce298950d7e03aba84ac8c154f8655c4f2a +f074481847bd804859b5e696007d4b4edfc150b12addbecba6b18b148a1e54d1bc81392f23b7f84137c2715a851dd0242a633f900710a218ed715505dfe56e86 +e877f0034e16bafb0e258ebb4faf06b769e888340b103d331115bebc4eb813bf83291b63624a0d1475a756c734f9bbc2cd28546ecbe1e20a3794ca175f3fae90 +fb6d2dd99bb07b55e5ccf68942bd0877b23c77b908e8db5f9db7f024d9239010f35bd4bbe2fcae387bfff9e2bc289f2fbe24cfaa301468dd8bd846dbb4ddf1c2 +ae7b4c191ba8292337a469bc25ec3d411f06f53a73e224c5292c8de0516732307070a1c0660d125c7d44553488700a4d7bddd3444299910e254ab984c3a219ae +a4adf1d0f82b7bd46cea4388ad1c12ab5d1ed8e1153d9c9f350a3246aad01c6873462b9ac05999ad5cc988826eafc3acae853a33b7ba11cd1445875ba1b236b1 +399483c90bd560b0b0263435085a21b0f22a9cf9356b38ec6046026d77eba3dc2dc60b17e92219e180643ed27acffba86e9c94c7ca9c225a0f1b0cfae0788ad5 +4adc5a9aec1b703b8b93caec1a0bd8e5de7b132fe5113cf312503b998e2c2927274bd051db6b35979b1ef271daf6c6704e86c73805af4bdd476216c26593af84 +0dfb5393d964f9cc9bad5c313709ea70f561ed3ea7b053075221d51696910d0d339585004b34272bff7213cc7a510a5454a3b349b1b206c1f0af490176745d4b +c663e2abb2b34b23da76f6352ba57ca2881844c1111ab189d8c7e07e1daaa04f40255c77988aa05fe06e4e5bdb4cb9c5394bbaf28d98c1d971ccd20867e556a7 +689ec9166e0a522183792b8907ba55ca6e943bbf2a26e52f48957218ffcf54d1fb09dc3eac04da033e5c0d0b8c74a6b43d2e54c4a10aa511f5fb021a07533b20 +5ae07e17a621a8e082dafc17e450ffb739676998b48643a4daa7211214f623150942f6a02c99e83b85583ddbbb2c4996113211551257a656ec1139246ca86be0 +aadedb3d1441a89b6a929501833b197fee7b9641a3503739e57c732a59b1f7da1cf8a73b1f9bcca0945b874d4393dbbf10b1680f66bbaa5d6f96e77b6f59113d +316bb31a795600b3d256d0cad2fe354538e7566b2bd69cc6cbcd5c38f0e2bcc63058344429dc2121fd07f63f2a7c66bf76e80d75c8f7a1b622f878a18941d840 +545fb28d07d205d20e8ea071b283369834296bdaac75d256cb37eb0bee740bbe278cad253b8bbfcf69eca23973d939b97891c6ce2cecd8da8e2d343578f6648a +c2d0383fc818c798cf64e52f597c740f1cbd05df0c264c49134cf09d4a60e8a107260f20f92d47b374e32f000000ffff0300504b030414000600080000002100 +0dd1909fb60000001b010000270000007468656d652f7468656d652f5f72656c732f7468656d654d616e616765722e786d6c2e72656c73848f4d0ac2301484f7 +8277086f6fd3ba109126dd88d0add40384e4350d363f2451eced0dae2c082e8761be9969bb979dc9136332de3168aa1a083ae995719ac16db8ec8e4052164e89 +d93b64b060828e6f37ed1567914b284d262452282e3198720e274a939cd08a54f980ae38a38f56e422a3a641c8bbd048f7757da0f19b017cc524bd62107bd500 +1996509affb3fd381a89672f1f165dfe514173d9850528a2c6cce0239baa4c04ca5bbabac4df000000ffff0300504b01022d0014000600080000002100e9de0f +bfff0000001c0200001300000000000000000000000000000000005b436f6e74656e745f54797065735d2e786d6c504b01022d0014000600080000002100a5d6 +a7e7c0000000360100000b00000000000000000000000000300100005f72656c732f2e72656c73504b01022d00140006000800000021006b799616830000008a +0000001c00000000000000000000000000190200007468656d652f7468656d652f7468656d654d616e616765722e786d6c504b01022d00140006000800000021 +0030dd4329a8060000a41b00001600000000000000000000000000d60200007468656d652f7468656d652f7468656d65312e786d6c504b01022d001400060008 +00000021000dd1909fb60000001b0100002700000000000000000000000000b20900007468656d652f7468656d652f5f72656c732f7468656d654d616e616765722e786d6c2e72656c73504b050600000000050005005d010000ad0a00000000} +{\*\colorschememapping 3c3f786d6c2076657273696f6e3d22312e302220656e636f64696e673d225554462d3822207374616e64616c6f6e653d22796573223f3e0d0a3c613a636c724d +617020786d6c6e733a613d22687474703a2f2f736368656d61732e6f70656e786d6c666f726d6174732e6f72672f64726177696e676d6c2f323030362f6d6169 +6e22206267313d226c743122207478313d22646b3122206267323d226c743222207478323d22646b322220616363656e74313d22616363656e74312220616363 +656e74323d22616363656e74322220616363656e74333d22616363656e74332220616363656e74343d22616363656e74342220616363656e74353d22616363656e74352220616363656e74363d22616363656e74362220686c696e6b3d22686c696e6b2220666f6c486c696e6b3d22666f6c486c696e6b222f3e} +{\*\latentstyles\lsdstimax371\lsdlockeddef0\lsdsemihiddendef0\lsdunhideuseddef0\lsdqformatdef0\lsdprioritydef99{\lsdlockedexcept \lsdqformat1 \lsdpriority0 \lsdlocked0 Normal;\lsdqformat1 \lsdlocked0 heading 1; +\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdlocked0 heading 2;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdlocked0 heading 3;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdlocked0 heading 4; +\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdlocked0 heading 5;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdlocked0 heading 6;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdlocked0 heading 7; +\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdlocked0 heading 8;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdlocked0 heading 9;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 2; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 5;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 6; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 7;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 8;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 9;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 1; +\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 2;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 3;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 4; +\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 5;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 6;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 7; +\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 8;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 9;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Normal Indent;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 footnote text; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 annotation text;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 header;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 footer;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index heading; +\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority35 \lsdlocked0 caption;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 table of figures;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 envelope address; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 envelope return;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 footnote reference;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 annotation reference;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 line number; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 page number;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 endnote reference;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 endnote text;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 table of authorities; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 macro;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 toa heading;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List 4; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List 5;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet 4; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet 5;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number 4; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number 5;\lsdqformat1 \lsdpriority10 \lsdlocked0 Title;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Closing;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Signature; +\lsdsemihidden1 \lsdunhideused1 \lsdpriority1 \lsdlocked0 Default Paragraph Font;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text Indent;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue 5; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Message Header;\lsdqformat1 \lsdpriority11 \lsdlocked0 Subtitle;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Salutation;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Date; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text First Indent;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text First Indent 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Note Heading;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text 2; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text Indent 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text Indent 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Block Text; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Hyperlink;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 FollowedHyperlink;\lsdqformat1 \lsdpriority22 \lsdlocked0 Strong;\lsdqformat1 \lsdpriority20 \lsdlocked0 Emphasis; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Document Map;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Plain Text;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 E-mail Signature;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Top of Form; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Bottom of Form;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Normal (Web);\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Acronym;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Address; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Cite;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Code;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Definition;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Keyboard; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Preformatted;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Sample;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Typewriter;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Variable; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 annotation subject;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 No List;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Outline List 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Outline List 2; +\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Outline List 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Balloon Text;\lsdpriority59 \lsdlocked0 Table Grid;\lsdsemihidden1 \lsdlocked0 Placeholder Text;\lsdqformat1 \lsdpriority1 \lsdlocked0 No Spacing; +\lsdpriority60 \lsdlocked0 Light Shading;\lsdpriority61 \lsdlocked0 Light List;\lsdpriority62 \lsdlocked0 Light Grid;\lsdpriority63 \lsdlocked0 Medium Shading 1;\lsdpriority64 \lsdlocked0 Medium Shading 2;\lsdpriority65 \lsdlocked0 Medium List 1; +\lsdpriority66 \lsdlocked0 Medium List 2;\lsdpriority67 \lsdlocked0 Medium Grid 1;\lsdpriority68 \lsdlocked0 Medium Grid 2;\lsdpriority69 \lsdlocked0 Medium Grid 3;\lsdpriority70 \lsdlocked0 Dark List;\lsdpriority71 \lsdlocked0 Colorful Shading; +\lsdpriority72 \lsdlocked0 Colorful List;\lsdpriority73 \lsdlocked0 Colorful Grid;\lsdpriority60 \lsdlocked0 Light Shading Accent 1;\lsdpriority61 \lsdlocked0 Light List Accent 1;\lsdpriority62 \lsdlocked0 Light Grid Accent 1; +\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 1;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 1;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 1;\lsdsemihidden1 \lsdlocked0 Revision;\lsdqformat1 \lsdpriority34 \lsdlocked0 List Paragraph; +\lsdqformat1 \lsdpriority29 \lsdlocked0 Quote;\lsdqformat1 \lsdpriority30 \lsdlocked0 Intense Quote;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 1;\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 1;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 1; +\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 1;\lsdpriority70 \lsdlocked0 Dark List Accent 1;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 1;\lsdpriority72 \lsdlocked0 Colorful List Accent 1;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 1; +\lsdpriority60 \lsdlocked0 Light Shading Accent 2;\lsdpriority61 \lsdlocked0 Light List Accent 2;\lsdpriority62 \lsdlocked0 Light Grid Accent 2;\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 2;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 2; +\lsdpriority65 \lsdlocked0 Medium List 1 Accent 2;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 2;\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 2;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 2;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 2; +\lsdpriority70 \lsdlocked0 Dark List Accent 2;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 2;\lsdpriority72 \lsdlocked0 Colorful List Accent 2;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 2;\lsdpriority60 \lsdlocked0 Light Shading Accent 3; +\lsdpriority61 \lsdlocked0 Light List Accent 3;\lsdpriority62 \lsdlocked0 Light Grid Accent 3;\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 3;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 3;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 3; +\lsdpriority66 \lsdlocked0 Medium List 2 Accent 3;\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 3;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 3;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 3;\lsdpriority70 \lsdlocked0 Dark List Accent 3; +\lsdpriority71 \lsdlocked0 Colorful Shading Accent 3;\lsdpriority72 \lsdlocked0 Colorful List Accent 3;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 3;\lsdpriority60 \lsdlocked0 Light Shading Accent 4;\lsdpriority61 \lsdlocked0 Light List Accent 4; +\lsdpriority62 \lsdlocked0 Light Grid Accent 4;\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 4;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 4;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 4;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 4; +\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 4;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 4;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 4;\lsdpriority70 \lsdlocked0 Dark List Accent 4;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 4; +\lsdpriority72 \lsdlocked0 Colorful List Accent 4;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 4;\lsdpriority60 \lsdlocked0 Light Shading Accent 5;\lsdpriority61 \lsdlocked0 Light List Accent 5;\lsdpriority62 \lsdlocked0 Light Grid Accent 5; +\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 5;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 5;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 5;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 5; +\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 5;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 5;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 5;\lsdpriority70 \lsdlocked0 Dark List Accent 5;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 5; +\lsdpriority72 \lsdlocked0 Colorful List Accent 5;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 5;\lsdpriority60 \lsdlocked0 Light Shading Accent 6;\lsdpriority61 \lsdlocked0 Light List Accent 6;\lsdpriority62 \lsdlocked0 Light Grid Accent 6; +\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 6;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 6;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 6;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 6; +\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 6;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 6;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 6;\lsdpriority70 \lsdlocked0 Dark List Accent 6;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 6; +\lsdpriority72 \lsdlocked0 Colorful List Accent 6;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 6;\lsdqformat1 \lsdpriority19 \lsdlocked0 Subtle Emphasis;\lsdqformat1 \lsdpriority21 \lsdlocked0 Intense Emphasis; +\lsdqformat1 \lsdpriority31 \lsdlocked0 Subtle Reference;\lsdqformat1 \lsdpriority32 \lsdlocked0 Intense Reference;\lsdqformat1 \lsdpriority33 \lsdlocked0 Book Title;\lsdsemihidden1 \lsdunhideused1 \lsdpriority37 \lsdlocked0 Bibliography; +\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority39 \lsdlocked0 TOC Heading;\lsdpriority41 \lsdlocked0 Plain Table 1;\lsdpriority42 \lsdlocked0 Plain Table 2;\lsdpriority43 \lsdlocked0 Plain Table 3;\lsdpriority44 \lsdlocked0 Plain Table 4; +\lsdpriority45 \lsdlocked0 Plain Table 5;\lsdpriority40 \lsdlocked0 Grid Table Light;\lsdpriority46 \lsdlocked0 Grid Table 1 Light;\lsdpriority47 \lsdlocked0 Grid Table 2;\lsdpriority48 \lsdlocked0 Grid Table 3;\lsdpriority49 \lsdlocked0 Grid Table 4; +\lsdpriority50 \lsdlocked0 Grid Table 5 Dark;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 1;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 1; +\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 1;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 1;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 1;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 1; +\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 1;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 2;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 2;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 2; +\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 2;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 2;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 2;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 2; +\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 3;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 3;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 3;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 3; +\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 3;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 3;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 3;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 4; +\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 4;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 4;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 4;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 4; +\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 4;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 4;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 5;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 5; +\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 5;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 5;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 5;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 5; +\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 5;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 6;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 6;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 6; +\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 6;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 6;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 6;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 6; +\lsdpriority46 \lsdlocked0 List Table 1 Light;\lsdpriority47 \lsdlocked0 List Table 2;\lsdpriority48 \lsdlocked0 List Table 3;\lsdpriority49 \lsdlocked0 List Table 4;\lsdpriority50 \lsdlocked0 List Table 5 Dark; +\lsdpriority51 \lsdlocked0 List Table 6 Colorful;\lsdpriority52 \lsdlocked0 List Table 7 Colorful;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 1;\lsdpriority47 \lsdlocked0 List Table 2 Accent 1;\lsdpriority48 \lsdlocked0 List Table 3 Accent 1; +\lsdpriority49 \lsdlocked0 List Table 4 Accent 1;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 1;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 1;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 1; +\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 2;\lsdpriority47 \lsdlocked0 List Table 2 Accent 2;\lsdpriority48 \lsdlocked0 List Table 3 Accent 2;\lsdpriority49 \lsdlocked0 List Table 4 Accent 2; +\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 2;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 2;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 2;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 3; +\lsdpriority47 \lsdlocked0 List Table 2 Accent 3;\lsdpriority48 \lsdlocked0 List Table 3 Accent 3;\lsdpriority49 \lsdlocked0 List Table 4 Accent 3;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 3; +\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 3;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 3;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 4;\lsdpriority47 \lsdlocked0 List Table 2 Accent 4; +\lsdpriority48 \lsdlocked0 List Table 3 Accent 4;\lsdpriority49 \lsdlocked0 List Table 4 Accent 4;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 4;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 4; +\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 4;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 5;\lsdpriority47 \lsdlocked0 List Table 2 Accent 5;\lsdpriority48 \lsdlocked0 List Table 3 Accent 5; +\lsdpriority49 \lsdlocked0 List Table 4 Accent 5;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 5;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 5;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 5; +\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 6;\lsdpriority47 \lsdlocked0 List Table 2 Accent 6;\lsdpriority48 \lsdlocked0 List Table 3 Accent 6;\lsdpriority49 \lsdlocked0 List Table 4 Accent 6; +\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 6;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 6;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 6;}}{\*\datastore 010500000200000018000000 +4d73786d6c322e534158584d4c5265616465722e362e3000000000000000000000060000 +d0cf11e0a1b11ae1000000000000000000000000000000003e000300feff090006000000000000000000000001000000010000000000000000100000feffffff00000000feffffff0000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffdfffffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffff52006f006f007400200045006e00740072007900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016000500ffffffffffffffffffffffff0c6ad98892f1d411a65f0040963251e500000000000000000000000080ea +bc1dafdccd01feffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000 +00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000105000000000000}} \ No newline at end of file diff --git a/Src/packages/Microsoft.Bcl.Immutable.1.0.12-beta/Microsoft.Bcl.Immutable.1.0.12-beta.nupkg b/Src/packages/Microsoft.Bcl.Immutable.1.0.12-beta/Microsoft.Bcl.Immutable.1.0.12-beta.nupkg new file mode 100644 index 00000000..8d665a63 Binary files /dev/null and b/Src/packages/Microsoft.Bcl.Immutable.1.0.12-beta/Microsoft.Bcl.Immutable.1.0.12-beta.nupkg differ diff --git a/Src/packages/Microsoft.Bcl.Immutable.1.0.12-beta/Microsoft.Bcl.Immutable.1.0.12-beta.nuspec b/Src/packages/Microsoft.Bcl.Immutable.1.0.12-beta/Microsoft.Bcl.Immutable.1.0.12-beta.nuspec new file mode 100644 index 00000000..e9cd4a7b --- /dev/null +++ b/Src/packages/Microsoft.Bcl.Immutable.1.0.12-beta/Microsoft.Bcl.Immutable.1.0.12-beta.nuspec @@ -0,0 +1,26 @@ + + + + Microsoft.Bcl.Immutable + 1.0.12-beta + Microsoft Immutable Collections + Microsoft + Microsoft + http://go.microsoft.com/fwlink/?LinkID=272980 + http://go.microsoft.com/fwlink/?LinkID=310193 + http://go.microsoft.com/fwlink/?LinkID=288859 + true + This packages provides collections that are thread safe and guaranteed to never change their contents, also known as immutable collections. Like strings, any methods that perform modifications will not change the existing instance but instead return a new instance. For efficiency reasons, the implementation uses a sharing mechanism to ensure that newly created instances share as much data as possible with the previous instance while ensuring that operations have a predictable time complexity. + +Supported Platforms: +- .NET Framework 4.5 +- .NET for Windows Store apps +- Windows Phone 8 +- Portable Class Libraries + Provides immutable collections that allow CPU and memory efficient mutation via new references. + + Copyright © Microsoft Corporation + + BCL Microsoft System Immutable Collections + + \ No newline at end of file diff --git a/Src/packages/Microsoft.Bcl.Immutable.1.0.12-beta/lib/portable-net45+win8+wp8/System.Collections.Immutable.dll b/Src/packages/Microsoft.Bcl.Immutable.1.0.12-beta/lib/portable-net45+win8+wp8/System.Collections.Immutable.dll new file mode 100644 index 00000000..d663ea2f Binary files /dev/null and b/Src/packages/Microsoft.Bcl.Immutable.1.0.12-beta/lib/portable-net45+win8+wp8/System.Collections.Immutable.dll differ diff --git a/Src/packages/Microsoft.Bcl.Immutable.1.0.12-beta/lib/portable-net45+win8+wp8/System.Collections.Immutable.xml b/Src/packages/Microsoft.Bcl.Immutable.1.0.12-beta/lib/portable-net45+win8+wp8/System.Collections.Immutable.xml new file mode 100644 index 00000000..af01fbea --- /dev/null +++ b/Src/packages/Microsoft.Bcl.Immutable.1.0.12-beta/lib/portable-net45+win8+wp8/System.Collections.Immutable.xml @@ -0,0 +1,11502 @@ + + + + System.Collections.Immutable + + + + + An internal non-generic interface implemented by ImmutableArray{T} + that allows for recognition of an ImmutableArray{T} instance and access + to its underlying array, without actually knowing the type of value + stored in it. + + + Casting to this interface requires a boxed instance of the ImmutableArray{T} struct, + and as such should be avoided. This interface is useful, however, where the value + is already boxed and we want to try to reuse immutable arrays instead of copying them. + ** This interface is INTENTIONALLY INTERNAL, as it gives access to the inner array. ** + + + + + Gets an untyped reference to the array. + + + + + A set of initialization methods for instances of . + + + + + A two element array useful for throwing exceptions the way LINQ does. + + + + + Creates an empty ImmutableArray{T}. + + The type of element stored in the array. + An empty array. + + + + Creates an ImmutableArray{T} with the specified element as its only member. + + The type of element stored in the array. + The element to store in the array. + A 1-element array. + + + + Creates an ImmutableArray{T} with the specified elements. + + The type of element stored in the array. + The first element to store in the array. + The second element to store in the array. + A 1-element array. + + + + Creates an ImmutableArray{T} with the specified elements. + + The type of element stored in the array. + The first element to store in the array. + The second element to store in the array. + The third element to store in the array. + A 1-element array. + + + + Creates an ImmutableArray{T} with the specified elements. + + The type of element stored in the array. + The first element to store in the array. + The second element to store in the array. + The third element to store in the array. + The third element to store in the array. + A 1-element array. + + + + Creates an empty ImmutableArray{T}. + + The type of element stored in the array. + The elements to store in the array. + An immutable array. + + + + Creates an empty ImmutableArray{T}. + + The type of element stored in the array. + The elements to store in the array. + An immutable array. + + + + Initializes a new instance of the struct. + + The array to initialize the array with. A defensive copy is made. + The index of the first element in the source array to include in the resulting array. + The number of elements from the source array to include in the resulting array. + + This overload allows helper methods or custom builder classes to efficiently avoid paying a redundant + tax for copying an array when the new array is a segment of an existing array. + + + + + Initializes a new instance of the struct. + + The array to initialize the array with. A defensive copy is made. + The index of the first element in the source array to include in the resulting array. + The number of elements from the source array to include in the resulting array. + + This overload allows helper methods or custom builder classes to efficiently avoid paying a redundant + tax for copying an array when the new array is a segment of an existing array. + + + + + Initializes a new instance of the class. + + The type of elements stored in the array. + A new builder. + + + + Initializes a new instance of the class. + + The type of elements stored in the array. + The size of the initial array backing the builder. + A new builder. + + + + Enumerates a sequence exactly once and produces an immutable array of its contents. + + The type of element in the sequence. + The sequence to enumerate. + An immutable array. + + + + LINQ extension method overrides that offer greater efficiency for than the standard LINQ methods + + + + + Projects each element of a sequence into a new form. + + The type of element contained by the collection. + The type of the result element. + The immutable array. + The selector. + + + + Filters a sequence of values based on a predicate. + + The type of element contained by the collection. + + + + Gets a value indicating whether any elements are in this collection. + + The type of element contained by the collection. + + + + + Gets a value indicating whether any elements are in this collection + that match a given condition. + + The type of element contained by the collection. + + The predicate. + + + + Gets a value indicating whether all elements in this collection + match a given condition. + + The type of element contained by the collection. + + The predicate. + + true if every element of the source sequence passes the test in the specified predicate, or if the sequence is empty; otherwise, false. + + + + + Determines whether two sequences are equal according to an equality comparer. + + The type of element in the compared array. + The type of element contained by the collection. + + + + Determines whether two sequences are equal according to an equality comparer. + + The type of element in the compared array. + The type of element contained by the collection. + + + + Determines whether two sequences are equal according to an equality comparer. + + The type of element in the compared array. + The type of element contained by the collection. + + + + Applies an accumulator function over a sequence. + + The type of element contained by the collection. + + + + Applies an accumulator function over a sequence. + + The type of the accumulated value. + The type of element contained by the collection. + + + + Applies an accumulator function over a sequence. + + The type of the accumulated value. + The type of result returned by the result selector. + The type of element contained by the collection. + + + + Returns the element at a specified index in a sequence. + + The type of element contained by the collection. + + + + Returns the element at a specified index in a sequence or a default value if the index is out of range. + + The type of element contained by the collection. + + + + Returns the first element in a sequence that satisfies a specified condition. + + The type of element contained by the collection. + + + + Returns the first element in a sequence that satisfies a specified condition. + + The type of element contained by the collection. + + + + + Returns the first element of a sequence, or a default value if the sequence contains no elements. + + The type of element contained by the collection. + + + + + Returns the first element of the sequence that satisfies a condition or a default value if no such element is found. + + The type of element contained by the collection. + + + + Returns the last element of a sequence. + + The type of element contained by the collection. + + + + + Returns the last element of a sequence that satisfies a specified condition. + + The type of element contained by the collection. + + + + Returns the last element of a sequence, or a default value if the sequence contains no elements. + + The type of element contained by the collection. + + + + + Returns the last element of a sequence that satisfies a condition or a default value if no such element is found. + + The type of element contained by the collection. + + + + Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence. + + The type of element contained by the collection. + + + + + Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists. + + The type of element contained by the collection. + + + + Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence. + + The type of element contained by the collection. + + + + + Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition. + + The type of element contained by the collection. + + + + Creates a dictionary based on the contents of this array. + + The type of the key. + The type of element contained by the collection. + + The key selector. + The newly initialized dictionary. + + + + Creates a dictionary based on the contents of this array. + + The type of the key. + The type of the element. + The type of element contained by the collection. + + The key selector. + The element selector. + The newly initialized dictionary. + + + + Creates a dictionary based on the contents of this array. + + The type of the key. + The type of element contained by the collection. + + The key selector. + The comparer to initialize the dictionary with. + The newly initialized dictionary. + + + + Creates a dictionary based on the contents of this array. + + The type of the key. + The type of the element. + The type of element contained by the collection. + + The key selector. + The element selector. + The comparer to initialize the dictionary with. + The newly initialized dictionary. + + + + Copies the contents of this array to a mutable array. + + The type of element contained by the collection. + + The newly instantiated array. + + + + Returns the first element in the collection. + + Thrown if the collection is empty. + + + + Returns the first element in the collection, or the default value if the collection is empty. + + + + + Returns the last element in the collection. + + Thrown if the collection is empty. + + + + Returns the last element in the collection, or the default value if the collection is empty. + + + + + Returns a value indicating whether this collection contains any elements. + + + + + A readonly array with O(1) indexable lookup time. + + The type of element stored by the array. + + + + A list of elements that can only be modified by creating a new instance of the list. + + The type of element stored in the list. + + Mutations on this list generate new lists. Incremental changes to a list share as much memory as possible with the prior versions of a list, + while allowing garbage collection to clean up any unique list data that is no longer being referenced. + + + + + Gets an empty list that retains the same sort or unordered semantics that this instance has. + + + + + Searches for the specified object and returns the zero-based index of the + first occurrence within the range of elements in the ImmutableList<T> + that starts at the specified index and contains the specified number of elements. + + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + + The zero-based starting index of the search. 0 (zero) is valid in an empty + list. + + + The number of elements in the section to search. + + + The equality comparer to use in the search. + + + The zero-based index of the first occurrence of item within the range of + elements in the ImmutableList<T> that starts at index and + contains count number of elements, if found; otherwise, –1. + + + + + Searches for the specified object and returns the zero-based index of the + last occurrence within the range of elements in the ImmutableList<T> + that contains the specified number of elements and ends at the specified + index. + + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + The starting position of the search. The search proceeds from toward the beginning of this instance. + The number of elements in the section to search. + + The equality comparer to use in the search. + + + The zero-based index of the last occurrence of item within the range of elements + in the ImmutableList<T> that contains count number of elements + and ends at index, if found; otherwise, –1. + + + + + Adds the specified value to this list. + + The value to add. + A new list with the element added, or this list if the element is already in this list. + + + + Adds the specified values to this list. + + The values to add. + A new list with the elements added. + + + + Inserts the specified value at the specified index. + + The index at which to insert the value. + The element to insert. + The new immutable list. + + + + Inserts the specified values at the specified index. + + The index at which to insert the value. + The elements to insert. + The new immutable list. + + + + Removes the specified value from this list. + + The value to remove. + + The equality comparer to use in the search. + + A new list with the element removed, or this list if the element is not in this list. + + + + Removes all the elements that match the conditions defined by the specified + predicate. + + + The System.Predicate<T> delegate that defines the conditions of the elements + to remove. + + + The new list. + + + + + Removes the specified values from this list. + + The items to remove if matches are found in this list. + + The equality comparer to use in the search. + + + A new list with the elements removed. + + + + + Removes the specified values from this list. + + The starting index to begin removal. + The number of elements to remove. + + A new list with the elements removed. + + + + + Removes the element at the specified index. + + The index. + A new list with the elements removed. + + + + Replaces an element in the list at a given position with the specified element. + + The position in the list of the element to replace. + The element to replace the old element with. + The new list -- even if the value being replaced is equal to the new value for that position. + + + + Replaces the first equal element in the list with the specified element. + + The element to replace. + The element to replace the old element with. + + The equality comparer to use in the search. + + The new list -- even if the value being replaced is equal to the new value for that position. + Thrown when the old value does not exist in the list. + + + + A singleton, shareable wrapper around an empty (non-null) array. + + + + + The backing field for this instance. References to this value should never be shared with outside code. + + + This would be private, but we make it internal so that our own extension methods can access it. + + + + + Initializes a new instance of the struct. + + The array to use or copy from. May be null for "default" arrays. + A value indicating whether to assume the source array will never be mutated. + + + + Checks equality between two instances. + + The instance to the left of the operator. + The instance to the right of the operator. + true if the values' underlying arrays are reference equal; false otherwise. + + + + Checks inequality between two instances. + + The instance to the left of the operator. + The instance to the right of the operator. + true if the values' underlying arrays are reference not equal; false otherwise. + + + + Checks equality between two instances. + + The instance to the left of the operator. + The instance to the right of the operator. + true if the values' underlying arrays are reference equal; false otherwise. + + + + Checks inequality between two instances. + + The instance to the left of the operator. + The instance to the right of the operator. + true if the values' underlying arrays are reference not equal; false otherwise. + + + + Searches the array for the specified item. + + The item to search for. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + + Searches the array for the specified item. + + The item to search for. + The index at which to begin the search. + The equality comparer to use in the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + + Searches the array for the specified item. + + The item to search for. + The index at which to begin the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + + Searches the array for the specified item. + + The item to search for. + The index at which to begin the search. + The number of elements to search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + + Searches the array for the specified item. + + The item to search for. + The index at which to begin the search. + The number of elements to search. + The equality comparer to use in the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + + Searches the array for the specified item in reverse. + + The item to search for. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + + Searches the array for the specified item in reverse. + + The item to search for. + The index at which to begin the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + + Searches the array for the specified item in reverse. + + The item to search for. + The index at which to begin the search. + The number of elements to search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + + Searches the array for the specified item in reverse. + + The item to search for. + The index at which to begin the search. + The number of elements to search. + The equality comparer to use in the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + + Determines whether the specified item exists in the array. + + The item to search for. + true if an equal value was found in the array; false otherwise. + + + + Copies the contents of this array to the specified array. + + The array to copy to. + + + + Copies the contents of this array to the specified array. + + The array to copy to. + The index into the destination array to which the first copied element is written. + + + + Copies the contents of this array to the specified array. + + The index into this collection of the first element to copy. + The array to copy to. + The index into the destination array to which the first copied element is written. + The number of elements to copy. + + + + Returns a new array with the specified value inserted at the specified position. + + The 0-based index into the array at which the new item should be added. + The item to insert at the start of the array. + A new array. + + + + Inserts the specified values at the specified index. + + The index at which to insert the value. + The elements to insert. + The new immutable collection. + + + + Returns a new array with the specified value inserted at the end. + + The item to insert at the end of the array. + A new array. + + + + Adds the specified values to this list. + + The values to add. + A new list with the elements added. + + + + Returns an array with the item at the specified position replaced. + + The index of the item to replace. + The new item. + The new array. + + + + Replaces the first equal element in the list with the specified element. + + The element to replace. + The element to replace the old element with. + The new list -- even if the value being replaced is equal to the new value for that position. + Thrown when the old value does not exist in the list. + + + + Replaces the first equal element in the list with the specified element. + + The element to replace. + The element to replace the old element with. + + The equality comparer to use in the search. + + The new list -- even if the value being replaced is equal to the new value for that position. + Thrown when the old value does not exist in the list. + + + + Returns an array with the first occurrence of the specified element removed from the array. + If no match is found, the current array is returned. + + The item to remove. + The new array. + + + + Returns an array with the first occurrence of the specified element removed from the array. + If no match is found, the current array is returned. + + The item to remove. + + The equality comparer to use in the search. + + The new array. + + + + Returns an array with the element at the specified position removed. + + The 0-based index into the array for the element to omit from the returned array. + The new array. + + + + Returns an array with the elements at the specified position removed. + + The 0-based index into the array for the element to omit from the returned array. + The number of elements to remove. + The new array. + + + + Removes the specified values from this list. + + The items to remove if matches are found in this list. + + A new list with the elements removed. + + + + + Removes the specified values from this list. + + The items to remove if matches are found in this list. + + The equality comparer to use in the search. + + + A new list with the elements removed. + + + + + Removes all the elements that match the conditions defined by the specified + predicate. + + + The System.Predicate<T> delegate that defines the conditions of the elements + to remove. + + + The new list. + + + + + Returns an empty array. + + + + + Returns a sorted instance of this array. + + + + + Returns a sorted instance of this array. + + The comparer to use in sorting. If null, the default comparer is used. + + + + Returns a sorted instance of this array. + + The index of the first element to consider in the sort. + The number of elements to include in the sort. + The comparer to use in sorting. If null, the default comparer is used. + + + + Returns a builder that is populated with the same contents as this array. + + The new builder. + + + + Returns an enumerator for the contents of the array. + + An enumerator. + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Indicates whether the current object is equal to another object of the same type. + + An object to compare with this object. + + true if the current object is equal to the parameter; otherwise, false. + + + + + Creates an immutable array for this array, cast to a different element type. + + The type of array element to return. + + A struct typed for the base element type. If the cast fails, an instance + is returned whose property returns true. + + + Arrays of derived elements types can be cast to arrays of base element types + without reallocating the array. + These upcasts can be reversed via this same method, casting an array of base + element types to their derived types. However, downcasting is only successful + when it reverses a prior upcasting operation. + + + + + Returns an enumerator for the contents of the array. + + An enumerator. + + + + Returns an enumerator for the contents of the array. + + An enumerator. + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + Adds an item to the . + + The object to add to the . + + The position into which the new element was inserted, or -1 to indicate that the item was not inserted into the collection, + + + + + + Removes all items from the . + + + + + + Determines whether the contains a specific value. + + The object to locate in the . + + true if the is found in the ; otherwise, false. + + + + + Determines the index of a specific item in the . + + The object to locate in the . + + The index of if found in the list; otherwise, -1. + + + + + Inserts an item to the at the specified index. + + The zero-based index at which should be inserted. + The object to insert into the . + + + + + Removes the first occurrence of a specific object from the . + + The object to remove from the . + + + + + Removes the item at the specified index. + + The zero-based index of the item to remove. + + + + + Copies the elements of the to an , starting at a particular index. + + The one-dimensional that is the destination of the elements copied from . The must have zero-based indexing. + The zero-based index in at which copying begins. + + + + Determines whether an object is structurally equal to the current instance. + + The object to compare with the current instance. + An object that determines whether the current instance and other are equal. + true if the two objects are equal; otherwise, false. + + + + Returns a hash code for the current instance. + + An object that computes the hash code of the current object. + The hash code for the current instance. + + + + Determines whether the current collection object precedes, occurs in the + same position as, or follows another object in the sort order. + + The object to compare with the current instance. + + An object that compares members of the current collection object with the + corresponding members of other. + + + An integer that indicates the relationship of the current collection object + to other. + + + + + Returns an array with items at the specified indexes removed. + + A **sorted set** of indexes to elements that should be omitted from the returned array. + The new array. + + + + Gets the element at the specified index in the read-only list. + + The zero-based index of the element to get. + The element at the specified index in the read-only list. + + + + Gets or sets the element at the specified index in the read-only list. + + The zero-based index of the element to get. + The element at the specified index in the read-only list. + Always thrown from the setter. + + + + Gets a value indicating whether this instance is read only. + + + true if this instance is read only; otherwise, false. + + + + + Gets a value indicating whether this collection is empty. + + + + + Gets the number of array in the collection. + + + + + Gets the number of array in the collection. + + + + + Gets the number of array in the collection. + + + + + Gets a value indicating whether this struct was initialized without an actual array instance. + + + + + Gets an untyped reference to the array. + + + + + Gets the array for this collection. Never null. + + + + + Gets a value indicating whether this instance is fixed size. + + + true if this instance is fixed size; otherwise, false. + + + + + Gets a value indicating whether this instance is read only. + + + true if this instance is read only; otherwise, false. + + + + + Gets the size of the array. + + + + + See the ICollection interface. + + + + + Gets the sync root. + + + + + Gets or sets the at the specified index. + + + The . + + The index. + + + + + + A writable array accessor that can be converted into an + instance without allocating memory. + + + + + The backing array for the builder. + + + + + The number of initialized elements in the array. + + + + + Initializes a new instance of the class. + + The initial capacity of the internal array. + + + + Initializes a new instance of the class. + + + + + Returns an immutable copy of the current contents of this collection. + + An immutable array. + + + + Removes all items from the . + + + + + Inserts an item to the at the specified index. + + The zero-based index at which should be inserted. + The object to insert into the . + + + + Adds an item to the . + + The object to add to the . + + + + Adds the specified items to the end of the array. + + The items. + + + + Adds the specified items to the end of the array. + + The items. + + + + Adds the specified items to the end of the array. + + The items. + + + + Adds the specified items to the end of the array. + + The items. + The number of elements from the source array to add. + + + + Adds the specified items to the end of the array. + + The items. + + + + Adds the specified items to the end of the array. + + The items. + The number of elements from the source array to add. + + + + Adds the specified items to the end of the array. + + The items. + + + + Adds the specified items to the end of the array. + + The items. + + + + Adds the specified items to the end of the array. + + The items. + + + + Removes the specified element. + + The element. + A value indicating whether the specified element was found and removed from the collection. + + + + Removes the item at the specified index. + + The zero-based index of the item to remove. + + + + Determines whether the contains a specific value. + + The object to locate in the . + + true if is found in the ; otherwise, false. + + + + + Creates a new array with the current contents of this Builder. + + + + + Copies the current contents to the specified array. + + The array to copy to. + The starting index of the target array. + + + + Resizes the array to accomodate the specified capacity requirement. + + The required capacity. + + + + Determines the index of a specific item in the . + + The object to locate in the . + + The index of if found in the list; otherwise, -1. + + + + + Searches the array for the specified item. + + The item to search for. + The index at which to begin the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + + Searches the array for the specified item. + + The item to search for. + The index at which to begin the search. + The number of elements to search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + + Searches the array for the specified item. + + The item to search for. + The index at which to begin the search. + The number of elements to search. + The equality comparer to use in the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + + Searches the array for the specified item in reverse. + + The item to search for. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + + Searches the array for the specified item in reverse. + + The item to search for. + The index at which to begin the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + + Searches the array for the specified item in reverse. + + The item to search for. + The index at which to begin the search. + The number of elements to search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + + Searches the array for the specified item in reverse. + + The item to search for. + The index at which to begin the search. + The number of elements to search. + The equality comparer to use in the search. + The 0-based index into the array where the item was found; or -1 if it could not be found. + + + + Reverses the order of elements in the collection. + + + + + Sorts the array. + + + + + Sorts the array. + + The comparer to use in sorting. If null, the default comparer is used. + + + + Sorts the array. + + The index of the first element to consider in the sort. + The number of elements to include in the sort. + The comparer to use in sorting. If null, the default comparer is used. + + + + Returns an enumerator for the contents of the array. + + An enumerator. + + + + Returns an enumerator for the contents of the array. + + An enumerator. + + + + Returns an enumerator for the contents of the array. + + An enumerator. + + + + Adds items to this collection. + + The type of source elements. + The source array. + The number of elements to add to this array. + + + + Gets or sets the length of the array. + + + If the value is decreased, the array contents are truncated. + If the value is increased, the added elements are initialized to default(T). + + + + + Gets or sets the element at the specified index. + + The index. + + + + + + + Gets a value indicating whether the is read-only. + + true if the is read-only; otherwise, false. + + + + + A simple struct we wrap the element type in. + When the array is of reference types, this speeds up runtime performance + because it skips some CLR covariant checks. (I think that's the reason -- Ask Roslyn). + + + + + Initializes a new instance of the struct. + + + + + The value. + + + + + An array enumerator. + + + It is important that this enumerator does NOT implement IDisposable. + We want the iterator to inline when we do foreach and to not result in + a try/finally frame in the client. + + + + + The array being enumerated. + + + + + The currently enumerated position. + + + -1 before the first call to . + >= this.array.Length after MoveNext returns false. + + + + + Initializes a new instance of the struct. + + The array to enumerate. Null arguments are safe. + + + + Advances to the next value to be enumerated. + + true if another item exists in the array; false otherwise. + + + + Gets the currently enumerated value. + + + + + An array enumerator that implements IEnumerator pattern (including IDisposable). + + + + + The resource pool of reusable mutable stacks for purposes of enumeration. + + + We utilize this resource pool to make "allocation free" enumeration achievable. + + + + + A shareable singleton for enumerating empty arrays. + + + + + The array being enumerated. + + + + + The currently enumerated position. + + + -1 before the first call to . + >= this.array.Length after MoveNext returns false. + + + + + Initializes a new instance of the class. + + + + + Advances to the next value to be enumerated. + + true if another item exists in the array; false otherwise. + + + + Resets enumeration to the start of the array. + + + + + Disposes this enumerator. + + + Currently has no action. + + + + + Creates an enumerator for the specified array. + + + + + Initializes a new or recycled instance of the struct. + + The array to enumerate. Null arguments are safe. + + + + Gets the currently enumerated value. + + + + + Gets the currently enumerated value. + + + + + Contains the inner HashBucketComparer class. + + + Contains the inner Builder class. + + + Contains the inner DebuggerProxy class. + + + Contains the inner Enumerator struct. + + + Contains the inner HashBucket struct. + + + Contains the inner MutationInput class. + + + Contains the inner MutationResult class. + + + An immutable unordered hash map implementation. + + The type of the key. + The type of the value. + + + + An immutable key-value dictionary. + + The type of the key. + The type of the value. + + + + Gets an empty dictionary with equivalent ordering and key/value comparison rules. + + + + + Adds the specified key and value to the dictionary. + + The key of the entry to add. + The value of the entry to add. + The new dictionary containing the additional key-value pair. + Thrown when the given key already exists in the dictionary but has a different value. + + If the given key-value pair are already in the dictionary, the existing instance is returned. + + + + + Adds the specified key-value pairs to the dictionary. + + The pairs. + The new dictionary containing the additional key-value pairs. + Thrown when one of the given keys already exists in the dictionary but has a different value. + + + + Sets the specified key and value to the dictionary, possibly overwriting an existing value for the given key. + + The key of the entry to add. + The value of the entry to add. + The new dictionary containing the additional key-value pair. + + If the given key-value pair are already in the dictionary, the existing instance is returned. + If the key already exists but with a different value, a new instance with the overwritten value will be returned. + + + + + Applies a given set of key=value pairs to an immutable dictionary, replacing any conflicting keys in the resulting dictionary. + + The key=value pairs to set on the dictionary. Any keys that conflict with existing keys will overwrite the previous values. + An immutable dictionary. + + + + Removes the specified keys from the dictionary with their associated values. + + The keys to remove. + A new dictionary with those keys removed; or this instance if those keys are not in the dictionary. + + + + Removes the specified key from the dictionary with its associated value. + + The key to remove. + A new dictionary with the matching entry removed; or this instance if the key is not in the dictionary. + + + + Determines whether this dictionary contains the specified key-value pair. + + The key value pair. + + true if this dictionary contains the key-value pair; otherwise, false. + + + + + Searches the dictionary for a given key and returns the equal key it finds, if any. + + The key to search for. + The key from the dictionary that the search found, or if the search yielded no match. + A value indicating whether the search was successful. + + This can be useful when you want to reuse a previously stored reference instead of + a newly constructed one (so that more sharing of references can occur) or to look up + the canonical value, or a value that has more complete data than the value you currently have, + although their comparer functions indicate they are equal. + + + + + Gets the value comparer used to determine whether values are equal. + + + + + Defined on a generic collection that hashes its contents using an . + + The type of element hashed in the collection. + + + + Gets the comparer used to obtain hash codes for the keys and check equality. + + + + + The default empty map. + + + + + The singleton delegate that freezes the contents of hash buckets when the root of the data structure is frozen. + + + + + The number of elements in the collection. + + + + + The root node of the tree that stores this map. + + + + + The comparer used when comparing hash buckets. + + + + + Initializes a new instance of the class. + + The root. + The comparers. + The number of elements in the map. + + + + Initializes a new instance of the class. + + The comparers. + + + + See the interface. + + + + + Gets the empty instance. + + + + + Creates a collection with the same contents as this collection that + can be efficiently mutated across multiple operations using standard + mutable interfaces. + + + This is an O(1) operation and results in only a single (small) memory allocation. + The mutable collection that is returned is *not* thread-safe. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + Applies a given set of key=value pairs to an immutable dictionary, replacing any conflicting keys in the resulting dictionary. + + The key=value pairs to set on the map. Any keys that conflict with existing keys will overwrite the previous values. + An immutable dictionary. + + + + See the interface. + + + + + See the interface. + + + + + Determines whether the specified key contains key. + + The key. + + true if the specified key contains key; otherwise, false. + + + + + Determines whether [contains] [the specified key value pair]. + + The key value pair. + + true if [contains] [the specified key value pair]; otherwise, false. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + Determines whether the ImmutableSortedMap<TKey,TValue> + contains an element with the specified value. + + + The value to locate in the ImmutableSortedMap<TKey,TValue>. + The value can be null for reference types. + + + true if the ImmutableSortedMap<TKey,TValue> contains + an element with the specified value; otherwise, false. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + See the IImmutableMap{TKey,TValue} interface + + + + + See the IImmutableMap{TKey,TValue} interface + + + + + Applies a given set of key=value pairs to an immutable dictionary, replacing any conflicting keys in the resulting dictionary. + + The key=value pairs to set on the map. Any keys that conflict with existing keys will overwrite the previous values. + An immutable dictionary. + + + + See the IImmutableMap{TKey,TValue} interface + + + + + See the IImmutableMap{TKey,TValue} interface + + + + + See the IImmutableMap{TKey,TValue} interface + + + + + Adds an element with the provided key and value to the . + + The object to use as the key of the element to add. + The object to use as the value of the element to add. + is null. + + + An element with the same key already exists in the . + + + The is read-only. + + + + + Removes the element with the specified key from the . + + The key of the element to remove. + + true if the element is successfully removed; otherwise, false. This method also returns false if was not found in the original . + + is null. + + + The is read-only. + + + + + Adds an element with the provided key and value to the object. + + The to use as the key of the element to add. + The to use as the value of the element to add. + + + + Determines whether the object contains an element with the specified key. + + The key to locate in the object. + + true if the contains an element with the key; otherwise, false. + + + + + Returns an object for the object. + + + An object for the object. + + + + + + Removes the element with the specified key from the object. + + The key of the element to remove. + + + + Clears this instance. + + + + + + Copies the elements of the to an , starting at a particular index. + + The one-dimensional that is the destination of the elements copied from . The must have zero-based indexing. + The zero-based index in at which copying begins. + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + Gets an empty collection with the specified comparers. + + The comparers. + The empty dictionary. + + + + Attempts to discover an instance beneath some enumerable sequence + if one exists. + + The sequence that may have come from an immutable map. + Receives the concrete typed value if one can be found. + true if the cast was successful; false otherwise. + + + + Performs the operation on a given data structure. + + + + + Performs the operation on a given data structure. + + + + + Performs the operation on a given data structure. + + + + + Performs the operation on a given data structure. + + + + + Performs the operation on a given data structure. + + + + + Performs the operation on a given data structure. + + + + + Performs the operation on a given data structure. + + + + + Performs the set operation on a given data structure. + + + + + Wraps the specified data structure with an immutable collection wrapper. + + The root of the data structure. + The comparers. + The number of elements in the data structure. + + The immutable collection. + + + + + Wraps the specified data structure with an immutable collection wrapper. + + The root of the data structure. + The adjusted count if the root has changed. + The immutable collection. + + + + Bulk adds entries to the map. + + The entries to add. + true when being called from ToHashMap to avoid StackOverflow. + + + + Gets the number of elements in this collection. + + + + + Gets a value indicating whether this instance is empty. + + + true if this instance is empty; otherwise, false. + + + + + Gets the key comparer. + + + + + See the interface. + + + + + Gets the keys in the map. + + + + + Gets the values in the map. + + + + + Gets the keys. + + + + + Gets the values. + + + + + Gets an empty map with default equality comparers. + + + + + Gets a data structure that captures the current state of this map, as an input into a query or mutating function. + + + + + Gets the with the specified key. + + + + + Gets or sets the with the specified key. + + + + + Gets a value indicating whether the object has a fixed size. + + true if the object has a fixed size; otherwise, false. + + + + Gets a value indicating whether the is read-only. + + true if the is read-only; otherwise, false. + + + + + Gets an containing the keys of the . + + + An containing the keys of the object that implements . + + + + + Gets an containing the values in the . + + + An containing the values in the object that implements . + + + + + Gets or sets the element with the specified key. + + The key. + + + + + Gets an object that can be used to synchronize access to the . + + An object that can be used to synchronize access to the . + + + + Gets a value indicating whether access to the is synchronized (thread safe). + + true if access to the is synchronized (thread safe); otherwise, false. + + + + A shareable container for the comparers used by an immutable dictionary. + + + To reduce allocations, we directly implement the HashBucket and Key-Only comparers, + but we try to keep this an implementation detail by exposing properties that return + references for these particular facilities, that are implemented as returning "this". + + + + + The default instance to use when all the comparers used are their default values. + + + + + The equality comparer to use for the key. + + + + + The value comparer. + + + + + Initializes a new instance of the class. + + The key only comparer. + The value comparer. + + + + Determines whether the specified objects are equal. + + The first object to compare. + The second object to compare. + + true if the specified objects are equal; otherwise, false. + + + + + Returns a hash code for this instance. + + The obj. + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Determines whether the specified objects are equal. + + The first object to compare. + The second object to compare. + + true if the specified objects are equal; otherwise, false. + + + + + Returns a hash code for this instance. + + The obj. + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Gets an instance that refers to the specified combination of comparers. + + The key comparer. + The value comparer. + An instance of + + + + Returns an instance of that shares the same key comparers + with this instance, but uses the specified value comparer. + + The new value comparer to use. + A new instance of + + + + Gets the key comparer. + + + The key comparer. + + + + + Gets the key only comparer. + + + The key only comparer. + + + + + Gets the value comparer. + + + The value comparer. + + + + + Gets the equality comparer to use with hash buckets. + + + + + A hash map that mutates with little or no memory allocations, + can produce and/or build on immutable hash map instances very efficiently. + + + + While + and other bulk change methods already provide fast bulk change operations on the collection, this class allows + multiple combinations of changes to be made to a set with equal efficiency. + + + Instance members of this class are not thread-safe. + + + + + + The root of the binary tree that stores the collection. Contents are typically not entirely frozen. + + + + + The comparers. + + + + + The number of elements in this collection. + + + + + Caches an immutable instance that represents the current state of the collection. + + Null if no immutable view has been created for the current version. + + + + A number that increments every time the builder changes its contents. + + + + + The object callers may use to synchronize access to this collection. + + + + + Initializes a new instance of the class. + + The map that serves as the basis for this Builder. + + + + Adds an element with the provided key and value to the object. + + The to use as the key of the element to add. + The to use as the value of the element to add. + + + + Determines whether the object contains an element with the specified key. + + The key to locate in the object. + + true if the contains an element with the key; otherwise, false. + + + + + Returns an object for the object. + + + An object for the object. + + + + + + Removes the element with the specified key from the object. + + The key of the element to remove. + + + + Copies the elements of the to an , starting at a particular index. + + The one-dimensional that is the destination of the elements copied from . The must have zero-based indexing. + The zero-based index in at which copying begins. + + + + Adds a sequence of values to this collection. + + The items. + + + + Removes any entries from the dictionaries with keys that match those found in the specified sequence. + + The keys for entries to remove from the dictionary. + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Gets the value for a given key if a matching key exists in the dictionary. + + The key to search for. + The value for the key, or default(TValue) if no matching key was found. + + + + Gets the value for a given key if a matching key exists in the dictionary. + + The key to search for. + The default value to return if no matching key is found in the dictionary. + + The value for the key, or if no matching key was found. + + + + + Creates an immutable hash map based on the contents of this instance. + + An immutable map. + + This method is an O(n) operation, and approaches O(1) time as the number of + actual mutations to the set since the last call to this method approaches 0. + + + + + Adds an element with the provided key and value to the . + + The object to use as the key of the element to add. + The object to use as the value of the element to add. + is null. + An element with the same key already exists in the . + The is read-only. + + + + Determines whether the contains an element with the specified key. + + The key to locate in the . + + true if the contains an element with the key; otherwise, false. + + is null. + + + + Determines whether the ImmutableSortedMap<TKey,TValue> + contains an element with the specified value. + + + The value to locate in the ImmutableSortedMap<TKey,TValue>. + The value can be null for reference types. + + + true if the ImmutableSortedMap<TKey,TValue> contains + an element with the specified value; otherwise, false. + + + + + Removes the element with the specified key from the . + + The key of the element to remove. + + true if the element is successfully removed; otherwise, false. This method also returns false if was not found in the original . + + is null. + + The is read-only. + + + + Gets the value associated with the specified key. + + The key whose value to get. + When this method returns, the value associated with the specified key, if the key is found; otherwise, the default value for the type of the parameter. This parameter is passed uninitialized. + + true if the object that implements contains an element with the specified key; otherwise, false. + + is null. + + + + See the interface. + + + + + Adds an item to the . + + The object to add to the . + The is read-only. + + + + Removes all items from the . + + The is read-only. + + + + Determines whether the contains a specific value. + + The object to locate in the . + + true if is found in the ; otherwise, false. + + + + + See the interface. + + + + + Removes the first occurrence of a specific object from the . + + The object to remove from the . + + true if was successfully removed from the ; otherwise, false. This method also returns false if is not found in the original . + + The is read-only. + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + Applies the result of some mutation operation to this instance. + + The result. + + + + Gets or sets the key comparer. + + + The key comparer. + + + + + Gets or sets the value comparer. + + + The value comparer. + + + + + Gets the number of elements contained in the . + + The number of elements contained in the . + + + + Gets a value indicating whether the is read-only. + + true if the is read-only; otherwise, false. + + + + See + + + + + Gets an containing the keys of the . + + An containing the keys of the object that implements . + + + + See + + + + + Gets an containing the values in the . + + An containing the values in the object that implements . + + + + Gets a value indicating whether the object has a fixed size. + + true if the object has a fixed size; otherwise, false. + + + + Gets a value indicating whether the is read-only. + + true if the is read-only; otherwise, false. + + + + + Gets an containing the keys of the . + + + An containing the keys of the object that implements . + + + + + Gets an containing the values in the . + + + An containing the values in the object that implements . + + + + + Gets an object that can be used to synchronize access to the . + + An object that can be used to synchronize access to the . + + + + Gets a value indicating whether access to the is synchronized (thread safe). + + true if access to the is synchronized (thread safe); otherwise, false. + + + + Gets or sets the element with the specified key. + + The key. + + + + + Gets the current version of the contents of this builder. + + + + + Gets the initial data to pass to a query or mutation method. + + + + + Gets or sets the root of this data structure. + + + + + Gets or sets the element with the specified key. + + The element with the specified key. + is null. + The property is retrieved and is not found. + The property is set and the is read-only. + + + + A simple view of the immutable collection that the debugger can show to the developer. + + + + + The collection to be enumerated. + + + + + The simple view of the collection. + + + + + Initializes a new instance of the class. + + The collection to display in the debugger + + + + Gets a simple debugger-viewable collection. + + + + + A simple view of the immutable collection that the debugger can show to the developer. + + + + + The collection to be enumerated. + + + + + The simple view of the collection. + + + + + Initializes a new instance of the class. + + The collection to display in the debugger + + + + Gets a simple debugger-viewable collection. + + + + + Enumerates the contents of the collection in an allocation-free manner. + + + + + The builder being enumerated, if applicable. + + + + + The enumerator over the sorted map whose keys are hash values. + + + + + The enumerator in use within an individual HashBucket. + + + + + The version of the builder (when applicable) that is being enumerated. + + + + + Initializes a new instance of the struct. + + The root. + The builder, if applicable. + + + + Advances the enumerator to the next element of the collection. + + + true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection. + + The collection was modified after the enumerator was created. + + + + Sets the enumerator to its initial position, which is before the first element in the collection. + + The collection was modified after the enumerator was created. + + + + Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + + + + + Throws an exception if the underlying builder's contents have been changed since enumeration started. + + Thrown if the collection has changed. + + + + Gets the current element. + + + + + Gets the current element. + + + + + Contains all the key/values in the collection that hash to the same value. + + + + + One of the values in this bucket. + + + + + Any other elements that hash to the same value. + + + This is null if and only if the entire bucket is empty (including ). + It's empty if has an element but no additional elements. + + + + + Initializes a new instance of the struct. + + The first element. + The additional elements. + + + + Returns an enumerator that iterates through the collection. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + Throws an exception to catch any errors in comparing HashBucket instances. + + + + + Adds the specified key. + + The key to add. + The value to add. + The key comparer. + The value comparer. + The intended behavior for certain cases that may come up during the operation. + A description of the effect was on adding an element to this HashBucket. + A new HashBucket that contains the added value and any values already held by this hashbucket. + + + + Removes the specified value if it exists in the collection. + + The key to remove. + The equality comparer. + A description of the effect was on adding an element to this HashBucket. + A new HashBucket that does not contain the removed value and any values already held by this hashbucket. + + + + Gets the value for the given key in the collection if one exists.. + + The key to search for. + The key comparer. + The value for the given key. + A value indicating whether the key was found. + + + + Searches the dictionary for a given key and returns the equal key it finds, if any. + + The key to search for. + The key comparer. + The key from the dictionary that the search found, or if the search yielded no match. + A value indicating whether the search was successful. + + This can be useful when you want to reuse a previously stored reference instead of + a newly constructed one (so that more sharing of references can occur) or to look up + the canonical value, or a value that has more complete data than the value you currently have, + although their comparer functions indicate they are equal. + + + + + Freezes this instance so that any further mutations require new memory allocations. + + + + + Gets a value indicating whether this instance is empty. + + + true if this instance is empty; otherwise, false. + + + + + Gets the first value in this bucket. + + + + + Gets the list of additional (hash collision) elements. + + + + + Enumerates all the elements in this instance. + + + + + The bucket being enumerated. + + + + + The current position of this enumerator. + + + + + The enumerator that represents the current position over the additionalValues of the HashBucket. + + + + + Initializes a new instance of the struct. + + The bucket. + + + + Advances the enumerator to the next element of the collection. + + + true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection. + + The collection was modified after the enumerator was created. + + + + Sets the enumerator to its initial position, which is before the first element in the collection. + + The collection was modified after the enumerator was created. + + + + Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + + + + + Gets the current element. + + + + + Gets the current element. + + + + + Describes the positions the enumerator state machine may be in. + + + + + The first element has not yet been moved to. + + + + + We're at the firstValue of the containing bucket. + + + + + We're enumerating the additionalValues in the bucket. + + + + + The end of enumeration has been reached. + + + + + Description of the current data structure as input into a + mutating or query method. + + + + + The root of the data structure for the collection. + + + + + The comparer used when comparing hash buckets. + + + + + The current number of elements in the collection. + + + + + Initializes a new instance of the struct. + + The root. + The comparers. + The current number of elements in the collection. + + + + Initializes a new instance of the struct. + + The map. + + + + Gets the root of the data structure for the collection. + + + + + Gets the key comparer. + + + + + Gets the key only comparer. + + + + + Gets the value comparer. + + + + + Gets the comparers. + + + + + Gets the current number of elements in the collection. + + + + + Describes the result of a mutation on the immutable data structure. + + + + + The root node of the data structure after the mutation. + + + + + The number of elements added or removed from the collection as a result of the operation (a negative number represents removed elements). + + + + + Initializes a new instance of the struct. + + The unchanged input. + + + + Initializes a new instance of the struct. + + The root. + The count adjustment. + + + + Returns an immutable hash map that captures the result of this mutation. + + The prior version of the map. Used to capture the equality comparer and previous count, when applicable. + The new collection. + + + + Gets the root node of the data structure after the mutation. + + + + + Gets the number of elements added or removed from the collection as a result of the operation (a negative number represents removed elements). + + + + + How to respond when a key collision is discovered. + + + + + Sets the value for the given key, even if that overwrites an existing value. + + + + + Skips the mutating operation if a key conflict is detected. + + + + + Throw an exception if the key already exists with a different key. + + + + + Throw an exception if the key already exists regardless of its value. + + + + + The result of a mutation operation. + + + + + The change was applied and did not require a change to the number of elements in the collection. + + + + + The change required element(s) to be added or removed from the collection. + + + + + No change was required (the operation ended in a no-op). + + + + + Contains interlocked exchange mechanisms for immutable collections. + + + + + Assigns a field or variable containing an immutable array to the specified value and returns the previous value. + + The type of element stored by the array. + The field or local variable to change. + The new value to assign. + The prior value at the specified . + + + + Assigns a field or variable containing an immutable array to the specified value + if it is currently equal to another specified value. Returns the previous value. + + The type of element stored by the array. + The field or local variable to change. + The new value to assign. + The value to check equality for before assigning. + The prior value at the specified . + + + + Obtains the value for the specified key from a dictionary, or adds a new value to the dictionary where the key did not previously exist. + + The type of key stored by the dictionary. + The type of value stored by the dictionary. + The type of argument supplied to the value factory. + The variable or field to atomically update if the specified is not in the dictionary. + The key for the value to retrieve or add. + The function to execute to obtain the value to insert into the dictionary if the key is not found. + The argument to pass to the value factory. + The value obtained from the dictionary or if it was not present. + + + + Obtains the value for the specified key from a dictionary, or adds a new value to the dictionary where the key did not previously exist. + + The type of key stored by the dictionary. + The type of value stored by the dictionary. + The variable or field to atomically update if the specified is not in the dictionary. + The key for the value to retrieve or add. + + The function to execute to obtain the value to insert into the dictionary if the key is not found. + This delegate will not be invoked more than once. + + The value obtained from the dictionary or if it was not present. + + + + Obtains the value for the specified key from a dictionary, or adds a new value to the dictionary where the key did not previously exist. + + The type of key stored by the dictionary. + The type of value stored by the dictionary. + The variable or field to atomically update if the specified is not in the dictionary. + The key for the value to retrieve or add. + The value to add to the dictionary if one is not already present. + The value obtained from the dictionary or if it was not present. + + + + Obtains the value from a dictionary after having added it or updated an existing entry. + + The type of key stored by the dictionary. + The type of value stored by the dictionary. + The variable or field to atomically update if the specified is not in the dictionary. + The key for the value to add or update. + The function that receives the key and returns a new value to add to the dictionary when no value previously exists. + The function that receives the key and prior value and returns the new value with which to update the dictionary. + The added or updated value. + + + + Obtains the value from a dictionary after having added it or updated an existing entry. + + The type of key stored by the dictionary. + The type of value stored by the dictionary. + The variable or field to atomically update if the specified is not in the dictionary. + The key for the value to add or update. + The value to use if no previous value exists. + The function that receives the key and prior value and returns the new value with which to update the dictionary. + The added or updated value. + + + + Adds the specified key and value to the dictionary if no colliding key already exists in the dictionary. + + The type of key stored by the dictionary. + The type of value stored by the dictionary. + The variable or field to atomically update if the specified is not in the dictionary. + The key to add, if is not already defined in the dictionary. + The value to add. + true if the key was not previously set in the dictionary and the value was set; false otherwise. + + + + Sets the specified key to the given value if the key already is set to a specific value. + + The type of key stored by the dictionary. + The type of value stored by the dictionary. + The variable or field to atomically update if the specified is not in the dictionary. + The key to update. + The new value to set. + The value that must already be set in the dictionary in order for the update to succeed. + true if the key and comparison value were present in the dictionary and the update was made; false otherwise. + + + + Removes an entry from the dictionary with the specified key if it is defined and returns its value. + + The type of key stored by the dictionary. + The type of value stored by the dictionary. + The variable or field to atomically update if the specified is not in the dictionary. + The key to remove. + Receives the value from the pre-existing entry, if one exists. + true if the key was found and removed; false otherwise. + + + + Pushes a new element onto a stack. + + The type of elements stored in the stack. + The variable or field to atomically update. + The value popped from the stack, if it was non-empty. + true if an element was removed from the stack; false otherwise. + + + + Pushes a new element onto a stack. + + The type of elements stored in the stack. + The variable or field to atomically update. + The value to push. + + + + Atomically removes the element at the head of a queue and returns it to the caller, if the queue is not empty. + + The type of element stored in the queue. + The variable or field to atomically update. + Receives the value from the head of the queue, if the queue is non-empty. + true if the queue was not empty and the head element was removed; false otherwise. + + + + Atomically enqueues an element to the tail of a queue. + + The type of element stored in the queue. + The variable or field to atomically update. + The value to enqueue. + + + + A set of initialization methods for instances of . + + + + + Returns an empty collection. + + The type of items stored by the collection. + The immutable collection. + + + + Creates a new immutable collection prefilled with the specified item. + + The type of items stored by the collection. + The item to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified items. + + The type of items stored by the collection. + The items to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified items. + + The type of items stored by the collection. + The items to prepopulate. + The new immutable collection. + + + + Pops the top element off the stack. + + The type of values contained in the stack. + The stack to modify. + The value that was removed from the stack. + + A stack; never null + + + + + A set of initialization methods for instances of . + + + + + Returns an empty collection. + + The type of items stored by the collection. + The immutable collection. + + + + Creates a new immutable collection prefilled with the specified item. + + The type of items stored by the collection. + The item to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified items. + + The type of items stored by the collection. + The items to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified items. + + The type of items stored by the collection. + The items to prepopulate. + The new immutable collection. + + + + Retrieves the item at the head of the queue, and returns a queue with the head element removed. + + The type of elements stored in the queue. + The queue to dequeue from. + Receives the value from the head of the queue. + The new queue with the head element removed. + + + + A set of initialization methods for instances of . + + + + + Returns an empty collection. + + The type of items stored by the collection. + The immutable collection. + + + + Returns an empty collection. + + The type of items stored by the collection. + The comparer. + + The immutable collection. + + + + + Creates a new immutable collection prefilled with the specified item. + + The type of items stored by the collection. + The item to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified item. + + The type of items stored by the collection. + The comparer. + The item to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified items. + + The type of items stored by the collection. + The items to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified items. + + The type of items stored by the collection. + The comparer. + The items to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified items. + + The type of items stored by the collection. + The items to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified items. + + The type of items stored by the collection. + The comparer. + The items to prepopulate. + The new immutable collection. + + + + Returns an empty collection. + + The type of items stored by the collection. + The immutable collection. + + + + Returns an empty collection. + + The type of items stored by the collection. + The comparer. + + The immutable collection. + + + + + Enumerates a sequence exactly once and produces an immutable set of its contents. + + The type of element in the sequence. + The sequence to enumerate. + The comparer to use for initializing and adding members to the sorted set. + An immutable set. + + + + Enumerates a sequence exactly once and produces an immutable set of its contents. + + The type of element in the sequence. + The sequence to enumerate. + An immutable set. + + + + A set of initialization methods for instances of . + + + + + Returns an empty collection. + + The type of items stored by the collection. + The immutable collection. + + + + Returns an empty collection. + + The type of items stored by the collection. + The equality comparer. + + The immutable collection. + + + + + Creates a new immutable collection prefilled with the specified item. + + The type of items stored by the collection. + The item to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified item. + + The type of items stored by the collection. + The equality comparer. + The item to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified items. + + The type of items stored by the collection. + The items to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified items. + + The type of items stored by the collection. + The equality comparer. + The items to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified items. + + The type of items stored by the collection. + The items to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified items. + + The type of items stored by the collection. + The equality comparer. + The items to prepopulate. + The new immutable collection. + + + + Creates a new immutable hash set builder. + + The type of items stored by the collection. + The immutable collection. + + + + Creates a new immutable hash set builder. + + The type of items stored by the collection. + The equality comparer. + + The immutable collection. + + + + + Enumerates a sequence exactly once and produces an immutable set of its contents. + + The type of element in the sequence. + The sequence to enumerate. + The equality comparer to use for initializing and adding members to the hash set. + An immutable set. + + + + Enumerates a sequence exactly once and produces an immutable set of its contents. + + The type of element in the sequence. + The sequence to enumerate. + An immutable set. + + + + A set of initialization methods for instances of . + + + + + Returns an empty collection. + + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The immutable collection. + + + + Returns an empty collection. + + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The key comparer. + The immutable collection. + + + + Returns an empty collection. + + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The key comparer. + The value comparer. + The immutable collection. + + + + Creates a new immutable collection prefilled with the specified items. + + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The items to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified items. + + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The key comparer. + The items to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified items. + + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The key comparer. + The value comparer. + The items to prepopulate. + The new immutable collection. + + + + Creates a new immutable sorted dictionary builder. + + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The immutable collection builder. + + + + Creates a new immutable sorted dictionary builder. + + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The key comparer. + The immutable collection builder. + + + + Creates a new immutable sorted dictionary builder. + + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The key comparer. + The value comparer. + The immutable collection builder. + + + + Constructs an immutable sorted dictionary based on some transformation of a sequence. + + The type of element in the sequence. + The type of key in the resulting map. + The type of value in the resulting map. + The sequence to enumerate to generate the map. + The function that will produce the key for the map from each sequence element. + The function that will produce the value for the map from each sequence element. + The key comparer to use for the map. + The value comparer to use for the map. + The immutable map. + + + + Constructs an immutable sorted dictionary based on some transformation of a sequence. + + The type of element in the sequence. + The type of key in the resulting map. + The type of value in the resulting map. + The sequence to enumerate to generate the map. + The function that will produce the key for the map from each sequence element. + The function that will produce the value for the map from each sequence element. + The key comparer to use for the map. + The immutable map. + + + + Constructs an immutable sorted dictionary based on some transformation of a sequence. + + The type of element in the sequence. + The type of key in the resulting map. + The type of value in the resulting map. + The sequence to enumerate to generate the map. + The function that will produce the key for the map from each sequence element. + The function that will produce the value for the map from each sequence element. + The immutable map. + + + + Creates an immutable sorted dictionary given a sequence of key=value pairs. + + The type of key in the map. + The type of value in the map. + The sequence of key=value pairs. + The key comparer to use when building the immutable map. + The value comparer to use for the immutable map. + An immutable map. + + + + Creates an immutable sorted dictionary given a sequence of key=value pairs. + + The type of key in the map. + The type of value in the map. + The sequence of key=value pairs. + The key comparer to use when building the immutable map. + An immutable map. + + + + Creates an immutable sorted dictionary given a sequence of key=value pairs. + + The type of key in the map. + The type of value in the map. + The sequence of key=value pairs. + An immutable map. + + + + A set of initialization methods for instances of . + + + + + Returns an empty collection. + + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The immutable collection. + + + + Returns an empty collection with the specified key comparer. + + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The key comparer. + + The immutable collection. + + + + + Returns an empty collection with the specified comparers. + + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The key comparer. + The value comparer. + + The immutable collection. + + + + + Creates a new immutable collection prefilled with the specified items. + + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The items to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified items. + + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The key comparer. + The items to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified items. + + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The key comparer. + The value comparer. + The items to prepopulate. + The new immutable collection. + + + + Creates a new immutable dictionary builder. + + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The new builder. + + + + Creates a new immutable dictionary builder. + + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The key comparer. + The new builder. + + + + Creates a new immutable dictionary builder. + + The type of keys stored by the dictionary. + The type of values stored by the dictionary. + The key comparer. + The value comparer. + The new builder. + + + + Constructs an immutable hash map based on some transformation of a sequence. + + The type of element in the sequence. + The type of key in the resulting map. + The type of value in the resulting map. + The sequence to enumerate to generate the map. + The function that will produce the key for the map from each sequence element. + The function that will produce the value for the map from each sequence element. + The key comparer to use for the map. + The value comparer to use for the map. + The immutable map. + + + + Constructs an immutable hash map based on some transformation of a sequence. + + The type of element in the sequence. + The type of key in the resulting map. + The type of value in the resulting map. + The sequence to enumerate to generate the map. + The function that will produce the key for the map from each sequence element. + The function that will produce the value for the map from each sequence element. + The key comparer to use for the map. + The immutable map. + + + + Constructs an immutable hash map based on some transformation of a sequence. + + The type of element in the sequence. + The type of key in the resulting map. + The type of value in the resulting map. + The sequence to enumerate to generate the map. + The function that will produce the key for the map from each sequence element. + The function that will produce the value for the map from each sequence element. + The immutable map. + + + + Creates an immutable hash map given a sequence of key=value pairs. + + The type of key in the map. + The type of value in the map. + The sequence of key=value pairs. + The key comparer to use when building the immutable map. + The value comparer to use for the immutable map. + An immutable map. + + + + Creates an immutable hash map given a sequence of key=value pairs. + + The type of key in the map. + The type of value in the map. + The sequence of key=value pairs. + The key comparer to use when building the immutable map. + An immutable map. + + + + Creates an immutable hash map given a sequence of key=value pairs. + + The type of key in the map. + The type of value in the map. + The sequence of key=value pairs. + An immutable map. + + + + Determines whether this map contains the specified key-value pair. + + The type of key in the map. + The type of value in the map. + The map to search. + The key to check for. + The value to check for on a matching key, if found. + + true if this map contains the key-value pair; otherwise, false. + + + + + Gets the value for a given key if a matching key exists in the dictionary. + + The dictionary to retrieve the value from. + The key to search for. + The value for the key, or default(TValue) if no matching key was found. + + + + Gets the value for a given key if a matching key exists in the dictionary. + + The type of the key. + The type of the value. + The dictionary to retrieve the value from. + The key to search for. + The default value to return if no matching key is found in the dictionary. + + The value for the key, or if no matching key was found. + + + + + A set of initialization methods for instances of . + + + + + Returns an empty collection. + + The type of items stored by the collection. + The immutable collection. + + + + Creates a new immutable collection prefilled with the specified item. + + The type of items stored by the collection. + The item to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified items. + + The type of items stored by the collection. + The items to prepopulate. + The new immutable collection. + + + + Creates a new immutable collection prefilled with the specified items. + + The type of items stored by the collection. + The items to prepopulate. + The new immutable collection. + + + + Creates a new immutable list builder. + + The type of items stored by the collection. + The immutable collection builder. + + + + Enumerates a sequence exactly once and produces an immutable list of its contents. + + The type of element in the sequence. + The sequence to enumerate. + An immutable list. + + + + Replaces the first equal element in the list with the specified element. + + The list to search. + The element to replace. + The element to replace the old element with. + The new list -- even if the value being replaced is equal to the new value for that position. + Thrown when the old value does not exist in the list. + + + + Removes the specified value from this list. + + The list to search. + The value to remove. + A new list with the element removed, or this list if the element is not in this list. + + + + Removes the specified values from this list. + + The list to search. + The items to remove if matches are found in this list. + + A new list with the elements removed. + + + + + Searches for the specified object and returns the zero-based index of the + first occurrence within the ImmutableList<T> + + The list to search. + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + + The zero-based index of the first occurrence of item within the range of + elements in the ImmutableList<T> that extends from index + to the last element, if found; otherwise, –1. + + + + + Searches for the specified object and returns the zero-based index of the + first occurrence within the ImmutableList<T> + + The list to search. + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + The equality comparer to use in the search. + + The zero-based index of the first occurrence of item within the range of + elements in the ImmutableList<T> that extends from index + to the last element, if found; otherwise, –1. + + + + + Searches for the specified object and returns the zero-based index of the + first occurrence within the range of elements in the ImmutableList<T> + that extends from the specified index to the last element. + + The list to search. + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + + The zero-based starting index of the search. 0 (zero) is valid in an empty + list. + + + The zero-based index of the first occurrence of item within the range of + elements in the ImmutableList<T> that extends from index + to the last element, if found; otherwise, –1. + + + + + Searches for the specified object and returns the zero-based index of the + first occurrence within the range of elements in the ImmutableList<T> + that extends from the specified index to the last element. + + The list to search. + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + + The zero-based starting index of the search. 0 (zero) is valid in an empty + list. + + + The number of elements in the section to search. + + + The zero-based index of the first occurrence of item within the range of + elements in the ImmutableList<T> that extends from index + to the last element, if found; otherwise, –1. + + + + + Searches for the specified object and returns the zero-based index of the + last occurrence within the entire ImmutableList<T>. + + The list to search. + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + + The zero-based index of the last occurrence of item within the entire the + ImmutableList<T>, if found; otherwise, –1. + + + + + Searches for the specified object and returns the zero-based index of the + last occurrence within the entire ImmutableList<T>. + + The list to search. + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + The equality comparer to use in the search. + + The zero-based index of the last occurrence of item within the entire the + ImmutableList<T>, if found; otherwise, –1. + + + + + Searches for the specified object and returns the zero-based index of the + last occurrence within the range of elements in the ImmutableList<T> + that extends from the first element to the specified index. + + The list to search. + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + + The zero-based starting index of the backward search. + + + The zero-based index of the last occurrence of item within the range of elements + in the ImmutableList<T> that extends from the first element + to index, if found; otherwise, –1. + + + + + Searches for the specified object and returns the zero-based index of the + last occurrence within the range of elements in the ImmutableList<T> + that extends from the first element to the specified index. + + The list to search. + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + + The zero-based starting index of the backward search. + + + The number of elements in the section to search. + + + The zero-based index of the last occurrence of item within the range of elements + in the ImmutableList<T> that extends from the first element + to index, if found; otherwise, –1. + + + + + Defined on a generic collection that sorts its contents using an . + + The type of element sorted in the collection. + + + + Gets the comparer used to sort keys. + + + + + A thin wrapper around the Keys or Values enumerators so they look like a collection. + + The type of key in the dictionary. + The type of value in the dictionary. + Either TKey or TValue. + + + + The underlying wrapped dictionary. + + + + + The key or value enumerable that this instance wraps. + + + + + Initializes a new instance of the class. + + The dictionary to base on. + The keys or values enumeration to wrap as a collection. + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + Copies the elements of the to an , starting at a particular index. + + The one-dimensional that is the destination of the elements copied from . The must have zero-based indexing. + The zero-based index in at which copying begins. + + + + See + + + + + See + + The number of elements contained in the . + + + + Gets the wrapped dictionary. + + + + + Gets a value indicating whether access to the is synchronized (thread safe). + + true if access to the is synchronized (thread safe); otherwise, false. + + + + Gets an object that can be used to synchronize access to the . + + An object that can be used to synchronize access to the . + + + + A lightweight collection view over and IEnumerable of keys. + + + + + Initializes a new instance of the class. + + + + + See + + + + + A lightweight collection view over and IEnumerable of values. + + + + + Initializes a new instance of the class. + + + + + See + + + + + An interface for binary tree nodes that allow our common enumerator to walk the graph. + + The type of value for each node. + + + + Gets the depth of the tree below this node. + + + + + Gets the value represented by the current node. + + + + + Gets the left branch of this node. + + + + + Gets the right branch of this node. + + + + + Gets a value indicating whether this node is empty. + + + + + Gets the number of non-empty nodes at this node and below. + + Thrown if the implementation does not store this value at the node. + + + + An interface that describes the methods that the ImmutableList and ImmutableList+Builder types have in common. + + The type of element in the collection. + + + + Converts the elements in the current ImmutableList<T> to + another type, and returns a list containing the converted elements. + + + A System.Converter<TInput,TOutput> delegate that converts each element from + one type to another type. + + + The type of the elements of the target array. + + + A ImmutableList<T> of the target type containing the converted + elements from the current ImmutableList<T>. + + + + + Performs the specified action on each element of the list. + + The System.Action<T> delegate to perform on each element of the list. + + + + Creates a shallow copy of a range of elements in the source ImmutableList<T>. + + + The zero-based ImmutableList<T> index at which the range + starts. + + + The number of elements in the range. + + + A shallow copy of a range of elements in the source ImmutableList<T>. + + + + + Copies the entire ImmutableList<T> to a compatible one-dimensional + array, starting at the beginning of the target array. + + + The one-dimensional System.Array that is the destination of the elements + copied from ImmutableList<T>. The System.Array must have + zero-based indexing. + + + + + Copies the entire ImmutableList<T> to a compatible one-dimensional + array, starting at the specified index of the target array. + + + The one-dimensional System.Array that is the destination of the elements + copied from ImmutableList<T>. The System.Array must have + zero-based indexing. + + + The zero-based index in array at which copying begins. + + + + + Copies a range of elements from the ImmutableList<T> to + a compatible one-dimensional array, starting at the specified index of the + target array. + + + The zero-based index in the source ImmutableList<T> at + which copying begins. + + + The one-dimensional System.Array that is the destination of the elements + copied from ImmutableList<T>. The System.Array must have + zero-based indexing. + + The zero-based index in array at which copying begins. + The number of elements to copy. + + + + Determines whether the ImmutableList<T> contains elements + that match the conditions defined by the specified predicate. + + + The System.Predicate<T> delegate that defines the conditions of the elements + to search for. + + + true if the ImmutableList<T> contains one or more elements + that match the conditions defined by the specified predicate; otherwise, + false. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the first occurrence within the entire ImmutableList<T>. + + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The first element that matches the conditions defined by the specified predicate, + if found; otherwise, the default value for type T. + + + + + Retrieves all the elements that match the conditions defined by the specified + predicate. + + + The System.Predicate<T> delegate that defines the conditions of the elements + to search for. + + + A ImmutableList<T> containing all the elements that match + the conditions defined by the specified predicate, if found; otherwise, an + empty ImmutableList<T>. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the first occurrence within + the entire ImmutableList<T>. + + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The zero-based index of the first occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the first occurrence within + the range of elements in the ImmutableList<T> that extends + from the specified index to the last element. + + The zero-based starting index of the search. + The System.Predicate<T> delegate that defines the conditions of the element to search for. + + The zero-based index of the first occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the first occurrence within + the range of elements in the ImmutableList<T> that starts + at the specified index and contains the specified number of elements. + + The zero-based starting index of the search. + The number of elements in the section to search. + The System.Predicate<T> delegate that defines the conditions of the element to search for. + + The zero-based index of the first occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the last occurrence within the entire ImmutableList<T>. + + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The last element that matches the conditions defined by the specified predicate, + if found; otherwise, the default value for type T. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the last occurrence within + the entire ImmutableList<T>. + + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The zero-based index of the last occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the last occurrence within + the range of elements in the ImmutableList<T> that extends + from the first element to the specified index. + + The zero-based starting index of the backward search. + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + The zero-based index of the last occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the last occurrence within + the range of elements in the ImmutableList<T> that contains + the specified number of elements and ends at the specified index. + + The zero-based starting index of the backward search. + The number of elements in the section to search. + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The zero-based index of the last occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Determines whether every element in the ImmutableList<T> + matches the conditions defined by the specified predicate. + + + The System.Predicate<T> delegate that defines the conditions to check against + the elements. + + + true if every element in the ImmutableList<T> matches the + conditions defined by the specified predicate; otherwise, false. If the list + has no elements, the return value is true. + + + + + Contains the inner Builder class. + + + Contains the inner DebuggerProxy class. + + + Contains the inner Enumerator class. + + + Contains the inner HashBucket struct. + + + Contains the inner MutationInput class. + + + Contains the inner MutationResult class. + + + Contains the inner NodeEnumerable class. + + + An immutable unordered hash set implementation. + + The type of elements in the set. + + + + A set of elements that can only be modified by creating a new instance of the set. + + The type of element stored in the set. + + Mutations on this set generate new sets. Incremental changes to a set share as much memory as possible with the prior versions of a set, + while allowing garbage collection to clean up any unique set data that is no longer being referenced. + + + + + Gets an empty set that retains the same sort or unordered semantics that this instance has. + + + + + Determines whether this set contains the specified value. + + The value. + + true if the set contains the specified value; otherwise, false. + + + + + Adds the specified value to this set. + + The value to add. + A new set with the element added, or this set if the element is already in this set. + + + + Removes the specified value from this set. + + The value to remove. + A new set with the element removed, or this set if the element is not in this set. + + + + Searches the set for a given value and returns the equal value it finds, if any. + + The value to search for. + The value from the set that the search found, or if the search yielded no match. + A value indicating whether the search was successful. + + This can be useful when you want to reuse a previously stored reference instead of + a newly constructed one (so that more sharing of references can occur) or to look up + a value that has more complete data than the value you currently have, although their + comparer functions indicate they are equal. + + + + + Produces a set that contains elements that exist in both this set and the specified set. + + The set to intersect with this one. + A new set that contains any elements that exist in both sets. + + + + Removes a given set of items from this set. + + The items to remove from this set. + The new set with the items removed; or the original set if none of the items were in the set. + + + + Produces a set that contains elements either in this set or a given sequence, but not both. + + The other sequence of items. + The new set. + + + + Adds a given set of items to this set. + + The items to add. + The new set with the items added; or the original set if all the items were already in the set. + + + + Checks whether a given sequence of items entirely describe the contents of this set. + + The sequence of items to check against this set. + A value indicating whether the sets are equal. + + + + Determines whether the current set is a proper (strict) subset of a specified collection. + + The collection to compare to the current set. + true if the current set is a correct subset of other; otherwise, false. + + + + Determines whether the current set is a proper superset of a specified collection. + + The collection to compare to the current set. + true if the current set is a correct superset of other; otherwise, false. + + + + Determines whether a set is a subset of a specified collection. + + The collection to compare to the current set. + true if the current set is a subset of other; otherwise, false. + + + + Determines whether the current set is a superset of a specified collection. + + The collection to compare to the current set. + true if the current set is a superset of other; otherwise, false. + + + + Determines whether the current set overlaps with the specified collection. + + The collection to compare to the current set. + true if the current set and other share at least one common element; otherwise, false. + + + + The default empty set. + + + + + The singleton delegate that freezes the contents of hash buckets when the root of the data structure is frozen. + + + + + The equality comparer used to hash the elements in the collection. + + + + + The number of elements in this collection. + + + + + The sorted map that this hash set wraps. The key is the hash code and the value is the bucket of all items that hashed to it. + + + + + Initializes a new instance of the class. + + The equality comparer. + + + + Initializes a new instance of the class. + + The sorted set that this set wraps. + The equality comparer used by this instance. + The number of elements in this collection. + + + + See the interface. + + + + + See the interface. + + + + + Creates a collection with the same contents as this collection that + can be efficiently mutated across multiple operations using standard + mutable interfaces. + + + This is an O(1) operation and results in only a single (small) memory allocation. + The mutable collection that is returned is *not* thread-safe. + + + + + See the interface. + + + + + See the interface. + + + + + Searches the set for a given value and returns the equal value it finds, if any. + + The value to search for. + The value from the set that the search found, or the original value if the search yielded no match. + A value indicating whether the search was successful. + + This can be useful when you want to reuse a previously stored reference instead of + a newly constructed one (so that more sharing of references can occur) or to look up + a value that has more complete data than the value you currently have, although their + comparer functions indicate they are equal. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + Produces a set that contains elements either in this set or a given sequence, but not both. + + The other sequence of items. + The new set. + + + + Checks whether a given sequence of items entirely describe the contents of this set. + + The sequence of items to check against this set. + A value indicating whether the sets are equal. + + + + Determines whether the current set is a property (strict) subset of a specified collection. + + The collection to compare to the current set. + true if the current set is a correct subset of other; otherwise, false. + + + + Determines whether the current set is a correct superset of a specified collection. + + The collection to compare to the current set. + true if the current set is a correct superset of other; otherwise, false. + + + + Determines whether a set is a subset of a specified collection. + + The collection to compare to the current set. + true if the current set is a subset of other; otherwise, false. + + + + Determines whether the current set is a superset of a specified collection. + + The collection to compare to the current set. + true if the current set is a superset of other; otherwise, false. + + + + Determines whether the current set overlaps with the specified collection. + + The collection to compare to the current set. + true if the current set and other share at least one common element; otherwise, false. + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + Produces a set that contains elements either in this set or a given sequence, but not both. + + The other sequence of items. + The new set. + + + + See the interface. + + + + + See the interface. + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + Copies the elements of the to an , starting at a particular index. + + The one-dimensional that is the destination of the elements copied from . The must have zero-based indexing. + The zero-based index in at which copying begins. + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through the collection. + + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + Performs the set operation on a given data structure. + + + + + Performs the set operation on a given data structure. + + + + + Performs the set operation on a given data structure. + + + + + Performs the set operation on a given data structure. + + + + + Performs the set operation on a given data structure. + + + + + Performs the set operation on a given data structure. + + + + + Performs the set operation on a given data structure. + + + + + Performs the set operation on a given data structure. + + + + + Performs the set operation on a given data structure. + + + + + Performs the set operation on a given data structure. + + + + + Performs the set operation on a given data structure. + + + + + Performs the set operation on a given data structure. + + + + + Performs the set operation on a given data structure. + + + + + Performs the set operation on a given data structure. + + + + + Wraps the specified data structure with an immutable collection wrapper. + + The root of the data structure. + The equality comparer. + The number of elements in the data structure. + The immutable collection. + + + + Wraps the specified data structure with an immutable collection wrapper. + + The root of the data structure. + The adjusted count if the root has changed. + The immutable collection. + + + + Bulk adds entries to the set. + + The entries to add. + true when being called from ToHashSet to avoid StackOverflow. + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See ICollection. + + + + + See the ICollection interface. + + + + + Gets the empty singleton instance for this type. + + + + + Gets a data structure that captures the current state of this map, as an input into a query or mutating function. + + + + + See the interface. + + + + + A hash set that mutates with little or no memory allocations, + can produce and/or build on immutable hash set instances very efficiently. + + + + While and other bulk change methods + already provide fast bulk change operations on the collection, this class allows + multiple combinations of changes to be made to a set with equal efficiency. + + + Instance members of this class are not thread-safe. + + + + + + The root of the binary tree that stores the collection. Contents are typically not entirely frozen. + + + + + The equality comparer. + + + + + The number of elements in this collection. + + + + + Caches an immutable instance that represents the current state of the collection. + + Null if no immutable view has been created for the current version. + + + + A number that increments every time the builder changes its contents. + + + + + Initializes a new instance of the class. + + The set. + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Creates an immutable hash set based on the contents of this instance. + + An immutable set. + + This method is an O(n) operation, and approaches O(1) time as the number of + actual mutations to the set since the last call to this method approaches 0. + + + + + Adds the specified item. + + The item. + True if the item did not already belong to the collection. + + + + Removes the first occurrence of a specific object from the . + + The object to remove from the . + + true if was successfully removed from the ; otherwise, false. This method also returns false if is not found in the original . + + The is read-only. + + + + Determines whether the contains a specific value. + + The object to locate in the . + + true if is found in the ; otherwise, false. + + + + + Removes all items from the . + + The is read-only. + + + + Removes all elements in the specified collection from the current set. + + The collection of items to remove from the set. + + + + Modifies the current set so that it contains only elements that are also in a specified collection. + + The collection to compare to the current set. + + + + Determines whether the current set is a proper (strict) subset of a specified collection. + + The collection to compare to the current set. + true if the current set is a correct subset of other; otherwise, false. + + + + Determines whether the current set is a proper (strict) superset of a specified collection. + + The collection to compare to the current set. + true if the current set is a superset of other; otherwise, false. + + + + Determines whether the current set is a subset of a specified collection. + + The collection to compare to the current set. + true if the current set is a subset of other; otherwise, false. + + + + Determines whether the current set is a superset of a specified collection. + + The collection to compare to the current set. + true if the current set is a superset of other; otherwise, false. + + + + Determines whether the current set overlaps with the specified collection. + + The collection to compare to the current set. + true if the current set and other share at least one common element; otherwise, false. + + + + Determines whether the current set and the specified collection contain the same elements. + + The collection to compare to the current set. + true if the current set is equal to other; otherwise, false. + + + + Modifies the current set so that it contains only elements that are present either in the current set or in the specified collection, but not both. + + The collection to compare to the current set. + + + + Modifies the current set so that it contains all elements that are present in both the current set and in the specified collection. + + The collection to compare to the current set. + + + + Adds an item to the . + + The object to add to the . + The is read-only. + + + + See the interface. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + Applies the result of some mutation operation to this instance. + + The result. + + + + Gets the number of elements contained in the . + + The number of elements contained in the . + + + + Gets a value indicating whether the is read-only. + + true if the is read-only; otherwise, false. + + + + Gets or sets the key comparer. + + + The key comparer. + + + + + Gets the current version of the contents of this builder. + + + + + Gets the initial data to pass to a query or mutation method. + + + + + Gets or sets the root of this data structure. + + + + + A simple view of the immutable collection that the debugger can show to the developer. + + + + + The collection to be enumerated. + + + + + The simple view of the collection. + + + + + Initializes a new instance of the class. + + The collection to display in the debugger + + + + Gets a simple debugger-viewable collection. + + + + + Enumerates the contents of the collection in an allocation-free manner. + + + + + The builder being enumerated, if applicable. + + + + + The enumerator over the sorted map whose keys are hash values. + + + + + The enumerator in use within an individual HashBucket. + + + + + The version of the builder (when applicable) that is being enumerated. + + + + + Initializes a new instance of the struct. + + The root. + The builder, if applicable. + + + + Advances the enumerator to the next element of the collection. + + + true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection. + + The collection was modified after the enumerator was created. + + + + Sets the enumerator to its initial position, which is before the first element in the collection. + + The collection was modified after the enumerator was created. + + + + Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + + + + + Throws an exception if the underlying builder's contents have been changed since enumeration started. + + Thrown if the collection has changed. + + + + Gets the current element. + + + + + Gets the current element. + + + + + The result of a mutation operation. + + + + + The change required element(s) to be added or removed from the collection. + + + + + No change was required (the operation ended in a no-op). + + + + + Contains all the keys in the collection that hash to the same value. + + + + + One of the values in this bucket. + + + + + Any other elements that hash to the same value. + + + This is null if and only if the entire bucket is empty (including ). + It's empty if has an element but no additional elements. + + + + + Initializes a new instance of the struct. + + The first element. + The additional elements. + + + + Returns an enumerator that iterates through the collection. + + + + + Adds the specified value. + + The value. + The value comparer. + A description of the effect was on adding an element to this HashBucket. + A new HashBucket that contains the added value and any values already held by this hashbucket. + + + + Determines whether the HashBucket contains the specified value. + + The value. + The value comparer. + + + + Searches the set for a given value and returns the equal value it finds, if any. + + The value to search for. + The value comparer. + The value from the set that the search found, or the original value if the search yielded no match. + + A value indicating whether the search was successful. + + + + + Removes the specified value if it exists in the collection. + + The value. + The equality comparer. + A description of the effect was on adding an element to this HashBucket. + A new HashBucket that does not contain the removed value and any values already held by this hashbucket. + + + + Freezes this instance so that any further mutations require new memory allocations. + + + + + Gets a value indicating whether this instance is empty. + + + true if this instance is empty; otherwise, false. + + + + + Enumerates all the elements in this instance. + + + + + The bucket being enumerated. + + + + + A value indicating whether this enumerator has been disposed. + + + + + The current position of this enumerator. + + + + + The enumerator that represents the current position over the additionalValues of the HashBucket. + + + + + Initializes a new instance of the struct. + + The bucket. + + + + Advances the enumerator to the next element of the collection. + + + true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection. + + The collection was modified after the enumerator was created. + + + + Sets the enumerator to its initial position, which is before the first element in the collection. + + The collection was modified after the enumerator was created. + + + + Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + + + + + Throws an ObjectDisposedException if this enumerator has been disposed. + + + + + Gets the current element. + + + + + Gets the current element. + + + + + Describes the positions the enumerator state machine may be in. + + + + + The first element has not yet been moved to. + + + + + We're at the firstValue of the containing bucket. + + + + + We're enumerating the additionalValues in the bucket. + + + + + The end of enumeration has been reached. + + + + + Description of the current data structure as input into a + mutating or query method. + + + + + The root of the data structure for the collection. + + + + + The equality comparer. + + + + + The current number of elements in the collection. + + + + + Initializes a new instance of the struct. + + The set. + + + + Initializes a new instance of the struct. + + The root. + The equality comparer. + The count. + + + + Gets the root of the data structure for the collection. + + + + + Gets the equality comparer. + + + + + Gets the current number of elements in the collection. + + + + + Interpretations for a count member. + + + + + The count member describes an adjustment to the previous count of the collection. + + + + + The count member describes the actual count of the collection. + + + + + Describes the result of a mutation on the immutable data structure. + + + + + The root node of the data structure after the mutation. + + + + + Either the number of elements added or removed from the collection as a result of the operation (a negative number represents removed elements), + or the total number of elements in the collection after the mutation. The appropriate interpretation of this value is indicated by the + field. + + + + + Whether to consider the field to be a count adjustment or total count. + + + + + Initializes a new instance of the struct. + + The root node of the result. + The total element count or a count adjustment. + The appropriate interpretation for the parameter. + + + + Returns an immutable hash set that captures the result of this mutation. + + The prior version of the set. Used to capture the equality comparer and previous count, when applicable. + The new collection. + + + + Gets the root node of the data structure after the mutation. + + + + + Gets either the number of elements added or removed from the collection as a result of the operation (a negative number represents removed elements), + or the total number of elements in the collection after the mutation. The appropriate interpretation of this value is indicated by the + property. + + + + + Gets the appropriate interpration for the property; whether to be a count adjustment or total count. + + + + + Enumerates over a sorted map used for hash buckets. + + + + + The root of the sorted map to enumerate. + + + + + Initializes a new instance of the struct. + + The root. + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + Describes an ordered collection of elements. + + The type of element in the collection. + + + + Gets the number of elements in the collection. + + + + + Gets the element in the collection at a given index. + + + + + Extension methods for immutable types. + + + + + Tries to divine the number of elements in a sequence without actually enumerating each element. + + The type of elements in the sequence. + The enumerable source. + Receives the number of elements in the enumeration, if it could be determined. + true if the count could be determined; false otherwise. + + + + Tries to divine the number of elements in a sequence without actually enumerating each element. + + The type of elements in the sequence. + The enumerable source. + Receives the number of elements in the enumeration, if it could be determined. + true if the count could be determined; false otherwise. + + + + Gets the number of elements in the specified sequence, + while guaranteeing that the sequence is only enumerated once + in total by this method and the caller. + + The type of element in the collection. + The sequence. + The number of elements in the sequence. + + + + Provides a known wrapper around a sequence of elements that provides the number of elements + and an indexer into its contents. + + The type of elements in the collection. + The collection. + An ordered collection. May not be thread-safe. Never null. + + + + Wraps a List{T} as an ordered collection. + + The type of element in the collection. + + + + The list being exposed. + + + + + Initializes a new instance of the class. + + The collection. + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + Gets the count. + + + + + Gets the at the specified index. + + + + + Wraps any IEnumerable as an ordered, indexable list. + + The type of element in the collection. + + + + The original sequence. + + + + + The list-ified sequence. + + + + + Initializes a new instance of the class. + + The sequence. + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + Gets the count. + + + + + Gets the at the specified index. + + + + + An immutable list implementation. + + The type of elements in the set. + + Contains the inner Builder class. + + + + + The singleton default empty instance. + + + + + The root node of the AVL tree that stores this set. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The root of the AVL tree with the contents of this set. + + + + See the interface. + + + + + See the interface. + + + + + Creates a collection with the same contents as this collection that + can be efficiently mutated across multiple operations using standard + mutable interfaces. + + + This is an O(1) operation and results in only a single (small) memory allocation. + The mutable collection that is returned is *not* thread-safe. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + Removes the specified values from this list. + + The starting index to begin removal. + The number of elements to remove. + A new list with the elements removed. + + + + Removes the specified values from this list. + + The items to remove if matches are found in this list. + + A new list with the elements removed. + + + + + Removes the specified values from this list. + + The items to remove if matches are found in this list. + + The equality comparer to use in the search. + + + A new list with the elements removed. + + + + + See the interface. + + + + + Removes all the elements that match the conditions defined by the specified + predicate. + + + The System.Predicate<T> delegate that defines the conditions of the elements + to remove. + + + The new list. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + Reverses the order of the elements in the entire ImmutableList<T>. + + The reversed list. + + + + Reverses the order of the elements in the specified range. + + The zero-based starting index of the range to reverse. + The number of elements in the range to reverse. + The reversed list. + + + + Sorts the elements in the entire ImmutableList<T> using + the default comparer. + + + + + Sorts the elements in the entire ImmutableList<T> using + the specified System.Comparison<T>. + + + The System.Comparison<T> to use when comparing elements. + + The sorted list. + + + + Sorts the elements in the entire ImmutableList<T> using + the specified comparer. + + + The System.Collections.Generic.IComparer<T> implementation to use when comparing + elements, or null to use the default comparer System.Collections.Generic.Comparer<T>.Default. + + The sorted list. + + + + Sorts the elements in a range of elements in ImmutableList<T> + using the specified comparer. + + + The zero-based starting index of the range to sort. + + + The length of the range to sort. + + + The System.Collections.Generic.IComparer<T> implementation to use when comparing + elements, or null to use the default comparer System.Collections.Generic.Comparer<T>.Default. + + The sorted list. + + + + Performs the specified action on each element of the list. + + The System.Action<T> delegate to perform on each element of the list. + + + + Copies the entire ImmutableList<T> to a compatible one-dimensional + array, starting at the beginning of the target array. + + + The one-dimensional System.Array that is the destination of the elements + copied from ImmutableList<T>. The System.Array must have + zero-based indexing. + + + + + Copies the entire ImmutableList<T> to a compatible one-dimensional + array, starting at the specified index of the target array. + + + The one-dimensional System.Array that is the destination of the elements + copied from ImmutableList<T>. The System.Array must have + zero-based indexing. + + + The zero-based index in array at which copying begins. + + + + + Copies a range of elements from the ImmutableList<T> to + a compatible one-dimensional array, starting at the specified index of the + target array. + + + The zero-based index in the source ImmutableList<T> at + which copying begins. + + + The one-dimensional System.Array that is the destination of the elements + copied from ImmutableList<T>. The System.Array must have + zero-based indexing. + + The zero-based index in array at which copying begins. + The number of elements to copy. + + + + Creates a shallow copy of a range of elements in the source ImmutableList<T>. + + + The zero-based ImmutableList<T> index at which the range + starts. + + + The number of elements in the range. + + + A shallow copy of a range of elements in the source ImmutableList<T>. + + + + + Converts the elements in the current ImmutableList<T> to + another type, and returns a list containing the converted elements. + + + A System.Converter<TInput,TOutput> delegate that converts each element from + one type to another type. + + + The type of the elements of the target array. + + + A ImmutableList<T> of the target type containing the converted + elements from the current ImmutableList<T>. + + + + + Determines whether the ImmutableList<T> contains elements + that match the conditions defined by the specified predicate. + + + The System.Predicate<T> delegate that defines the conditions of the elements + to search for. + + + true if the ImmutableList<T> contains one or more elements + that match the conditions defined by the specified predicate; otherwise, + false. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the first occurrence within the entire ImmutableList<T>. + + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The first element that matches the conditions defined by the specified predicate, + if found; otherwise, the default value for type T. + + + + + Retrieves all the elements that match the conditions defined by the specified + predicate. + + + The System.Predicate<T> delegate that defines the conditions of the elements + to search for. + + + A ImmutableList<T> containing all the elements that match + the conditions defined by the specified predicate, if found; otherwise, an + empty ImmutableList<T>. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the first occurrence within + the entire ImmutableList<T>. + + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The zero-based index of the first occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the first occurrence within + the range of elements in the ImmutableList<T> that extends + from the specified index to the last element. + + The zero-based starting index of the search. + The System.Predicate<T> delegate that defines the conditions of the element to search for. + + The zero-based index of the first occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the first occurrence within + the range of elements in the ImmutableList<T> that starts + at the specified index and contains the specified number of elements. + + The zero-based starting index of the search. + The number of elements in the section to search. + The System.Predicate<T> delegate that defines the conditions of the element to search for. + + The zero-based index of the first occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the last occurrence within the entire ImmutableList<T>. + + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The last element that matches the conditions defined by the specified predicate, + if found; otherwise, the default value for type T. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the last occurrence within + the entire ImmutableList<T>. + + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The zero-based index of the last occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the last occurrence within + the range of elements in the ImmutableList<T> that extends + from the first element to the specified index. + + The zero-based starting index of the backward search. + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + The zero-based index of the last occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the last occurrence within + the range of elements in the ImmutableList<T> that contains + the specified number of elements and ends at the specified index. + + The zero-based starting index of the backward search. + The number of elements in the section to search. + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The zero-based index of the last occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for the specified object and returns the zero-based index of the + first occurrence within the range of elements in the ImmutableList<T> + that starts at the specified index and contains the specified number of elements. + + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + + The zero-based starting index of the search. 0 (zero) is valid in an empty + list. + + + The number of elements in the section to search. + + + The equality comparer to use in the search. + + + The zero-based index of the first occurrence of item within the range of + elements in the ImmutableList<T> that starts at index and + contains count number of elements, if found; otherwise, –1. + + + + + Searches for the specified object and returns the zero-based index of the + last occurrence within the range of elements in the ImmutableList<T> + that contains the specified number of elements and ends at the specified + index. + + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + The zero-based starting index of the backward search. + The number of elements in the section to search. + + The equality comparer to use in the search. + + + The zero-based index of the last occurrence of item within the range of elements + in the ImmutableList<T> that contains count number of elements + and ends at index, if found; otherwise, –1. + + + + + Determines whether every element in the ImmutableList<T> + matches the conditions defined by the specified predicate. + + + The System.Predicate<T> delegate that defines the conditions to check against + the elements. + + + true if every element in the ImmutableList<T> matches the + conditions defined by the specified predicate; otherwise, false. If the list + has no elements, the return value is true. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + Inserts the specified value at the specified index. + + The index at which to insert the value. + The element to add. + The new immutable list. + + + + Inserts the specified value at the specified index. + + The index at which to insert the value. + The elements to add. + The new immutable list. + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + Removes the element at the specified index. + + The index. + A new list with the elements removed. + + + + Replaces an element in the list at a given position with the specified element. + + The position in the list of the element to replace. + The element to replace the old element with. + The new list. + + + + Replaces an element in the list with the specified element. + + The element to replace. + The element to replace the old element with. + + The equality comparer to use in the search. + + The new list. + Thrown when the old value does not exist in the list. + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + Inserts the specified index. + + The index. + The item. + + + + + Removes the value at the specified index. + + The index. + + + + + Adds the specified item. + + The item. + + + + + Clears this instance. + + + + + + Removes the specified item. + + The item. + + + + + + See the ICollection interface. + + + + + Adds an item to the . + + The object to add to the . + + The position into which the new element was inserted, or -1 to indicate that the item was not inserted into the collection, + + + + + + Removes the item at the specified index. + + The zero-based index of the item to remove. + + + + + Clears this instance. + + + + + + Determines whether the contains a specific value. + + The object to locate in the . + + true if the is found in the ; otherwise, false. + + + + + + Determines the index of a specific item in the . + + The object to locate in the . + + The index of if found in the list; otherwise, -1. + + + + + + Inserts an item to the at the specified index. + + The zero-based index at which should be inserted. + The object to insert into the . + + + + + Removes the first occurrence of a specific object from the . + + The object to remove from the . + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + CAUTION: when this enumerator is actually used as a valuetype (not boxed) do NOT copy it by assigning to a second variable + or by passing it to another method. When this enumerator is disposed of it returns a mutable reference type stack to a resource pool, + and if the value type enumerator is copied (which can easily happen unintentionally if you pass the value around) there is a risk + that a stack that has already been returned to the resource pool may still be in use by one of the enumerator copies, leading to data + corruption and/or exceptions. + + + + + Creates a new sorted set wrapper for a node tree. + + The root of the collection. + The immutable sorted set instance. + + + + Attempts to discover an instance beneath some enumerable sequence + if one exists. + + The sequence that may have come from an immutable list. + Receives the concrete typed value if one can be found. + true if the cast was successful; false otherwise. + + + + Creates a wrapping collection type around a root node. + + The root node to wrap. + A wrapping collection type for the new tree. + + + + Creates an immutable list with the contents from a sequence of elements. + + The sequence of elements from which to create the list. + The immutable list. + + + + See the interface. + + + + + See the interface. + + + + + See ICollection. + + + + + See the ICollection interface. + + + + + Gets an empty set with the default sort comparer. + + + + + Gets the element of the set at the given index. + + The 0-based index of the element in the set to return. + The element at the given position. + + + + Gets the element in the collection at a given index. + + + + + Gets or sets the value at the specified index. + + + + + Gets a value indicating whether the is read-only. + + true if the is read-only; otherwise, false. + + + + + Gets a value indicating whether the has a fixed size. + + true if the has a fixed size; otherwise, false. + + + + + Gets a value indicating whether the is read-only. + + true if the is read-only; otherwise, false. + + + + + + Gets or sets the at the specified index. + + + The . + + The index. + + + + + + Enumerates the contents of a binary tree. + + + This struct can and should be kept in exact sync with the other binary tree enumerators: + ImmutableList.Enumerator, ImmutableSortedMap.Enumerator, and ImmutableSortedSet.Enumerator. + + CAUTION: when this enumerator is actually used as a valuetype (not boxed) do NOT copy it by assigning to a second variable + or by passing it to another method. When this enumerator is disposed of it returns a mutable reference type stack to a resource pool, + and if the value type enumerator is copied (which can easily happen unintentionally if you pass the value around) there is a risk + that a stack that has already been returned to the resource pool may still be in use by one of the enumerator copies, leading to data + corruption and/or exceptions. + + + + + The resource pool of reusable mutable stacks for purposes of enumeration. + + + We utilize this resource pool to make "allocation free" enumeration achievable. + + + + + The builder being enumerated, if applicable. + + + + + The starting index of the collection at which to begin enumeration. + + + + + The number of elements to include in the enumeration. + + + + + The number of elements left in the enumeration. + + + + + A value indicating whether this enumerator walks in reverse order. + + + + + The set being enumerated. + + + + + The stack to use for enumerating the binary tree. + + + + + The node currently selected. + + + + + The version of the builder (when applicable) that is being enumerated. + + + + + Initializes an Enumerator structure. + + The root of the set to be enumerated. + The builder, if applicable. + The index of the first element to enumerate. + The number of elements in this collection. + true if the list should be enumerated in reverse order. + + + + Disposes of this enumerator and returns the stack reference to the resource pool. + + + + + Advances enumeration to the next element. + + A value indicating whether there is another element in the enumeration. + + + + Restarts enumeration. + + + + + Obtains the right branch of the given node (or the left, if walking in reverse). + + + + + Obtains the left branch of the given node (or the right, if walking in reverse). + + + + + Throws an ObjectDisposedException if this enumerator has been disposed. + + + + + Throws an exception if the underlying builder's contents have been changed since enumeration started. + + Thrown if the collection has changed. + + + + Pushes this node and all its Left descendents onto the stack. + + The starting node to push onto the stack. + + + + The current element. + + + + + The current element. + + + + + A node in the AVL tree storing this set. + + + + + The default empty node. + + + + + The key associated with this node. + + + + + A value indicating whether this node has been frozen (made immutable). + + + Nodes must be frozen before ever being observed by a wrapping collection type + to protect collections from further mutations. + + + + + The depth of the tree beneath this node. + + + + + The number of elements contained by this subtree starting at this node. + + + If this node would benefit from saving 4 bytes, we could have only a few nodes + scattered throughout the graph actually record the count of nodes beneath them. + Those without the count could query their descendents, which would often short-circuit + when they hit a node that *does* include a count field. + + + + + The left tree. + + + + + The right tree. + + + + + Initializes a new instance of the class + that is pre-frozen. + + + + + Initializes a new instance of the class + that is not yet frozen. + + The value stored by this node. + The left branch. + The right branch. + Whether this node is prefrozen. + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through the collection. + + The builder, if applicable. + + A that can be used to iterate through the collection. + + + + + Creates a node tree that contains the contents of a list. + + An indexable list with the contents that the new node tree should contain. + The starting index within that should be captured by the node tree. + The number of elements from that should be captured by the node tree. + The root of the created node tree. + + + + Adds the specified key to the tree. + + The key. + The new tree. + + + + Adds a value at a given index to this node. + + The location for the new value. + The value to add. + The new tree. + + + + Removes a value at a given index to this node. + + The location for the new value. + The new tree. + + + + Removes all the elements that match the conditions defined by the specified + predicate. + + + The System.Predicate<T> delegate that defines the conditions of the elements + to remove. + + + The new node tree. + + + + + Replaces a value at a given index. + + The location for the new value. + The new value for the node. + The new tree. + + + + Reverses the order of the elements in the entire ImmutableList<T>. + + The reversed list. + + + + Reverses the order of the elements in the specified range. + + The zero-based starting index of the range to reverse. + The number of elements in the range to reverse. + The reversed list. + + + + Sorts the elements in the entire ImmutableList<T> using + the default comparer. + + + + + Sorts the elements in the entire ImmutableList<T> using + the specified System.Comparison<T>. + + + The System.Comparison<T> to use when comparing elements. + + The sorted list. + + + + Sorts the elements in the entire ImmutableList<T> using + the specified comparer. + + + The System.Collections.Generic.IComparer<T> implementation to use when comparing + elements, or null to use the default comparer System.Collections.Generic.Comparer<T>.Default. + + The sorted list. + + + + Sorts the elements in a range of elements in ImmutableList<T> + using the specified comparer. + + + The zero-based starting index of the range to sort. + + + The length of the range to sort. + + + The System.Collections.Generic.IComparer<T> implementation to use when comparing + elements, or null to use the default comparer System.Collections.Generic.Comparer<T>.Default. + + The sorted list. + + + + Searches for the specified object and returns the zero-based index of the + first occurrence within the range of elements in the ImmutableList<T> + that starts at the specified index and contains the specified number of elements. + + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + The equality comparer to use for testing the match of two elements. + + The zero-based index of the first occurrence of item within the range of + elements in the ImmutableList<T> that starts at index and + contains count number of elements, if found; otherwise, –1. + + + + + Searches for the specified object and returns the zero-based index of the + first occurrence within the range of elements in the ImmutableList<T> + that starts at the specified index and contains the specified number of elements. + + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + + The zero-based starting index of the search. 0 (zero) is valid in an empty + list. + + + The number of elements in the section to search. + + The equality comparer to use for testing the match of two elements. + + The zero-based index of the first occurrence of item within the range of + elements in the ImmutableList<T> that starts at index and + contains count number of elements, if found; otherwise, –1. + + + + + Searches for the specified object and returns the zero-based index of the + last occurrence within the range of elements in the ImmutableList<T> + that contains the specified number of elements and ends at the specified + index. + + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + The zero-based starting index of the backward search. + The number of elements in the section to search. + The equality comparer to use for testing the match of two elements. + + The zero-based index of the last occurrence of item within the range of elements + in the ImmutableList<T> that contains count number of elements + and ends at index, if found; otherwise, –1. + + + + + Copies the entire ImmutableList<T> to a compatible one-dimensional + array, starting at the beginning of the target array. + + + The one-dimensional System.Array that is the destination of the elements + copied from ImmutableList<T>. The System.Array must have + zero-based indexing. + + + + + Copies the entire ImmutableList<T> to a compatible one-dimensional + array, starting at the specified index of the target array. + + + The one-dimensional System.Array that is the destination of the elements + copied from ImmutableList<T>. The System.Array must have + zero-based indexing. + + + The zero-based index in array at which copying begins. + + + + + Copies a range of elements from the ImmutableList<T> to + a compatible one-dimensional array, starting at the specified index of the + target array. + + + The zero-based index in the source ImmutableList<T> at + which copying begins. + + + The one-dimensional System.Array that is the destination of the elements + copied from ImmutableList<T>. The System.Array must have + zero-based indexing. + + The zero-based index in array at which copying begins. + The number of elements to copy. + + + + Copies the elements of the to an , starting at a particular index. + + The one-dimensional that is the destination of the elements copied from . The must have zero-based indexing. + The zero-based index in at which copying begins. + + + + Converts the elements in the current ImmutableList<T> to + another type, and returns a list containing the converted elements. + + + A System.Converter<TInput,TOutput> delegate that converts each element from + one type to another type. + + + The type of the elements of the target array. + + + A node tree with the transformed list. + + + + + Determines whether every element in the ImmutableList<T> + matches the conditions defined by the specified predicate. + + + The System.Predicate<T> delegate that defines the conditions to check against + the elements. + + + true if every element in the ImmutableList<T> matches the + conditions defined by the specified predicate; otherwise, false. If the list + has no elements, the return value is true. + + + + + Determines whether the ImmutableList<T> contains elements + that match the conditions defined by the specified predicate. + + + The System.Predicate<T> delegate that defines the conditions of the elements + to search for. + + + true if the ImmutableList<T> contains one or more elements + that match the conditions defined by the specified predicate; otherwise, + false. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the first occurrence within the entire ImmutableList<T>. + + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The first element that matches the conditions defined by the specified predicate, + if found; otherwise, the default value for type T. + + + + + Retrieves all the elements that match the conditions defined by the specified + predicate. + + + The System.Predicate<T> delegate that defines the conditions of the elements + to search for. + + + A ImmutableList<T> containing all the elements that match + the conditions defined by the specified predicate, if found; otherwise, an + empty ImmutableList<T>. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the first occurrence within + the entire ImmutableList<T>. + + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The zero-based index of the first occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the first occurrence within + the range of elements in the ImmutableList<T> that extends + from the specified index to the last element. + + The zero-based starting index of the search. + The System.Predicate<T> delegate that defines the conditions of the element to search for. + + The zero-based index of the first occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the first occurrence within + the range of elements in the ImmutableList<T> that starts + at the specified index and contains the specified number of elements. + + The zero-based starting index of the search. + The number of elements in the section to search. + The System.Predicate<T> delegate that defines the conditions of the element to search for. + + The zero-based index of the first occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the last occurrence within the entire ImmutableList<T>. + + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The last element that matches the conditions defined by the specified predicate, + if found; otherwise, the default value for type T. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the last occurrence within + the entire ImmutableList<T>. + + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The zero-based index of the last occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the last occurrence within + the range of elements in the ImmutableList<T> that extends + from the first element to the specified index. + + The zero-based starting index of the backward search. + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + The zero-based index of the last occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the last occurrence within + the range of elements in the ImmutableList<T> that contains + the specified number of elements and ends at the specified index. + + The zero-based starting index of the backward search. + The number of elements in the section to search. + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The zero-based index of the last occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Freezes this node and all descendent nodes so that any mutations require a new instance of the nodes. + + + + + AVL rotate left operation. + + The tree. + The rotated tree. + + + + AVL rotate right operation. + + The tree. + The rotated tree. + + + + AVL rotate double-left operation. + + The tree. + The rotated tree. + + + + AVL rotate double-right operation. + + The tree. + The rotated tree. + + + + Returns a value indicating whether the tree is in balance. + + The tree. + 0 if the tree is in balance, a positive integer if the right side is heavy, or a negative integer if the left side is heavy. + + + + Determines whether the specified tree is right heavy. + + The tree. + + true if [is right heavy] [the specified tree]; otherwise, false. + + + + + Determines whether the specified tree is left heavy. + + + + + Balances the specified tree. + + The tree. + A balanced tree. + + + + Creates a node mutation, either by mutating this node (if not yet frozen) or by creating a clone of this node + with the described changes. + + The left branch of the mutated node. + The right branch of the mutated node. + The mutated (or created) node. + + + + Creates a node mutation, either by mutating this node (if not yet frozen) or by creating a clone of this node + with the described changes. + + The new value for this node. + The mutated (or created) node. + + + + Gets a value indicating whether this instance is empty. + + + true if this instance is empty; otherwise, false. + + + + + Gets the height of the tree beneath this node. + + + + + Gets the left branch of this node. + + + + + Gets the right branch of this node. + + + + + Gets the value represented by the current node. + + + + + Gets the number of elements contained by this subtree starting at this node. + + + + + Gets the key. + + + + + Gets the element of the set at the given index. + + The 0-based index of the element in the set to return. + The element at the given position. + + + + A simple view of the immutable list that the debugger can show to the developer. + + + + + The collection to be enumerated. + + + + + The simple view of the collection. + + + + + Initializes a new instance of the class. + + The list to display in the debugger + + + + Initializes a new instance of the class. + + The list to display in the debugger + + + + Gets a simple debugger-viewable list. + + + + + A list that mutates with little or no memory allocations, + can produce and/or build on immutable list instances very efficiently. + + + + While and other bulk change methods + already provide fast bulk change operations on the collection, this class allows + multiple combinations of changes to be made to a set with equal efficiency. + + + Instance members of this class are not thread-safe. + + + + + + The binary tree used to store the contents of the list. Contents are typically not entirely frozen. + + + + + Caches an immutable instance that represents the current state of the collection. + + Null if no immutable view has been created for the current version. + + + + A number that increments every time the builder changes its contents. + + + + + The object callers may use to synchronize access to this collection. + + + + + Initializes a new instance of the class. + + A list to act as the basis for a new list. + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Performs the specified action on each element of the list. + + The System.Action<T> delegate to perform on each element of the list. + + + + Copies the entire ImmutableList<T> to a compatible one-dimensional + array, starting at the beginning of the target array. + + + The one-dimensional System.Array that is the destination of the elements + copied from ImmutableList<T>. The System.Array must have + zero-based indexing. + + + + + Copies the entire ImmutableList<T> to a compatible one-dimensional + array, starting at the specified index of the target array. + + + The one-dimensional System.Array that is the destination of the elements + copied from ImmutableList<T>. The System.Array must have + zero-based indexing. + + + The zero-based index in array at which copying begins. + + + + + Copies a range of elements from the ImmutableList<T> to + a compatible one-dimensional array, starting at the specified index of the + target array. + + + The zero-based index in the source ImmutableList<T> at + which copying begins. + + + The one-dimensional System.Array that is the destination of the elements + copied from ImmutableList<T>. The System.Array must have + zero-based indexing. + + The zero-based index in array at which copying begins. + The number of elements to copy. + + + + Creates a shallow copy of a range of elements in the source ImmutableList<T>. + + + The zero-based ImmutableList<T> index at which the range + starts. + + + The number of elements in the range. + + + A shallow copy of a range of elements in the source ImmutableList<T>. + + + + + Converts the elements in the current ImmutableList<T> to + another type, and returns a list containing the converted elements. + + + A System.Converter<TInput,TOutput> delegate that converts each element from + one type to another type. + + + The type of the elements of the target array. + + + A ImmutableList<T> of the target type containing the converted + elements from the current ImmutableList<T>. + + + + + Determines whether the ImmutableList<T> contains elements + that match the conditions defined by the specified predicate. + + + The System.Predicate<T> delegate that defines the conditions of the elements + to search for. + + + true if the ImmutableList<T> contains one or more elements + that match the conditions defined by the specified predicate; otherwise, + false. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the first occurrence within the entire ImmutableList<T>. + + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The first element that matches the conditions defined by the specified predicate, + if found; otherwise, the default value for type T. + + + + + Retrieves all the elements that match the conditions defined by the specified + predicate. + + + The System.Predicate<T> delegate that defines the conditions of the elements + to search for. + + + A ImmutableList<T> containing all the elements that match + the conditions defined by the specified predicate, if found; otherwise, an + empty ImmutableList<T>. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the first occurrence within + the entire ImmutableList<T>. + + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The zero-based index of the first occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the first occurrence within + the range of elements in the ImmutableList<T> that extends + from the specified index to the last element. + + The zero-based starting index of the search. + The System.Predicate<T> delegate that defines the conditions of the element to search for. + + The zero-based index of the first occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the first occurrence within + the range of elements in the ImmutableList<T> that starts + at the specified index and contains the specified number of elements. + + The zero-based starting index of the search. + The number of elements in the section to search. + The System.Predicate<T> delegate that defines the conditions of the element to search for. + + The zero-based index of the first occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the last occurrence within the entire ImmutableList<T>. + + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The last element that matches the conditions defined by the specified predicate, + if found; otherwise, the default value for type T. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the last occurrence within + the entire ImmutableList<T>. + + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The zero-based index of the last occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the last occurrence within + the range of elements in the ImmutableList<T> that extends + from the first element to the specified index. + + The zero-based starting index of the backward search. + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + The zero-based index of the last occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for an element that matches the conditions defined by the specified + predicate, and returns the zero-based index of the last occurrence within + the range of elements in the ImmutableList<T> that contains + the specified number of elements and ends at the specified index. + + The zero-based starting index of the backward search. + The number of elements in the section to search. + + The System.Predicate<T> delegate that defines the conditions of the element + to search for. + + + The zero-based index of the last occurrence of an element that matches the + conditions defined by match, if found; otherwise, –1. + + + + + Searches for the specified object and returns the zero-based index of the + first occurrence within the range of elements in the ImmutableList<T> + that extends from the specified index to the last element. + + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + + The zero-based starting index of the search. 0 (zero) is valid in an empty + list. + + + The zero-based index of the first occurrence of item within the range of + elements in the ImmutableList<T> that extends from index + to the last element, if found; otherwise, –1. + + + + + Searches for the specified object and returns the zero-based index of the + first occurrence within the range of elements in the ImmutableList<T> + that starts at the specified index and contains the specified number of elements. + + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + + The zero-based starting index of the search. 0 (zero) is valid in an empty + list. + + + The number of elements in the section to search. + + + The zero-based index of the first occurrence of item within the range of + elements in the ImmutableList<T> that starts at index and + contains count number of elements, if found; otherwise, –1. + + + + + Searches for the specified object and returns the zero-based index of the + first occurrence within the range of elements in the ImmutableList<T> + that starts at the specified index and contains the specified number of elements. + + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + + The zero-based starting index of the search. 0 (zero) is valid in an empty + list. + + + The number of elements in the section to search. + + The equality comparer to use in the search. + + The zero-based index of the first occurrence of item within the range of + elements in the ImmutableList<T> that starts at index and + contains count number of elements, if found; otherwise, –1. + + + + + Searches for the specified object and returns the zero-based index of the + last occurrence within the range of elements in the ImmutableList<T> + that contains the specified number of elements and ends at the specified + index. + + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + + The zero-based index of the last occurrence of item within the range of elements + in the ImmutableList<T> that contains count number of elements + and ends at index, if found; otherwise, –1. + + + + + Searches for the specified object and returns the zero-based index of the + last occurrence within the range of elements in the ImmutableList<T> + that contains the specified number of elements and ends at the specified + index. + + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + The zero-based starting index of the backward search. + + The zero-based index of the last occurrence of item within the range of elements + in the ImmutableList<T> that contains count number of elements + and ends at index, if found; otherwise, –1. + + + + + Searches for the specified object and returns the zero-based index of the + last occurrence within the range of elements in the ImmutableList<T> + that contains the specified number of elements and ends at the specified + index. + + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + The zero-based starting index of the backward search. + The number of elements in the section to search. + + The zero-based index of the last occurrence of item within the range of elements + in the ImmutableList<T> that contains count number of elements + and ends at index, if found; otherwise, –1. + + + + + Searches for the specified object and returns the zero-based index of the + last occurrence within the range of elements in the ImmutableList<T> + that contains the specified number of elements and ends at the specified + index. + + + The object to locate in the ImmutableList<T>. The value + can be null for reference types. + + The zero-based starting index of the backward search. + The number of elements in the section to search. + The equality comparer to use in the search. + + The zero-based index of the last occurrence of item within the range of elements + in the ImmutableList<T> that contains count number of elements + and ends at index, if found; otherwise, –1. + + + + + Determines whether every element in the ImmutableList<T> + matches the conditions defined by the specified predicate. + + + The System.Predicate<T> delegate that defines the conditions to check against + the elements. + + + true if every element in the ImmutableList<T> matches the + conditions defined by the specified predicate; otherwise, false. If the list + has no elements, the return value is true. + + + + + Inserts the elements of a collection into the ImmutableList<T> + at the specified index. + + + The zero-based index at which the new elements should be inserted. + + + The collection whose elements should be inserted into the ImmutableList<T>. + The collection itself cannot be null, but it can contain elements that are + null, if type T is a reference type. + + + + + Removes all the elements that match the conditions defined by the specified + predicate. + + + The System.Predicate<T> delegate that defines the conditions of the elements + to remove. + + + The number of elements removed from the ImmutableList<T> + + + + + Reverses the order of the elements in the entire ImmutableList<T>. + + + + + Reverses the order of the elements in the specified range. + + The zero-based starting index of the range to reverse. + The number of elements in the range to reverse. + + + + Sorts the elements in the entire ImmutableList<T> using + the default comparer. + + + + + Sorts the elements in the entire ImmutableList<T> using + the specified System.Comparison<T>. + + + The System.Comparison<T> to use when comparing elements. + + + + + Sorts the elements in the entire ImmutableList<T> using + the specified comparer. + + + The System.Collections.Generic.IComparer<T> implementation to use when comparing + elements, or null to use the default comparer System.Collections.Generic.Comparer<T>.Default. + + + + + Sorts the elements in a range of elements in ImmutableList<T> + using the specified comparer. + + + The zero-based starting index of the range to sort. + + + The length of the range to sort. + + + The System.Collections.Generic.IComparer<T> implementation to use when comparing + elements, or null to use the default comparer System.Collections.Generic.Comparer<T>.Default. + + + + + Creates an immutable list based on the contents of this instance. + + An immutable list. + + This method is an O(n) operation, and approaches O(1) time as the number of + actual mutations to the set since the last call to this method approaches 0. + + + + + Adds an item to the . + + The object to add to the . + + The position into which the new element was inserted, or -1 to indicate that the item was not inserted into the collection, + + + + + + Clears this instance. + + + + + + Determines whether the contains a specific value. + + The object to locate in the . + + true if the is found in the ; otherwise, false. + + + + + + Determines the index of a specific item in the . + + The object to locate in the . + + The index of if found in the list; otherwise, -1. + + + + + + Inserts an item to the at the specified index. + + The zero-based index at which should be inserted. + The object to insert into the . + + + + + Removes the first occurrence of a specific object from the . + + The object to remove from the . + + + + + Copies the elements of the to an , starting at a particular index. + + The one-dimensional that is the destination of the elements copied from . The must have zero-based indexing. + The zero-based index in at which copying begins. + + + + + Gets the number of elements in this list. + + + + + Gets a value indicating whether this instance is read-only. + + Always false. + + + + Gets the current version of the contents of this builder. + + + + + Gets or sets the root node that represents the data in this collection. + + + + + Gets or sets the value for a given index into the list. + + The index of the desired element. + The value at the specified index. + + + + Gets the element in the collection at a given index. + + + + + Gets a value indicating whether the has a fixed size. + + true if the has a fixed size; otherwise, false. + + + + + Gets a value indicating whether the is read-only. + + true if the is read-only; otherwise, false. + + + + + + Gets or sets the at the specified index. + + + The . + + The index. + + + + + + Gets a value indicating whether access to the is synchronized (thread safe). + + true if access to the is synchronized (thread safe); otherwise, false. + + + + + Gets an object that can be used to synchronize access to the . + + An object that can be used to synchronize access to the . + + + + + An immutable queue. + + The type of elements stored in the queue. + + + + An immutable queue. + + The type of elements in the queue. + + + + Gets an empty queue. + + + + + Gets the element at the front of the queue. + + + The element on the top of the stack. + + + + + Adds an element to the back of the queue. + + The value. + + The new queue. + + + + + Returns a queue that is missing the front element. + + A queue; never null. + + + + Gets a value indicating whether this is the empty queue. + + + true if this queue is empty; otherwise, false. + + + + + The singleton empty queue. + + + Additional instances representing the empty queue may exist on deserialized instances. + Actually since this queue is a struct, instances don't even apply and there are no singletons. + + + + + The end of the queue that enqueued elements are pushed onto. + + + + + The end of the queue from which elements are dequeued. + + + + + Backing field for the property. + + + + + Initializes a new instance of the class. + + The forward stack. + The backward stack. + + + + Gets the empty queue. + + + + + Gets an empty queue. + + + + + Gets the element at the front of the queue. + + + + + Adds an element to the back of the queue. + + The value. + + The new queue. + + + + + Adds an element to the back of the queue. + + The value. + + The new queue. + + + + + Returns a queue that is missing the front element. + + A queue; never null. + + + + Retrieves the item at the head of the queue, and returns a queue with the head element removed. + + Receives the value from the head of the queue. + The new queue with the head element removed. + + + + Returns a queue that is missing the front element. + + A queue; never null. + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + Gets a value indicating whether this instance is empty. + + + true if this instance is empty; otherwise, false. + + + + + Gets the empty queue. + + + + + Gets the reversed stack. + + + + + A memory allocation-free enumerator of . + + + + + The original queue being enumerated. + + + + + The remaining forwards stack of the queue being enumerated. + + + + + The remaining backwards stack of the queue being enumerated. + Its order is reversed when the field is first initialized. + + + + + Initializes a new instance of the struct. + + The queue to enumerate. + + + + Advances enumeration to the next element. + + A value indicating whether there is another element in the enumeration. + + + + Restarts enumeration. + + + + + Disposes this instance. + + + + + The current element. + + + + + The current element. + + + + + A simple view of the immutable collection that the debugger can show to the developer. + + + + + The collection to be enumerated. + + + + + The simple view of the collection. + + + + + Initializes a new instance of the class. + + The collection to display in the debugger + + + + Gets a simple debugger-viewable collection. + + + + + An immutable sorted map implementation. + + The type of the key. + The type of the value. + + Contains the inner Builder class. + + + + + The singleton default empty instance. + + + + + The root node of the AVL tree that stores this map. + + + + + The number of elements in the set. + + + + + The comparer used to sort keys in this map. + + + + + The comparer used to detect equivalent values in this map. + + + + + Initializes a new instance of the class. + + The key comparer. + The value comparer. + + + + Initializes a new instance of the class. + + The root of the tree containing the contents of the map. + The number of elements in this map. + The key comparer. + The value comparer. + + + + See the interface. + + + + + See the interface. + + + + + Creates a collection with the same contents as this collection that + can be efficiently mutated across multiple operations using standard + mutable interfaces. + + + This is an O(1) operation and results in only a single (small) memory allocation. + The mutable collection that is returned is *not* thread-safe. + + + + + See the interface. + + + + + See the interface. + + + + + Applies a given set of key=value pairs to an immutable dictionary, replacing any conflicting keys in the resulting dictionary. + + The key=value pairs to set on the map. Any keys that conflict with existing keys will overwrite the previous values. + An immutable dictionary. + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + Determines whether the ImmutableSortedMap<TKey,TValue> + contains an element with the specified value. + + + The value to locate in the ImmutableSortedMap<TKey,TValue>. + The value can be null for reference types. + + + true if the ImmutableSortedMap<TKey,TValue> contains + an element with the specified value; otherwise, false. + + + + + See the interface. + + + + + See the interface. + + + + + Applies a given set of key=value pairs to an immutable dictionary, replacing any conflicting keys in the resulting dictionary. + + The key=value pairs to set on the map. Any keys that conflict with existing keys will overwrite the previous values. + An immutable dictionary. + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + Adds an element with the provided key and value to the . + + The object to use as the key of the element to add. + The object to use as the value of the element to add. + is null. + + + An element with the same key already exists in the . + + + The is read-only. + + + + + Removes the element with the specified key from the . + + The key of the element to remove. + + true if the element is successfully removed; otherwise, false. This method also returns false if was not found in the original . + + is null. + + + The is read-only. + + + + + Adds an element with the provided key and value to the object. + + The to use as the key of the element to add. + The to use as the value of the element to add. + + + + Determines whether the object contains an element with the specified key. + + The key to locate in the object. + + true if the contains an element with the key; otherwise, false. + + + + + Returns an object for the object. + + + An object for the object. + + + + + + Removes the element with the specified key from the object. + + The key of the element to remove. + + + + Clears this instance. + + + + + + Copies the elements of the to an , starting at a particular index. + + The one-dimensional that is the destination of the elements copied from . The must have zero-based indexing. + The zero-based index in at which copying begins. + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Creates a new sorted set wrapper for a node tree. + + The root of the collection. + The number of elements in the map. + The key comparer to use for the map. + The value comparer to use for the map. + The immutable sorted set instance. + + + + Attempts to discover an instance beneath some enumerable sequence + if one exists. + + The sequence that may have come from an immutable map. + Receives the concrete typed value if one can be found. + true if the cast was successful; false otherwise. + + + + Bulk adds entries to the map. + + The entries to add. + true to allow the sequence to include duplicate keys and let the last one win; false to throw on collisions. + true when being called from ToHashMap to avoid StackOverflow. + + + + Creates a wrapping collection type around a root node. + + The root node to wrap. + The number of elements in the new tree, assuming it's different from the current tree. + A wrapping collection type for the new tree. + + + + Efficiently creates a new collection based on the contents of some sequence. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + Gets the keys. + + + + + Gets the values. + + + + + See the interface. + + + + + Gets an empty map with default sort and equality comparers. + + + + + Gets the with the specified key. + + + + + Gets or sets the with the specified key. + + + + + Gets a value indicating whether the object has a fixed size. + + true if the object has a fixed size; otherwise, false. + + + + Gets a value indicating whether the is read-only. + + true if the is read-only; otherwise, false. + + + + + Gets an containing the keys of the . + + + An containing the keys of the object that implements . + + + + + Gets an containing the values in the . + + + An containing the values in the object that implements . + + + + + Gets or sets the element with the specified key. + + The key. + + + + + Gets an object that can be used to synchronize access to the . + + An object that can be used to synchronize access to the . + + + + Gets a value indicating whether access to the is synchronized (thread safe). + + true if access to the is synchronized (thread safe); otherwise, false. + + + + Enumerates the contents of a binary tree. + + + This struct can and should be kept in exact sync with the other binary tree enumerators: + ImmutableList.Enumerator, ImmutableSortedMap.Enumerator, and ImmutableSortedSet.Enumerator. + + CAUTION: when this enumerator is actually used as a valuetype (not boxed) do NOT copy it by assigning to a second variable + or by passing it to another method. When this enumerator is disposed of it returns a mutable reference type stack to a resource pool, + and if the value type enumerator is copied (which can easily happen unintentionally if you pass the value around) there is a risk + that a stack that has already been returned to the resource pool may still be in use by one of the enumerator copies, leading to data + corruption and/or exceptions. + + + + + The resource pool of reusable mutable stacks for purposes of enumeration. + + + We utilize this resource pool to make "allocation free" enumeration achievable. + + + + + The builder being enumerated, if applicable. + + + + + The set being enumerated. + + + + + The stack to use for enumerating the binary tree. + + + + + The node currently selected. + + + + + The version of the builder (when applicable) that is being enumerated. + + + + + Initializes an Enumerator structure. + + The root of the set to be enumerated. + The builder, if applicable. + + + + Disposes of this enumerator and returns the stack reference to the resource pool. + + + + + Advances enumeration to the next element. + + A value indicating whether there is another element in the enumeration. + + + + Restarts enumeration. + + + + + Throws an ObjectDisposedException if this enumerator has been disposed. + + + + + Throws an exception if the underlying builder's contents have been changed since enumeration started. + + Thrown if the collection has changed. + + + + Pushes this node and all its Left descendents onto the stack. + + The starting node to push onto the stack. + + + + The current element. + + + + + The current element. + + + + + A node in the AVL tree storing this map. + + + + + The default empty node. + + + + + The key associated with this node. + + + + + The value associated with this node. + + + Sadly this field could be readonly but doing so breaks serialization due to bug: + http://connect.microsoft.com/VisualStudio/feedback/details/312970/weird-argumentexception-when-deserializing-field-in-typedreferences-cannot-be-static-or-init-only + + + + + A value indicating whether this node has been frozen (made immutable). + + + Nodes must be frozen before ever being observed by a wrapping collection type + to protect collections from further mutations. + + + + + The depth of the tree beneath this node. + + + + + The left tree. + + + + + The right tree. + + + + + Initializes a new instance of the class + that is pre-frozen. + + + + + Initializes a new instance of the class + that is not yet frozen. + + The key. + The value. + The left. + The right. + Whether this node is prefrozen. + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through the collection. + + The builder, if applicable. + + A that can be used to iterate through the collection. + + + + + See + + + + + See + + + + + Creates a node tree from an existing (mutable) collection. + + The collection. + The root of the node tree. + + + + Adds the specified key. + + The key. + The value. + The key comparer. + The value comparer. + Receives a value indicating whether this node tree has mutated because of this operation. + + + + Adds the specified key. + + The key. + The value. + The key comparer. + The value comparer. + Receives a value indicating whether an existing value was replaced. + Receives a value indicating whether this node tree has mutated because of this operation. + + + + Removes the specified key. + + The key. + The key comparer. + Receives a value indicating whether this node tree has mutated because of this operation. + The new AVL tree. + + + + Gets the value or default. + + The key. + The key comparer. + The value. + + + + Tries to get the value. + + The key. + The key comparer. + The value. + True if the key was found. + + + + Searches the dictionary for a given key and returns the equal key it finds, if any. + + The key to search for. + The key comparer. + The key from the dictionary that the search found, or if the search yielded no match. + A value indicating whether the search was successful. + + This can be useful when you want to reuse a previously stored reference instead of + a newly constructed one (so that more sharing of references can occur) or to look up + the canonical value, or a value that has more complete data than the value you currently have, + although their comparer functions indicate they are equal. + + + + + Determines whether the specified key contains key. + + The key. + The key comparer. + + true if the specified key contains key; otherwise, false. + + + + + Determines whether the ImmutableSortedMap<TKey,TValue> + contains an element with the specified value. + + + The value to locate in the ImmutableSortedMap<TKey,TValue>. + The value can be null for reference types. + + The value comparer to use. + + true if the ImmutableSortedMap<TKey,TValue> contains + an element with the specified value; otherwise, false. + + + + + Determines whether [contains] [the specified pair]. + + The pair. + The key comparer. + The value comparer. + + true if [contains] [the specified pair]; otherwise, false. + + + + + Freezes this node and all descendent nodes so that any mutations require a new instance of the nodes. + + + + + AVL rotate left operation. + + The tree. + The rotated tree. + + + + AVL rotate right operation. + + The tree. + The rotated tree. + + + + AVL rotate double-left operation. + + The tree. + The rotated tree. + + + + AVL rotate double-right operation. + + The tree. + The rotated tree. + + + + Returns a value indicating whether the tree is in balance. + + The tree. + 0 if the tree is in balance, a positive integer if the right side is heavy, or a negative integer if the left side is heavy. + + + + Determines whether the specified tree is right heavy. + + The tree. + + true if [is right heavy] [the specified tree]; otherwise, false. + + + + + Determines whether the specified tree is left heavy. + + + + + Balances the specified tree. + + The tree. + A balanced tree. + + + + Creates a node tree that contains the contents of a list. + + An indexable list with the contents that the new node tree should contain. + The starting index within that should be captured by the node tree. + The number of elements from that should be captured by the node tree. + The root of the created node tree. + + + + Adds the specified key. + + The key. + The value. + The key comparer. + The value comparer. + if true, an existing key=value pair will be overwritten with the new one. + Receives a value indicating whether an existing value was replaced. + Receives a value indicating whether this node tree has mutated because of this operation. + The new AVL tree. + + + + Creates a node mutation, either by mutating this node (if not yet frozen) or by creating a clone of this node + with the described changes. + + The left branch of the mutated node. + The right branch of the mutated node. + The mutated (or created) node. + + + + Searches the specified key. + + The key. + The key comparer. + + + + Gets a value indicating whether this instance is empty. + + + true if this instance is empty; otherwise, false. + + + + + Gets the left branch of this node. + + + + + Gets the right branch of this node. + + + + + Gets the depth of the tree below this node. + + + + + Gets the value represented by the current node. + + + + + Gets the number of elements contained by this node and below. + + + + + Gets the keys. + + + + + Gets the values. + + + + + A simple view of the immutable collection that the debugger can show to the developer. + + + + + The collection to be enumerated. + + + + + The simple view of the collection. + + + + + Initializes a new instance of the class. + + The collection to display in the debugger + + + + Gets a simple debugger-viewable collection. + + + + + A sorted map that mutates with little or no memory allocations, + can produce and/or build on immutable sorted map instances very efficiently. + + + + This class allows multiple combinations of changes to be made to a set with equal efficiency. + + + Instance members of this class are not thread-safe. + + + + + + The binary tree used to store the contents of the map. Contents are typically not entirely frozen. + + + + + The key comparer. + + + + + The value comparer. + + + + + The number of entries in the map. + + + + + Caches an immutable instance that represents the current state of the collection. + + Null if no immutable view has been created for the current version. + + + + A number that increments every time the builder changes its contents. + + + + + The object callers may use to synchronize access to this collection. + + + + + Initializes a new instance of the class. + + A map to act as the basis for a new map. + + + + Adds an element with the provided key and value to the object. + + The to use as the key of the element to add. + The to use as the value of the element to add. + + + + Determines whether the object contains an element with the specified key. + + The key to locate in the object. + + true if the contains an element with the key; otherwise, false. + + + + + Returns an object for the object. + + + An object for the object. + + + + + + Removes the element with the specified key from the object. + + The key of the element to remove. + + + + Copies the elements of the to an , starting at a particular index. + + The one-dimensional that is the destination of the elements copied from . The must have zero-based indexing. + The zero-based index in at which copying begins. + + + + See + + + + + See + + + + + See + + + + + See + + + + + See the interface. + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + Determines whether the ImmutableSortedMap<TKey,TValue> + contains an element with the specified value. + + + The value to locate in the ImmutableSortedMap<TKey,TValue>. + The value can be null for reference types. + + + true if the ImmutableSortedMap<TKey,TValue> contains + an element with the specified value; otherwise, false. + + + + + Removes any entries from the dictionaries with keys that match those found in the specified sequence. + + The keys for entries to remove from the dictionary. + + + + Removes any entries from the dictionaries with keys that match those found in the specified sequence. + + The keys for entries to remove from the dictionary. + + + + Gets the value for a given key if a matching key exists in the dictionary. + + The key to search for. + The value for the key, or default(TValue) if no matching key was found. + + + + Gets the value for a given key if a matching key exists in the dictionary. + + The key to search for. + The default value to return if no matching key is found in the dictionary. + + The value for the key, or if no matching key was found. + + + + + Creates an immutable sorted map based on the contents of this instance. + + An immutable map. + + This method is an O(n) operation, and approaches O(1) time as the number of + actual mutations to the set since the last call to this method approaches 0. + + + + + See + + + + + See + + + + + See + + + + + See + + + + + Gets the number of elements in this map. + + + + + Gets a value indicating whether this instance is read-only. + + Always false. + + + + Gets the current version of the contents of this builder. + + + + + Gets or sets the root node that represents the data in this collection. + + + + + Gets or sets the value for a given key. + + The key. + The value associated with the given key. + + + + Gets a value indicating whether the object has a fixed size. + + true if the object has a fixed size; otherwise, false. + + + + Gets a value indicating whether the is read-only. + + true if the is read-only; otherwise, false. + + + + + Gets an containing the keys of the . + + + An containing the keys of the object that implements . + + + + + Gets an containing the values in the . + + + An containing the values in the object that implements . + + + + + Gets an object that can be used to synchronize access to the . + + An object that can be used to synchronize access to the . + + + + Gets a value indicating whether access to the is synchronized (thread safe). + + true if access to the is synchronized (thread safe); otherwise, false. + + + + Gets or sets the key comparer. + + + The key comparer. + + + + + Gets or sets the value comparer. + + + The value comparer. + + + + + Gets or sets the element with the specified key. + + The key. + + + + + A simple view of the immutable collection that the debugger can show to the developer. + + + + + The collection to be enumerated. + + + + + The simple view of the collection. + + + + + Initializes a new instance of the class. + + The collection to display in the debugger + + + + Gets a simple debugger-viewable collection. + + + + + An immutable sorted set implementation. + + The type of elements in the set. + + We implement IReadOnlyList{T} because it adds an ordinal indexer. + We implement IList{T} because it gives us IndexOf(T), which is important for some folks. + + + Contains the inner Builder class. + + + + + This is the factor between the small collection's size and the large collection's size in a bulk operation, + under which recreating the entire collection using a fast method rather than some incremental update + (that requires tree rebalancing) is preferable. + + + + + The singleton default empty instance. + + + + + The root node of the AVL tree that stores this set. + + + + + The comparer used to sort elements in this set. + + + + + Initializes a new instance of the class. + + The comparer. + + + + Initializes a new instance of the class. + + The root of the AVL tree with the contents of this set. + The comparer. + + + + See the interface. + + + + + Creates a collection with the same contents as this collection that + can be efficiently mutated across multiple operations using standard + mutable interfaces. + + + This is an O(1) operation and results in only a single (small) memory allocation. + The mutable collection that is returned is *not* thread-safe. + + + + + See the interface. + + + + + See the interface. + + + + + Searches the set for a given value and returns the equal value it finds, if any. + + The value to search for. + The value from the set that the search found, or the original value if the search yielded no match. + A value indicating whether the search was successful. + + This can be useful when you want to reuse a previously stored reference instead of + a newly constructed one (so that more sharing of references can occur) or to look up + a value that has more complete data than the value you currently have, although their + comparer functions indicate they are equal. + + + + + See the interface. + + + + + See the interface. + + + + + Produces a set that contains elements either in this set or a given sequence, but not both. + + The other sequence of items. + The new set. + + + + See the interface. + + + + + See the interface. + + + + + Checks whether a given sequence of items entirely describe the contents of this set. + + The sequence of items to check against this set. + A value indicating whether the sets are equal. + + + + Determines whether the current set is a property (strict) subset of a specified collection. + + The collection to compare to the current set. + true if the current set is a correct subset of other; otherwise, false. + + + + Determines whether the current set is a correct superset of a specified collection. + + The collection to compare to the current set. + true if the current set is a correct superset of other; otherwise, false. + + + + Determines whether a set is a subset of a specified collection. + + The collection to compare to the current set. + true if the current set is a subset of other; otherwise, false. + + + + Determines whether the current set is a superset of a specified collection. + + The collection to compare to the current set. + true if the current set is a superset of other; otherwise, false. + + + + Determines whether the current set overlaps with the specified collection. + + The collection to compare to the current set. + true if the current set and other share at least one common element; otherwise, false. + + + + Returns an System.Collections.Generic.IEnumerable<T> that iterates over this + collection in reverse order. + + + An enumerator that iterates over the System.Collections.Generic.SortedSet<T> + in reverse order. + + + + + Gets the position within this set that the specified value does or would appear. + + The value whose position is being sought. + + The index of the specified in the sorted set, + if is found. If is not + found and is less than one or more elements in this set, + a negative number which is the bitwise complement of the index of the first + element that is larger than value. If is not found + and is greater than any of the elements in the set, + a negative number which is the bitwise complement of (the index of the last + element plus 1). + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + Produces a set that contains elements either in this set or a given sequence, but not both. + + The other sequence of items. + The new set. + + + + See the interface. + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + Adds an item to the . + + The object to add to the . + + The position into which the new element was inserted, or -1 to indicate that the item was not inserted into the collection, + + + + + + Clears this instance. + + + + + + Determines whether the contains a specific value. + + The object to locate in the . + + true if the is found in the ; otherwise, false. + + + + + Determines the index of a specific item in the . + + The object to locate in the . + + The index of if found in the list; otherwise, -1. + + + + + Inserts an item to the at the specified index. + + The zero-based index at which should be inserted. + The object to insert into the . + + + + + Removes the first occurrence of a specific object from the . + + The object to remove from the . + + + + + Removes at. + + The index. + + + + + Copies the elements of the to an , starting at a particular index. + + The one-dimensional that is the destination of the elements copied from . The must have zero-based indexing. + The zero-based index in at which copying begins. + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + CAUTION: when this enumerator is actually used as a valuetype (not boxed) do NOT copy it by assigning to a second variable + or by passing it to another method. When this enumerator is disposed of it returns a mutable reference type stack to a resource pool, + and if the value type enumerator is copied (which can easily happen unintentionally if you pass the value around) there is a risk + that a stack that has already been returned to the resource pool may still be in use by one of the enumerator copies, leading to data + corruption and/or exceptions. + + + + + Discovers an immutable sorted set for a given value, if possible. + + + + + Creates a new sorted set wrapper for a node tree. + + The root of the collection. + The comparer used to build the tree. + The immutable sorted set instance. + + + + Adds items to this collection using the standard spine rewrite and tree rebalance technique. + + The items to add. + The new collection. + + This method is least demanding on memory, providing the great chance of memory reuse + and does not require allocating memory large enough to store all items contiguously. + It's performance is optimal for additions that do not significantly dwarf the existing + size of this collection. + + + + + Creates a wrapping collection type around a root node. + + The root node to wrap. + A wrapping collection type for the new tree. + + + + Creates an immutable sorted set with the contents from this collection and a sequence of elements. + + The sequence of elements to add to this set. + The immutable sorted set. + + + + Gets the maximum value in the collection, as defined by the comparer. + + The maximum value in the set. + + + + Gets the minimum value in the collection, as defined by the comparer. + + The minimum value in the set. + + + + See the interface. + + + + + See the interface. + + + + + See the interface. + + + + + Gets an empty set with the default sort comparer. + + + + + Gets the element of the set at the given index. + + The 0-based index of the element in the set to return. + The element at the given position. + + + + See the interface. + + + + + See the interface. + + + + + Gets a value indicating whether the has a fixed size. + + true if the has a fixed size; otherwise, false. + + + + Gets a value indicating whether the is read-only. + + true if the is read-only; otherwise, false. + + + + + See ICollection. + + + + + See the ICollection interface. + + + + + Gets or sets the at the specified index. + + + The . + + The index. + + + + + Enumerates the contents of a binary tree. + + + This struct can and should be kept in exact sync with the other binary tree enumerators: + ImmutableList.Enumerator, ImmutableSortedMap.Enumerator, and ImmutableSortedSet.Enumerator. + + CAUTION: when this enumerator is actually used as a valuetype (not boxed) do NOT copy it by assigning to a second variable + or by passing it to another method. When this enumerator is disposed of it returns a mutable reference type stack to a resource pool, + and if the value type enumerator is copied (which can easily happen unintentionally if you pass the value around) there is a risk + that a stack that has already been returned to the resource pool may still be in use by one of the enumerator copies, leading to data + corruption and/or exceptions. + + + + + The resource pool of reusable mutable stacks for purposes of enumeration. + + + We utilize this resource pool to make "allocation free" enumeration achievable. + + + + + The builder being enumerated, if applicable. + + + + + A flag indicating whether this enumerator works in reverse sort order. + + + + + The set being enumerated. + + + + + The stack to use for enumerating the binary tree. + + + + + The node currently selected. + + + + + The version of the builder (when applicable) that is being enumerated. + + + + + Initializes an Enumerator structure. + + The root of the set to be enumerated. + The builder, if applicable. + true to enumerate the collection in reverse. + + + + Disposes of this enumerator and returns the stack reference to the resource pool. + + + + + Advances enumeration to the next element. + + A value indicating whether there is another element in the enumeration. + + + + Restarts enumeration. + + + + + Throws an ObjectDisposedException if this enumerator has been disposed. + + + + + Throws an exception if the underlying builder's contents have been changed since enumeration started. + + Thrown if the collection has changed. + + + + Pushes this node and all its Left (or Right, if reversed) descendents onto the stack. + + The starting node to push onto the stack. + + + + The current element. + + + + + The current element. + + + + + An reverse enumerable of a sorted set. + + + + + The root node to enumerate. + + + + + Initializes a new instance of the class. + + The root of the data structure to reverse enumerate. + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + A node in the AVL tree storing this set. + + + + + The default empty node. + + + + + The key associated with this node. + + + + + A value indicating whether this node has been frozen (made immutable). + + + Nodes must be frozen before ever being observed by a wrapping collection type + to protect collections from further mutations. + + + + + The depth of the tree beneath this node. + + + + + The number of elements contained by this subtree starting at this node. + + + If this node would benefit from saving 4 bytes, we could have only a few nodes + scattered throughout the graph actually record the count of nodes beneath them. + Those without the count could query their descendents, which would often short-circuit + when they hit a node that *does* include a count field. + + + + + The left tree. + + + + + The right tree. + + + + + Initializes a new instance of the class + that is pre-frozen. + + + + + Initializes a new instance of the class + that is not yet frozen. + + The value stored by this node. + The left branch. + The right branch. + Whether this node is prefrozen. + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through the collection. + + The builder, if applicable. + + A that can be used to iterate through the collection. + + + + + Creates a node tree from an existing (mutable) collection. + + The collection. + The root of the node tree. + + + + See the interface. + + + + + See the interface. + + + + + Adds the specified key to the tree. + + The key. + The comparer. + Receives a value indicating whether this node tree has mutated because of this operation. + The new tree. + + + + Removes the specified key from the tree. + + The key. + The comparer. + Receives a value indicating whether this node tree has mutated because of this operation. + The new tree. + + + + Determines whether the specified key is in this tree. + + The key. + The comparer. + + true if the tree contains the specified key; otherwise, false. + + + + + Freezes this node and all descendent nodes so that any mutations require a new instance of the nodes. + + + + + Searches for the specified key. + + The key to search for. + The comparer. + The matching node, or the Empty node if no match was found. + + + + Searches for the specified key. + + The key to search for. + The comparer. + The matching node, or the Empty node if no match was found. + + + + Returns an System.Collections.Generic.IEnumerable<T> that iterates over this + collection in reverse order. + + + An enumerator that iterates over the System.Collections.Generic.SortedSet<T> + in reverse order. + + + + + AVL rotate left operation. + + The tree. + The rotated tree. + + + + AVL rotate right operation. + + The tree. + The rotated tree. + + + + AVL rotate double-left operation. + + The tree. + The rotated tree. + + + + AVL rotate double-right operation. + + The tree. + The rotated tree. + + + + Returns a value indicating whether the tree is in balance. + + The tree. + 0 if the tree is in balance, a positive integer if the right side is heavy, or a negative integer if the left side is heavy. + + + + Determines whether the specified tree is right heavy. + + The tree. + + true if [is right heavy] [the specified tree]; otherwise, false. + + + + + Determines whether the specified tree is left heavy. + + + + + Balances the specified tree. + + The tree. + A balanced tree. + + + + Creates a node tree that contains the contents of a list. + + An indexable list with the contents that the new node tree should contain. + The starting index within that should be captured by the node tree. + The number of elements from that should be captured by the node tree. + The root of the created node tree. + + + + Creates a node mutation, either by mutating this node (if not yet frozen) or by creating a clone of this node + with the described changes. + + The left branch of the mutated node. + The right branch of the mutated node. + The mutated (or created) node. + + + + Gets a value indicating whether this instance is empty. + + + true if this instance is empty; otherwise, false. + + + + + Gets the height of the tree beneath this node. + + + + + Gets the left branch of this node. + + + + + Gets the right branch of this node. + + + + + Gets the value represented by the current node. + + + + + Gets the number of elements contained by this subtree starting at this node. + + + + + Gets the key. + + + + + Gets the maximum value in the collection, as defined by the comparer. + + The maximum value in the set. + + + + Gets the minimum value in the collection, as defined by the comparer. + + The minimum value in the set. + + + + Gets the element of the set at the given index. + + The 0-based index of the element in the set to return. + The element at the given position. + + + + A simple view of the immutable collection that the debugger can show to the developer. + + + + + The collection to be enumerated. + + + + + The simple view of the collection. + + + + + Initializes a new instance of the class. + + The collection to display in the debugger + + + + Gets a simple debugger-viewable collection. + + + + + A sorted set that mutates with little or no memory allocations, + can produce and/or build on immutable sorted set instances very efficiently. + + + + While and other bulk change methods + already provide fast bulk change operations on the collection, this class allows + multiple combinations of changes to be made to a set with equal efficiency. + + + Instance members of this class are not thread-safe. + + + + + + The root of the binary tree that stores the collection. Contents are typically not entirely frozen. + + + + + The comparer to use for sorting the set. + + + + + Caches an immutable instance that represents the current state of the collection. + + Null if no immutable view has been created for the current version. + + + + A number that increments every time the builder changes its contents. + + + + + The object callers may use to synchronize access to this collection. + + + + + Initializes a new instance of the class. + + A set to act as the basis for a new set. + + + + Adds an element to the current set and returns a value to indicate if the + element was successfully added. + + The element to add to the set. + true if the element is added to the set; false if the element is already in the set. + + + + Removes all elements in the specified collection from the current set. + + The collection of items to remove from the set. + + + + Modifies the current set so that it contains only elements that are also in a specified collection. + + The collection to compare to the current set. + + + + Determines whether the current set is a proper (strict) subset of a specified collection. + + The collection to compare to the current set. + true if the current set is a correct subset of other; otherwise, false. + + + + Determines whether the current set is a proper (strict) superset of a specified collection. + + The collection to compare to the current set. + true if the current set is a superset of other; otherwise, false. + + + + Determines whether the current set is a subset of a specified collection. + + The collection to compare to the current set. + true if the current set is a subset of other; otherwise, false. + + + + Determines whether the current set is a superset of a specified collection. + + The collection to compare to the current set. + true if the current set is a superset of other; otherwise, false. + + + + Determines whether the current set overlaps with the specified collection. + + The collection to compare to the current set. + true if the current set and other share at least one common element; otherwise, false. + + + + Determines whether the current set and the specified collection contain the same elements. + + The collection to compare to the current set. + true if the current set is equal to other; otherwise, false. + + + + Modifies the current set so that it contains only elements that are present either in the current set or in the specified collection, but not both. + + The collection to compare to the current set. + + + + Modifies the current set so that it contains all elements that are present in both the current set and in the specified collection. + + The collection to compare to the current set. + + + + Adds an element to the current set and returns a value to indicate if the + element was successfully added. + + The element to add to the set. + + + + Removes all elements from this set. + + + + + Determines whether the set contains a specific value. + + The object to locate in the set. + true if item is found in the set; false otherwise. + + + + See + + + + + Removes the first occurrence of a specific object from the set. + + The object to remove from the set. + true if the item was removed from the set; false if the item was not found in the set. + + + + Returns an enumerator that iterates through the collection. + + A enumerator that can be used to iterate through the collection. + + + + Returns an enumerator that iterates through the collection. + + A enumerator that can be used to iterate through the collection. + + + + Returns an enumerator that iterates through the collection. + + A enumerator that can be used to iterate through the collection. + + + + Returns an System.Collections.Generic.IEnumerable<T> that iterates over this + collection in reverse order. + + + An enumerator that iterates over the System.Collections.Generic.SortedSet<T> + in reverse order. + + + + + Creates an immutable sorted set based on the contents of this instance. + + An immutable set. + + This method is an O(n) operation, and approaches O(1) time as the number of + actual mutations to the set since the last call to this method approaches 0. + + + + + Copies the elements of the to an , starting at a particular index. + + The one-dimensional that is the destination of the elements copied from . The must have zero-based indexing. + The zero-based index in at which copying begins. + + + + + Gets the number of elements in this set. + + + + + Gets a value indicating whether this instance is read-only. + + Always false. + + + + Gets the maximum value in the collection, as defined by the comparer. + + The maximum value in the set. + + + + Gets the minimum value in the collection, as defined by the comparer. + + The minimum value in the set. + + + + Gets or sets the System.Collections.Generic.IComparer<T> object that is used to determine equality for the values in the System.Collections.Generic.SortedSet<T>. + + The comparer that is used to determine equality for the values in the set. + + When changing the comparer in such a way as would introduce collisions, the conflicting elements are dropped, + leaving only one of each matching pair in the collection. + + + + + Gets the current version of the contents of this builder. + + + + + Gets or sets the root node that represents the data in this collection. + + + + + Gets a value indicating whether access to the is synchronized (thread safe). + + true if access to the is synchronized (thread safe); otherwise, false. + + + + + Gets an object that can be used to synchronize access to the . + + An object that can be used to synchronize access to the . + + + + + A simple view of the immutable collection that the debugger can show to the developer. + + + + + The collection to be enumerated. + + + + + The simple view of the collection. + + + + + Initializes a new instance of the class. + + The collection to display in the debugger + + + + Gets a simple debugger-viewable collection. + + + + + An immutable stack. + + The type of element stored by the stack. + + + + An immutable stack. + + The type of elements stored in the stack. + + + + Gets an empty stack. + + + + + Pushes an element onto a stack and returns the new stack. + + The element to push onto the stack. + The new stack. + + + + Pops the top element off the stack. + + The new stack; never null + + + + Gets the element on the top of the stack. + + + + + Gets a value indicating whether this is the empty stack. + + + true if this stack is empty; otherwise, false. + + + + + The singleton empty stack. + + + Additional instances representing the empty stack may exist on deserialized stacks. + + + + + The element on the top of the stack. + + + + + A stack that constaints the rest of the elements (under the top element). + + + + + Initializes a new instance of the class + that acts as the empty stack. + + + + + Initializes a new instance of the class. + + The head element on the stack. + The rest of the elements on the stack. + + + + Gets the empty stack, upon which all stacks are built. + + + + + Gets an empty stack. + + + + + Gets the element on the top of the stack. + + + The element on the top of the stack. + + + + + Pushes an element onto a stack and returns the new stack. + + The element to push onto the stack. + The new stack. + + + + Pushes an element onto a stack and returns the new stack. + + The element to push onto the stack. + The new stack. + + + + Returns a stack that lacks the top element on this stack. + + A stack; never null + + + + Pops the top element off the stack. + + The value that was removed from the stack. + + A stack; never null + + + + + Returns a stack that lacks the top element on this stack. + + A stack; never null + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + Reverses the order of a stack. + + The reversed stack. + + + + Gets the empty stack, upon which all stacks are built. + + + + + Gets a value indicating whether this instance is empty. + + + true if this instance is empty; otherwise, false. + + + + + Enumerates a stack with no memory allocations. + + + + + The original stack being enumerated. + + + + + The remaining stack not yet enumerated. + + + + + Initializes a new instance of the struct. + + The stack to enumerator. + + + + Moves to the first or next element. + + A value indicating whether there are any more elements. + + + + Resets the position to just before the first element in the list. + + + + + Disposes this instance. + + + + + Gets the current element. + + + + + Gets the current element. + + + + + A simple view of the immutable collection that the debugger can show to the developer. + + + + + The collection to be enumerated. + + + + + The simple view of the collection. + + + + + Initializes a new instance of the class. + + The collection to display in the debugger + + + + Gets a simple debugger-viewable collection. + + + + + Common runtime checks that throw ArgumentExceptions upon failure. + + + + + Throws an exception if the specified parameter's value is null. + + The type of the parameter. + The value of the argument. + The name of the parameter to include in any thrown exception. + The value of the parameter. + Thrown if is null + + + + Throws an exception if the specified parameter's value is null. + + The type of the parameter. + The value of the argument. + The name of the parameter to include in any thrown exception. + The value of the parameter. + Thrown if is null + + This method exists for callers who themselves only know the type as a generic parameter which + may or may not be a class, but certainly cannot be null. + + + + + Throws an if a condition does not evaluate to true. + + + + + Throws an if a condition does not evaluate to true. + + Nothing. This method always throws. + + + + Throws an ArgumentException if a condition does not evaluate to true. + + + + + Throws an ArgumentException if a condition does not evaluate to true. + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Object is not a array with the same initialization state as the array to compare it to.. + + + + + Looks up a localized string similar to Object is not a array with the same number of elements as the array to compare it to.. + + + + + Looks up a localized string similar to Cannot find the old value. + + + + + Looks up a localized string similar to Collection was modified; enumeration operation may not execute.. + + + + + Looks up a localized string similar to An element with the same key but a different value already exists.. + + + + + Looks up a localized string similar to This operation does not apply to an empty instance.. + + + + + Indicates to Code Analysis that a method validates a particular parameter. + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to '{0}' must contain at least one element.. + + + + + Looks up a localized string similar to '{0}' cannot be an empty string ("") or start with the null character.. + + + + + Looks up a localized string similar to '{0}' cannot contain a null (Nothing in Visual Basic) element.. + + + + + Looks up a localized string similar to The parameter "{0}" cannot consist entirely of white space characters.. + + + + diff --git a/Src/packages/NUnit.2.6.2/NUnit.2.6.2.nupkg b/Src/packages/NUnit.2.6.2/NUnit.2.6.2.nupkg new file mode 100644 index 00000000..26f15bdc Binary files /dev/null and b/Src/packages/NUnit.2.6.2/NUnit.2.6.2.nupkg differ diff --git a/Src/packages/NUnit.2.6.2/NUnit.2.6.2.nuspec b/Src/packages/NUnit.2.6.2/NUnit.2.6.2.nuspec new file mode 100644 index 00000000..dc58abdb --- /dev/null +++ b/Src/packages/NUnit.2.6.2/NUnit.2.6.2.nuspec @@ -0,0 +1,28 @@ + + + + NUnit + 2.6.2 + NUnit + Charlie Poole + Charlie Poole + http://nunit.org/nuget/license.html + http://nunit.org/ + http://nunit.org/nuget/nunit_32x32.png + false + NUnit features a fluent assert syntax, parameterized, generic and theory tests and is user-extensible. A number of runners, both from the NUnit project and by third parties, are able to execute NUnit tests. + +Version 2.6 is the seventh major release of this well-known and well-tested programming tool. + +This package includes only the framework assembly. You will need to install the NUnit.Runners package unless you are using a third-party runner. + NUnit is a unit-testing framework for all .Net languages with a strong TDD focus. + Version 2.6 is the seventh major release of NUnit. + +Unlike earlier versions, this package includes only the framework assembly. You will need to install the NUnit.Runners package unless you are using a third-party runner. + +The nunit.mocks assembly is now provided by the NUnit.Mocks package. The pnunit.framework assembly is provided by the pNUnit package. + + en-US + test testing tdd framework fluent assert theory plugin addin + + \ No newline at end of file diff --git a/Src/Lib/NUnit/DotNet/nunit.framework.dll b/Src/packages/NUnit.2.6.2/lib/nunit.framework.dll similarity index 100% rename from Src/Lib/NUnit/DotNet/nunit.framework.dll rename to Src/packages/NUnit.2.6.2/lib/nunit.framework.dll diff --git a/Src/Lib/NUnit/DotNet/nunit.framework.xml b/Src/packages/NUnit.2.6.2/lib/nunit.framework.xml similarity index 100% rename from Src/Lib/NUnit/DotNet/nunit.framework.xml rename to Src/packages/NUnit.2.6.2/lib/nunit.framework.xml diff --git a/Src/packages/NUnit.2.6.2/license.txt b/Src/packages/NUnit.2.6.2/license.txt new file mode 100644 index 00000000..530a6e00 --- /dev/null +++ b/Src/packages/NUnit.2.6.2/license.txt @@ -0,0 +1,15 @@ +Copyright © 2002-2012 Charlie Poole +Copyright © 2002-2004 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov +Copyright © 2000-2002 Philip A. Craig + +This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. + +Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment (see the following) in the product documentation is required. + +Portions Copyright © 2002-2012 Charlie Poole or Copyright © 2002-2004 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov or Copyright © 2000-2002 Philip A. Craig + +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + +3. This notice may not be removed or altered from any source distribution. diff --git a/Src/packages/repositories.config b/Src/packages/repositories.config new file mode 100644 index 00000000..71be91d7 --- /dev/null +++ b/Src/packages/repositories.config @@ -0,0 +1,4 @@ + + + + \ No newline at end of file