Liefert true zurueck, wenn der uebergebene Wert innerhalb der erlaubten
Laenge liegt.

@param wert Fachwert oder gekapselter Wert
@return true oder false
330757
@Override
    public boolean isValid(T wert) {
        int length = Objects.toString(wert, "").length();
        return (length >= min) && (length <= max);
    }
332507
@Override
	public boolean hasNextCase() {
		// this method only returns true if dependent values are grouped
		if (!dependent) {
			return false;
		}
		for (Constraint c : constraints) {
			if (c.hasNextCase()) {
				return true;
			}
		}
		return false;
	}
952271
private boolean filter(Class<?> clazz, List<ClassFilter> filters) {
        boolean flag = true;
        for (ClassFilter filter : filters) {
            if (filter.filter(clazz)) {
                flag = false;
                break;
            }
        }
        return flag;
    }
649328
public boolean isCurrent(EGLSurface eglSurface) {
        return mEGLContext.equals(EGL14.eglGetCurrentContext()) &&
                eglSurface.equals(EGL14.eglGetCurrentSurface(EGL14.EGL_DRAW));
    }
1045495
public synchronized boolean getBoolean()
   {
      final byte value = get();
      if(value == CommsConstants.TRUE_BYTE) return true;
      else if(value == CommsConstants.FALSE_BYTE) return false;
      else throw new IllegalStateException("Unexpected byte: " + value);     
   }
89809
private boolean isWellFormed()
    {
        for (int i = 0 ; i < maxHeight ; i++)
        {
            int c = 0;
            for (Node node = head ; node != null ; node = node.next(i))
            {
                if (node.prev(i) != null && node.prev(i).next(i) != node)
                    return false;
                if (node.next(i) != null && node.next(i).prev(i) != node)
                    return false;
                c += node.size[i];
                if (i + 1 < maxHeight && node.parent(i + 1).next(i + 1) == node.next(i))
                {
                    if (node.parent(i + 1).size[i + 1] != c)
                        return false;
                    c = 0;
                }
            }
            if (i == maxHeight - 1 && c != size + 1)
                return false;
        }
        return true;
    }
1108624
public static boolean isAssignable(Class<?> targetType, Class<?> sourceType) {
		if (null == targetType || null == sourceType) {
			return false;
		}

		// 对象类型
		if (targetType.isAssignableFrom(sourceType)) {
			return true;
		}

		// 基本类型
		if (targetType.isPrimitive()) {
			// 原始类型
			Class<?> resolvedPrimitive = BasicType.wrapperPrimitiveMap.get(sourceType);
			if (resolvedPrimitive != null && targetType.equals(resolvedPrimitive)) {
				return true;
			}
		} else {
			// 包装类型
			Class<?> resolvedWrapper = BasicType.primitiveWrapperMap.get(sourceType);
			if (resolvedWrapper != null && targetType.isAssignableFrom(resolvedWrapper)) {
				return true;
			}
		}
		return false;
	}
793936
public boolean isSameAs(UnconditionalValueDerefSet otherFact) {
        return valueNumbersUnconditionallyDereferenced.equals(otherFact.valueNumbersUnconditionallyDereferenced)
                && derefLocationSetMap.equals(otherFact.derefLocationSetMap);
    }
351788
public String berechnePruefziffer(String wert) {
        int sum = getQuersumme(wert);
        return Integer.toString((10 - sum % 10) % 10);
    }
333302
public synchronized boolean isParseCorrect()
	{
		boolean isParseCorrect = true;
		for (IVdmSourceUnit source : vdmSourceUnits)
		{
			if (source.hasParseErrors())
			{
				isParseCorrect = false;
				break;
			}
		}
		return isParseCorrect;
	}
129205
public static boolean isEmptyAll(String... args) {
        for (String arg : args) {
            if (!isEmpty(arg)) {
                return false;
            }
        }
        return true;
    }
1100716
public boolean isFatal() {
        if (this.fatal) // dann brauchen wir den Cause nicht mehr checken
            return true;

        Throwable t = this.getCause();
        if (t == this)
            return false; // sind wir selbst
        if (t instanceof HBCI_Exception)
            return ((HBCI_Exception) t).isFatal();

        return false;
    }
794913
public boolean getBoolean(String attribute) {
        String s = get(attribute);
        if ("true".equals(s) || "1".equals(s)) {
            return true;
        } else
        if ("false".equals(s) || "0".equals(s)) {
            return false;
        }
        throw new IllegalArgumentException("Attribute " + attribute + " is non-boolean");
    }
444251
public boolean matches(Class<?>[] args) {
        int i;
        Class<?>[] paras;

        paras = getParameterTypes();
        if (args.length != paras.length) {
            return false;
        }
        for (i = 0; i < args.length; i++) {
            if (!paras[i].isAssignableFrom(args[i])) {
                return false;
            }
        }
        return true;
    }
283624
public boolean canPing() {
        try {
            val connection = (HttpURLConnection) new URL(this.swivelUrl).openConnection();
            connection.setRequestMethod(HttpMethod.GET.name());
            connection.connect();
            return connection.getResponseCode() == HttpStatus.SC_OK;
        } catch (final Exception e) {
            LOGGER.warn(e.getMessage(), e);
        }
        return false;
    }
77774
public Fachwert getFachwert(Class<? extends Fachwert> clazz, Object... args) {
        Class[] argTypes = toTypes(args);
        try {
            Constructor<? extends Fachwert> ctor = clazz.getConstructor(argTypes);
            return ctor.newInstance(args);
        } catch (ReflectiveOperationException ex) {
            Throwable cause = ex.getCause();
            if (cause instanceof ValidationException) {
                throw (ValidationException) cause;
            } else if (cause instanceof IllegalArgumentException) {
                throw new LocalizedValidationException(cause.getMessage(), cause);
            } else {
                throw new IllegalArgumentException("cannot create " + clazz + " with " + Arrays.toString(args), ex);
            }
        }
    }
559462
private final Boolean getBoolean(NamedList<Object> response, String... args) {
    Object objectItem = response.findRecursive(args);
    Boolean result = null;
    if (objectItem != null && objectItem instanceof Boolean) {
      result = (Boolean) objectItem;
    }
    return result;
  }