Ignore future reports on this object.

        This prevents future reports from causing notifications or appearing
        in the various moderation listing. The report count will still
        increment.
499013
def ignore_reports(self):
        
        url = self.reddit_session.config['ignore_reports']
        data = {'id': self.fullname}
        return self.reddit_session.request_json(url, data=data)
700815
public void removeOutsideCornerFeatures() {
		if( pairs2D.size() != storagePairs2D.size )
			throw new RuntimeException("This can only be called when all the features have been added");

		pairs2D.remove(11);
		pairs2D.remove(5);
		pairs2D.remove(0);
	}
427512
public void cancel() {
        final OnCancelListener listener;
        synchronized (this) {
            if (mIsCanceled) {
                return;
            }
            mIsCanceled = true;
            mCancelInProgress = true;
            listener = mOnCancelListener;
        }

        try {
            if (listener != null) {
                listener.onCancel();
            }
        } finally {
            synchronized (this) {
                mCancelInProgress = false;
                notifyAll();
            }
        }
    }
166180
def stop(cls):
        
        manager = LocationManager.instance()
        if manager:
            for l in manager.listeners:
                manager.removeUpdates(l)
            manager.listeners = []
1020232
def disable_by_count(self):
        
        if self.enable_count > 0:
            self.enable_count -= 1
            if self.enable_count == 0:
                self.disable()
191834
private void avoidObstacle(int nextStep, int max)
    {
        if (nextStep >= max - 1)
        {
            pathStoppedRequested = true;
        }
        final Collection<Integer> cid = mapPath.getObjectsId(path.getX(nextStep), path.getY(nextStep));
        if (sharedPathIds.containsAll(cid))
        {
            setDestination(destX, destY);
        }
        else
        {
            if (!ignoredIds.containsAll(cid))
            {
                setDestination(destX, destY);
            }
        }
    }
180228
public void cancelPendingTake() {
        CompletableFuture<Queue<T>> pending;
        synchronized (this.contents) {
            pending = this.pendingTake;
            this.pendingTake = null;
        }

        // Cancel any pending poll request.
        if (pending != null) {
            pending.cancel(true);
        }
    }
899996
public static void ignoreUpdate(Version ver) {
        FOKLogger.info(UpdateChecker.class.getName(), "User ignores all updates up to (and including) version " + ver.toString());
        updatePrefs.setPreference(latestSeenVersionPrefKey, ver.toString());
    }
215153
public void stop() {
        lock.writeLock().lock();
        try {
            debugRelativeTime("Stop!");
            this.stopped = true;
            if (this.future != null && !this.future.isDone()) {
                debugRelativeTime("Cancelling");
                this.future.cancel(true);
            }
            this.future = null;
        } finally {
            lock.writeLock().unlock();
        }

    }
813217
def clearAnnouncements(self):
        
        try:
            q = models.Announcement.delete().where(
                models.Announcement.id > 0)
            q.execute()
        except Exception as e:
            raise exceptions.RepoManagerException(e)
323871
public final void stop() {
    if (!this.started) {
      log.warn(String.format("Reporter %s has already been stopped.", this.name));
      return;
    }
    try {
      stopImpl();
      this.started = false;
    } catch (Exception exception) {
      log.warn(String.format("Reporter %s did not stop correctly.", this.name), exception);
    }
  }
129131
def ignore(self, matcher):
        '''
         
        '''
        events  = self.eventtree.findAndRemove(matcher)
        for e in events:
            self.queue.unblock(e)
            e.canignore = True
995781
@Override
    public void stop(Future<Void> stopFuture) throws Exception {
        // Stop the real verticle
        if (realVerticle != null) {
            realVerticle.stop(stopFuture);
            realVerticle = null;
        }
    }
1120148
function() {
    var len = this.selectedFeatures.length;

    clearEnabledFeatures();
    for (var i = 0; i < len; i++) {
      setEnabledFeatures(this.selectedFeatures[i]);
      var feature = this.allFeatures[this.selectedFeatures[i]];

      if (feature.reporting) {
        this.featuresWithReporting.push(feature);
      }
      if (feature.update) {
        this.featuresWithUpdate.push(feature);
      }
    }

    if (this.featuresWithReporting.length > 0) {
      this.reportingEnabled = true;
    }

    if (this.featuresWithUpdate.length > 0) {
      this.updateEnabled = true;
    }
  }
952526
def stop(self):
        
        temp_archive = self.sdk.stop_archive(self.id)
        for k,v in iteritems(temp_archive.attrs()):
            setattr(self, k, v)
56322
public void clear() {
        synchronized (mLock) {
            if (mOriginalValues != null) {
                mOriginalValues.clear();
            } else {
                mObjects.clear();
            }
        }
        if (mNotifyOnChange) notifyDataSetChanged();
    }
468798
public void removeReporter(ContextAwareReporter reporter) {
    if (this.reporters.contains(reporter)) {
      reporter.stop();
      this.reporters.remove(reporter);
    }
  }