* Returns the [KtLifetimeToken] for the currently active analysis, or `null` if no analysis is in progress.
     */
    public val currentToken: KtLifetimeToken?

    public companion object {
        public fun getInstance(project: Project): KaLifetimeTracker =
            project.getService(KaLifetimeTracker::class.java)
    }

            modelNode.setPrivateData(Collection.class, values);
        }
    }

    protected abstract C toMutationSafe(Collection<?> backingCollection);

    @Override
    public C getInstance() {
        Collection<?> delegate = getBackingValue();
        if (delegate == null) {
            if (overwritable || state.isCanMutate()) {

public class ICUNormalizer implements Normalizer {
    protected Transliterator transliterator;

    public ICUNormalizer(final String transliteratorId) {
        transliterator = Transliterator.getInstance(transliteratorId);
    }

    @Override
    public String normalize(final String text, final String field, final String... langs) {
        return transliterator.transliterate(text);
    }

    @TestOnly
    override fun incrementModificationTrackers(includeBinaryTrackers: Boolean) {
        KotlinStandaloneModificationTrackerFactory.getInstance(project).incrementModificationsCount(includeBinaryTrackers)
    }

    @Override
    public SSLContext createSslContext() {
        return cache.getUnchecked(getCurrentProperties());
    }

    private static Map<String, String> getCurrentProperties() {
        return SystemProperties.getInstance().withSystemProperties(() -> {
            Map<String, String> currentProperties = new TreeMap<>();
            for (String prop : SSL_SYSTEM_PROPERTIES) {
                currentProperties.put(prop, System.getProperty(prop));

public interface KotlinForeignValueProviderService : KotlinOptionalPlatformComponent {
    public fun getForeignValues(codeFragment: KtCodeFragment): Map<String, String>

    public companion object {
        public fun getInstance(): KotlinForeignValueProviderService? {
            return ApplicationManager.getApplication().getService(KotlinForeignValueProviderService::class.java)
        }
    }

public abstract class KotlinResolutionScopeProvider : KotlinPlatformComponent {
    public abstract fun getResolutionScope(module: KtModule): GlobalSearchScope

    public companion object {
        public fun getInstance(project: Project): KotlinResolutionScopeProvider =
            project.getService(KotlinResolutionScopeProvider::class.java)
    }

 */
public interface KaAnalysisPermissionChecker : KaEngineService {
    public fun isAnalysisAllowed(): Boolean

    public fun getRejectionReason(): String

    public companion object {
        public fun getInstance(project: Project): KaAnalysisPermissionChecker =
            project.getService(KaAnalysisPermissionChecker::class.java)
    }

        return new IvParameterSpec(initVector);
    }

    private Cipher encryptingCipher(SecretKey key, IVCollector collector) throws EncryptionException {
        try {
            Cipher newCipher = Cipher.getInstance(transformation);
            newCipher.init(Cipher.ENCRYPT_MODE, key);
            if (initVectorLength > 0) {
                assert collector != null;
                byte[] iv = newCipher.getIV();

class NoResultsStore<T extends PerformanceTestResult> implements WritableResultsStore<T> {

    private static final INSTANCE = new NoResultsStore()

    static <T extends PerformanceTestResult> WritableResultsStore<T> getInstance() {
        return INSTANCE
    }

    @Override
    void report(T results) {
    }

    @Override
    List<PerformanceExperiment> getPerformanceExperiments() {
        []
    }