we want to avoid cycles.
776525
protected void setupNotificationArea() throws Throwable {
        final String sourceMethod = "setupNotificationArea";

        URL notificationsURL = null;
        HttpsURLConnection connection = null;
        try {
            // Get URL for creating a notification area
            notificationsURL = serverConnection.getNotificationsURL();

            if (logger.isLoggable(Level.FINEST)) {
                logger.logp(Level.FINEST, logger.getName(), sourceMethod, "[" + RESTClientMessagesUtil.getObjID(this) + "] About to call notificationURL: " + notificationsURL);
            }

            // Get connection to server
            connection = serverConnection.getConnection(notificationsURL, HttpMethod.POST, true);

            // Create NotificationSettings object
            NotificationSettings ns = new NotificationSettings();
            ns.deliveryInterval = serverConnection.getConnector().getNotificationDeliveryInterval();
            ns.inboxExpiry = serverConnection.getConnector().getNotificationInboxExpiry();

            // Write CreateMBean JSON to connection output stream
            OutputStream output = connection.getOutputStream();
            converter.writeNotificationSettings(output, ns);
            output.flush();
        } catch (ConnectException ce) {
            // Server is down; not a client bug
            throw ce;
        } catch (IOException io) {
            throw serverConnection.getRequestErrorException(sourceMethod, io, notificationsURL);
        }

        // Check response code from server
        final int responseCode = connection.getResponseCode();

        if (logger.isLoggable(Level.FINEST)) {
            logger.logp(Level.FINEST, logger.getName(), sourceMethod, "Received responseCode: " + responseCode);
        }

        switch (responseCode) {
            case HttpURLConnection.HTTP_OK:
                JSONConverter converter = JSONConverter.getConverter();
                try {
                    // Process and return server response, which should be a NotificationArea
                    NotificationArea area = converter.readNotificationArea(connection.getInputStream());

                    inboxURL = new DynamicURL(serverConnection.connector, area.inboxURL);
                    registrationsURL = new DynamicURL(serverConnection.connector, area.registrationsURL);
                    serverRegistrationsURL = new DynamicURL(serverConnection.connector, area.serverRegistrationsURL);
                    notificationClientURL = new DynamicURL(serverConnection.connector, area.clientURL);

                    if (logger.isLoggable(Level.FINER)) {
                        logger.logp(Level.FINER, logger.getName(), "setupNotificationArea", "Successfully setup inboxURL: " + inboxURL.getURL());
                    }
                    break;
                } catch (Exception e) {
                    throw serverConnection.getResponseErrorException(sourceMethod, e, notificationsURL);
                } finally {
                    JSONConverter.returnConverter(converter);
                }
            case HttpURLConnection.HTTP_NOT_FOUND:
                throw new IOException(RESTClientMessagesUtil.getMessage(RESTClientMessagesUtil.URL_NOT_FOUND));
            case HttpURLConnection.HTTP_UNAVAILABLE:
            case HttpURLConnection.HTTP_BAD_REQUEST:
            case HttpURLConnection.HTTP_INTERNAL_ERROR:
                // Server response should be a serialized Throwable
                throw serverConnection.getServerThrowable(sourceMethod, connection);
            case HttpURLConnection.HTTP_UNAUTHORIZED:
            case HttpURLConnection.HTTP_FORBIDDEN:
                throw serverConnection.getBadCredentialsException(responseCode, connection);
            default:
                throw serverConnection.getResponseCodeErrorException(sourceMethod, responseCode, connection);
        }
    }
937110
def clear_cycles(self):
        """"""
        if self.rater is None:
            raise IndexError('You need to have at least one rater')

        cycles = self.rater.find('cycles')
        for cyc in list(cycles):
            cycles.remove(cyc)

        self.save()
974073
private void blockMe(int cyclesToBlock) {
	long unblock = cycles + cyclesToBlock;

	BlockedEntry newEntry = new BlockedEntry(unblock);
	blockedCollection.add(newEntry);

	while (unblock > cycles) {
	    try {
		newEntry.getSync().acquire(); // blocks
	    } catch (InterruptedException exc) {
		log.error("[temporaryBlock] Spurious wakeup", exc);
	    }
	}

    }
1238286
def stop_choose(self):
        """"""
        if self.choosed:
            self.choosed = False
            self.pos = self.pos + Sep(-5, 0)
569991
public ComponentContainer stopComponents() {
    try {
      stopChildren();
      if (pico.getLifecycleState().isStarted()) {
        pico.stop();
      }
      pico.dispose();
    } finally {
      if (parent != null) {
        parent.removeChild(this);
      }
    }
    return this;
  }
1177181
function cancel(opt_reason) {
    if (!isPending()) {
      return;
    }

    if (opt_canceller) {
      opt_reason = opt_canceller(opt_reason) || opt_reason;
    }

    reject(opt_reason);
  }
1353018
function(ev) {
      if(ev && ev.preventDefault) {
        ev.preventDefault();
      };
      if(ev && ev.stopPropagation) {
        ev.stopPropagation();
      };
    }
408740
def stop(self):
        """"""
        self._presubs.remove(self._sdk_presub_params)
        if self._immediacy == FirstValue.on_value_update:
            self._unsubscribe_all_matching()
        super(ResourceValues, self).stop()
637480
def ignore_stops_before_now(self):
        """"""
        self._sentinel_stop = object()
        self._q.put(self._sentinel_stop)
882371
function warning() {
  let sentence = "";
  const avoidList = getWords("avoid_list");
  const avoid = nu.chooseFrom(avoidList);
  const rnum = Math.floor(Math.random() * 10);
  if (rnum <= 3) {
    sentence = `You would be well advised to avoid ${avoid}`;
  } else if (rnum <= 6){
    sentence = `Avoid ${avoid} at all costs`;
  } else if (rnum <= 8) {
    sentence = `Steer clear of ${avoid} for a stress-free week`;
  } else {
    sentence = `For a peaceful week, avoid ${avoid}`;
  }
  return nu.sentenceCase(sentence);
}
468073
def Stop(self):
    """"""
    self._shutdown = True
    self._new_updates.set()  # Wake up the transmission thread.

    if self._main_thread is not None:
      self._main_thread.join()
      self._main_thread = None

    if self._transmission_thread is not None:
      self._transmission_thread.join()
      self._transmission_thread = None
505632
public function hasCycle()
    {
        $components = new ConnectedComponents($this->graph);
        if ($components->isSingle()) {
            $alg = new Degree($this->graph);

            foreach ($this->graph->getVertices() as $vertex) {
                // uneven degree => fail
                if ($alg->getDegreeVertex($vertex) & 1) {
                    return false;
                }
            }

            return true;
        }

        return false;
    }
74625
protected static void removeInstance( Object instance ) {
      Set set = getCycleSet();
      set.remove( instance );
      if(set.size() == 0) {
          cycleSet.remove();
      }
   }
1114837
def stop_everything(self):
        """"""
        for x in range(118):
            for c in range(16):
                self.stop_Note(x, c)
300416
def off(self):
        """"""
        self._send_method(StandardSend(self._address,
                                       COMMAND_LIGHT_OFF_0X13_0X00),
                          self._off_message_received)
976344
def off(self):
        """"""
        msg = X10Send.unit_code_msg(self.address.x10_housecode,
                                    self.address.x10_unitcode)
        self._send_method(msg)

        msg = X10Send.command_msg(self.address.x10_housecode,
                                  X10_COMMAND_OFF)
        self._send_method(msg, False)
        self._update_subscribers(0x00)
801653
function onCycle(cycle, opts) {
  let hz = Math.round(cycle.hz).toLocaleString()
  let rme = '\xb1' + cycle.stats.rme.toFixed(2) + '%'

  // add colors
  hz = color(34) + hz + color(0)
  rme = color(33) + rme + color(0)

  const padding = ' '.repeat(opts.width - cycle.name.length)
  console.log(`${cycle.name}${padding}  ${hz} ops/sec  ${rme}`)
}