Report accumulated warnings to the BugReporter. Clears all accumulated
warnings as a side-effect.
496788
public void reportAccumulatedBugs() {
        for (Map.Entry<BugInstance, Data> e : map.entrySet()) {
            BugInstance bug = e.getKey();
            Data d = e.getValue();
            reportBug(bug, d);
        }
        clearBugs();
    }
1185343
def warning(self, message, *args, **kwargs):
        
        warncls = kwargs.pop('warning', None)
        if warncls and self.raise_warnings:
            warnings.warn(message, warncls)

        return self.log(logging.WARNING, message, *args, **kwargs)
600063
def _PrintWarningsDetails(self, storage):
    
    if not storage.HasWarnings():
      self._output_writer.Write('No warnings stored.\n\n')
      return

    for index, warning in enumerate(storage.GetWarnings()):
      title = 'Warning: {0:d}'.format(index)
      table_view = views.ViewsFactory.GetTableView(
          self._views_format_type, title=title)

      table_view.AddRow(['Message', warning.message])
      table_view.AddRow(['Parser chain', warning.parser_chain])

      path_specification = warning.path_spec.comparable
      for path_index, line in enumerate(path_specification.split('\n')):
        if not line:
          continue

        if path_index == 0:
          table_view.AddRow(['Path specification', line])
        else:
          table_view.AddRow(['', line])

      table_view.Write(self._output_writer)
796825
public void clear() {
    messages = Collections.emptyList();
    isMessagesListMutable = false;
    if (builders != null) {
      for (SingleFieldBuilder<MType, BType, IType> entry :
          builders) {
        if (entry != null) {
          entry.dispose();
        }
      }
      builders = null;
    }
    onChanged();
    incrementModCounts();
  }
428230
public void clearBugCounts() {
        for (int i = 0; i < totalErrors.length; i++) {
            totalErrors[i] = 0;
        }
        for (PackageStats stats : packageStatsMap.values()) {
            stats.clearBugCounts();
        }
    }
84461
def report(self, reporter, ignore_nfd=False, ignore_ws=False):
		
		if self.strip_errors and not ignore_ws:
			reporter.add(self.strip_errors, 'leading or trailing whitespace')

		if self.norm_errors and not ignore_nfd:
			reporter.add(self.norm_errors, 'not in Unicode NFD')
275854
def display_warnings(warnings, settings)
      num_fixable = warnings.select { |warn| warn.fixable? }.size
      num_total = warnings.size

      results = "#{num_total} warnings found. #{num_fixable} are fixable."
      puts results
      puts '=' * results.size

      warnings.each do |warning|
        puts "#{warning.file}:#{warning.line_number} #{warning.name} " +
             "(#{warning.severity}) - #{warning.desc}"
      end
    end
28950
public void report() {
        synchronized (this) {
            report(registry.getGauges(filter),
                    registry.getCounters(filter),
                    registry.getHistograms(filter),
                    registry.getMeters(filter),
                    registry.getTimers(filter));
        }
    }
947119
def reporting(self):
        
        self.thread_debug("reporting")
        res = resource.getrusage(resource.RUSAGE_SELF)
        self.NOTIFY("",
                    type='internal-usage',
                    maxrss=round(res.ru_maxrss/1024, 2),
                    ixrss=round(res.ru_ixrss/1024, 2),
                    idrss=round(res.ru_idrss/1024, 2),
                    isrss=round(res.ru_isrss/1024, 2),
                    threads=threading.active_count(),
                    proctot=len(self.monitors),
                    procwin=self.stats.procwin)
957472
private void reportable() {
        final SimpleOutput reportable = new SimpleOutput();
        reportable.setErrorStream(System.err);
        reportable.setOutputStream(System.out);
        setReportable(reportable);
    }
671929
public void setWarnings(java.util.Collection<Warning> warnings) {
        if (warnings == null) {
            this.warnings = null;
            return;
        }

        this.warnings = new java.util.ArrayList<Warning>(warnings);
    }
816760
public void printWarning() {
    System.out.print("Warning: ");
    System.out.print(description);
    if (value != null)
      System.out.print(" (" + value + ")");
    System.out.println();
  }
989947
private void cleanup() {
        StatsDataReference ref = null;
        while ((ref = (StatsDataReference) statisticsReferenceQueue.poll()) != null) {
            StatsData oldStats = null;
            StatsData updatedStats = null;
            do {
                oldStats = terminatedThreadStats.get();
                updatedStats = aggregateStats(oldStats, ref.statsData);
            } while (!terminatedThreadStats.compareAndSet(oldStats, updatedStats));
            allReferences.remove(ref);
        }
    }
221652
public void accumulateBug(BugInstance bug, SourceLineAnnotation sourceLine) {
        if (sourceLine == null) {
            throw new NullPointerException("Missing source line");
        }
        int priority = bug.getPriority();
        if (!performAccumulation) {
            bug.addSourceLine(sourceLine);
        } else {
            bug.setPriority(Priorities.NORMAL_PRIORITY);
        }

        lastBug = bug;
        lastSourceLine = sourceLine;
        Data d = map.get(bug);
        if (d == null) {
            String hash = bug.getInstanceHash();
            BugInstance conflictingBug = hashes.get(hash);
            if (conflictingBug != null) {
                if (conflictingBug.getPriority() <= priority) {
                    return;
                }
                map.remove(conflictingBug);
            }
            d = new Data(priority, sourceLine);
            map.put(bug, d);
            hashes.put(hash, bug);
        } else if (d.priority > priority) {
            if (d.priority >= Priorities.LOW_PRIORITY) {
                reportBug(bug, d);
                d.allSource.clear();
            }
            d.priority = priority;
            d.primarySource = sourceLine;
        } else if (priority >= Priorities.LOW_PRIORITY && priority > d.priority) {
            bug.setPriority(priority);
            reporter.reportBug(bug);
            return;
        }
        d.allSource.add(sourceLine);
    }
407096
private void evictionWarningIfNeeded() {
        // If not logging eviction warnings, just return.
        if (evictionWarningThrottle <= 0) {
            return;
        }

        evictionsSinceWarning++;

        if (evictionsSinceWarning >= evictionWarningThrottle) {
            DateFormat dateFormat = DateFormat.getDateTimeInstance();
            if (LOGGER.isInfoEnabled()) {
                LOGGER.info("There have been " + evictionsSinceWarning
                        + " evictions from the cache since "
                        + dateFormat.format(lastEvictionWarning));
            }
            evictionsSinceWarning = 0;
            lastEvictionWarning = new Date();
        }
    }
131062
@Override
    public void report() {
        // collect sinks and report each once
        Set<InjectionSink> injectionSinksToReport = new HashSet<InjectionSink>();
        for (Set<InjectionSink> injectionSinkSet : injectionSinks.values()) {
            for (InjectionSink injectionSink : injectionSinkSet) {
                injectionSinksToReport.add(injectionSink);
            }
        }
        for (InjectionSink injectionSink : injectionSinksToReport) {
            bugReporter.reportBug(injectionSink.generateBugInstance(false));
        }
    }
119134
def warnings(self):
        
        response = self._get(url.status_warnings)
        self._check_response(response, 200)
        return self._create_response(response)