* limitations under the License.
 */

package org.gradle.internal.logging.events;

import org.gradle.api.logging.LogLevel;

import javax.annotation.Nullable;

/**
 * Notifies output consumers that might be queueing messages to immediately flush their queues.
 */
public class FlushOutputEvent extends OutputEvent implements InteractiveEvent {
    @Nullable
    @Override
    public LogLevel getLogLevel() {

            try {
                Files.deleteIfExists(cacheDirTag);
            } catch (IOException e1) {
                // logging at warn here so it's more visible to the end-user, who might see the file and assume
                // that it is written properly.
                LOGGER.warn("Failed to delete partial cache directory tag file: " + cacheDirTag, e1);
            }
        }
    }

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        originalReader.accept(pathAndVisitor.right(), ClassReader.EXPAND_FRAMES);

        return writer.toByteArray();
    }

     *
     * @param sourceDescription a description of the source of plugins, where the plugin requested could not be found
     * @param notFoundMessage message on why the plugin couldn't be found (e.g. it might be available by a different version)
     */
    public static PluginResolutionResult notFound(String sourceDescription, String notFoundMessage) {

            """
            myFun {
                a = "x"
                a = b
                b = f(a = "x")
                b = f(a = "x") { test() }
                call(x = { }) // TODO: right now, it is reported as an unsupported language feature FunctionDeclaration, report it in a more precise way?
                multiLambda({ }, { })
                1
                a.b()
                a.x = 1

 *
 * Both have to be serializable, and it's encouraged to use the minimal footprint which allows
 * determining up-to-date status. For example, a SHA1 of a resource might be enough, rather than storing
 * the whole resource itself.
 *
 * @param <IN> a service specific type, representing a query of the service, which can be replayed later

@EventScope(Scope.Build::class)
interface CoupledProjectsListener {
    /**
     * Notified when the build logic for a [referrer] project accesses the mutable state of some other [target] project.
     *
     * The [referrer] and [target] might represent the same project, and the listener implementation
     * should handle this specifically, probably ignoring such calls, as a project is naturally coupled with itself.
     */

    /**
     * Notified when model builders for a {@code consumer} project requests an intermediate model of some other {@code target} project.
     * <p>
     * The {@code consumer} and {@code target} might represent the same project, and the listener implementation
     * should handle this specifically, probably ignoring such calls.
     */
    void onToolingModelDependency(ProjectState consumer, ProjectState target);

----

A new set of publishing tasks are now available called `publish`, and `publishToMavenLocal`.

Similarly, the new tasks from the Maven Publish plugin are now available in IntelliJ in the Gradle right-hand pane.

image::tutorial/intellij-idea-plugin.png[]

== Step 3. Configuring the Plugin
Add the publishing information to your `build.gradle(.kts)` file:

[.multi-language-sample]
=====

                            // The artifact rule report/css/*.css => performanceResultsDir is there to clean up the target directory.
                            // If we don't clean that up there might be leftover json files from other report builds running on the same machine.
                            """