<code>repeated .jscomp.Requirement requirement = 1;</code>
320548
public com.google.javascript.jscomp.RequirementOrBuilder getRequirementOrBuilder(
      int index) {
    return requirement_.get(index);
  }
962662
public void required(String tagName, String actionName, String attributeName, Object attribute) throws ApplicationException {
	if (attribute == null)
	    throw new ApplicationException("Attribute [" + attributeName + "] for tag [" + tagName + "] is required if attribute action has the value [" + actionName + "]");

    }
326699
public ResultSetStreamer require(String column, Assertion assertion) {
        if (_requires == Collections.EMPTY_MAP) _requires = new HashMap<String, Assertion>();
        _requires.put(column, assertion);
        return this;
    }
1259698
private void processPostStartRequirements(ConditionContext context, AnnotationValue<Requires> requirements) {
        processPreStartRequirements(context, requirements);

        if (context.isFailing()) {
            return;
        }

        if (!matchesPresenceOfBeans(context, requirements)) {
            return;
        }

        if (!matchesAbsenceOfBeans(context, requirements)) {
            return;
        }

        matchesCustomConditions(context, requirements);
    }
932222
public com.google.javascript.jscomp.Requirement.TypeMatchingStrategy getTypeMatchingStrategy() {
    com.google.javascript.jscomp.Requirement.TypeMatchingStrategy result = com.google.javascript.jscomp.Requirement.TypeMatchingStrategy.valueOf(typeMatchingStrategy_);
    return result == null ? com.google.javascript.jscomp.Requirement.TypeMatchingStrategy.LOOSE : result;
  }
855637
private void required(String attributeName, String attributValue) throws ApplicationException {
	if (StringUtil.isEmpty(attributValue))
	    throw new ApplicationException("invalid attribute constellation for the tag zip", "attribute [" + attributeName + "] is required, if action is [" + action + "]");
    }
68976
private void require(int len)
  {
    int offset = _offset;
    int length = _length;
    
    if (offset + len < length) {
      return;
    }
    
    flush(_offset);
  }
501311
public int getRequiredInt(String key) {
        Optional<Integer> value = getInteger(key);
        if (value.isPresent()) {
            return value.get();
        }
        throw new IllegalStateException(String.format("required key [%s] not found", key));
    }
100741
public static Requirement newInstance(String name)
    {
        Requirement requirement = new Requirement();
        requirement.setName(name);
        return requirement;
    }
403641
boolean requires(final String value) {
        if (requires(myPrefix, value) || requires(myPostfix, value)) {
            return true;
        }

        if (mySuffixes == null) {
            return false;
        }
        for (final Literal suffix : mySuffixes) {
            if (requires(suffix, value)) {
                return true;
            }
        }
        return false;
    }
575723
public function loadRequirements()
    {
        foreach ($this->getStylesheets() as $css) {
            Requirements::css($this->getRelativePath().'/'.basename($css));
        }
        foreach ($this->getJavascripts() as $js) {
            Requirements::javascript($this->getRelativePath().'/'.basename($js));
        }    	
    }
629105
private String getPrefixItem(String requirement, String minVersion, String maxVersion) {
        
        switch (requirement) {
        case Languages.JAVA: return "java";
        case Languages.PYTHON: return "python";
        case Languages.RUBY: return "ruby";
        case Languages.NET: return "dotnet";
        case Languages.PHP: return "php";
        
        case Containers.JBOSS6: return "jboss";
        case Containers.JBOSS7: return "jboss";
        case Containers.JETTY6: return "jetty";
        case Containers.TOMCAT: return "tomcat";
        case Containers.TOMCAT8: return "tomcat";

        case Categories.MYSQL: return "mysql";
        case Categories.MARIADB: return "maria";
        case Categories.POSTGRESQL: return "postgresql";
        case Categories.MONGODB: return "mongoDB";
        case Categories.REDIS: return "redis";

        default:
            return "";
        }
    }
406519
public static Requirement buildIvy(String requirement) {
        try {
            return buildLoose(requirement);
        } catch (SemverException ignored) {
        }

        Matcher matcher = IVY_DYNAMIC_PATCH_PATTERN.matcher(requirement);
        if (matcher.find()) {
            int major = Integer.valueOf(matcher.group(1));
            int minor = Integer.valueOf(matcher.group(2));
            Requirement lower = new Requirement(new Range(major + "." + minor + ".0", Range.RangeOperator.GTE), null, null, null);
            Requirement upper = new Requirement(new Range(major + "." + (minor + 1) + ".0", Range.RangeOperator.LT), null, null, null);
            return new Requirement(null, lower, RequirementOperator.AND, upper);
        }
        matcher = IVY_DYNAMIC_MINOR_PATTERN.matcher(requirement);
        if (matcher.find()) {
            int major = Integer.valueOf(matcher.group(1));
            Requirement lower = new Requirement(new Range(major + ".0.0", Range.RangeOperator.GTE), null, null, null);
            Requirement upper = new Requirement(new Range((major + 1) + ".0.0", Range.RangeOperator.LT), null, null, null);
            return new Requirement(null, lower, RequirementOperator.AND, upper);
        }
        matcher = IVY_LATEST_PATTERN.matcher(requirement);
        if (matcher.find()) {
            return new Requirement(new Range("0.0.0", Range.RangeOperator.GTE), null, null, null);
        }
        matcher = IVY_MATH_BOUNDED_PATTERN.matcher(requirement);
        if (matcher.find()) {
            Range.RangeOperator lowerOp = "[".equals(matcher.group(1)) ? Range.RangeOperator.GTE : Range.RangeOperator.GT;
            Semver lowerVersion = new Semver(matcher.group(2), Semver.SemverType.LOOSE);
            Semver upperVersion = new Semver(matcher.group(3), Semver.SemverType.LOOSE);
            Range.RangeOperator upperOp = "]".equals(matcher.group(4)) ? Range.RangeOperator.LTE : Range.RangeOperator.LT;
            Requirement lower = new Requirement(new Range(extrapolateVersion(lowerVersion), lowerOp), null, null, null);
            Requirement upper = new Requirement(new Range(extrapolateVersion(upperVersion), upperOp), null, null, null);
            return new Requirement(null, lower, RequirementOperator.AND, upper);
        }
        matcher = IVY_MATH_LOWER_UNBOUNDED_PATTERN.matcher(requirement);
        if (matcher.find()) {
            Semver version = new Semver(matcher.group(1), Semver.SemverType.LOOSE);
            Range.RangeOperator op = "]".equals(matcher.group(2)) ? Range.RangeOperator.LTE : Range.RangeOperator.LT;
            return new Requirement(new Range(extrapolateVersion(version), op), null, null, null);
        }
        matcher = IVY_MATH_UPPER_UNBOUNDED_PATTERN.matcher(requirement);
        if (matcher.find()) {
            Range.RangeOperator op = "[".equals(matcher.group(1)) ? Range.RangeOperator.GTE : Range.RangeOperator.GT;
            Semver version = new Semver(matcher.group(2), Semver.SemverType.LOOSE);
            return new Requirement(new Range(extrapolateVersion(version), op), null, null, null);
        }

        throw new SemverException("Invalid requirement");
    }
1014599
private void require(char delim) throws SAXException, IOException {
        char c = readCh();

        if (c != delim) {
            fatal("required character", c, Character.valueOf(delim).toString());
        }
    }
869975
def requires_one(*args)
      missing, required = missing_attributes(args)

      if missing.length == args.length
        fail(ArgumentError, "#{missing.keys[0...-1].join(', ')} or #{missing.keys[-1]} are required for this operation")
      end

      required
    end
1342465
protected AstNode cmp(boolean required) throws ScanException, ParseException {
		AstNode v = add(required);
		if (v == null) {
			return null;
		}
		while (true) {
			switch (token.getSymbol()) {
				case LT:
					consumeToken();
					v = createAstBinary(v, add(true), AstBinary.LT);
					break;
				case LE:
					consumeToken();
					v = createAstBinary(v, add(true), AstBinary.LE);
					break;
				case GE:
					consumeToken();
					v = createAstBinary(v, add(true), AstBinary.GE);
					break;
				case GT:
					consumeToken();
					v = createAstBinary(v, add(true), AstBinary.GT);
					break;
				case EXTENSION:
					if (getExtensionHandler(token).getExtensionPoint() == ExtensionPoint.CMP) {
						v = getExtensionHandler(consumeToken()).createAstNode(v, add(true));
						break;
					}
				default:
					return v;
			}
		}
	}
566544
@ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.ALL} )
    @JoinColumn(name="REQUIREMENT_ID")
    public Requirement getRequirement()
    {
        return requirement;
    }