// Dummy functions to be overwritten by any datastore plugin included
			load_node	: function (obj, s_call, e_call) { this.__callback({ "obj" : obj }); },
			_is_loaded	: function (obj) { return true; },

			// Basic operations: create
			create_node	: function (obj, position, js, callback, is_loaded) {
				obj = this._get_node(obj);
				position = typeof position === "undefined" ? "last" : position;
				var d = $("<li />"),

            loaded = true;
        } catch (Exception e) {
            throw closer.rethrow(e);
        } finally {
            closer.close();
        }
    }

    public boolean isLoaded() {
        return loaded;
    }

    public File getFile() {
        return file;
    }

    public long getLoadedSize() {
        if (loaded) {
            return file.length();
        } else {

            delegate.scheduleRequestedTasks(selector, plan)
        } // Else, already scheduled
    }

    private
    fun maybeLoadFromCache(): Boolean {
        return configurationCache.isLoaded
    }

    private val cache: BuildTreeConfigurationCache
) : BuildTreeWorkGraphPreparer {
    override fun prepareToScheduleTasks(workGraph: BuildTreeWorkGraph.Builder) {
        if (!cache.isLoaded) {
            delegate.prepareToScheduleTasks(workGraph)
        } // else, not required
    }

    }

    override fun maybePrepareModel(action: () -> Unit) {
        if (isLoaded) {
            return
        }
        runWorkThatContributesToCacheEntry {
            action()
        }
    }

    override fun <T : Any> loadOrCreateModel(creator: () -> T): T {
        if (isLoaded) {
            runLoadedSideEffects()
            return loadModel().uncheckedCast()
        }

     */
    fun finalizeCacheEntry()

    // This is a temporary property to allow migration from a root build scoped cache to a build tree scoped cache
    val isLoaded: Boolean

    // This is a temporary method to allow migration from a root build scoped cache to a build tree scoped cache
    fun attachRootBuild(host: DefaultConfigurationCache.Host)

            @Override
            public void run(BuildOperationContext context) {
                loadInner(key, new OpFiringEntryReader(loadTarget));
                context.setResult(
                    loadTarget.isLoaded()
                        ? new LoadOperationHitResult(loadTarget.getLoadedSize())
                        : LoadOperationMissResult.INSTANCE
                );
            }

            @Override

        service.load(key, entryReader);
    }

    private static Optional<BuildCacheLoadResult> maybeUnpack(LoadTarget loadTarget, Function<File, BuildCacheLoadResult> unpackFunction) {
        if (loadTarget.isLoaded()) {
            return Optional.ofNullable(unpackFunction.apply(loadTarget.getFile()));
        }
        return Optional.empty();
    }

    @Override
    public boolean canStore() {

d.push(this),c++,n()}var s=t.querySelectorAll("link[rel=import]"),c=0,l=s.length,u=[],d=[];if(l)for(var...

descriptor.IncludeRule, java.util.Map); public final boolean hasProblem(); public final Exception getProblem(); public final String getProblemMessage(); public final boolean isDownloaded(); public final boolean isSearched(); public final boolean isLoaded(); public final IvyNode findNode(org.apache.ivy.core.module.id.ModuleRevisionId); final boolean isRoot(); public final IvyNode getRoot(); public final org.apache.ivy.plugins.conflict.ConflictManager getConflictManager(org.apache.ivy.core.module.id.ModuleId);...