external:
      currentAverageValue: "0"
      currentValue: "0"
      metricName: metricNameValue
      metricSelector:
        matchExpressions:
        - key: keyValue
          operator: operatorValue
          values:
          - valuesValue
        matchLabels:
          matchLabelsKey: matchLabelsValue
    object:
      averageValue: "0"
      currentValue: "0"
      metricName: metricNameValue

            // TODO Should the loop go on the outside to make updates smaller and less likely to collide, and also cheaper to re-run?
            locationsWrittenByCurrentBuild.updateAndGet(currentValue -> {
                FileHierarchySet newValue = currentValue;
                for (String location : locations) {
                    newValue = newValue.plus(location);
                }
                return newValue;
            });
        }

    @Override
    protected void validateMutation() {
        throw new UnsupportedOperationException("Minimal dependencies are immutable.");
    }

    @Override
    protected void validateMutation(Object currentValue, Object newValue) {
        validateMutation();
    }

    @Override
    public void copyTo(AbstractExternalModuleDependency target) {
        super.copyTo(target);
    }

                result.added.add(currentProperty)
                return true
            }

            @Override
            boolean updated(String property, String previousValue, String currentValue) {
                result.updated.add(property)
                return true
            }
        })
        return result
    }

    @Override
    protected void validateMutation() {
        throw new UnsupportedOperationException("Minimal dependencies are immutable.");
    }

    @Override
    protected void validateMutation(Object currentValue, Object newValue) {
        validateMutation();
    }

    @Override
    public void mutateAttributes(AttributeContainer attributes) {
        attributesMutator.execute(attributes);
    }

            read(decoder)
        }
        store.createValueStore(stateType, writer, reader)
    }

    private
    val previousValues = ConcurrentHashMap<K, BlockAddress>()

    private
    val currentValues = ConcurrentHashMap<K, CalculatedValueContainer<BlockAddress, *>>()

    protected
    abstract fun projectPathForKey(key: K): Path?

    protected
    abstract fun write(encoder: Encoder, value: V)