<p>
The minimum DB engine version required for the corresponding allowed value for this option setting.
</p>

@param minimumEngineVersionPerAllowedValue
The minimum DB engine version required for the corresponding allowed value for this option setting.
480168
public void setMinimumEngineVersionPerAllowedValue(java.util.Collection<MinimumEngineVersionPerAllowedValue> minimumEngineVersionPerAllowedValue) {
        if (minimumEngineVersionPerAllowedValue == null) {
            this.minimumEngineVersionPerAllowedValue = null;
            return;
        }

        this.minimumEngineVersionPerAllowedValue = new com.amazonaws.internal.SdkInternalList<MinimumEngineVersionPerAllowedValue>(
                minimumEngineVersionPerAllowedValue);
    }
785356
def QA_SU_save_etf_min(engine, client=DATABASE):
    

    engine = select_save_engine(engine)
    engine.QA_SU_save_etf_min(client=client)
476473
public com.google.appengine.v1.Version getVersion() {
    return version_ == null ? com.google.appengine.v1.Version.getDefaultInstance() : version_;
  }
696252
public void setMinValue(final BigDecimal minValue) {
		BigDecimal currMin = getMinValue();
		if (!Objects.equals(minValue, currMin)) {
			getOrCreateComponentModel().minValue = minValue;
		}
	}
591230
static boolean supportedJavaVersion(String javaVersion, String javaVendor, int major, int minor, String point) {
        String[] versionParts = javaVersion.split("\\.");
        int currentMajor = Integer.parseInt(versionParts[0]);
        int currentMinor = Integer.parseInt(versionParts[1]);
        String currentPoint = versionParts[2];

        if (currentMajor > major) {
            return true;
        } else if (currentMajor == major) {
            if (currentMinor > minor) {
                return true;
            } else if (currentMinor == minor) {
                // java.version point version is not a version number and for Azul (zing) it does not follow the
                // the number_number... format used by Oracle and Open JDK (e.g. 1.7.0-zing_5.10.1.0). So just
                // allow any zing version that starts with major.minor.
                return javaVendor.startsWith("Azul") || currentPoint.compareTo(point) >= 0;
            }
        }

        return false;
    }
210645
public static int getAppVersion(@NonNull final Context context) {
        try {
            final PackageInfo packageInfo = context.getPackageManager()
                    .getPackageInfo(context.getPackageName(), 0);
            return packageInfo.versionCode;
        } catch (PackageManager.NameNotFoundException ignore) {
            // ignore
        }

        return Integer.MIN_VALUE;
    }
220150
private void setVersion(Object val) throws CertificateException {
        if (!(val instanceof CertificateVersion)) {
            throw new CertificateException("Version class type invalid.");
        }
        version = (CertificateVersion)val;
    }
1022836
@Override
    public void setVersion(String version) {
        try {
            this.message.setVersion(version);
        } catch (UnsupportedProtocolVersionException e) {
            this.message.setVersion(VersionValues.V11);
        }
    }
199454
public boolean isSatisfiedBy(Semver version) {
        if (this.range != null) {
            // We are on a leaf
            return this.range.isSatisfiedBy(version);
        } else {
            // We have several sub-requirements
            switch (this.op) {
                case AND:
                    try {
                        List<Range> set = getAllRanges(this, new ArrayList<Range>());
                        for (Range range : set) {
                            if (!range.isSatisfiedBy(version)) {
                                return false;
                            }
                        }
                        if (version.getSuffixTokens().length > 0) {
                            // Find the set of versions that are allowed to have prereleases
                            // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
                            // That should allow `1.2.3-pr.2` to pass.
                            // However, `1.2.4-alpha.notready` should NOT be allowed,
                            // even though it's within the range set by the comparators.
                            for (Range range : set) {
                                if (range.version == null) {
                                    continue;
                                }
                                if (range.version.getSuffixTokens().length>0) {
                                    Semver allowed = range.version;
                                    if (Objects.equals(version.getMajor(), allowed.getMajor()) &&
                                            Objects.equals(version.getMinor(), allowed.getMinor()) &&
                                            Objects.equals(version.getPatch(), allowed.getPatch())) {
                                        return true;
                                    }
                                }
                            }
                            // Version has a -pre, but it's not one of the ones we like.
                            return false;
                        }
                        return true;
                    } catch (Exception e) {
                        // Could be that we have a OR in AND - fallback to default test
                        return this.req1.isSatisfiedBy(version) && this.req2.isSatisfiedBy(version);
                    }
                case OR:
                    return this.req1.isSatisfiedBy(version) || this.req2.isSatisfiedBy(version);
            }
            throw new RuntimeException("Code error. Unknown RequirementOperator: " + this.op); // Should never happen
        }
    }
192025
@Override
    public void validateDefault(InputProblemReporter rep, boolean normalize)
        throws XMLStreamException
    {
        String normStr = validateDefaultName(rep, normalize);
        if (normalize) {
            mDefValue.setValue(normStr);
        }

        // Ok, but was it declared?

        /* 03-Dec-2004, TSa: This is rather ugly -- need to know we
         *   actually really get a DTD reader, and DTD reader needs
         *   to expose a special method... but it gets things done.
         */
        EntityDecl ent = ((MinimalDTDReader) rep).findEntity(normStr);
        checkEntity(rep, normStr, ent);
    }
725938
@Override
    public MavenVersionRangeResult resolveVersionRange(final String coordinate) throws IllegalArgumentException {
        Validate.isNullOrEmpty(coordinate);

        final MavenCoordinate mavenCoordinate = MavenCoordinates.createCoordinate(coordinate);
        return this.getMavenWorkingSession().resolveVersionRange(mavenCoordinate);
    }
1331127
private void enforceVersionSupported()
    {
        if ( _versionSupported != null )
        {
            int majorSupported = _versionSupported.major();
            int minorSupported = _versionSupported.minor();

            if ( majorSupported < 0 )    // no real version support requirement
                return;

            AptControlInterface ci = getControlInterface();
            if ( ci == null )
                return;

            int majorPresent = -1;
            int minorPresent = -1;
            Version ciVersion = ci.getVersion();
            if ( ciVersion != null )
            {
                majorPresent = ciVersion.major();
                minorPresent = ciVersion.minor();

                if ( majorSupported >= majorPresent &&
                     (minorSupported < 0 || minorSupported >= minorPresent) )
                {
                    // Version requirement is satisfied
                    return;
                }
            }

            //
            // Version requirement failed
            //

            _ap.printError( _implDecl, "versionsupported.failed", _implDecl.getSimpleName(), majorSupported, minorSupported,
                            majorPresent, minorPresent );
        }
    }
64051
public void setPOMVersion(final String pomVersion) {
        if (pomVersion == null && this.pomVersion == null) {
            return;
        } else if (pomVersion == null) {
            removeChild(this.pomVersion);
            this.pomVersion = null;
        } else if (this.pomVersion == null) {
            this.pomVersion = new KeyValueNode<String>(CommonConstants.CS_MAVEN_POM_VERSION_TITLE, pomVersion);
            appendChild(this.pomVersion, false);
        } else {
            this.pomVersion.setValue(pomVersion);
        }
    }
136543
public void setVersion(int major, int minor) {
        if (major > 65535 || minor > 65535) {
            throw new IllegalArgumentException("Version number element cannot exceed 65535");
        }

        mVersion = (minor << 16) | (major & 0xffff);

        String target;
        switch (major) {
        default:
            target = null;
            break;
        case 45:
            target = minor == 3 ? "1.0" : null;
            break;
        case 46:
            target = minor == 0 ? "1.2" : null;
            break;
        case 47:
            target = minor == 0 ? "1.3" : null;
            break;
        case 48:
            target = minor == 0 ? "1.4" : null;
            break;
        case 49:
            target = minor == 0 ? "1.5" : null;
            break;
        case 50:
            target = minor == 0 ? "1.6" : null;
            break;
        case 51:
            target = minor == 0 ? "1.7" : null;
            break;
        }

        mTarget = target;
    }
148822
public boolean isCompatibleWith(String runtimeVersion) {
    if (null == this.minimalSqVersion) {
      // no constraint defined on the plugin
      return true;
    }

    Version effectiveMin = Version.create(minimalSqVersion.getName()).removeQualifier();
    Version effectiveVersion = Version.create(runtimeVersion).removeQualifier();

    if (runtimeVersion.endsWith("-SNAPSHOT")) {
      // check only the major and minor versions (two first fields)
      effectiveMin = Version.create(effectiveMin.getMajor() + "." + effectiveMin.getMinor());
    }

    return effectiveVersion.compareTo(effectiveMin) >= 0;
  }
480193
public LongParameter setMinimumValue(long minimumValue) {
		if (hasMaximumValue) {
			Util.checkParameter(minimumValue <= maximumValue,
				"Minimum value (" + minimumValue + ") must be less than or equal to maximum (" + maximumValue + ")");
		}

		this.hasMinimumValue = true;
		this.minimumValue = minimumValue;

		return this;
	}
1276449
private void initVersion() {
        VersionValues ver = getServiceContext().getRequestVersion();
        VersionValues configVer = getServiceContext().getHttpConfig().getOutgoingVersion();
        if (VersionValues.V10.equals(configVer) && VersionValues.V11.equals(ver)) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "Configuration forcing 1.0 instead of 1.1");
            }
            setVersion(configVer);
        } else {
            setVersion(ver);
        }
    }