Returns true if both expressions are in the specified schema.

@see Expression#isApplicableTo(Schema)
7991
@Override
	public boolean isApplicableTo(Schema sch) {
		return lhs.isApplicableTo(sch) && rhs.isApplicableTo(sch);
	}
293189
private boolean validInstanceOfExpression(Node expr) {
    // The expression must have two children:
    // - The instanceOf keyword
    // - A string
    if (!checkParameterCount(expr, Keywords.INSTANCEOF)) {
      return false;
    }
    if (!validTypeTransformationExpression(getCallArgument(expr, 0))) {
      warnInvalidInside(Keywords.INSTANCEOF.name, expr);
      return false;
    }
    return true;
  }
910892
@Override
    public boolean isOptional()
    {
        boolean isNullable = true;
        if (!isId())
        {
            Column anno = member.getAnnotation(Column.class);
            if (anno != null)
            {
                isNullable = anno.nullable();
            }
        }
        else
        {
            isNullable = false;
        }
        return isNullable;
    }
195517
static void checkTypes(ImmutableList<Type> types, Iterable<? extends Expression> exprs) {
    int size = Iterables.size(exprs);
    checkArgument(
        size == types.size(),
        "Supplied the wrong number of parameters. Expected %s, got %s",
        types.size(),
        size);
    // checkIsAssignableTo is an no-op if DEBUG is false
    if (Flags.DEBUG) {
      int i = 0;
      for (Expression expr : exprs) {
        expr.checkAssignableTo(types.get(i), "Parameter %s", i);
        i++;
      }
    }
  }
1128727
public static void checkSchema(Schema schema) {
    Preconditions.checkNotNull(schema, "Schema cannot be null");
    List<String> incompatible = getIncompatibleNames(schema);
    ValidationException.check(incompatible.isEmpty(),
        "Field names are not alphanumeric (plus '_'): %s",
        Joiner.on(", ").join(incompatible));
  }
935298
public static boolean isInternalId(String schema) {

        String translatedId = translateLegacySystemId(schema);
        if (translatedId.startsWith(INTERNAL_SCHEME)) {
            return true;
        }
        return false;
    }
352642
public static boolean isClosureDeclaration(ASTNode expression) {
        if (expression instanceof DeclarationExpression) {
            if (((DeclarationExpression) expression).getRightExpression() instanceof ClosureExpression) {
                return true;
            }
        }
        if (expression instanceof FieldNode) {
            ClassNode type = ((FieldNode) expression).getType();
            if (AstUtil.classNodeImplementsType(type, Closure.class)) {
                return true;
            } else if (((FieldNode) expression).getInitialValueExpression() instanceof ClosureExpression) {
                return true;
            }
        }
        return false;
    }
192324
public static boolean isAssignable(TypeName typeName, Class<?> assignableClazz) {
		try {
			if (typeName instanceof ParameterizedTypeName) {
				typeName = ((ParameterizedTypeName) typeName).rawType;
			} else if (typeName instanceof ArrayTypeName) {
				typeName = ((ArrayTypeName) typeName).componentType;
			}

			Class<?> resolvedType = Class.forName(typeName.toString());
			return assignableClazz.isAssignableFrom(resolvedType);
		} catch (ClassNotFoundException e) {
			return false;
		}
	}
476431
public boolean matchJsonToSchema(JSONObject schema, JSONObject json) throws Exception {
        SchemaLoader.builder()
                 .useDefaults(true)
                 .schemaJson(schema)
                 .build()
                 .load()
                 .build()
                 .validate(json);
        return true;
    }
1295259
private static boolean isCoercibleFrom(EvaluationContext ctx, Object src, Class<?> target) {
        // TODO: This isn't pretty but it works. Significant refactoring would
        //       be required to avoid the exception.
        try {
            ELSupport.coerceToType(ctx, src, target);
        } catch (ELException e) {
            return false;
        }
        return true;
    }
578975
static boolean isExpression(String expression) {

        if (null == expression) {
            return false;
        }

        //check to see if attribute has an expression
        int start = expression.indexOf("#{");
        return start != -1 && expression.indexOf('}', start+2) != -1;
    }
596376
private boolean validTemplateTypeOfExpression(Node expr) {
    // The expression must have three children. The templateTypeOf keyword, a
    // templatized type and an index
    if (!checkParameterCount(expr, Keywords.TEMPLATETYPEOF)) {
      return false;
    }
    // The parameter must be a valid type expression
    if (!validTypeTransformationExpression(getCallArgument(expr, 0))) {
      warnInvalidInside(Keywords.TEMPLATETYPEOF.name, expr);
      return false;
    }
    if (!getCallArgument(expr, 1).isNumber()) {
      warnInvalid("index", expr);
      warnInvalidInside(Keywords.TEMPLATETYPEOF.name, expr);
      return false;
    }
    double index = getCallArgument(expr, 1).getDouble();
    if (index < 0 || index % 1 != 0) {
      warnInvalid("index", expr);
      warnInvalidInside(Keywords.TEMPLATETYPEOF.name, expr);
      return false;
    }
    return true;
  }
304421
private boolean querySupported(Query<Entity> q) {
    return !containsAnyOperator(q, unsupportedOperators)
        && !containsComputedAttribute(q, getEntityType())
        && !containsNestedQueryRuleField(q);
  }
928243
public boolean isWritable(Class<?> type) {
        return Finder.class.isAssignableFrom(type)
                || Query.class.isAssignableFrom(type)
                || ExpressionList.class.isAssignableFrom(type)
                || FutureList.class.isAssignableFrom(type);
    }
431852
private boolean validRecordParam(Node expr) {
    if (expr.isObjectLit()) {
      // Each value of a property must be a valid expression
      for (Node prop : expr.children()) {
        if (prop.isShorthandProperty()) {
          warnInvalid("property, missing type", prop);
          return false;
        } else if (!validTypeTransformationExpression(prop.getFirstChild())) {
          return false;
        }
      }
    } else if (!validTypeTransformationExpression(expr)) {
      return false;
    }
    return true;
  }
286896
public boolean isTableMin() {
        // do not support GROUP BY for now
        if (m_groupByExpressions.isEmpty() == false) {
            return false;
        }
        if (m_aggregateTypes.size() != 1) {
            return false;
        }
        if (m_aggregateTypes.get(0).equals(ExpressionType.AGGREGATE_MIN) == false) {
            return false;
        }

        return true;
    }
1099487
boolean isOptional(Field field) {
        if(field.schema().getType() == Type.UNION) {
            for(Schema nestedType: field.schema().getTypes()) {
                if(nestedType.getType() == Type.NULL) {
                    return true;
                }
            }
        }
        return false;
    }