* limitations under the License.
 */

package org.gradle.internal.serialize;

import com.google.common.base.Objects;

/**
 * This abstract class provide a sensible default implementation for {@code Serializer} equality. This equality
 * implementation is required to enable cache instance reuse within the same Gradle runtime. Serializers are used
 * as cache parameter which need to be compared to determine compatible cache.
 */

    return LexicographicalComparatorHolder.PureJavaComparator.INSTANCE;
  }

  /**
   * Provides a lexicographical comparator implementation; either a Java implementation or a faster
   * implementation based on {@link Unsafe}.
   *
   * <p>Uses reflection to gracefully fall back to the Java implementation if {@code Unsafe} isn't
   * available.
   */
  @VisibleForTesting
  static class LexicographicalComparatorHolder {

     *
     * @return a dependency factory
     * @implSpec Do not implement this method. Gradle generates the implementation automatically.
     *
     * @see DependencyFactory
     */
    @Inject
    protected abstract DependencyFactory getDependencyFactory();

    /**

    public ListProperty<PluginDeclaration> getDeclarations() {
        return declarations;
    }

    /**
     * Returns all {@code (id, implementation class)} pairs from {@link #getDeclarations()}.
     * <p>
     * This map is the only input needed from the plugin declarations to create the plugin descriptors.
     */
    @Input

    }

    @Override
    public boolean hasLocation(Location location) {
        if (hasEmptySourcePaths) {
            // There is currently a requirement in the JDK9 javac implementation
            // that when javac is invoked with an explicitly empty sourcepath
            // (i.e. {@code --sourcepath ""}), it won't allow you to compile a java 9

 *
 * <p>This uses the same efficient implementation as {@link Ordering#leastOf(Iterable, int)},
 * offering expected O(n + k log k) performance (worst case O(n log k)) for n calls to {@link
 * #offer} and a call to {@link #topK}, with O(k) memory. In comparison, quickselect has the same
 * asymptotics but requires O(n) memory, and a {@code PriorityQueue} implementation takes O(n log

        super(names, objectFactory, baseName, sourceFiles, componentHeaderDirs, configurations, implementation, targetPlatform, toolChain, platformToolProvider, identity);

 * the base class for all provider (and property) implementations.</p>
 *
 * <h3>Lazy properties</h3>
 *
 * <p>For the public API, see {@link org.gradle.api.provider.Property Property}.</p>
 *
 * <p>For the base internal implementation, see {@link org.gradle.api.internal.provider.AbstractProperty}.</p>
 *

        throw new UnsupportedOperationException("This operation is not supported by this implementation");
    }

    @Override
    public void addClassRule(SpecConfigurableRule ruleAction) {
        throw new UnsupportedOperationException("This operation is not supported by this implementation");
    }

    @Override
    public SpecRuleAction<? super ComponentMetadataDetails> getRule() {

    }

    public void blankLine() {
        node("");
    }

    /**
     * Starts a new node with the given type name.
     */
    public TreeFormatter node(Class<?> type) {
        // Implementation is currently dumb, can be made smarter
        if (type.isInterface()) {
            node("Interface ");
        } else {
            node("Class ");
        }
        appendType(type);
        return this;