Checks if the LogLevel is higher than the set LogLevel and all registered Filters pass and then publishes the LogEntry

@param entry the logEntry to log
773985
public void log(final LogEntry entry)
    {
        if (entry.getLevel().compareTo(this.level) < 0)
        {
            return;
        }
        if (!this.filters.isEmpty())
        {
            for (LogFilter filter : this.filters)
            {
                if (!filter.accept(entry))
                {
                    return;
                }
            }
        }
        this.publish(entry);
    }
907485
@Override
	public void log(Level level, String msg, Object param1) {
		
		super.log(level, maskPassword(msg), param1);
	}
140141
private void highlightEntryParser(HighlightSearchEntry entry) {
		String text;
		int lastPos = 0;
		
		text = this.getText();
		
		Highlighter hilite = this.getHighlighter();
		HighlightPainter painter = new DefaultHighlighter.DefaultHighlightPainter(entry.getColor());
		
		while ( (lastPos = text.indexOf(entry.getToken(), lastPos)) > -1) {
			try {
				hilite.addHighlight(lastPos, lastPos + entry.getToken().length(), painter);
				lastPos += entry.getToken().length();
			} catch (BadLocationException e) {
				log.warn("Could not highlight entry", e);
			}
		}
	}
447869
public void log(ConsumerJournalEntry journalEntry) {
        StringBuffer buffer = new StringBuffer();
        buffer.append("Event: method='").append(journalEntry.getMethodName())
                .append("', ").append(journalEntry.getIdentifier())
                .append("\n");
        if (logLevel == LEVEL_HIGH) {
            JournalEntryContext context = journalEntry.getContext();
            buffer.append("    context=").append(context.getClass().getName())
                    .append("\n");
            buffer.append(writeMapValues("environmentAttributes", context
                    .getEnvironmentAttributes()));
            buffer.append(writeMapValues("subjectAttributes", context
                    .getSubjectAttributes()));
            buffer.append(writeMapValues("actionAttributes", context
                    .getActionAttributes()));
            buffer.append(writeMapValues("resourceAttributes", context
                    .getResourceAttributes()));
            buffer.append(writeMapValues("recoveryAttributes", context
                    .getRecoveryAttributes()));
            buffer.append("        password='*********'\n");
            buffer.append("        noOp=").append(context.getNoOp())
                    .append("\n");
        }
        if (logLevel == LEVEL_HIGH || logLevel == LEVEL_MEDIUM) {
            buffer.append("        now=" + journalEntry.getContext().getNoOp()
                    + "\n");
            buffer.append("    arguments\n");
            Map<String, Object> argumentsMap = journalEntry.getArgumentsMap();
            for (Iterator<String> names = argumentsMap.keySet().iterator(); names
                    .hasNext();) {
                String name = names.next();
                Object value = argumentsMap.get(name);
                if (value instanceof String[]) {
                    buffer.append(writeStringArray(name, (String[]) value));
                } else {
                    buffer.append("        " + name + "='" + value + "'\n");
                }
            }
        }
        log(buffer.toString());
    }
994739
public void doesNotContainEntry(@NullableDecl Object key, @NullableDecl Object value) {
    checkNoNeedToDisplayBothValues("entrySet()")
        .that(actual().entrySet())
        .doesNotContain(immutableEntry(key, value));
  }
812079
@Override
    public boolean accept( final AuditLogEntry entry ) {
        if ( !acceptedTypes.containsKey( entry.getGenericType() ) ) {
            return false;
        }
        return acceptedTypes.get( entry.getGenericType() );
    }
1095403
def _log(code, message, level, domain):
        """"""
        entry = LogEntry(level, domain, code, message)
        Logger.journal.append(entry)

        if Logger.silent:
            return

        if level >= Logger._verbosity:
            _print_entry(entry)
597438
public boolean add(E entry)
	{
		super.add(entry);
		
		if(this.size() > this.maxSize)
		{
			super.removeRange(0, this.size() - maxSize);
		}
		
		return true;
	}
825498
@Override
    void addEntry(int hash, K key, V value, int bucketIndex) {
	super.addEntry(hash, key, value, bucketIndex);

	// Remove eldest entry if instructed
	Entry<K, V> eldest = header.after;
	if (removeEldestEntry(eldest)) {
	    removeEntryForKey(eldest.key);
	}
    }
471951
@Override
	public void log(Level level, String msg) {
		
		super.log(level, maskPassword(msg));
	}
1072049
protected void writePropertiesToLog(Logger logger, Level level) {
    writeToLog(logger, level, getMapAsString(this.properties, separator), null);

    if (this.exception != null) {
      writeToLog(this.logger, Level.ERROR, "Error:", this.exception);
    }
  }
1354321
def _store_entry(self, entry):
        
        # Get the logger and log the message
        self.__logs.append(entry)

        # Notify listeners
        for listener in self.__listeners.copy():
            try:
                listener.logged(entry)
            except Exception as ex:
                # Create a new log entry, without using logging nor notifying
                # listener (to avoid a recursion)
                err_entry = LogEntry(
                    logging.WARNING,
                    "Error notifying logging listener {0}: {1}".format(
                        listener, ex
                    ),
                    sys.exc_info(),
                    self._context.get_bundle(),
                    None,
                )

                # Insert the new entry before the real one
                self.__logs.pop()
                self.__logs.append(err_entry)
                self.__logs.append(entry)
199628
@Override
    public void add(QueryableEntry entry) {
        if (++resultSize > resultLimit) {
            throw new QueryResultSizeExceededException();
        }

        rows.add(orderAndLimitExpected ? entry : convertEntryToRow(entry));
    }
77588
public ValidationResult check(Entry entry)
	{
		result = new ValidationResult();

		if (entry.isDelete())
		{
			reportMessage(Severity.FIX, entry.getOrigin(), FIX_ID, entry.getPrimaryAccession());
		}
		return result;
	}
1062448
public boolean add( AuditLogEntry e ) {
        if ( filter == null ) {
            throw new IllegalStateException( "AuditLogFilter has not been set. Please set before inserting entries." );
        }
        if ( filter.accept( e ) ) {
            entries.addFirst( e );
            return true;
        }
        return false;
    }
248309
public boolean adjustEntry(E entry) {
    final SpatialDirectoryEntry se = (SpatialDirectoryEntry) entry;
    final ModifiableHyperBoundingBox mbr = computeMBR();
    boolean changed = false;
    if(se.hasMBR()) {
      final int dim = se.getDimensionality();
      // Test for changes
      for(int i = 0; i < dim; i++) {
        if(Math.abs(se.getMin(i) - mbr.getMin(i)) > Float.MIN_NORMAL) {
          changed = true;
          break;
        }
        if(Math.abs(se.getMax(i) - mbr.getMax(i)) > Float.MIN_NORMAL) {
          changed = true;
          break;
        }
      }
    }
    else { // No preexisting MBR.
      changed = true;
    }
    if(changed) {
      se.setMBR(mbr);
    }
    return changed;
  }
305811
function pushLogEntry(logEntry) {
    var logger = window[appSettings.loggerVar];
    if (logger) {
        logger.logs.push(logEntry);

        if (window.console) {
            if (typeof console.error === "function" && typeof console.warn === "function") {
                switch (logEntry.type) {
                    case enumerations.logType.wtf:
                        console.error(toFriendlyString(logEntry));
                        break;
                    case enumerations.logType.error:
                        if (appSettings.logLevel <= enumerations.logLevel.error && appSettings.logLevel > enumerations.logLevel.off) {
                            console.error(toFriendlyString(logEntry));
                        }
                        break;
                    case enumerations.logType.warning:
                        if (appSettings.logLevel <= enumerations.logLevel.warn && appSettings.logLevel > enumerations.logLevel.off) {
                            console.warn(toFriendlyString(logEntry));
                        }
                        break;
                    default:
                        if (appSettings.logLevel <= enumerations.logLevel.debug && appSettings.logLevel > enumerations.logLevel.off) {
                            console.log(toFriendlyString(logEntry));
                            break;
                        }
                }

            } else {
                console.log(toFriendlyString(logEntry));
            }
        }
    }
}