Arg<TF_StrTensor, [{shape {N}.  The names of the tensors to be restored. This is tensor name in the model.}]>:$tensor_names,
    Arg<TF_StrTensor, [{shape {N}.  The slice specs of the tensors to be restored.
Empty strings indicate that they are non-partitioned tensors.}]>:$shape_and_slices,
    // VarHandles for restored tensors.
    Variadic<TF_Tensor>:$var_handles,
    // Data types for restored tensor.
    TypeArrayAttr: $restored_dtypes,

        when:
        def normalization = new DefaultRuntimeClasspathNormalization()
        then:
        normalization.computeCachedState() == null
    }

    def "file ignores can be restored from the cached state"() {
        given:
        def originalNormalization = new DefaultRuntimeClasspathNormalization()
        originalNormalization.ignore(ignoredPattern)

        when:

         */
        <T> Action<T> reapplyLater(Action<T> action);

        /**
         * Runs an action that represents some deferred execution of the user code. While the action is running, the details of this application are restored.
         */
        void reapply(Runnable runnable);

        /**

            appendLine()
            appendLine("Restored in ${restoreAtModule.moduleDescription}:")
            appendLine(prettyRenderedRestored ?: NOT_RESTORED)
        }
        testServices.assertions.assertEqualsToTestDataFileSibling(actualPretty, extension = ".pretty.txt")
    }

    companion object {
        private const val NOT_RESTORED = "<NOT RESTORED>"
    }

 *
 * The class can operate in two modes. First is the tracking mode when all environment-modifying operations are stored
 * and the list of the operations can be retrieved as the CachedEnvironmentState object. This mode is intended for the
 * builds with the configuration phase. The second mode applies the restored state to the environment and doesn't

 * To pass the symbol from one read action to another the KtSymbolPointer should be used
 *
 * We can restore the symbol
 *  * for symbol which came from Kotlin source it will be restored based on [com.intellij.psi.SmartPsiElementPointer]
 *  * restoring symbols which came from Java source is not supported yet
 *  * for library symbols:
 *    * for function & property symbol if its signature was not changed

        return CompiledLanguage.JAVA
    }

    @Override
    def setup() {
        buildFile << """
            ${mavenCentralRepository()}
        """
    }

    def "incremental state is restored from the build cache"() {
        source("class A {}", "class B {}")
        withBuildCache().run language.compileTaskName
        def cachedBuild = outputs.snapshot {

        },
```

When a transitioned object is restored temporarily to local MinIO instance via PostRestoreObject API, the object data is copied back from the remote tier, and additional metadata for the restored object is maintained as referenced below. Once the restore period expires, the local copy of the object is removed by the scanner during its periodic runs.

	-w
		Do not print reformatted sources to standard output.
		If a file's formatting is different from gofmt's, overwrite it
		with gofmt's version. If an error occurred during overwriting,
		the original file is restored from an automatic backup.

Debugging support:

	-cpuprofile filename
		Write cpu profile to the specified file.

The rewrite rule specified with the -r flag must be a string of the form:

 * limitations under the License.
 */

package org.gradle.internal.logging.config;

/**
 * Some configurable logging system, whose state can be snapshot, mutated and restored.
 */
public interface LoggingSystem {
    /**
     * Snapshots the current configuration state of this logging system.
     */
    Snapshot snapshot();

    /**