public void Send(ICopyable data) { ConnectionList cl = Node.ConnectionTable.GetConnections(ConnectionType.Structured); // We start with the node immediately after the starting index int start = cl.IndexOf(From); if (start < 0) { start = ~start; } // We end with the node immediately before the end index int end = cl.IndexOf(To); if (end < 0) { end = ~end; } // If start >= end, because From < To or because this is a terminal // node and there are no other entities to forward it to. So the // second test ensures that the first entity is actually inside the // range to forward it to. AHAddress start_addr = cl[start].Address as AHAddress; if (start >= end && start_addr.IsBetweenFromLeft(From, To)) { end += cl.Count; } List <Connection> cons = SortByDistance(cl, start, end, Forwarders); for (int i = 0; i < cons.Count; i++) { Connection con = cons[i]; int next = i + 1; AHAddress nfrom = con.Address as AHAddress; Address nto = To; if (next < cons.Count) { nto = GetLeftNearTarget(cons[next].Address as AHAddress); } con.Edge.Send(new CopyList(PType, Source.ToMemBlock(), nfrom.ToMemBlock(), nto.ToMemBlock(), _forwarders, _hops, data)); } _sent_to = cons.Count; }
/** <summary>Reassign range info(Start and End) based on recalculated range.</summary> <param name = "rg_size">Current range size(round distance between start address and end address of this Entry).</param> <remarks>new_start = mid - rg_size/2, new_end = mid + rg_size/2 </remarks> */ public Entry ReAssignRange(BigInteger rg_size) { // calculate middle address of range BigInteger start_int = Start.ToBigInteger(); BigInteger end_int = End.ToBigInteger(); BigInteger mid_int = (start_int + end_int) / 2; if (mid_int % 2 == 1) { mid_int = mid_int -1; } AHAddress mid_addr = new AHAddress(mid_int); /* * If we have a case where start -> end includes zero, * this is the wrap around. So, we can imagine that * we have end' = end + Address.Full. So, * mid' = (start + end')/2 = (start + end)/2 + Address.Full/2 = (start + end)/ 2 + Address.Half */ if (!mid_addr.IsBetweenFromLeft(Start, End)) { mid_int += Address.Half; } //addresses for new range BigInteger rg_half = rg_size / 2; if (rg_half % 2 == 1) { rg_half -= 1; } AHAddress n_a = new AHAddress(mid_int - rg_half); AHAddress n_b = new AHAddress(mid_int + rg_half); return new Entry(Content, Alpha, n_a, n_b); }
//returns true if addr is in a given range including boundary. /** * This returns true if addr is between start and end in a ring. * IsBetweenFrom*() excludes both start and end, but InRange() includes both. * @param addr, this node's address * @param start, the beginning address of range * @param end, the ending address of range */ public bool InRange(AHAddress addr, AHAddress start, AHAddress end) { return addr.IsBetweenFromLeft(start, end) || addr.Equals(start) || addr.Equals(end); }
public void Test() { byte[] buf1 = new byte[20]; for (int i = 0; i <= 18; i++) { buf1[i] = 0x00; } buf1[19] = 0x0A; AHAddress test_address_1 = new AHAddress( MemBlock.Reference(buf1, 0, buf1.Length) ); byte[] buf2 = new byte[20]; for (int i = 0; i <= 18; i++) { buf2[i] = 0xFF; } buf2[19] = 0xFE; AHAddress test_address_2 = new AHAddress( MemBlock.Reference(buf2, 0, buf2.Length) ); //test_address_1 is to the left of test_address_2 //because it only a few steps in the clockwise direction: Assert.IsTrue( test_address_1.IsLeftOf( test_address_2 ), "IsLeftOf"); Assert.IsTrue( test_address_2.IsRightOf( test_address_1 ), "IsRightOf"); //This distance is twelve: Assert.AreEqual( test_address_2.DistanceTo( test_address_1), new BigInteger(12), "DistanceTo"); Assert.IsTrue( test_address_1.CompareTo(test_address_2) < 0, "CompareTo"); Assert.IsTrue( test_address_2.CompareTo(test_address_1) > 0, "CompareTo"); byte[] buf3 = new byte[Address.MemSize]; test_address_2.CopyTo(buf3); AHAddress test3 = new AHAddress(MemBlock.Reference(buf3,0,buf3.Length)); Assert.IsTrue( test3.CompareTo( test_address_2 ) == 0 , "CompareTo"); Assert.IsTrue( test3.CompareTo( test3 ) == 0, "CompareTo"); //As long as the address does not wrap around, adding should increase it: AHAddress a4 = new AHAddress( test_address_1.ToBigInteger() + 100 ); Assert.IsTrue( a4.CompareTo( test_address_1 ) > 0, "adding increases"); Assert.IsTrue( a4.CompareTo( test_address_2 ) < 0, "smaller than biggest"); //Here are some consistency tests: for( int i = 0; i < 1000; i++) { System.Random r = new Random(); byte[] b1 = new byte[Address.MemSize]; r.NextBytes(b1); //Make sure it is class 0: Address.SetClass(b1, 0); byte[] b2 = new byte[Address.MemSize]; r.NextBytes(b2); //Make sure it is class 0: Address.SetClass(b2, 0); byte[] b3 = new byte[Address.MemSize]; r.NextBytes(b3); //Make sure it is class 0: Address.SetClass(b3, 0); AHAddress a5 = new AHAddress( MemBlock.Reference(b1,0,b1.Length) ); AHAddress a6 = new AHAddress( MemBlock.Reference(b2,0,b2.Length) ); AHAddress a7 = new AHAddress( MemBlock.Reference(b3,0,b3.Length) ); Assert.IsTrue( a5.CompareTo(a6) == -1 * a6.CompareTo(a5), "consistency"); //Nothing is between the same address: Assert.IsFalse( a5.IsBetweenFromLeft(a6, a6), "Empty Between Left"); Assert.IsFalse( a5.IsBetweenFromRight(a7, a7), "Empty Between Right"); //Endpoints are not between: Assert.IsFalse( a6.IsBetweenFromLeft(a6, a7), "End point Between Left"); Assert.IsFalse( a6.IsBetweenFromRight(a6, a7), "End point Between Right"); Assert.IsFalse( a7.IsBetweenFromLeft(a6, a7), "End point Between Left"); Assert.IsFalse( a7.IsBetweenFromRight(a6, a7), "End point Between Right"); if ( a5.IsBetweenFromLeft(a6, a7) ) { //Then the following must be true: Assert.IsTrue( a6.LeftDistanceTo(a5) < a6.LeftDistanceTo(a7), "BetweenLeft true"); } else { //Then the following must be false: Assert.IsFalse( a6.LeftDistanceTo(a5) < a6.LeftDistanceTo(a7), "BetweenLeft false"); } if ( a5.IsBetweenFromRight(a6, a7) ) { //Then the following must be true: Assert.IsTrue( a6.RightDistanceTo(a5) < a6.RightDistanceTo(a7), "BetweenRight true"); } else { //Then the following must be false: Assert.IsFalse( a6.RightDistanceTo(a5) < a6.RightDistanceTo(a7), "BetweenRight false"); } if( a5.IsCloserToFirst(a6, a7) ) { Assert.IsTrue( a5.DistanceTo(a6).abs() < a5.DistanceTo(a7).abs(), "IsCloser 1"); } else { Assert.IsFalse( a5.DistanceTo(a6).abs() < a5.DistanceTo(a7).abs(), "IsCloser 2"); } Assert.IsFalse(a5.IsCloserToFirst(a6, a7) && a5.IsCloserToFirst(a7,a6), "can only be closer to one!"); if( false == a5.Equals(a6) ) { Assert.IsTrue(a5.IsCloserToFirst(a5, a6), "Always closer to self"); } Assert.IsFalse(a5.IsBetweenFromLeft(a6, a7) == a5.IsBetweenFromRight(a6, a7), "can't be between left and between right"); } }
public void Test() { byte[] buf1 = new byte[20]; for (int i = 0; i <= 18; i++) { buf1[i] = 0x00; } buf1[19] = 0x0A; AHAddress test_address_1 = new AHAddress(MemBlock.Reference(buf1, 0, buf1.Length)); byte[] buf2 = new byte[20]; for (int i = 0; i <= 18; i++) { buf2[i] = 0xFF; } buf2[19] = 0xFE; AHAddress test_address_2 = new AHAddress(MemBlock.Reference(buf2, 0, buf2.Length)); //test_address_1 is to the left of test_address_2 //because it only a few steps in the clockwise direction: Assert.IsTrue(test_address_1.IsLeftOf(test_address_2), "IsLeftOf"); Assert.IsTrue(test_address_2.IsRightOf(test_address_1), "IsRightOf"); //This distance is twelve: Assert.AreEqual(test_address_2.DistanceTo(test_address_1), new BigInteger(12), "DistanceTo"); Assert.IsTrue(test_address_1.CompareTo(test_address_2) < 0, "CompareTo"); Assert.IsTrue(test_address_2.CompareTo(test_address_1) > 0, "CompareTo"); byte[] buf3 = new byte[Address.MemSize]; test_address_2.CopyTo(buf3); AHAddress test3 = new AHAddress(MemBlock.Reference(buf3, 0, buf3.Length)); Assert.IsTrue(test3.CompareTo(test_address_2) == 0, "CompareTo"); Assert.IsTrue(test3.CompareTo(test3) == 0, "CompareTo"); //As long as the address does not wrap around, adding should increase it: AHAddress a4 = new AHAddress(test_address_1.ToBigInteger() + 100); Assert.IsTrue(a4.CompareTo(test_address_1) > 0, "adding increases"); Assert.IsTrue(a4.CompareTo(test_address_2) < 0, "smaller than biggest"); //Here are some consistency tests: for (int i = 0; i < 1000; i++) { System.Random r = new Random(); byte[] b1 = new byte[Address.MemSize]; r.NextBytes(b1); //Make sure it is class 0: Address.SetClass(b1, 0); byte[] b2 = new byte[Address.MemSize]; r.NextBytes(b2); //Make sure it is class 0: Address.SetClass(b2, 0); byte[] b3 = new byte[Address.MemSize]; r.NextBytes(b3); //Make sure it is class 0: Address.SetClass(b3, 0); AHAddress a5 = new AHAddress(MemBlock.Reference(b1, 0, b1.Length)); AHAddress a6 = new AHAddress(MemBlock.Reference(b2, 0, b2.Length)); AHAddress a7 = new AHAddress(MemBlock.Reference(b3, 0, b3.Length)); Assert.IsTrue(a5.CompareTo(a6) == -1 * a6.CompareTo(a5), "consistency"); //Nothing is between the same address: Assert.IsFalse(a5.IsBetweenFromLeft(a6, a6), "Empty Between Left"); Assert.IsFalse(a5.IsBetweenFromRight(a7, a7), "Empty Between Right"); //Endpoints are not between: Assert.IsFalse(a6.IsBetweenFromLeft(a6, a7), "End point Between Left"); Assert.IsFalse(a6.IsBetweenFromRight(a6, a7), "End point Between Right"); Assert.IsFalse(a7.IsBetweenFromLeft(a6, a7), "End point Between Left"); Assert.IsFalse(a7.IsBetweenFromRight(a6, a7), "End point Between Right"); if (a5.IsBetweenFromLeft(a6, a7)) { //Then the following must be true: Assert.IsTrue(a6.LeftDistanceTo(a5) < a6.LeftDistanceTo(a7), "BetweenLeft true"); } else { //Then the following must be false: Assert.IsFalse(a6.LeftDistanceTo(a5) < a6.LeftDistanceTo(a7), "BetweenLeft false"); } if (a5.IsBetweenFromRight(a6, a7)) { //Then the following must be true: Assert.IsTrue(a6.RightDistanceTo(a5) < a6.RightDistanceTo(a7), "BetweenRight true"); } else { //Then the following must be false: Assert.IsFalse(a6.RightDistanceTo(a5) < a6.RightDistanceTo(a7), "BetweenRight false"); } if (a5.IsCloserToFirst(a6, a7)) { Assert.IsTrue(a5.DistanceTo(a6).abs() < a5.DistanceTo(a7).abs(), "IsCloser 1"); } else { Assert.IsFalse(a5.DistanceTo(a6).abs() < a5.DistanceTo(a7).abs(), "IsCloser 2"); } Assert.IsFalse(a5.IsCloserToFirst(a6, a7) && a5.IsCloserToFirst(a7, a6), "can only be closer to one!"); if (false == a5.Equals(a6)) { Assert.IsTrue(a5.IsCloserToFirst(a5, a6), "Always closer to self"); } Assert.IsFalse(a5.IsBetweenFromLeft(a6, a7) == a5.IsBetweenFromRight(a6, a7), "can't be between left and between right"); } }
/** <summary>Returns a list of keys stored at this node that exist between the two addresses. Such keys returned are the storest path between the two addresses.</summary> <param name="add1">One of the address end points.</param> <param name="add2">Another of the address end points.</param> <returns>A LinkedList of key entries between add1 and add2</returns> */ public LinkedList<MemBlock> GetKeysBetween(AHAddress add1, AHAddress add2) { LinkedList<MemBlock> keys = new LinkedList<MemBlock>(); if(add1.IsRightOf(add2)) { foreach(MemBlock key in list_of_keys) { AHAddress key_addr = new AHAddress(key); if(key_addr.IsBetweenFromLeft(add1, add2)) { keys.AddLast(key); } } } else { foreach(MemBlock key in list_of_keys) { AHAddress key_addr = new AHAddress(key); if(key_addr.IsBetweenFromRight(add1, add2)) { keys.AddLast(key); } } } return keys; }