C# AHAddress.IsBetweenFromLeft方法代码示例

 /**
 <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");
      }
    }

 /**
 <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;
 }