@Override
    boolean isInInitialState();

    /**
     * Called after an update is complete, returns a new clean state based on this state.
     */
    LockState completeUpdate();

    /**
     * Called before an update is complete, returns a new dirty state based on this state.
     */
    LockState beforeUpdate();

    /**
     * Adds a content filter based on the provided closure.  The Closure will be called with each line (stripped of line
     * endings) and should return a String to replace the line or {@code null} to remove the line.  If every line is
     * removed, the result will be an empty file, not an absent one.
     *
     * @param closure to implement line based filtering
     * @return this
     */

# GraphQL

As **FastAPI** is based on the **ASGI** standard, it's very easy to integrate any **GraphQL** library also compatible with ASGI.

You can combine normal FastAPI *path operations* with GraphQL on the same application.

!!! tip
    **GraphQL** solves some very specific use cases.

    It has **advantages** and **disadvantages** when compared to common **web APIs**.

  let summary = "Add remarks based on resource alias analysis result, for "
    "testing purpose.";
  let constructor = "::mlir::tf_test::CreateTestResourceAliasAnalysisPass()";
}

def TestClusteringPolicyPass : Pass<"tf-test-clustering-policy", "mlir::func::FuncOp"> {
  let summary = "Test pass for clustering based on the user defined policy";

    /**
     * Creates a [KaSubstitutor] based on the inheritance relationship between [subClass] and [superClass].
     *
     * The semantic of resulted [KaSubstitutor] is the substitutor that should be applied to a member of [superClass],
     * so it can be called on an instance of [subClass].
     *
     * Basically, it's a composition of inheritance-based substitutions for all the inheritance chain.
     *

import org.apache.maven.plugin.MojoExecution;
import org.apache.maven.project.MavenProject;

/**
 * <p>
 * A MojoExecutionConfigurator is responsible for creating the configuration for Mojo based on configuration for a Mojo
 * in the MavenProject and the default configuration for the Mojo from the containing plugin's plugin.xml descriptor.
 * </p>

        protected String getPropertyOptionDescription() {
            return "Test Description of a test property based option"
        }
    }

    def convert(String... args) {
        converter.convert(Arrays.asList(args), new HashMap<String, String>()).sort()
    }

    def "configures property based options"() {
        def parser = Mock(CommandLineParser);
        def option = Mock(CommandLineOption);
        setup:

     * @param severity The severity of the problem, must not be {@code null}.
     * @param message The detail message of the problem, may be {@code null}.
     * @param line The one-based index of the line containing the problem or {@code -1} if unknown.
     * @param column The one-based index of the column containing the problem or {@code -1} if unknown.
     * @param cause The cause of the problem, may be {@code null}.
     */

import org.apache.maven.api.services.MavenException;

@Experimental
public class ModelParserException extends MavenException {

    /**
     * The one-based index of the line containing the error.
     */
    private final int lineNumber;

    /**
     * The one-based index of the column containing the error.
     */
    private final int columnNumber;

    public ModelParserException() {
        this(null, null);
    }

@startuml
!include lib/C4_Container.puml

LAYOUT_TOP_DOWN

title Container diagram for the Gradle Kotlin DSL

Person(dev, "Developer", "Developer using a Kotlin DSL based Gradle build")

System_Boundary(gradleBuildTool, "Gradle") {

    System_Ext(gradle, "Gradle Build Tool", "The Gradle Build Tool")

    System_Boundary(gradleKotlinDsl, "Gradle Kotlin DSL") {