calculatedValueContainerFactory.create(Describables.of("unknown value"), value as Any)
            } else {
                val supplier = readNonNull<ValueCalculator<Any>>()
                calculatedValueContainerFactory.create(Describables.of("unknown value"), supplier)
            }
        }
    }

            indexOfStackFrame(_, _) >> { start, predicate -> stack.findIndexOf(start) { predicate.test(it, StackTraceRelevance.USER_CODE) } }
        }
        def longDisplayName = Describables.of("<long source>")
        def shortDisplayName = Describables.of("<short source>")

        given:

        }

        val name = readString()
        val origin = if (readBoolean()) {
            ClassLoaderScopeOrigin.Script(readString(), Describables.of(readString()), Describables.of(readString()))
        } else {
            null
        }
        val localClassPath = readClassPath()
        val localImplementationHash = readHashCode()

        val dependencyMetadata = factory.create(Describables.of(configurationName, "dependencies"), ValueCalculator {
            ConfigurationDependencyMetadata(
                dependencies, emptySet(), emptyList(),
            )
        })

        val artifactMetadata = factory.create(Describables.of(configurationName, "artifacts"), ValueCalculator {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.cc.impl.problems

import org.gradle.internal.Describables
import org.gradle.internal.configuration.problems.PropertyProblem
import org.gradle.internal.configuration.problems.PropertyTrace
import org.gradle.internal.configuration.problems.StructuredMessage

import org.gradle.internal.serialize.graph.WriteContext
import org.gradle.internal.serialize.graph.readFile
import org.gradle.internal.serialize.graph.writeFile
import org.gradle.internal.Describables
import org.gradle.internal.component.local.model.ComponentFileArtifactIdentifier
import org.gradle.internal.model.CalculatedValueContainerFactory


class DefaultResolvableArtifactCodec(

import org.gradle.internal.Describables;
import org.gradle.internal.DisplayName;
import org.gradle.internal.Factory;
import org.gradle.internal.typeconversion.NotationParser;

import javax.annotation.Nullable;
import java.util.List;
import java.util.Optional;

public class DefaultVariant implements ConfigurationVariantInternal {
    private final Describable parentDisplayName;
    private final String name;

                ComponentSelectionDescriptorInternal moduleReplacement = ComponentSelectionReasons.SELECTED_BY_RULE.withDescription(Describables.of(identifier, "replaced with", replacement.getTarget()));
                if (reason != null) {
                    moduleReplacement = moduleReplacement.withDescription(Describables.of(reason));
                }
                selected.addCause(moduleReplacement);
            }
        }
    }

 * limitations under the License.
 */

package org.gradle.api.internal.artifacts.configurations;

import org.gradle.api.artifacts.ResolveException;
import org.gradle.internal.Describables;
import org.gradle.internal.DisplayName;

import java.util.Collection;
import java.util.Optional;

/**
 * The "Host" or owner of a resolution -- the thing in charge of the resolution, or the thing being resolved.

        this.localComponentProvider = localComponentProvider;

        this.originalComponents = calculatedValueContainerFactory.createCache(Describables.of("local metadata"));
        this.foreignIdentifiedComponents = calculatedValueContainerFactory.createCache(Describables.of("foreign metadata"));
    }

    @Override