import org.gradle.internal.buildtree.BuildTreeModelSideEffectExecutor


internal
class ConfigurationCacheBuildTreeModelSideEffectExecutor : BuildTreeModelSideEffectExecutor {

    lateinit var sideEffectStore: BuildTreeModelSideEffectStore

    override fun runIsolatableSideEffect(sideEffect: BuildTreeModelSideEffect) {
        sideEffect.runSideEffect()
        sideEffectStore.write(sideEffect)
    }

        override val hasScheduledWork: Boolean
            get() = gradle.taskGraph.size() > 0

        override val scheduledWork: ScheduledWork
            get() {
                lateinit var work: ScheduledWork
                gradle.taskGraph.visitScheduledNodes { nodes, entryNodes -> work = ScheduledWork(nodes, entryNodes) }
                return work
            }
    }

    private

    private
    inline fun <reified T> newInstance() =
        objectFactory().newInstance(T::class.java)

    private
    fun <T : Any> valueCarriedBy(isolatedAction: TestableIsolatedAction<T>): T {
        lateinit var value: T
        isolatedAction.execute {
            value = it
        }
        return value
    }

    private

    override val sharedIdentities = ReadIdentities()

    private
    var singletonProperty: Any? = null

    override lateinit var classLoader: ClassLoader

    override fun onFinish(action: () -> Unit) {
        pendingOperations.add(action)
    }

    fun finish() {
        for (op in pendingOperations) {
            op()

        fun <T> factory(serviceType: Class<T>): Factory<T>
    }

    private
    lateinit var cacheAction: ConfigurationCacheAction

    // Have one or more values been successfully written to the entry?
    private
    var cacheEntryRequiresCommit = false

    private
    lateinit var host: Host

    private
    val loadedSideEffects = mutableListOf<BuildTreeModelSideEffect>()

    private
    var reusedProjects = 0

    private
    var updatedProjects = 0

    private
    var incompatibleTasks = newConcurrentHashSet<String>()

    private
    lateinit var cacheAction: ConfigurationCacheAction

    val shouldDiscardEntry: Boolean
        get() {
            if (cacheAction == LOAD) {
                return false
            }