|
public IsBetweenFromLeft ( |
||
| start | ||
| end | ||
| return | bool | |
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;
}
