/// <summary> /// Gets the hash of a JSON number value. /// </summary> /// <param name="number">The number to hash.</param> /// <param name="seed">The seed to use.</param> /// <returns>The hash of a JSON number value.</returns> private static UInt192 GetNumberHash(double number, UInt192 seed) { UInt192 hash = DistinctHash.GetHash(DistinctHash.NumberHashSeed, seed); hash = DistinctHash.GetHash((UInt192)BitConverter.DoubleToInt64Bits(number), hash); return(hash); }
/// <summary> /// Gets the hash of a JSON string value. /// </summary> /// <param name="value">The value to hash.</param> /// <param name="seed">The seed to use.</param> /// <returns>The hash of a JSON string value.</returns> private static UInt192 GetStringHash(string value, UInt192 seed) { UInt192 hash = DistinctHash.GetHash(DistinctHash.StringHashSeed, seed); byte[] stringBytes = Encoding.UTF8.GetBytes(value); return(DistinctHash.GetHash(stringBytes, hash)); }
/// <summary> /// Gets the hash of a JSON object. /// </summary> /// <param name="cosmosObject">The object to hash.</param> /// <param name="seed">The seed to use.</param> /// <returns>The hash of a JSON object.</returns> private static UInt192 GetObjectHash(CosmosObject cosmosObject, UInt192 seed) { // Start the object with a distinct hash, so that empty object doesn't hash to another value. UInt192 hash = DistinctHash.GetHash(DistinctHash.ObjectHashSeed, seed); //// Intermediate hashes of all the properties, which we don't want to xor with the final hash //// otherwise the following will collide: ////{ //// "pet":{ //// "name":"alice", //// "age":5 //// }, //// "pet2":{ //// "name":"alice", //// "age":5 //// } ////} //// ////{ //// "pet":{ //// "name":"bob", //// "age":5 //// }, //// "pet2":{ //// "name":"bob", //// "age":5 //// } ////} //// because they only differ on the name, but it gets repeated meaning that //// hash({"name":"bob", "age":5}) ^ hash({"name":"bob", "age":5}) is the same as //// hash({"name":"alice", "age":5}) ^ hash({"name":"alice", "age":5}) UInt192 intermediateHash = 0; // Property order should not result in a different hash. // This is consistent with equality comparison. foreach (KeyValuePair <string, CosmosElement> kvp in cosmosObject) { UInt192 nameHash = DistinctHash.GetHash( CosmosString.Create(kvp.Key), DistinctHash.PropertyNameHashSeed); UInt192 propertyHash = DistinctHash.GetHash(kvp.Value, nameHash); //// xor is symmetric meaning that a ^ b = b ^ a //// Which is great since now we can add the property hashes to the intermediate hash //// in any order and get the same result, which upholds our definition of equality. //// Note that we don't have to worry about a ^ a = 0 = b ^ b for duplicate property values, //// since the hash of property values are seeded with the hash of property names, //// which are unique within an object. intermediateHash ^= propertyHash; } // Only if the object was not empty do we want to bring in the intermediate hash. if (intermediateHash > 0) { hash = DistinctHash.GetHash(intermediateHash, hash); } return(hash); }
/// <summary> /// Gets the hash of a JToken given a seed. /// </summary> /// <param name="cosmosElement">The cosmos element to hash.</param> /// <param name="seed">The seed to use.</param> /// <returns>The hash of the JToken.</returns> private static UInt192 GetHash(CosmosElement cosmosElement, UInt192 seed) { if (cosmosElement == null) { return(DistinctHash.GetUndefinedHash(seed)); } CosmosElementType cosmosElementType = cosmosElement.Type; UInt192 hash; switch (cosmosElementType) { case CosmosElementType.Array: hash = DistinctHash.GetArrayHash(cosmosElement as CosmosArray, seed); break; case CosmosElementType.Boolean: hash = DistinctHash.GetBooleanHash((cosmosElement as CosmosBoolean).Value, seed); break; case CosmosElementType.Null: hash = DistinctHash.GetNullHash(seed); break; case CosmosElementType.Number: // TODO: we need to differentiate between the different number types. CosmosNumber cosmosNumber = cosmosElement as CosmosNumber; double number; if (cosmosNumber.IsFloatingPoint) { number = cosmosNumber.AsFloatingPoint().Value; } else { number = cosmosNumber.AsInteger().Value; } hash = DistinctHash.GetNumberHash(number, seed); break; case CosmosElementType.Object: hash = DistinctHash.GetObjectHash(cosmosElement as CosmosObject, seed); break; case CosmosElementType.String: hash = DistinctHash.GetStringHash((cosmosElement as CosmosString).Value, seed); break; default: throw new ArgumentException($"Unexpected {nameof(CosmosElementType)} : {cosmosElementType}"); } return(hash); }
/// <summary> /// Adds a string to the distinct map. /// </summary> /// <param name="value">The string to add.</param> /// <returns>Whether or not the value was successfully added.</returns> private bool AddStringValue(string value) { bool added = false; int utf8Length = Encoding.UTF8.GetByteCount(value); // If you fit the string with full fidelity in 24 bytes, then you might as well just hash the string. if (utf8Length <= UnorderdDistinctMap.UInt192Length) { // Zero out the array since you want all trailing bytes to be 0 for the conversions that happen next. Array.Clear(this.utf8Buffer, 0, this.utf8Buffer.Length); Encoding.UTF8.GetBytes(value, 0, utf8Length, this.utf8Buffer, 0); if (utf8Length == 0) { added = this.AddSimpleValue(SimpleValues.EmptyString); } else if (utf8Length <= UnorderdDistinctMap.UIntLength) { uint uintValue = BitConverter.ToUInt32(this.utf8Buffer, 0); added = this.stringsLength4.Add(uintValue); } else if (utf8Length <= UnorderdDistinctMap.ULongLength) { ulong uLongValue = BitConverter.ToUInt64(this.utf8Buffer, 0); added = this.stringLength8.Add(uLongValue); } else if (utf8Length <= UnorderdDistinctMap.UInt128Length) { UInt128 uInt128Value = UInt128.FromByteArray(this.utf8Buffer, 0); added = this.stringLength16.Add(uInt128Value); } else { UInt192 uInt192Value = UInt192.FromByteArray(this.utf8Buffer, 0); added = this.stringLength24.Add(uInt192Value); } } else { // Else the string is too large and we will just store the hash. UInt192 uint192Value = DistinctHash.GetHash(CosmosString.Create(value)); added = this.stringLength24Plus.Add(uint192Value); } return(added); }
/// <summary> /// Adds a JToken to this map if it hasn't already been added. /// </summary> /// <param name="cosmosElement">The element to add.</param> /// <param name="hash">The hash of the token.</param> /// <returns>Whether or not the item was added to this Distinct Map.</returns> /// <remarks>This function assumes data is added in sorted order.</remarks> public override bool Add(CosmosElement cosmosElement, out UInt128 hash) { hash = DistinctHash.GetHash(cosmosElement); bool added; if (this.lastHash != hash) { this.lastHash = hash; added = true; } else { added = false; } return(added); }
/// <summary> /// Gets the hash of a JSON array. /// </summary> /// <param name="cosmosArray">The array to hash.</param> /// <param name="seed">The seed to use.</param> /// <returns>The hash of a JSON array.</returns> private static UInt192 GetArrayHash(CosmosArray cosmosArray, UInt192 seed) { // Start the array with a distinct hash, so that empty array doesn't hash to another value. UInt192 hash = DistinctHash.GetHash(DistinctHash.ArrayHashSeed, seed); // Incorporate all the array items into the hash. for (int index = 0; index < cosmosArray.Count; index++) { CosmosElement arrayItem = cosmosArray[index]; // Order of array items matter in equality check, so we add the index just to be safe. // For now we know that murmurhash will correctly give a different hash for // [true, false, true] and [true, true, false] // due to the way the seed works. // But we add the index just incase that property does not hold in the future. UInt192 arrayItemSeed = DistinctHash.ArrayIndexHashSeed + index; hash = DistinctHash.GetHash(hash, DistinctHash.GetHash(arrayItem, arrayItemSeed)); } return(hash); }
/// <summary> /// Gets the hash given a value and a seed. /// </summary> /// <param name="value">The value to hash.</param> /// <param name="seed">The seed.</param> /// <returns>The hash.</returns> public static UInt192 GetHash(UInt192 value, UInt192 seed) { return(DistinctHash.GetHash(UInt192.ToByteArray(value), seed)); }
/// <summary> /// Gets the hash of a boolean JSON value. /// </summary> /// <param name="boolean">The boolean to hash.</param> /// <param name="seed">The seed.</param> /// <returns>The hash of a boolean JSON value.</returns> private static UInt192 GetBooleanHash(bool boolean, UInt192 seed) { return(DistinctHash.GetHash(boolean ? DistinctHash.TrueHashSeed : DistinctHash.FalseHashSeed, seed)); }
/// <summary> /// Gets the hash of a null JSON value. /// </summary> /// <param name="seed">The seed to use.</param> /// <returns>The hash of a null JSON value given a seed.</returns> private static UInt192 GetNullHash(UInt192 seed) { return(DistinctHash.GetHash(DistinctHash.NullHashSeed, seed)); }
/// <summary> /// Gets the hash of a JToken value. /// </summary> /// <param name="cosmosElement">The element to load.</param> /// <returns>The hash of the JToken.</returns> public static UInt192 GetHash(CosmosElement cosmosElement) { return(DistinctHash.GetHash(cosmosElement, DistinctHash.RootHashSeed)); }
/// <summary> /// Adds an object value to the distinct map. /// </summary> /// <param name="cosmosObject">The object to add.</param> /// <returns>Whether or not the value was successfully added.</returns> private bool AddObjectValue(CosmosObject cosmosObject) { UInt128 hash = DistinctHash.GetHash(cosmosObject); return(this.objects.Add(hash)); }
/// <summary> /// Adds an array value to the distinct map. /// </summary> /// <param name="array">The array to add.</param> /// <returns>Whether or not the value was successfully added.</returns> private bool AddArrayValue(CosmosArray array) { UInt128 hash = DistinctHash.GetHash(array); return(this.arrays.Add(hash)); }
public override Output ExecuteTest(Input input) { UInt128 hash = DistinctHash.GetHash(input.CosmosElement); return(new Output(hash)); }
/// <summary> /// Gets the hash given a value and a seed. /// </summary> /// <param name="value">The value to hash.</param> /// <param name="seed">The seed.</param> /// <returns>The hash.</returns> public static UInt128 GetHash(UInt128 value, UInt128 seed) { return(DistinctHash.GetHash(UInt128.ToByteArray(value), seed)); }
/// <summary> /// Compares to objects and returns their partial sort relationship. /// </summary> /// <param name="element1">The first element to compare.</param> /// <param name="element2">The second element to compare.</param> /// <returns> /// Less than zero if obj1 comes before obj2 in the sort order. /// Zero if obj1 and obj2 are interchangeable in the sort order. /// Greater than zero if obj2 comes before obj1 in the sort order. /// </returns> public int Compare(CosmosElement element1, CosmosElement element2) { if (object.ReferenceEquals(element1, element2)) { return(0); } if (object.ReferenceEquals(element1, MinValueItem.Singleton)) { return(-1); } if (object.ReferenceEquals(element2, MinValueItem.Singleton)) { return(1); } if (object.ReferenceEquals(element1, MaxValueItem.Singleton)) { return(1); } if (object.ReferenceEquals(element2, MaxValueItem.Singleton)) { return(-1); } if (element1 == Undefined) { return(-1); } if (element2 == Undefined) { return(1); } CosmosElementType type1 = element1.Type; int cmp = CompareTypes(element1, element2); if (cmp == 0) { // If they are the same type then you need to break the tie. switch (type1) { case CosmosElementType.Boolean: cmp = Comparer <bool> .Default.Compare( (element1 as CosmosBoolean).Value, (element2 as CosmosBoolean).Value); break; case CosmosElementType.Null: // All nulls are the same. cmp = 0; break; case CosmosElementType.Number: CosmosNumber number1 = element1 as CosmosNumber; CosmosNumber number2 = element2 as CosmosNumber; if (number1.NumberType == CosmosNumberType.Number64) { double double1; if (number1.IsFloatingPoint) { double1 = number1.AsFloatingPoint().Value; } else { double1 = number1.AsInteger().Value; } double double2; if (number2.IsFloatingPoint) { double2 = number2.AsFloatingPoint().Value; } else { double2 = number2.AsInteger().Value; } cmp = Comparer <double> .Default.Compare( double1, double2); } else if (number1.IsFloatingPoint) { double double1 = number1.AsFloatingPoint().Value; double double2 = number2.AsFloatingPoint().Value; cmp = Comparer <double> .Default.Compare(double1, double2); } else { long integer1 = number1.AsInteger().Value; long integer2 = number2.AsInteger().Value; cmp = Comparer <long> .Default.Compare(integer1, integer2); } break; case CosmosElementType.String: CosmosString string1 = element1 as CosmosString; CosmosString string2 = element2 as CosmosString; cmp = string.CompareOrdinal( string1.Value, string2.Value); break; case CosmosElementType.Guid: CosmosGuid guid1 = element1 as CosmosGuid; CosmosGuid guid2 = element2 as CosmosGuid; cmp = guid1.Value.CompareTo(guid2.Value); break; case CosmosElementType.Binary: CosmosBinary binary1 = element1 as CosmosBinary; CosmosBinary binary2 = element2 as CosmosBinary; cmp = ItemComparer.CompareTo(binary1, binary2); break; case CosmosElementType.Array: case CosmosElementType.Object: { UInt192 hash1 = DistinctHash.GetHash(element1); UInt192 hash2 = DistinctHash.GetHash(element2); return(hash1.CompareTo(hash2)); } default: throw new ArgumentException($"Unknown: {nameof(CosmosElementType)}: {type1}"); } } return(cmp); }