docs: public void advertiseSelf(TrustGraphAdvertisement message) {
  
  
          /* 
           * Choose the route length and number of neighbors to 
           * advertise to based on the number of neighbors this 
           * node has.  The product of these two values determines 
           * the intended reach.  The route length is bounded by 
           * the minimum and maximum route length paramters and the 
           * number of neighbors is bounded by the degree.  
           * 
           * If there are more neighbors available than are needed, 
           * the random ordering kept by the routing table is used 
           * to select the subset to advertise to.  
           *
           * If there are too many neighbors to use (ie more than 
           * reach/min route len) The largest subset of neighbors 
           * is chosen and each is sent a route approximately 
           * reach/min in length.
           * 
           * TR2008-918 does not explicitly outline how to allocate
           * inexact divisions of route length or what to do in the 
           * case that neither boundary condition is violated.
           *
           * This implementation assumes that all neighbors should 
           * be advertised to and that the strategy for allocating 
           * route lengths to sum to the intended reach should 
           * be repeatable in keeping with the intent of the 
           * limited advertisement. 
           * 
           */
          
          final int idealReach = getIdealReach(); 
          final int minRouteLength = getMinRouteLength();
          final int maxRouteLength = getMaxRouteLength();
  
          final List<TrustGraphNodeId> neighbors =
              getRoutingTable().getOrderedNeighbors();
          final int neighborCount = neighbors.size();
  
          /* if there are not enough neighbors to reach the 
           * ideal number with maximum route length per neighbor, 
           * just use them all.
           */ 
          if ( neighborCount * maxRouteLength < idealReach ) {
              for (TrustGraphNodeId n : neighbors) {
                  sendAdvertisement(message, n, maxRouteLength);
              }
          }
          /* Otherwise, use as many neigbors as possible. 
           * The number of usable neighbors is bounded above 
           * by idealReach/minRouteLength.
           */
          else {
              // use as many neighbors as possible
              final int routes;
              // too many neighbors, if all were used at min route length
              if (neighborCount * minRouteLength > idealReach ) {
                  routes = idealReach / minRouteLength;
              }
              // can use all
              else {
                  routes = neighborCount;
              }
  
              /* distribute route lengths between min and max that sum to
               * idealReach.
               * 
               * floor(idealReach/routes is the base length of each route, and 
               * any remainder is spread out as one extra hop on each of the 
               * first 'remainder' routes.
               */ 
              final int stdLen = idealReach / routes;
              final int remainder = idealReach % routes;
  
              /* send the actual adverstisements.  Use the first 'routes' neighbors
               * in the random ordering assigned by the routing table. 
               */
              Iterator<TrustGraphNodeId> it = neighbors.iterator();
              for (int i = 0; i < routes; i++) {
                  int routeLength = stdLen;
                  if (i < remainder) {
                      routeLength += 1;
                  }
                  sendAdvertisement(message, it.next(), routeLength);
              }
          }
      }