public interface PluginRealmCache {
    /**
     * CacheRecord
     */
    class CacheRecord {
        public ClassRealm getRealm() {
            return realm;
        }

        public List<Artifact> getArtifacts() {
            return artifacts;
        }

        private final ClassRealm realm;

        private final List<Artifact> artifacts;

        public CacheRecord(ClassRealm realm, List<Artifact> artifacts) {

	return &simpleCache{cache: utilcache.NewExpiringWithClock(clock)}
}

func (c *simpleCache) get(key string) (*cacheRecord, bool) {
	record, ok := c.cache.Get(key)
	if !ok {
		return nil, false
	}
	value, ok := record.(*cacheRecord)
	return value, ok
}

func (c *simpleCache) set(key string, value *cacheRecord, ttl time.Duration) {
	c.cache.Set(key, value, ttl)
}

func (c *simpleCache) remove(key string) {

		stripeCount: uint32(stripeCount),
		hashFunc:    hash,
		caches:      caches,
	}
}

func (c *stripedCache) get(key string) (*cacheRecord, bool) {
	return c.caches[c.hashFunc(key)%c.stripeCount].get(key)
}
func (c *stripedCache) set(key string, value *cacheRecord, ttl time.Duration) {
	c.caches[c.hashFunc(key)%c.stripeCount].set(key, value, ttl)
}
func (c *stripedCache) remove(key string) {

        } else {
            return new ArrayList<>();
        }
    }

    public ProjectRealmCache.CacheRecord createProjectRealm(
            MavenProject project, Model model, ProjectBuildingRequest request) {
        return new ProjectRealmCache.CacheRecord(null, null);
    }

    public void selectProjectRealm(MavenProject project) {}

				cache.remove(key)
			} else {
				cache.set(key, &cacheRecord{}, time.Second)
			}
		}
	})
}

func testCache(cache cache, t *testing.T) {
	if result, ok := cache.get("foo"); ok || result != nil {
		t.Errorf("Expected null, false, got %#v, %v", result, ok)
	}

	record1 := &cacheRecord{resp: &authenticator.Response{User: &user.DefaultInfo{Name: "bob"}}}

)

var errAuthnCrash = apierrors.NewInternalError(errors.New("authentication failed unexpectedly"))

const sharedLookupTimeout = 30 * time.Second

// cacheRecord holds the three return values of the authenticator.Token AuthenticateToken method
type cacheRecord struct {
	resp *authenticator.Response
	ok   bool
	err  error

	// this cache assumes token authn has no side-effects or temporal dependence.

            pluginDescriptor.setArtifacts(new ArrayList<>(cacheRecord.getArtifacts()));
            for (ComponentDescriptor<?> componentDescriptor : pluginDescriptor.getComponents()) {
                componentDescriptor.setRealm(cacheRecord.getRealm());
            }

            pluginRealmCache.register(project, cacheKey, cacheRecord);
        }
    }

        }

        artifactRepositories = repositorySystem.getEffectiveRepositories(artifactRepositories);

        return artifactRepositories;
    }

    public synchronized ProjectRealmCache.CacheRecord createProjectRealm(
            MavenProject project, Model model, ProjectBuildingRequest request)
            throws PluginResolutionException, PluginVersionResolutionException, PluginManagerException {

                            e);
        }
        project.setPluginArtifactRepositories(pluginRepositories);

        if (event.request().isProcessPlugins()) {
            try {
                ProjectRealmCache.CacheRecord record =
                        projectBuildingHelper.createProjectRealm(project, model, projectBuildingRequest);

                project.setClassRealm(record.getRealm());

     * @return The record with the project realm and extension artifact filter, never {@code null}.
     * @throws PluginResolutionException If any build extension could not be resolved.
     */
    ProjectRealmCache.CacheRecord createProjectRealm(MavenProject project, Model model, ProjectBuildingRequest request)
            throws PluginResolutionException, PluginVersionResolutionException, PluginManagerException;

    /**