package com.google.common.escape;

/** @author Jesse Wilson */
final class Platform {

  private static final char[] CHAR_BUFFER = new char[1024];

  static char[] charBufferFromThreadLocal() {
    // ThreadLocal is not available to GWT, so we always reuse the same
    // instance.  It is always safe to return the same instance because
    // javascript is single-threaded, and only used by blocks that doesn't
    // involve async callbacks.

        private final Map<Key<?>, Provider<?>> seeded = new HashMap<>();

        private final Map<Key<?>, Object> provided = new HashMap<>();
    }

    private final ThreadLocal<LinkedList<ScopeState>> values = new ThreadLocal<>();

    public MojoExecutionScope() {}

    public void enter() {
        LinkedList<ScopeState> stack = values.get();
        if (stack == null) {
            stack = new LinkedList<>();

 * <p>
 * This class is thread-safe, though it only tracks pending exceptions per-thread.
 */
public class TransformErrorHandler {
    @SuppressWarnings("ThreadLocalUsage")
    private final ThreadLocal<ClassNotFoundException> lastError = new ThreadLocal<ClassNotFoundException>();
    private final String classLoaderName;

    public TransformErrorHandler(String classLoaderName) {
        this.classLoaderName = classLoaderName;
    }

        Runtime.value = "after"
        assertThat(
            extract(value),
            equalTo("before")
        )
    }

    object Runtime {
        private
        val local = ThreadLocal<Any?>()

        var value: Any?
            get() = local.get()
            set(value) = local.set(value)
    }

    data class BeanOf<T>(val value: T)

import java.util.Locale;

public class LinePerThreadBufferingOutputStream extends PrintStream {
    private final TextStream handler;
    @SuppressWarnings("ThreadLocalUsage")
    private final ThreadLocal<PrintStream> stream = new ThreadLocal<PrintStream>();
    private final String lineSeparator = System.getProperty("line.separator");
    public LinePerThreadBufferingOutputStream(TextStream handler) {
        super(NullOutputStream.INSTANCE, true);

 * [analyze][org.jetbrains.kotlin.analysis.api.analyze] call.
 */
internal class KaBaseWriteActionStartedChecker(parentDisposable: Disposable) {
    private val currentAnalyzeCallDepth = ThreadLocal.withInitial { 0 }

    init {
        val listener = object : ApplicationListener {
            override fun writeActionFinished(action: Any) {
                if (currentAnalyzeCallDepth.get() > 0) {

    private final Clock clock;
    private final BuildOperationIdFactory buildOperationIdFactory;
    @SuppressWarnings("ThreadLocalUsage")
    private final ThreadLocal<ProgressLoggerImpl> current = new ThreadLocal<ProgressLoggerImpl>();
    private final CurrentBuildOperationRef currentBuildOperationRef = CurrentBuildOperationRef.instance();

import org.jetbrains.kotlin.analysis.api.platform.lifetime.KaLifetimeTracker

internal class KaBaseLifetimeTracker : KaLifetimeTracker {
    private val lifetimeOwnersStack = ThreadLocal.withInitial<PersistentList<KtLifetimeToken>> { persistentListOf() }

    override val currentToken: KtLifetimeToken? get() = lifetimeOwnersStack.get().lastOrNull()

    fun beforeEnteringAnalysis(session: KtAnalysisSession) {

// In addition, the default ThreadLocal constructor requires T to have
// a public default constructor.
//
// An object managed for a thread by a ThreadLocal instance is deleted
// when the thread exits.  Or, if the ThreadLocal instance dies in
// that thread, when the ThreadLocal dies.  It's the user's
// responsibility to ensure that all other threads using a ThreadLocal

   *
   * <p>This class would certainly be simpler and easier to reason about if it were built with
   * ThreadLocal; however, ThreadLocal is not well optimized for the case where the ThreadLocal is
   * non-static, and is initialized/removed frequently - this causes churn in the Thread specific
   * hashmaps. Using a static ThreadLocal to avoid that overhead would mean that different