public void configure(CommandLineParser parser) {
        for (BooleanCommandLineOptionConfiguration config : commandLineOptionConfigurations) {
            configureCommandLineOption(parser, new String[] {config.getLongOption()}, config.getDescription(), config.isDeprecated(), config.isIncubating());
            String disabledOption = getDisabledCommandLineOption(config);

        }
    }

    @Override
    public void configure(CommandLineParser parser) {
        for (CommandLineOptionConfiguration config : commandLineOptionConfigurations) {
            configureCommandLineOption(parser, config.getAllOptions(), config.getDescription(), config.isDeprecated(), config.isIncubating()).hasArgument();
        }
    }

    @Override

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.api.internal;

/**
 * A marker interface for rules which can be safely reused because they are either
 * stateless, or effectively immutable. Ideally this should be inferred, which is
 * why the interface is internal.
 */
public interface ReusableAction {

package org.gradle.model.dsl.internal.transform;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Marker annotation attached to rule block closures at compile time to indicate they have been transformed.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface RulesBlock {

 */
public interface BuildOption<T> extends Option {

    @Nullable
    String getProperty();

    void applyFromProperty(Map<String, String> properties, T settings);

    void configure(CommandLineParser parser);

    void applyFromCommandLine(ParsedCommandLine options, T settings);

    String getDeprecatedProperty();

package org.gradle.internal.cc.impl

import org.gradle.api.internal.DocumentationRegistry
import org.gradle.internal.exceptions.Contextual
import org.gradle.internal.exceptions.DefaultMultiCauseException


/**
 * Marker interface for exception handling.
 */
internal
interface ConfigurationCacheThrowable


/**
 * State might be corrupted and should be discarded.
 */
@Contextual

    val documentationSection: DocumentationSection? = null
)


data class DecoratedFailure(
    val summary: StructuredMessage?,
    val parts: List<StackTracePart>?
) {
    companion object {
        val MARKER = DecoratedFailure(null, null)
    }
}


data class StackTracePart(
    val isInternal: Boolean,
    val text: String
)


class FailureDecorator {

    private

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.model;

import org.gradle.api.Incubating;

/**
 * A marker type for a class that is a collection of rules.
 * <p>
 * A rule source is not used like a regular Java object.
 * It is a stateless container of methods and possibly constants.
 * <p>

 * A successful {@literal PUT} request must return any 2xx response.
 * <p>
 * {@literal PUT} requests may also return a {@literal 413 Payload Too Large} response to indicate that the payload is larger than can be accepted.
 * This is useful when {@link #isUseExpectContinue()} is enabled.
 * <p>
 * Redirecting responses may be issued with {@literal 301}, {@literal 302}, {@literal 303}, {@literal 307} or {@literal 308} responses.

    }

    private
    fun assertParserConsumes(parser: Parser<Any>, input: String) {
        val whitespace = "   "
        assertThat(
            parser.consumeFrom(input + whitespace + "something more"),
            equalTo(input)
        )

        assertThat(
            parser.consumeFrom(input + "\nsomething"),
            equalTo(input)
        )
    }
}