private final ArrayBlockingQueue<Exchange> eventQueue;

    /**
     * Constructor that makes passed in delegate run on single thread, and will block on last event.
     */
    public SimplexTransferListener(TransferListener delegate) {
        this(delegate, QUEUE_SIZE, BATCH_MAX_SIZE, true);
    }

    /**
     * Constructor that may alter behaviour of this listener.
     *

import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.lexer.KtKeywordToken

public class KaKeywordsRenderer private constructor(
    public val keywordRenderer: KaKeywordRenderer,
    public val keywordFilter: KaRendererKeywordFilter,
) {

import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.platform.TargetPlatform

public class KotlinCompositePackageProvider private constructor(
    override val providers: List<KotlinPackageProvider>,
) : KotlinPackageProvider(), KotlinCompositeProvider<KotlinPackageProvider> {
    override fun doesPackageExist(packageFqName: FqName, platform: TargetPlatform): Boolean {

import org.gradle.internal.service.scopes.ServiceScope


/**
 * Holds the list of imports implicitly added to every Kotlin build script.
 */
@ServiceScope(Scope.Global::class)
class ImplicitImports internal constructor(
    @Transient
    private val importsReader: ImportsReader
) {

    val list by lazy {
        gradleImports() + gradleKotlinDslImports()
    }

    private
    fun gradleImports() =

import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
import org.jetbrains.kotlin.name.ClassId

internal class KaFirAnnotationListForReceiverParameter private constructor(
    private val firCallableSymbol: FirCallableSymbol<*>,
    private val receiverParameter: FirAnnotationContainer,
    private val builder: KaSymbolByFirBuilder,
) : AbstractList<KaAnnotation>(), KaAnnotationList {

import org.jetbrains.kotlin.utils.addToStdlib.partitionIsInstance

/**
 * With each call to [merge], [SublistMerger] can merge all elements of a specific (reified) type into a single element using a supplied
 * constructor and then add it to [destination]. Unmerged elements are added to [destination] using [finish].
 *
 * The purpose of [SublistMerger] is to merge multiple different types of elements from a single origin list without the need for

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
      LiftQuantizableSpotsAsFunctionsDRQPass)

  // Constructor used by the PassRegistration. This is only used by test.
  explicit LiftQuantizableSpotsAsFunctionsDRQPass() = default;

  // Constructor used by manually creating the pass.
  explicit LiftQuantizableSpotsAsFunctionsDRQPass(
      const QuantMethod quantization_method, const OpSet target_opset,

 *
 * @since 8.8
 */
@DisableCachingByDefault(because = "Not worth caching")
@Incubating
public abstract class UpdateDaemonJvm extends DefaultTask {
    /**
     * Constructor.
     *
     * @since 8.8
     */
    @Inject
    public UpdateDaemonJvm() {

    }

    @TaskAction
    void generate() {
        IncubationLogger.incubatingFeatureUsed("Daemon JVM criteria");

    }
    return analysisSession.substitutorFactory.buildSubstitutor(KaSubstitutorBuilder(token).apply(build))
}


public class KaSubstitutorBuilder
@KaAnalysisApiInternals constructor(override val token: KaLifetimeToken) : KaLifetimeOwner {
    private val backingMapping = mutableMapOf<KaTypeParameterSymbol, KaType>()

 *
 * @deprecated Maven 3 compatability - please use {@link MetadataStaxWriter}
 */
@Deprecated
public class MetadataXpp3Writer {

    private final MetadataStaxWriter delegate;

    /**
     * Default constructor
     */
    public MetadataXpp3Writer() {
        delegate = new MetadataStaxWriter();
    }

    /**
     * Method setFileComment.
     *
     * @param fileComment a fileComment object.
     */