Set the minor number.

@param minor
The minor number. The value should be in the range from 0 to 65535.

@throws IllegalArgumentException
The given value is out of the valid range.
491655
public void setMinor(int minor)
    {
        if (minor < 0 || 0xFFFF < minor)
        {
            throw new IllegalArgumentException("'minor' is out of the valid range: " + minor);
        }

        mMinor = minor;

        byte[] data = getData();
        data[MINOR_INDEX    ] = (byte)((minor >> 8) & 0xFF);
        data[MINOR_INDEX + 1] = (byte)((minor     ) & 0xFF);
    }
144269
public void setDigits10Map(String[] digits10Map) {
        ArgUtils.notEmpty(digits10Map, "digits10Map");

        if(digits10Map.length != 5) {
            throw new IllegalArgumentException("digits10Map length should be 5.");
        }

        this.digits10Map = digits10Map;
    }
702806
public void setM(double m)
    {
        if(m < 0 || Double.isInfinite(m) || Double.isNaN(m))
            throw new ArithmeticException("The minimum count must be a non negative number");
        this.m = m;
    }
146049
public static void lessThan(long value, long maxValue, String name) {
        if (value <= 0) {
            throw new IllegalArgumentException(name + " should be > 0, current value " + value);
        }
        if (value > maxValue) {
            throw new IllegalArgumentException(name + " should be <= " + maxValue + ", current value " + value);
        }
    }
1191267
@Override
	public void setMinY(double y) {
		double o = this.maxyProperty.doubleValue();
		if (o<y) {
			this.minyProperty.set(o);
			this.maxyProperty.set(y);
		}
		else {
			this.minyProperty.set(y);
		}
	}
1199226
public String validate(String proposedValue) throws IllegalArgumentException
	{
		if (MathExtensions.isBetween(minimum, maximum, proposedValue.length(), true, true))
		{
			return proposedValue;
		}
		else
		{
			throw new IllegalArgumentException();
		}
	}
125291
public void setIdleMin(int min)
  {
    if (min == _idleMin) {
      // avoid update() overhead if unchanged
      return;
    }
    
    if (min <= 0) {
      min = DEFAULT_IDLE_MIN;
    }
    
    if (_threadMax < min)
      throw new ConfigException(L.l("IdleMin ({0}) must be less than ThreadMax ({1})", min, _threadMax));
    if (min <= 0)
      throw new ConfigException(L.l("IdleMin ({0}) must be greater than 0.", min));

    _idleMin = min;
    
    update();
  }
1165684
@Override
  public void setDecimal(int ordinal, Decimal value, int precision) {
    assertIndexIsValid(ordinal);
    if (precision <= Decimal.MAX_LONG_DIGITS()) {
      // compact format
      if (value == null) {
        setNullAt(ordinal);
      } else {
        setLong(ordinal, value.toUnscaledLong());
      }
    } else {
      // fixed length
      long cursor = getLong(ordinal) >>> 32;
      assert cursor > 0 : "invalid cursor " + cursor;
      // zero-out the bytes
      Platform.putLong(baseObject, baseOffset + cursor, 0L);
      Platform.putLong(baseObject, baseOffset + cursor + 8, 0L);

      if (value == null) {
        setNullAt(ordinal);
        // keep the offset for future update
        Platform.putLong(baseObject, getFieldOffset(ordinal), cursor << 32);
      } else {

        final BigInteger integer = value.toJavaBigDecimal().unscaledValue();
        byte[] bytes = integer.toByteArray();
        assert(bytes.length <= 16);

        // Write the bytes to the variable length portion.
        Platform.copyMemory(
          bytes, Platform.BYTE_ARRAY_OFFSET, baseObject, baseOffset + cursor, bytes.length);
        setLong(ordinal, (cursor << 32) | ((long) bytes.length));
      }
    }
  }
185179
public final void setValue(final int value)
	{
		expUnitAdjustment = 0;
		try {
			data = toDpt(dimensionlessCounter, value);
		}
		catch (final KNXFormatException e) {
			logger.error("{} {} coding {} (value {}) should alway have correct format", dpt.getID(),
					dpt.getDescription(), binary(dimensionlessCounter), value, e);
		}
	}
1015736
public void setTag(String tag) throws IllegalArgumentException {
		if (tag == null
				|| (tag != null && (tag.length() < 1 || tag.length() > 32))) {
			throw new IllegalArgumentException(
					"The tag must not be null, the length between 1..32");
		}

		this.tag = tag;
	}
357723
public void setMajor(int major)
    {
        if (major < 0 || 0xFFFF < major)
        {
            throw new IllegalArgumentException("'major' is out of the valid range: " + major);
        }

        mMajor = major;

        byte[] data = getData();
        data[MAJOR_INDEX    ] = (byte)((major >> 8) & 0xFF);
        data[MAJOR_INDEX + 1] = (byte)((major     ) & 0xFF);
    }
1182879
public void set(int index, Number value) {
        if (isImmutable) 
            throw new UnsupportedOperationException(
                "Cannot modify an immutable vector");           
        vector.set(getIndex(index), value);
        magnitude = -1;
    }
615515
public void setInteger(String key, int value) {
        prefHelper_.prefsEditor_.putInt(key, value);
        prefHelper_.prefsEditor_.apply();
    }
159540
public void setSeverityNormalized(java.util.Collection<NumberFilter> severityNormalized) {
        if (severityNormalized == null) {
            this.severityNormalized = null;
            return;
        }

        this.severityNormalized = new java.util.ArrayList<NumberFilter>(severityNormalized);
    }
982211
public function setMin($min)
    {
        if (is_numeric($min) || Format::isVariableRef($min)) {
            $this->min = $min;
        } else {
            $msg = "'Min' must be a numeric value or a variableRef, '" . gettype($min) . "' given.";
            throw new InvalidArgumentException($msg);
        }
    }
1366379
public void setAffected(byte subrange, boolean v) throws IllegalArgumentException {
        if (this.status == null) {
            throw new IllegalArgumentException("Can not set affected if no status present!");
        }
        // ceck
        if (this.status.length < (subrange / 8)) {
            throw new IllegalArgumentException("Argument exceeds status!");
        }
        int index_l = (subrange / 8);
        int index = subrange % 8; // number of bit to lit... ech
        int n2Pattern = (int) Math.pow(2, index); // hmm no int pows... sucks

        if (v) {
            this.status[index_l] |= n2Pattern;
        } else {
            // not, we have to inverse pattern...
            n2Pattern = 0xFF ^ n2Pattern; // this will create bits with zeros in place of n2Pattern ones!
            this.status[index_l] &= n2Pattern; // do logical and, this will kill proper bit and leave rest unchanged
        }
    }
790155
public function setMin($min)
    {
        $min = (int) $min;

        if ($min < 0) {
            throw new \InvalidArgumentException('Error: Minimum cannot be smaller than zero');
        }
        if ($min > $this->max) {
            // We do not throw an exception but silently adjust the maximum.
            $this->max = $min;
        }

        $this->min = $min;
    }