<p>
Returns whether any selectors are currently matching at the specified selection level.
</p>

@param level the selection level.
@return true if any selectors are matching at the specified level, false if not.
340942
public boolean isMatchingAny(final int level) {
        if (level >= this.levelCounter) {
            throw new IllegalArgumentException(
                    "Cannot return current selection: max level is " + this.levelCounter + " (specified: " + level + ")");
        }
        if (this.levels == null) {
            return false;
        }
        return this.levels[level].isSelectionActive();
    }
713874
boolean containsMessages(final Level level) {
        if (level == null) {
            throw new NullPointerException("Level can't be null");
        }

        return !this.messages.get(level).isEmpty();
    }
1173883
protected void processPlainSelect(PlainSelect plainSelect, int level) {
        if (level > 1) {
            if (isNotEmptyList(plainSelect.getOrderByElements())) {
                if (plainSelect.getTop() == null) {
                    plainSelect.setTop(TOP100_PERCENT);
                }
            }
        }
        if (plainSelect.getFromItem() != null) {
            processFromItem(plainSelect.getFromItem(), level + 1);
        }
        if (plainSelect.getJoins() != null && plainSelect.getJoins().size() > 0) {
            List<Join> joins = plainSelect.getJoins();
            for (Join join : joins) {
                if (join.getRightItem() != null) {
                    processFromItem(join.getRightItem(), level + 1);
                }
            }
        }
    }
230667
public boolean isLoggable(final Level level) {
        switch (level) {
            case TRACE:
                return isTraceEnabled();
            case DEBUG:
                return isDebugEnabled();
            case INFO:
                return isInfoEnabled();
            case WARN:
                return isWarnEnabled();
            case ERROR:
                return isErrorEnabled();
            default:
                throw new IllegalStateException("Logging level [" + level + "] is invalid");
        }
    }
881633
static boolean hasArrayIndex(Map<String,String> meta, int level) {
        return meta.containsKey(level + ARRAY_IDX_SUFFIX);
    }
761565
public static boolean hasMaxRows(RowSelection selection) {
		return selection != null && selection.getMaxRows() != null && selection.getMaxRows() > 0;
	}
662125
public static boolean isStaticSelector(JCTree base, Names names) {
        if (base == null)
            return false;
        switch (base.getTag()) {
            case IDENT:
                JCIdent id = (JCIdent)base;
                return id.name != names._this &&
                        id.name != names._super &&
                        isStaticSym(base);
            case SELECT:
                return isStaticSym(base) &&
                    isStaticSelector(((JCFieldAccess)base).selected, names);
            case TYPEAPPLY:
            case TYPEARRAY:
                return true;
            case ANNOTATED_TYPE:
                return isStaticSelector(((JCAnnotatedType)base).underlyingType, names);
            default:
                return false;
        }
    }
275912
protected static boolean isCoveredByMinimumLevel(final org.tinylog.Level level) {
		return provider.getMinimumLevel(null).ordinal() <= level.ordinal();
	}
1025584
public boolean setProtectionLevel(int level) {
    	boolean result = false;
    	switch(level) {
    	case RtfProtection.LEVEL_NONE:
    		if(this.protectionHash == null) {
    			break;
    		}
    	case RtfProtection.LEVEL_ANNOTPROT:
    	case RtfProtection.LEVEL_FORMPROT:
    	case RtfProtection.LEVEL_REVPROT:
    	case RtfProtection.LEVEL_READPROT:
        	this.protectionLevel = level;
        	result = true;
        	break;
   		default:
    	}
    	return result;
    }
20432
public boolean containLogsFrom(LogLevel level)
    {
        for (LogEvent log : this) {
            if (log.getLevel().compareTo(level) <= 0) {
                return true;
            }
        }

        return false;
    }
1293362
public boolean contains(Matcher matcher) {
        return element.matcher == matcher || (parent != null && parent.contains(matcher));
    }
706833
public T getSingleValue() {
        List<T> values = getSelectedValue();
        if (!values.isEmpty()) {
            return values.get(0);
        }
        return null;
    }
1265612
private static boolean isCoveredByMinimumLevel(final String tag, final Level level) {
		return provider.getMinimumLevel(tag).ordinal() <= level.ordinal();
	}
866098
private void checkMarkupLevel(final int markupLevel) {
        if (markupLevel >= this.matchedMarkupLevels.length) {
            final int newLen = Math.max(markupLevel + 1, this.matchedMarkupLevels.length + MATCHED_MARKUP_LEVELS_LEN);
            final boolean[] newMatchedMarkupLevels = new boolean[newLen];
            Arrays.fill(newMatchedMarkupLevels, false);
            System.arraycopy(this.matchedMarkupLevels, 0, newMatchedMarkupLevels, 0, this.matchedMarkupLevels.length);
            this.matchedMarkupLevels = newMatchedMarkupLevels;
        }
    }
701762
@Override
    public MatchType match(int level, Node node) {
        if(! (node instanceof Element)) {
            return MatchType.NOT_A_MATCH;
        }
        Element element = (Element) node;
        if(this.level != level) {
            return MatchType.NOT_A_MATCH;
        } else if(nodename.equals(element.getName())) {
            return MatchType.NODE_MATCH;
        }
        return MatchType.NOT_A_MATCH;
    }
1250119
@Override
  public boolean contains(IVersion version)
  {
    return range1.contains(version) && range2.contains(version);
  }
452684
@Nullable
    public static Level findLevel(@Nullable String name) {
        if(name == null || name.isEmpty())
            return null;
        return Level.parse(name);

    }