<pre>
The delta for Bindings between two policies.
</pre>

<code>repeated .google.iam.v1.BindingDelta binding_deltas = 1;</code>
191925
public com.google.iam.v1.BindingDeltaOrBuilder getBindingDeltasOrBuilder(
      int index) {
    return bindingDeltas_.get(index);
  }
980760
function Delta(id, silent) {
    var scutt = Scuttlebutt(id)
        , delta = new EventEmitter()
        , updates = {}
        , state = { id: scutt.id }
        , log = silent ? noop : error

    id = delta.id = scutt.id

    scutt.applyUpdate = applyUpdate
    // history is a global variable -.-
    scutt.history = $history

    delta.validate = validate
    delta.set = set
    delta.get = get
    delta.has = has
    // stupid tokens
    delta.delete = $delete
    delta.toJSON = toJSON
    delta.createStream = scutt.createStream.bind(scutt)

    return delta

    function applyUpdate(update) {
        var key = update[0]
            , value = update[1]
            , recentUpdate = updates[key]

        // If the most recent update for that key is newer then the incoming
        // update. Then ignore it
        if (recentUpdate && recentUpdate[2] > update[2]) {
            return
        }

        updates[key] = update

        if (value === undefined) {
            delete state[key]
        } else {
            state[key] = value
        }

        delta.emit("change", key, value)
        delta.emit("change:" + key, value)

        return true
    }

    function $history(sources) {
        return reduce(updates, isRecent, sources, []).sort(byTimestamp)
    }

    function validate(changes) {
        try {
            delta.emit("validate", changes)
            return true
        } catch (e) {
            log("[DELTA-STREAM]: validation", e.message, e)
            return false
        }
    }

    function set(key, value) {
        if (key === "id" && value !== id) {
            console.log("invalid", key, value)
            throw Error("id cannot be changed")
        }

        if (typeof key === "string") {
            scutt.localUpdate(key, value)
        } else {
            forEach(key, setKeyValue)
        }
    }

    function setKeyValue(value, key) {
        set(key, value)
    }

    function get(key) {
        return state[key]
    }

    function has(key) {
        return key in state
    }

    function $delete(key) {
        set(key, undefined)
    }

    function toJSON() {
        return state
    }
}
555728
public com.google.privacy.dlp.v2.PrivacyMetric.DeltaPresenceEstimationConfigOrBuilder
      getDeltaPresenceEstimationConfigOrBuilder() {
    if (typeCase_ == 6) {
      return (com.google.privacy.dlp.v2.PrivacyMetric.DeltaPresenceEstimationConfig) type_;
    }
    return com.google.privacy.dlp.v2.PrivacyMetric.DeltaPresenceEstimationConfig
        .getDefaultInstance();
  }
1236382
private static int getAppendLimitDelta(String maxLimit) {
    LOG.debug("Getting append limit delta");
    int limitDelta = 0;
    if (!Strings.isNullOrEmpty(maxLimit)) {
      String[] limitParams = maxLimit.split("-");
      if (limitParams.length >= 2) {
        limitDelta = Integer.parseInt(limitParams[1]);
      }
    }
    return limitDelta;
  }
847878
protected final void declareReturnType(IndentingWriter o, List<IType> intermediates, boolean usesDefaltValues) throws BindingException {
    generateAccessModifier(o);

    if (returnType == null && intermediates == null) {
      o.print("void ");
    } else {
      // we assume that the [retval] param to be passed by reference
      TypeBinding retBinding = TypeBinding.bind(g, returnType, null);

      // add @ReturnValue if necessary
      if ((!retBinding.isDefault && needsMarshalAs()) || (retParam != -1 && (params[retParam].isIn() || retParam != params.length - 1))
          || intermediates != null
          || usesDefaltValues) {
        o.print("@ReturnValue(");
        o.beginCommaMode();
        if (!retBinding.isDefault && needsMarshalAs()) {
          o.comma();
          o.print("type=NativeType." + retBinding.nativeType.name());
        }
        if (retParam != -1 && params[retParam].isIn()) {
          o.comma();
          o.print("inout=true");
        }
        if (retParam != -1 && retParam != params.length - 1 || usesDefaltValues) {
          o.comma();
          o.print("index=" + retParam);
        }

        if (intermediates != null) {
          o.comma();
          o.print("defaultPropertyThrough={");
          o.beginCommaMode();
          for (IType im : intermediates) {
            TypeBinding vb = TypeBinding.bind(g, im, null);
            o.comma();
            o.print(vb.javaType);
            o.print(".class");
          }
          o.endCommaMode();
          o.print("}");
        }

        o.endCommaMode();
        o.println(")");
      }

      o.print(retBinding.javaType);
      o.print(' ');
    }
  }
696439
public java.util.List<com.google.iam.v1.BindingDelta> getBindingDeltasList() {
    return bindingDeltas_;
  }
224723
IntTreePMap<V> withKeysChangedAbove(final int key, final int delta) {
		// TODO check preconditions of changeKeysAbove()
		// TODO make public?
		return withRoot( root.changeKeysAbove(key, delta) );
	}
12780
public com.google.cloud.datalabeling.v1beta1.LabelImageBoundingPolyOperationMetadataOrBuilder
      getImageBoundingPolyDetailsOrBuilder() {
    if (detailsCase_ == 11) {
      return (com.google.cloud.datalabeling.v1beta1.LabelImageBoundingPolyOperationMetadata)
          details_;
    }
    return com.google.cloud.datalabeling.v1beta1.LabelImageBoundingPolyOperationMetadata
        .getDefaultInstance();
  }
307130
private static void compareMaps(Delta delta, Collection deltas, LinkedList stack, ID idFetcher)
    {
        Map<Object, Object> srcMap = (Map<Object, Object>) delta.srcValue;
        Map<Object, Object> targetMap = (Map<Object, Object>) delta.targetValue;

        // Walk source Map keys and see if they exist in target map.  If not, that entry needs to be removed.
        // If the key exists in both, then the value must tested for equivalence.  If !equal, then a PUT command
        // is created to re-associate target value to key.
        final String sysId = "(" + System.identityHashCode(srcMap) + ')';
        for (Map.Entry entry : srcMap.entrySet())
        {
            Object srcKey = entry.getKey();
            Object srcValue = entry.getValue();
            String srcPtr = sysId + "['" + System.identityHashCode(srcKey) + "']";

            if (targetMap.containsKey(srcKey))
            {
                Object targetValue = targetMap.get(srcKey);
                if (srcValue == null || targetValue == null)
                {   // Null value in either source or target
                    if (srcValue != targetValue)
                    {   // Value differed, must create PUT command to overwrite source value associated to key
                        addMapPutDelta(delta, deltas, srcPtr, targetValue, srcKey);
                    }
                }
                else if (isIdObject(srcValue, idFetcher) && isIdObject(targetValue, idFetcher))
                {   // Both source and destination have same object (by id) as the value, add delta to stack (field-by-field check for item).
                    if (idFetcher.getId(srcValue).equals(idFetcher.getId(targetValue)))
                    {
                        stack.push(new Delta(delta.id, delta.fieldName, srcPtr, srcValue, targetValue, null));
                    }
                    else
                    {   // Different ID associated to same key, must create PUT command to overwrite source value associated to key
                        addMapPutDelta(delta, deltas, srcPtr, targetValue, srcKey);
                    }
                }
                else if (!DeepEquals.deepEquals(srcValue, targetValue))
                {   // Non-null, non-ID value associated to key, and the two values are not equal.  Create PUT command to overwrite.
                    addMapPutDelta(delta, deltas, srcPtr, targetValue, srcKey);
                }
            }
            else
            {   // target does not have this Key in it's map, therefore create REMOVE command to remove it from source map.
                Delta removeDelta = new Delta(delta.id, delta.fieldName, srcPtr, srcValue, null, srcKey);
                removeDelta.setCmd(MAP_REMOVE);
                deltas.add(removeDelta);
            }
        }

        for (Map.Entry entry : targetMap.entrySet())
        {
            Object targetKey = entry.getKey();
            String srcPtr = sysId + "['" + System.identityHashCode(targetKey) + "']";

            if (!srcMap.containsKey(targetKey))
            {   // Add Delta command map.put
                Delta putDelta = new Delta(delta.id, delta.fieldName, srcPtr, null, entry.getValue(), targetKey);
                putDelta.setCmd(MAP_PUT);
                deltas.add(putDelta);
            }
        }
        // TODO: If LinkedHashMap, may need to issue commands to reorder...
    }
530030
public com.google.privacy.dlp.v2.AnalyzeDataSourceRiskDetails
          .DeltaPresenceEstimationResultOrBuilder
      getDeltaPresenceEstimationResultOrBuilder() {
    if (resultCase_ == 9) {
      return (com.google.privacy.dlp.v2.AnalyzeDataSourceRiskDetails.DeltaPresenceEstimationResult)
          result_;
    }
    return com.google.privacy.dlp.v2.AnalyzeDataSourceRiskDetails.DeltaPresenceEstimationResult
        .getDefaultInstance();
  }
1359957
public com.google.cloud.datalabeling.v1beta1.NormalizedBoundingPoly getNormalizedBoundingPoly() {
    if (boundedAreaCase_ == 2) {
      return (com.google.cloud.datalabeling.v1beta1.NormalizedBoundingPoly) boundedArea_;
    }
    return com.google.cloud.datalabeling.v1beta1.NormalizedBoundingPoly.getDefaultInstance();
  }
730357
public Vector3Axis delta(Vector3f v) {
        Vector3Axis ret = new Vector3Axis(Float.NaN, Float.NaN, Float.NaN);
        if (x != Float.NaN && v.x != Float.NaN && !equal(x, v.x)) {
            ret.set(x - v.x, Layout.Axis.X);
        }
        if (y != Float.NaN && v.y != Float.NaN && !equal(y, v.y)) {
            ret.set(y - v.y, Layout.Axis.Y);
        }
        if (z != Float.NaN && v.z != Float.NaN && !equal(z, v.z)) {
            ret.set(z - v.z, Layout.Axis.Z);
        }
        return ret;
    }
419808
public java.util.List<? extends com.google.iam.v1.BindingDeltaOrBuilder> 
      getBindingDeltasOrBuilderList() {
    return bindingDeltas_;
  }
360313
public static IntegerBinding getExponent(final ObservableDoubleValue d) {
        return createIntegerBinding(() -> Math.getExponent(d.get()), d);
    }
264343
void addDelta(TableKelp db, int offset, int length)
  {
    if (_delta == null) {
      _delta = new int[2 * db.getDeltaMax()];
    }
    
    _delta[_deltaTail++] = offset;
    _delta[_deltaTail++] = length;
  }
646831
public final double addAndGet(double delta) 
    {
        while(true) 
        {
            double orig = get();
            double newVal = orig + delta;
            if (compareAndSet(orig, newVal))
                return newVal;
        }
    }
720413
public com.google.iam.v1.BindingDelta.Action getAction() {
    com.google.iam.v1.BindingDelta.Action result = com.google.iam.v1.BindingDelta.Action.valueOf(action_);
    return result == null ? com.google.iam.v1.BindingDelta.Action.UNRECOGNIZED : result;
  }