C# Address.Equals方法代码示例

 /// Simulator != thread-safe!
 protected static Address SimulatorCache(Address a) {
   int idx = NumberSerializer.ReadInt(a.ToMemBlock(), 0);
   Address tmp = _cache.GetValue(idx);
   if(a.Equals(tmp)) {
     return tmp;
   }
   _cache.Replace(idx, a);
   return a;
 }

 /// <summary>Is the right person sending me this packet?</summary>
 /// <param name="ip">The IP source.</param>
 /// <param name="addr">The Brunet.Address source.</summary>
 public bool Check(MemBlock ip, Address addr)
 {
   // Check current results
   Address stored_addr = null;
   bool update;
   bool exists = _cache.TryGetValue(ip, out stored_addr, out update);
   if(addr.Equals(stored_addr)) {
     if(update) {
       Miss(ip);
     }
     return true;
   } else if(!exists) {
     Miss(ip);
     return false;
   } else {
     // Bad mapping
     throw new AddressResolutionException(String.Format(
           "IP:Address mismatch, expected: {0}, got: {1}",
           addr, stored_addr), AddressResolutionException.Issues.Mismatch);
   }
 }

        /// <summary>Is the right person sending me this packet?</summary>
        /// <param name="ip">The IP source.</param>
        /// <param name="addr">The Brunet.Address source.</summary>
        public bool Check(MemBlock ip, Address addr)
        {
            // Check current results
              Address stored_addr = null;
              lock(_sync) {
            _results.TryGetValue(ip, out stored_addr);
              }

              if(addr.Equals(stored_addr)) {
            // Match!
            return true;
              } else if(stored_addr == null) {
            // No entry, check previous contents
            lock(_sync) {
              _last_results.TryGetValue(ip, out stored_addr);
            }
            if(Miss(ip)) {
              IncrementMisses(ip);
            }
            return addr.Equals(stored_addr);
              } else {
            // Bad mapping
            Miss(ip);
            throw new AddressResolutionException(String.Format(
              "IP:Address mismatch, expected: {0}, got: {1}",
              addr, stored_addr), AddressResolutionException.Issues.Mismatch);
              }
        }

    /// <summary>Is the right person sending me this packet?</summary>
    /// <param name="ip">The IP source.</param>
    /// <param name="addr">The Brunet.Address source.</summary>
    public bool Check(MemBlock ip, Address addr)
    {
      Address stored_addr = Resolve(ip);

      if(stored_addr != null) {
        if(addr.Equals(stored_addr)) {
          return true;
        } else{
          throw new AddressResolutionException(String.Format(
                "IP:Address mismatch, expected: {0}, got: {1}",
                addr, stored_addr), AddressResolutionException.Issues.Mismatch);
        }
      }

      // No mapping, so use the given mapping
      _incoming_cache.Update(ip, addr);
      return true;
    }

 /**
  * Note that a LinkProtocolState only gets a lock *AFTER* it has
  * received a LinkMessageReply.  Prior to that, the Linker that
  * created it holds the lock (if the _linker.Target is not null).
  *
  * So, given that we are being asked to transfer a lock, we must
  * have already gotten our LinkMessageReply set, or we wouldn't
  * hold the lock in the first place.
  *
  * So, we only transfer locks to other Linkers when we are finished
  * since us holding a lock means we have already head some
  * communication from the other side.
  * 
  * Since the CT.Lock and CT.Unlock methods can't be called when this
  * is being called, we know that _target_lock won't change during
  * this method.
  */
 public bool AllowLockTransfer(Address a, string contype, ILinkLocker l)
 {
   bool hold_lock = (a.Equals( _target_lock ) && contype == _contype);
   if( false == hold_lock ) {
     //This is a bug.
     throw new Exception(String.Format("We don't hold the lock: {0}", a));
   }
   if( (l is Linker) && IsFinished ) {
     return true;
   }
   return false;
 }

    /**
     * Allow if we are transfering to a LinkProtocolState or ConnectionPacketHandler
     * Note this method does not change anything, if the transfer is done, it
     * is done by the ConnectionTable while it holds its lock.
     */
    public bool AllowLockTransfer(Address a, string contype, ILinkLocker l) {
      bool allow = false;
      bool hold_lock = (a.Equals( _target_lock ) && contype == _contype);
      if( false == hold_lock ) {
        //We don't even hold this lock!
        throw new Exception(
                            String.Format("{2} asked to transfer a lock({0}) we don't hold: ({1})",
                                          a, _target_lock, this));
      }
      if( l is Linker ) {
        //Never transfer to another linker:
      }
      else if ( l is ConnectionPacketHandler.CphState ) {
      /**
       * The ConnectionPacketHandler only locks when it
       * has actually received a packet.  This is a "bird in the
       * hand" situation, however, if both sides in the double
       * link case transfer the lock, then we have accomplished
       * nothing.
       *
       * There is a specific case to worry about: the case of
       * a firewall, where only one node can contact the other.
       * In this case, it may be very difficult to connect if
       * we don't eventually transfer the lock to the
       * ConnectionPacketHandler.  In the case of bi-directional
       * connectivity, we only transfer the lock if the
       * address we are locking is greater than our own (which
       * clearly cannot be true for both sides).
       * 
       * To handle the firewall case, we keep count of how
       * many times we have been asked to transfer the lock.  On
       * the third time we are asked, we assume we are in the firewall
       * case and we allow the transfer, this is just a hueristic.
       */
        int reqs = Interlocked.Increment(ref _cph_transfer_requests);
        if ( (reqs >= 3 ) || ( a.CompareTo( LocalNode.Address ) > 0) ) {
          allow = true;
        }
      }
      else if( l is LinkProtocolState ) {
        LinkProtocolState lps = (LinkProtocolState)l;
        /**
         * Or Transfer the lock to a LinkProtocolState if:
         * 1) We created this LinkProtocolState
         * 2) The LinkProtocolState has received a packet
         */
        if( (lps.Linker == this ) && ( lps.LinkMessageReply != null ) ) {
          allow = true;
        }
      }
#if LINK_DEBUG
      if (ProtocolLog.LinkDebug.Enabled) {
	  ProtocolLog.Write(ProtocolLog.LinkDebug,
                            String.Format("{0}: Linker({1}) {2}: transfering lock on {3} to {4}",
                              _local_n.Address, _lid, (_target_lock == null), a, l));
      }
#endif
      return allow;
    }

 /// <summary>Is the right person sending me this packet?</summary>
 /// <param name="ip">The IP source.</param>
 /// <param name="addr">The Brunet.Address source.</summary>
 public bool Check(MemBlock ip, Address addr)
 {
     Address stored_addr = _results[ip] as Address;
       if(addr.Equals(stored_addr)) {
     return true;
       } else if(stored_addr == null) {
     if(Miss(ip)) {
       IncrementMisses(ip);
     }
     return false;
       } else {
     Miss(ip);
     throw new AddressResolutionException(String.Format("IP:Address mismatch, expected: {0}, got: {1}",
       addr, stored_addr), AddressResolutionException.Issues.Mismatch);
       }
 }

 /**
  * Callback function that is invoked when TargetSelector fetches candidate scores in a range.
  * Initiates connection setup. 
  * Node: All connection messages can be tagged with a token string. This token string is currenly being
  * used to keep the following information about a shortcut:
  * 1. The node who initiated the shortcut setup.
  * 2. The random target near which shortcut was chosen.
  * @param start address pointing to the start of range to query.
  * @param score_table list of candidate addresses sorted by score.
  * @param current currently selected optimal (nullable) 
  */
 protected void CreateShortcutCallback(Address start, SortedList score_table, Address current) {
   if (score_table.Count > 0) {
     /**
      * we remember our address and the start of range inside the token.
      * token is the concatenation of 
      * (a) local node address
      * (b) random target for the range queried by target selector
      */
     string token = _node.Address + start.ToString();
     //connect to the min_target
     Address min_target = (Address) score_table.GetByIndex(0);
     ISender send = null;
     if (start.Equals(min_target)) {
       //looks like the target selector simply returned our random address
       if (LogEnabled) {
         ProtocolLog.Write(ProtocolLog.SCO, 
                           String.Format("SCO local: {0}, Connecting (shortcut) to min_target: {1} (greedy), random_target: {2}.", 
                                         _node.Address, min_target, start));
       }
       //use a greedy sender
       send = new AHGreedySender(_node, min_target);
     } else {
       if (LogEnabled) {
         ProtocolLog.Write(ProtocolLog.SCO, 
                           String.Format("SCO local: {0}, Connecting (shortcut) to min_target: {1} (exact), random_target: {2}.", 
                               _node.Address, min_target, start));
       }
       //use exact sender
       send = new AHExactSender(_node, min_target);
     }
     ConnectTo(send, min_target, STRUC_SHORT, token);
   }
 }

 /**
  * Factory method to reduce memory allocations by caching
  * commonly used NodeInfo objects
  */
 public static NodeInfo CreateInstance(Address a) {
   //Read some of the least significant bytes out,
   //AHAddress all have last bit 0, so we skip the last byte which
   //will have less entropy
   MemBlock mb = a.ToMemBlock();
   ushort idx = (ushort)NumberSerializer.ReadShort(mb, Address.MemSize - 3);
   NodeInfo ni = _mb_cache[idx];
   if( ni != null ) {
     if (a.Equals(ni._address)) {
       return ni;
     }
   }
   ni = new NodeInfo(a);
   _mb_cache[idx] = ni;
   return ni;
 }

        /// <summary>Is the right person sending me this packet?</summary>
        /// <param name="ip">The IP source.</param>
        /// <param name="addr">The Brunet.Address source.</summary>
        public bool Check(MemBlock ip, Address addr)
        {
            if(addr.Equals(_results[ip])) {
            return true;
              }

              Miss(ip);
              return false;
        }