* {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by
   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a
   * method propagate untouched, just as we'd typically let it do for a non-reflective call.
   * However, we can't usually write {@code throw t;} when {@code t} has a static type of {@link

   * {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by
   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a
   * method propagate untouched, just as we'd typically let it do for a non-reflective call.
   * However, we can't usually write {@code throw t;} when {@code t} has a static type of {@link

 *   <li>Supports both internal session operations and client-provided trace information</li>
 * </ul>
 *
 * <p>For internal session operations, the trace typically contains {@code *Request} objects
 * that represent the current processing state. Client code can also create traces with
 * application-specific data to provide context when invoking session methods.</p>
 *

   * {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by
   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a
   * method propagate untouched, just as we'd typically let it do for a non-reflective call.
   * However, we can't usually write {@code throw t;} when {@code t} has a static type of {@link

   * {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by
   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a
   * method propagate untouched, just as we'd typically let it do for a non-reflective call.
   * However, we can't usually write {@code throw t;} when {@code t} has a static type of {@link

into a dwelling.  In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage.  For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product.  A product

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

/**
 * Exception thrown when requested content cannot be found.
 * Typically used when a document or resource is not available during crawling or indexing.
 */
public class ContentNotFoundException extends FessSystemException {

    private static final long serialVersionUID = 1L;

    /**

        // Verify that flags are set correctly (DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG)
        // The actual values for DCERPC_FIRST_FRAG and DCERPC_LAST_FRAG are typically 0x01 and 0x02 respectively.
        int expectedFlags = 0x01 | 0x02; // DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG

     */
    default boolean embedded() {
        return parserRequest().embedded();
    }

    /**
     * Returns the current working directory for the Maven execution.
     * This is typically the directory from which Maven was invoked.
     *
     * @return the current working directory path
     */
    @Nonnull
    Path cwd();

    /**
     * Returns the Maven installation directory.

/**
 * The sockets and streams of an HTTP, HTTPS, or HTTPS+HTTP/2 connection. May be used for multiple
 * HTTP request/response exchanges. Connections may be direct to the origin server or via a proxy.
 *
 * Typically instances of this class are created, connected and exercised automatically by the HTTP
 * client. Applications may use this class to monitor HTTP connections as members of a
 * [connection pool][ConnectionPool].
 *