*/

package org.gradle.internal.snapshot;

import java.nio.file.Path;

public interface SnapshottingFilter {
    SnapshottingFilter EMPTY = new SnapshottingFilter() {
        @Override
        public boolean isEmpty() {
            return true;
        }

        @Override
        public FileSystemSnapshotPredicate getAsSnapshotPredicate() {
            return (location, relativePath) -> true;
        }

        @Override

    }

    public int getColumnNumber() {
        return columnNumber;
    }

    public String getLocation() {
        StringBuilder buffer = new StringBuilder(256);

        if (!getSource().isEmpty()) {
            if (buffer.length() > 0) {
                buffer.append(", ");
            }
            buffer.append(getSource());
        }

        if (getLineNumber() > 0) {

            if (!getters.isEmpty() && !setters.isEmpty()) {
                return new Accessors(owningClass, propertyName, getters, setters);
            }
            List<Accessor> superclassAccessors = findAccessors(owningClass.getAllMethods()).get(propertyName);
            if (superclassAccessors == null) {
                return null;
            }
            if (!setters.isEmpty()) {

            if (scopeToCollect != null && !scopeToCollect.isEmpty()) {
                scopesToCollect.add(scopeToCollect);
            }

            String scopeToResolve = mojoDescriptor.getDependencyResolutionRequired();
            if (scopeToResolve != null && !scopeToResolve.isEmpty()) {
                scopesToResolve.add(scopeToResolve);
            }
        }

      assertTrue(Thread.holdsLock(mutex));
      return delegate.removeAll(collection);
    }

    @Override
    public boolean isEmpty() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.isEmpty();
    }

    @Override
    public boolean contains(Object object) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.contains(object);
    }

                if (dependency.getGroupId() == null
                        || dependency.getGroupId().isEmpty()
                        || dependency.getArtifactId() == null
                        || dependency.getArtifactId().isEmpty()
                        || dependency.getVersion() == null
                        || dependency.getVersion().isEmpty()) {
                    // guard against case where best-effort resolution for invalid models is requested

     *
     * @return The identifier of the POM or an empty string if not known, never {@code null}.
     */
    public String getModelId() {
        if (result == null || result.getModelIds().isEmpty()) {
            return "";
        }
        return result.getModelIds().get(0);
    }

    /**
     * Gets the problems that caused this exception.
     *

                                problem.getColumnNumber() > 0 ? "column " + problem.getColumnNumber() : "")
                        .filter(s -> !s.isEmpty())
                        .collect(Collectors.joining(", "));
                if (!loc.isEmpty()) {
                    sb.append(" @ ").append(loc);
                }
            }
            return sb.toString();
        }
        return null;
    }

      }
    }

    Optional<Object> getOptional() {
      if (extras.isEmpty()) {
        return Optional.ofNullable(element);
      } else {
        throw multiples(false);
      }
    }

    Object getElement() {
      if (element == null) {
        throw new NoSuchElementException();
      } else if (extras.isEmpty()) {
        return element;
      } else {
        throw multiples(false);

            if (!queuedNodes.isEmpty()) {
                formatter.node("Waiting for nodes");
                formatter.startChildren();
                for (String item : queuedNodes) {
                    formatter.node(item);
                }
                formatter.endChildren();
            }
            if (!readyToStartNodes.isEmpty()) {
                formatter.node("Nodes ready to start");