Returns <code>true</code> if the given log entry type matches this filter.<p>

@param type the log entry type to test

@return <code>true</code> if the given log entry type matches this filter
8183
public boolean matchType(CmsLogEntryType type) {

        if (m_excludeTypes.contains(type)) {
            return false;
        }
        if (m_includeTypes.isEmpty()) {
            return true;
        }
        return m_includeTypes.contains(type);
    }
1204081
public boolean isFilterMatch(BaseMessageHeader messageHeader)
    {
        boolean bMatch = super.isFilterMatch(messageHeader);
        if (bMatch)
        {
            if (!(messageHeader instanceof RecordMessageHeader))
                return false;   // Never
            if (m_iDatabaseType != -1)
                if (m_iDatabaseType != ((RecordMessageHeader)messageHeader).getDatabaseType())
                    return false;   // No match
        }
        return bMatch;  // Match
    }
115431
public static boolean isCollectionType(final Type type) {
        return isParameterizedType(type) && isCollectionType((Class<?>) ((ParameterizedType) type).getRawType());
    }
452378
public static boolean typesMatch(ParaObject so) {
		return (so == null) ? false : so.getClass().equals(toClass(so.getType()));
	}
226097
private boolean match(final ByteBuffer buf) throws IOException {
		boolean matches = true;
		switch (getType()) {
		case MagicMimeEntry.STRING_TYPE: {
			matches = matchString(buf);
			break;
		}

		case MagicMimeEntry.SHORT_TYPE: {
			matches = matchShort(buf, ByteOrder.BIG_ENDIAN, false, (short) 0xFF);
			break;
		}

		case MagicMimeEntry.LESHORT_TYPE:
		case MagicMimeEntry.BESHORT_TYPE: {
			ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
			if (getType() == MagicMimeEntry.LESHORT_TYPE) {
				byteOrder = ByteOrder.LITTLE_ENDIAN;
			}
			boolean needMask = false;
			short sMask = 0xFF;
			final int indx = this.typeStr.indexOf('&');
			if (indx >= 0) {
				sMask = (short) Integer.parseInt(this.typeStr.substring(indx + 3), 16);
				needMask = true;
			} else if (getContent().startsWith("&")) {
				sMask = (short) Integer.parseInt(getContent().substring(3), 16);
				needMask = true;
			}
			matches = matchShort(buf, byteOrder, needMask, sMask);
			break;
		}

		case MagicMimeEntry.LELONG_TYPE:
		case MagicMimeEntry.BELONG_TYPE: {
			ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
			if (getType() == MagicMimeEntry.LELONG_TYPE) {
				byteOrder = ByteOrder.LITTLE_ENDIAN;
			}
			boolean needMask = false;
			long lMask = 0xFFFFFFFF;
			final int indx = this.typeStr.indexOf('&');
			if (indx >= 0) {
				lMask = Long.parseLong(this.typeStr.substring(indx + 3), 16);
				needMask = true;
			} else if (getContent().startsWith("&")) {
				lMask = Long.parseLong(getContent().substring(3), 16);
				needMask = true;
			}
			matches = matchLong(buf, byteOrder, needMask, lMask);
			break;
		}

		case MagicMimeEntry.BYTE_TYPE: {
			matches = matchByte(buf);
		}

		default: {
			matches = false;
			break;
		}
		}
		return matches;
	}
999535
public boolean isSameFilter(BaseMessageFilter filter)
    {
        if (filter.getClass().equals(this.getClass()))
        {
            if (filter.isFilterMatch(this))
                ;   // return true;? todo (don) You need to figure out how to compare filters
        }
        return false;
    }
482003
public static boolean isPropertyType(final Type type) {
        if (type instanceof GenericArrayType) {
            return isPropertyType(((GenericArrayType) type).getGenericComponentType());
        }
        if (type instanceof ParameterizedType) {
            return isPropertyType(((ParameterizedType) type).getRawType());
        }
        return type instanceof Class && isPropertyType((Class) type);
    }
665188
public static <T extends Tree> Matcher<T> isVoidType() {
    return new Matcher<T>() {
      @Override
      public boolean matches(T t, VisitorState state) {
        Type type = getType(t);
        return type != null && state.getTypes().isSameType(type, state.getSymtab().voidType);
      }
    };
  }
634668
public static boolean containsLogFromNumber(List<CallLogEntry> logs, String number) {
        for(CallLogEntry log : logs) {
            if(log.number.equals(number)) {
                return true;
            }
        }
        return false;
	}
10505
public static <T extends MethodDescription> ElementMatcher.Junction<T> isSetter(TypeDescription type) {
        return isSetter(is(type));
    }
1093859
public boolean containsLogEntry(long entryIndex) {
        long sequence = toSequence(entryIndex);
        return sequence >= logs.headSequence() && sequence <= logs.tailSequence();
    }
110170
public static boolean isSingle(Class<?> type) {
        for (Class<?> reactiveType : SINGLE_TYPES) {
            if (reactiveType.isAssignableFrom(type)) {
                return true;
            }
        }
        return false;
    }
1118374
public static boolean isJavaBasicType(@Nullable Class<?> type) {
        if (type == null) {
            return false;
        }
        final String name = type.getName();
        return isJavaBasicType(name);
    }
1299439
public static Predicate<Entity> isMarkedAsType(final Class<? extends Entity> type) {
	return i -> i.isMarkedAsType(type);
    }
1195222
boolean isMatch(Class<?> beanType, Object id) {

    return beanType.equals(this.beanType) && idMatch(id);
  }
1019630
public static boolean isSingleValueType(Class<?> type) {

        LettuceAssert.notNull(type, "Class must not be null!");

        return findDescriptor(type).map((descriptor) -> !descriptor.isMultiValue() && !descriptor.isNoValue()).orElse(false);
    }
1286811
public static boolean nameFilter(String type) {

        if ("date".equals(type) || "object".equals(type)) {
            return false;
        }
        return NAME_FILTER.contains(type);
    }