* governing permissions and limitations under the License.
 */
package org.codelibs.fess.crawler.exception;

/**
 * CrawlingAccessException is an exception class that represents an issue encountered while accessing a resource during the crawling process.
 * It extends CrawlerSystemException and provides functionality to set and check the log level for the exception.
 *
 * <p>

 */
public enum LogType {
    /** Indicates the start of a crawling process. */
    START_CRAWLING,
    /** Indicates the cleanup phase of crawling. */
    CLEANUP_CRAWLING,
    /** Indicates an unsupported URL was encountered when crawling started. */
    UNSUPPORTED_URL_AT_CRAWLING_STARTED,
    /** Indicates checking the last modified date of a resource. */
    CHECK_LAST_MODIFIED,
    /** Indicates the resource has not been modified. */

package jcifs.smb1.smb1;

import java.util.Map;

/**
 * Represents a DFS (Distributed File System) referral in SMB1 protocol.
 * This class extends SmbException to provide DFS referral information when a DFS path is encountered.
 */
public class DfsReferral extends SmbException {

    /** Number of characters consumed from the path */
    public int pathConsumed;
    /** Time to live for this referral in seconds */
    public long ttl;

    @Override
    public void endDocument() throws SAXException {
        globalParams.clear();
        tagQueue.clear();
    }

    /**
     * SAX event handler called when an XML start element is encountered.
     * Processes collection definitions and tracks the element hierarchy.
     *
     * @param uri the namespace URI, or empty string if none

    /**
     * A service in this state has completed execution normally. It does minimal work and consumes
     * minimal resources.
     */
    TERMINATED,

    /**
     * A service in this state has encountered a problem and may not be operational. It cannot be
     * started nor stopped.
     */
    FAILED,
  }

  /**

  /**
   * Encapsulates the action to be taken when a potential deadlock is encountered. Clients can use
   * one of the predefined {@link Policies} or specify a custom implementation. Implementations must
   * be thread-safe.
   *
   * @since 13.0
   */
  public interface Policy {

    /**
     * Called when a potential deadlock is encountered. Implementations can throw the given {@code

     * WINS for example. Natrually it is not practical for every NbtAddress
     * to be populated will all state requiring a Node Status on every host
     * encountered. The below methods allow state to be populated when requested
     * in a lazy fashon.
     */

    void checkData(final CIFSContext tc) throws UnknownHostException {
        if (this.hostName.isUnknown()) {

   * calling the function on that value. The resulting multimap is created as an immutable snapshot.
   * In the returned multimap, keys appear in the order they are first encountered, and the values
   * corresponding to each key appear in the same order as they are encountered.
   *
   * <p><b>{@code Stream} equivalent:</b> {@code
   * stream.collect(ImmutableListMultimap.toImmutableListMultimap(keyFunction, v -> v))}.
   *

        /** Connection is established but not ready for RDMA operations */
        CONNECTED,
        /** Connection is fully established and ready for RDMA operations */
        ESTABLISHED,
        /** Connection encountered an error */
        ERROR,
        /** Connection is being closed */
        CLOSING,
        /** Connection is closed */
        CLOSED
    }

    /** Remote endpoint address */

        this(statistics, 3, 1000); // 3 retries with 1 second delay
    }

    /**
     * Handle RDMA connection error and attempt recovery
     *
     * @param connection RDMA connection that encountered error
     * @param error the error that occurred
     * @return true if error was handled and connection recovered, false if fallback needed
     */