public void setCreatedTime(Long value) {
        registerModifiedProperty("createdTime");
        this.createdTime = value;
    }

    public String getKey() {
        checkSpecifiedProperty("key");
        return convertEmptyToNull(key);
    }

    public void setKey(String value) {
        registerModifiedProperty("key");
        this.key = value;
    }

    public String getValue() {

    public void write(Encoder encoder, Map<U, V> value) throws Exception {
        encoder.writeInt(value.size());
        for (Map.Entry<U, V> entry : value.entrySet()) {
            keySerializer.write(encoder, entry.getKey());
            valueSerializer.write(encoder, entry.getValue());
        }
    }

    @Override
    public boolean equals(Object obj) {
        if (!super.equals(obj)) {
            return false;
        }

  private static final Predicate<@Nullable Integer> EVEN = input -> input == null || input % 2 == 0;
  static final Predicate<Entry<String, Integer>> CORRECT_LENGTH =
      input -> input.getKey().length() == input.getValue();

  abstract Map<String, Integer> createUnfiltered();

  public void testFilteredKeysIllegalPut() {
    Map<String, Integer> unfiltered = createUnfiltered();

        }

        private String cachePath(String group, String module, String version) {
            return Pattern.quote("${userHomeDir.path.replace(File.separator, '/')}") + "/caches/${CacheLayout.MODULES.getKey()}/${CacheLayout.FILE_STORE.getKey()}/" + Pattern.quote("${group}/${module}/${version}/") + "\\w+/"
        }

        void assertHasNoSource() {
            assert !entry.@sourcepath
        }

    super(delegate);

    ImmutableMap.Builder<V, K> builder = ImmutableMap.builder();
    for (Entry<K, V> entry : delegate.entrySet()) {
      builder.put(entry.getValue(), entry.getKey());
    }
    ImmutableMap<V, K> backwardMap = builder.build();
    this.inverse = new RegularImmutableBiMap<V, K>(backwardMap, this);
  }

        final PrimaryCipher cipher = ComponentUtil.getPrimaryCipher();
        ParameterUtil.parse(value).entrySet().stream().map(e -> {
            final String k = e.getKey();
            final String v = e.getValue();
            if (properyPattern.matcher(k).matches() && !v.startsWith(CIPHER_PREFIX)) {
                return new Pair<>(k, CIPHER_PREFIX + cipher.encrypt(v));
            }

        this.baseDir = cacheBuilderFactory.getRootDir();
        this.cacheDir = cacheBuilderFactory.baseDirForCrossVersionCache(CacheLayout.MODULES.getKey());
    }

    public DefaultArtifactCacheMetadata(GlobalScopedCacheBuilderFactory cacheBuilderFactory, File baseDir) {
        this(cacheBuilderFactory.createCacheBuilderFactory(baseDir));
    }

    @Override

      protected Entry<Class<? extends @NonNull B>, B> delegate() {
        return entry;
      }

      @Override
      @ParametricNullness
      public B setValue(@ParametricNullness B value) {
        cast(getKey(), value);
        return super.setValue(value);
      }
    };
  }

  @Override
  public Set<Entry<Class<? extends @NonNull B>, B>> entrySet() {

    public Collection<? extends Metadata> prepare(Collection<? extends Artifact> artifacts) {
        for (Artifact artifact : artifacts) {
            if (artifact.isSnapshot()) {
                Object key = LocalSnapshotMetadata.getKey(artifact);
                LocalSnapshotMetadata snapshotMetadata = snapshots.get(key);
                if (snapshotMetadata == null) {
                    snapshotMetadata = new LocalSnapshotMetadata(artifact, timestamp);

            for (Map.Entry<String, SomeToolingModel> entry : model.entrySet()) {
                result.computeIfAbsent(entry.getKey(), k -> new ArrayList<>()).add(entry.getValue());
            }
        }

        return result;
    }