package org.gradle.sample.plugin;

import java.io.Serializable;
import java.lang.String;
import java.util.List;
import java.util.Arrays;

/**
 * This is the implementation of the custom tooling model. It must be serializable and must have methods and properties that
 * are compatible with the custom tooling model interface. It may or may not implement the custom tooling model interface.
 */
public class DefaultModel implements Serializable {

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Implementation classes for the Gradle platform plugin.
 *
 * @see org.gradle.api.plugins.catalog.VersionCatalogPlugin
 */
@NonNullApi
package org.gradle.api.plugins.catalog.internal;

public abstract class Actions {

    static final Action<?> DO_NOTHING = new NullAction<Object>();

    /**
     * Creates an action implementation that simply does nothing.
     *
     * A new action instance is created each time.
     *
     * @return An action object with an empty implementation
     */
    @SuppressWarnings("unchecked")
    public static <T> Action<T> doNothing() {
        return (Action<T>) DO_NOTHING;
    }

                buildScriptBuilder.plugin(null, applicationConventionPlugin());
                buildScriptBuilder.dependencies().dependency("implementation", null, BuildInitDependency.of("org.apache.commons:commons-text"));
                buildScriptBuilder.dependencies().projectDependency("implementation", null, ":utilities");
            } else {
                buildScriptBuilder.plugin(null, libraryConventionPlugin());

  }

  /**
   * Returns the platform preferred map implementation that preserves insertion order when used only
   * for insertions.
   */
  static <K, V> Map<K, V> preservesInsertionOrderOnPutsMap() {
    return Maps.newLinkedHashMap();
  }

  /**
   * Returns the platform preferred set implementation that preserves insertion order when used only
   * for insertions.
   */

 * interface in order to add the proper getter methods? What about the concrete feature class which implements
 * that new interface? Does it extend the default implementation class? Is there a way we can avoid
 * Java inheritance?</p>
 *
 * Even though the single implementation of this interface also implements {@link org.gradle.api.component.AdhocComponentWithVariants},
 * we do not want to extend that interface here, as it is slated for removal.

/**
 * An implementation of a Groovy MetaClass that is instrumented and might need to cancel some optimizations
 * in order to get the instrumentation to work properly.
 */
public interface InstrumentedMetaClass {
    /**
     * Checks if accessing a property by the specified name would be intercepted by the instrumentation at this
     * specific moment. The implementation may return different values at different times.

import org.gradle.api.file.FileVisitor;
import org.gradle.api.internal.file.FileTreeInternal;
import org.gradle.api.tasks.util.PatternSet;

import java.io.File;

/**
 * A minimal file tree implementation. An implementation can optionally also implement the following interfaces:
 *
 * <ul>
 *  <li>{@link FileSystemMirroringFileTree}</li>
 *  <li>{@link LocalFileTree}</li>
 *  <li>{@link PatternFilterableFileTree}</li>
 * </ul>

    MavenFailOnSeverityLogger(String name, LogLevelRecorder logLevelRecorder) {
        super(name);
        this.logLevelRecorder = logLevelRecorder;
    }

    /**
     * A simple implementation which always logs messages of level WARN
     * according to the format outlined above.
     */
    @Override
    public void warn(String msg) {
        super.warn(msg);
        logLevelRecorder.record(Level.WARN);

        if (!problemId.getGroup().equals(GradleCoreProblemGroup.validation().property())) {
            return false;
        } else {
            List<String> candidates = Arrays.asList("unknown-implementation", "unknown-implementation-nested", "implicit-dependency");
            return candidates.contains(problemId.getName());
        }
    }