Implements SameValue as described in ES5 9.12, additionally checking
if new value is defined.
@param newValue the new value
@param currentValue the current value
@return true if values are the same as defined by ES5 9.12
162577
protected boolean sameValue(Object newValue, Object currentValue) {
        if (newValue == NOT_FOUND) {
            return true;
        }
        if (currentValue == NOT_FOUND) {
            currentValue = Undefined.instance;
        }
        // Special rules for numbers: NaN is considered the same value,
        // while zeroes with different signs are considered different.
        if (currentValue instanceof Number && newValue instanceof Number) {
            double d1 = ((Number)currentValue).doubleValue();
            double d2 = ((Number)newValue).doubleValue();
            if (Double.isNaN(d1) && Double.isNaN(d2)) {
                return true;
            }
            if (d1 == 0.0 && Double.doubleToLongBits(d1) != Double.doubleToLongBits(d2)) {
                return false;
            }
        }
        return ScriptRuntime.shallowEq(currentValue, newValue);
    }
1356795
public boolean compareAndSet(final long expectedValue, final long updateValue)
    {
        return UnsafeAccess.UNSAFE.compareAndSwapLong(byteArray, addressOffset, expectedValue, updateValue);
    }
816178
boolean valuesAreTheSameAsDefault()
    {
        if (getDefaultValues() == null || getDefaultValues().size() == 0)
            return false;
        if (getValues() == null || getValues().size() == 0)
            return false;
        if (getDefaultValues().size() != getValues().size())
            return false;
        for (int v = 0; v < getDefaultValues().size(); v++)
            if (!getDefaultValues().get(v).equals(getValues().get(v)))
                return false;
        return true;
    }
308688
def free=(new_val)
      return nil if new_val == @free
      raise JSS::InvalidDataError, 'New value must be true or false' unless new_val.jss_boolean?
      @free = new_val
      @need_to_update = true
    end
560541
public boolean isValueUpdate(Long configId, String newValue) {

        //
        // 判断值有没有更新
        //
        String oldValue = configMgr.getValue(configId);

        if (newValue.equals(oldValue)) {
            return false;
        }
        return true;
    }
27866
public boolean setValueIfGreater(final int newValue) {
        final boolean greater = _value.setIfSignificantToUser(newValue);
        if (greater) {
            WidgetUtils.invokeSwingAction(() -> DCProgressBar.super.setValue(newValue));
        }
        return greater;
    }
827148
public void addValue(long newValue) {
    // keep a "total" timer for all values
    InApplicationMonitor.getInstance().addTimerMeasurement(timerName, newValue);

    // keep track of the current maximum value
    if (newValue > currentMaxValue) {
      currentMaxValue = newValue;
    }

    // select the bin to put this value in
    long binIndex;
    if (newValue > maxLimit) {
      binIndex = maxLimit / factor;
    } else {
      binIndex = newValue / factor;
    }

    // add the new value to the appropriate bin
    String binName = getBinName(binIndex);
    InApplicationMonitor.getInstance().incrementCounter(binName);
  }
1282287
public boolean sameAs(Frame<ValueType> other) {
        if (isTop != other.isTop) {
            return false;
        }

        if (isTop && other.isTop) {
            return true;
        }

        if (isBottom != other.isBottom) {
            return false;
        }

        if (isBottom && other.isBottom) {
            return true;
        }

        if (getNumSlots() != other.getNumSlots()) {
            return false;
        }

        for (int i = 0; i < getNumSlots(); ++i) {
            if (!getValue(i).equals(other.getValue(i))) {
                return false;
            }
        }

        return true;
    }
283947
function (newValue) {
		var oldValue = this._value;
		if (oldValue !== newValue) {
			this._value = newValue;
			this.trigger(EVENT_CHANGE, this, newValue, oldValue);
		}
	}
356070
public boolean cas(T expected, T newValue) {
        try {
            lock.writeLock().lock();

            if (Objects.equals(value, expected)) {
                this.value = newValue;
                return true;
            } else
                return false;
        } finally {
            lock.writeLock().unlock();
        }
    }
62047
public void bind(Object newValue)
    {
    	if (getValue() == null)
    	{
    		setValue(newValue);
    	}	
    	else
    	{
    		setValue2(newValue);
    		setBound(true); 		
    	}
    }
1116990
public V setValue(final V iValue) {
    V oldValue = getValue();

    int index = tree.getPageIndex();
    if (dataProvider.setValueAt(index, iValue))
      markDirty();

    return oldValue;
  }
97400
public synchronized void skipTo(final long newValue) throws IllegalStateException {
    if (newValue < currentValue) {
      throw new IllegalStateException(
          "Cannot skip to less than the current value (="
          + currentValue + "), where newValue=" + newValue);
    }
    currentValue = newValue;
  }
379927
public static <T> T same(T value) {
        reportMatcher(new Same(value));
        if (value == null)
            return null;
        return (T) Primitives.defaultValue(value.getClass());
    }
1221639
protected void setInternalValue(String newValue, boolean repaintIsNotNeeded) {
        super.setInternalValue(newValue);
        extension.setSignature(newValue, changingVariables || repaintIsNotNeeded);
    }
1248082
public void setCurrentValue(final float currentValue) {
        this.currentValue = currentValue;
        initialValue = currentValue;
        targetValue = currentValue;
        transitionInProgress = false;
    }
719156
function(newState, newValues) {
      if (state == null && newState != null) {
        state = newState;
        values = newValues;
        if (deferred.length)
          defer(function() {
            for (var i = 0; i < deferred.length; i++)
            deferred[i]();
          });
      }
      return state;
    }