import java.util.logging.Level;
import org.jspecify.annotations.Nullable;

/**
 * A support class for {@code ListenableFuture} implementations to manage their listeners. An
 * instance contains a list of listeners, each with an associated {@code Executor}, and guarantees
 * that every {@code Runnable} that is {@linkplain #add added} will be executed after {@link
 * #execute()} is called. Any {@code Runnable} added after the call to {@code execute} is still

     * @return The query class name.
     */
    protected abstract String getQueryClassName();

    /**
     * Registers this query command with the query processor.
     * Associates this command with its query class name in the processor.
     */
    public void register() {
        ComponentUtil.getQueryProcessor().add(getQueryClassName(), this);
    }

    /**

import java.util.concurrent.RejectedExecutionException;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * A {@link Future} that accepts completion listeners. Each listener has an associated executor, and
 * it is invoked using this executor once the future's computation is {@linkplain Future#isDone()
 * complete}. If the computation has already completed when the listener is added, the listener will

import java.util.concurrent.RejectedExecutionException;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * A {@link Future} that accepts completion listeners. Each listener has an associated executor, and
 * it is invoked using this executor once the future's computation is {@linkplain Future#isDone()
 * complete}. If the computation has already completed when the listener is added, the listener will

    /**
     * @return the {@link LockGraphNode} associated with this lock.
     */
    LockGraphNode getLockGraphNode();

    /**
     * @return {@code true} if the current thread has acquired this lock.
     */
    boolean isAcquiredByCurrentThread();
  }

  /**
   * A {@code LockGraphNode} associated with each lock instance keeps track of the directed edges in

        }
        return null;
    }

    /**
     * Retrieves tags associated with an object in the specified bucket.
     * @param bucketName the name of the bucket containing the object
     * @param path the path to the object within the bucket
     * @return the tags associated with the object, or null if no tags exist or object not found
     */

            The important difference is this will not resolve the files for the dependencies, i.e. the artifacts
            associated with a Maven project can lack a file. As such, this annotation is meant for Mojos that only
            want to analyze the set of transitive dependencies, in particular during early lifecycle phases where

import java.nio.charset.Charset;

import jcifs.smb1.Config;
import jcifs.smb1.util.Hexdump;

/**
 * NetBIOS name representation for SMB1 protocol.
 * This class represents a NetBIOS name with its associated type and scope.
 */
public class Name {

    private static final int TYPE_OFFSET = 31;
    private static final int SCOPE_OFFSET = 33;

            for (PluginExecution execution : plugin.getExecutions()) {
                // if the phase is specified then I don't have to go fetch the plugin yet and pull it down
                // to examine the phase it is associated to.
                String phase = execution.getPhase();
                if (aliases.containsKey(phase)) {
                    phase = aliases.get(phase);
                }
                if (phase != null) {

          return optional.orNull();
        }
      };

  /**
   * Sets.cartesianProduct doesn't allow sets that contain null, but we want null to mean "don't
   * call the associated CacheBuilder method" - that is, get the default CacheBuilder behavior. This
   * method wraps the elements in the input sets (which may contain null) as Optionals, calls