* Instances of {@code JobStateReason} do not appear in a Print Job's attribute * set directly. Rather, a {@link JobStateReasons JobStateReasons} attribute * appears in the Print Job's attribute set. The * {@link JobStateReasons JobStateReasons} attribute contains zero, one, or more * than one {@code JobStateReason} objects which pertain to the Print Job's * status. The printer adds a JobStateReason object to the Print Job's * {@link JobStateReasons JobStateReasons} attribute when the corresponding * condition becomes true of the Print Job, and the printer removes the * {@code JobStateReason} object again when the corresponding condition becomes * false, regardless of whether the Print Job's overall * {@link JobState JobState} also changed. *
* IPP Compatibility: The category name returned by {@code getName()} is * the IPP attribute name. The enumeration's integer value is the IPP enum * value. The {@code toString()} method returns the IPP string representation of * the attribute value. * * @author Alan Kaminsky */ public class JobStateReason extends EnumSyntax implements Attribute { /** * Use serialVersionUID from JDK 1.4 for interoperability. */ private static final long serialVersionUID = -8765894420449009168L; /** * The printer has created the Print Job, but the printer has not finished * accessing or accepting all the print data yet. */ public static final JobStateReason JOB_INCOMING = new JobStateReason(0); /** * The printer has created the Print Job, but the printer is expecting * additional print data before it can move the job into the * {@code PROCESSING} state. If a printer starts processing before it has * received all data, the printer removes the {@code JOB_DATA_INSUFFICIENT} * reason, but the {@code JOB_INCOMING} reason remains. If a printer starts * processing after it has received all data, the printer removes the * {@code JOB_DATA_INSUFFICIENT} and {@code JOB_INCOMING} reasons at the * same time. */ public static final JobStateReason JOB_DATA_INSUFFICIENT = new JobStateReason(1); /** * The printer could not access one or more documents passed by reference * (i.e., the print data representation object is a {@code URL}). This * reason is intended to cover any file access problem,including file does * not exist and access denied because of an access control problem. Whether * the printer aborts the job and moves the job to the {@code ABORTED} job * state or prints all documents that are accessible and moves the job to * the {@code COMPLETED} job state and adds the * {@code COMPLETED_WITH_ERRORS} reason to the job's * {@link JobStateReasons JobStateReasons} attribute depends on * implementation and/or site policy. This value should be supported if the * printer supports doc flavors with {@code URL} print data representation * objects. */ public static final JobStateReason DOCUMENT_ACCESS_ERROR = new JobStateReason(2); /** * The job was not completely submitted for some unforeseen reason. * Possibilities include (1) the printer has crashed before the job was * fully submitted by the client, (2) the printer or the document transfer * method has crashed in some non-recoverable way before the document data * was entirely transferred to the printer, (3) the client crashed before * the job was fully submitted. */ public static final JobStateReason SUBMISSION_INTERRUPTED = new JobStateReason(3); /** * The printer is transmitting the job to the output device. */ public static final JobStateReason JOB_OUTGOING = new JobStateReason(4); /** * The value of the job's {@link JobHoldUntil JobHoldUntil} attribute was * specified with a date-time that is still in the future. The job must not * be a candidate for processing until this reason is removed and there are * no other reasons to hold the job. This value should be supported if the * {@link JobHoldUntil JobHoldUntil} job template attribute is supported. */ public static final JobStateReason JOB_HOLD_UNTIL_SPECIFIED = new JobStateReason(5); /** * At least one of the resources needed by the job, such as media, fonts, * resource objects, etc., is not ready on any of the physical printers for * which the job is a candidate. This condition may be detected when the job * is accepted, or subsequently while the job is pending or processing, * depending on implementation. The job may remain in its current state or * be moved to the {@code PENDING_HELD} state, depending on implementation * and/or job scheduling policy. */ public static final JobStateReason RESOURCES_ARE_NOT_READY = new JobStateReason(6); /** * The value of the printer's {@link PrinterStateReasons * PrinterStateReasons} attribute contains a * {@link PrinterStateReason PrinterStateReason} value of * {@code STOPPED_PARTLY}. */ public static final JobStateReason PRINTER_STOPPED_PARTLY = new JobStateReason(7); /** * The value of the printer's {@link PrinterState PrinterState} attribute ia * {@code STOPPED}. */ public static final JobStateReason PRINTER_STOPPED = new JobStateReason(8); /** * The job is in the {@code PROCESSING} state, but more specifically, the * printer ia interpreting the document data. */ public static final JobStateReason JOB_INTERPRETING = new JobStateReason(9); /** * The job is in the {@code PROCESSING} state, but more specifically, the * printer has queued the document data. */ public static final JobStateReason JOB_QUEUED = new JobStateReason(10); /** * The job is in the {@code PROCESSING} state, but more specifically, the * printer is interpreting document data and producing another electronic * representation. */ public static final JobStateReason JOB_TRANSFORMING = new JobStateReason(11); /** * The job is in the {@code PENDING_HELD}, {@code PENDING}, or * {@code PROCESSING} state, but more specifically, the printer has * completed enough processing of the document to be able to start marking * and the job is waiting for the marker. Systems that require human * intervention to release jobs put the job into the {@code PENDING_HELD} * job state. Systems that automatically select a job to use the marker put * the job into the {@code PENDING} job state or keep the job in the * {@code PROCESSING} job state while waiting for the marker, depending on * implementation. All implementations put the job into (or back into) the * {@code PROCESSING} state when marking does begin. */ public static final JobStateReason JOB_QUEUED_FOR_MARKER = new JobStateReason(12); /** * The output device is marking media. This value is useful for printers * which spend a great deal of time processing (1) when no marking is * happening and then want to show that marking is now happening or (2) when * the job is in the process of being canceled or aborted while the job * remains in the {@code PROCESSING} state, but the marking has not yet * stopped so that impression or sheet counts are still increasing for the * job. */ public static final JobStateReason JOB_PRINTING = new JobStateReason(13); /** * The job was canceled by the owner of the job, i.e., by a user whose * authenticated identity is the same as the value of the originating user * that created the Print Job, or by some other authorized end-user, such as * a member of the job owner's security group. This value should be * supported. */ public static final JobStateReason JOB_CANCELED_BY_USER = new JobStateReason(14); /** * The job was canceled by the operator, i.e., by a user who has been * authenticated as having operator privileges (whether local or remote). If * the security policy is to allow anyone to cancel anyone's job, then this * value may be used when the job is canceled by someone other than the * owner of the job. For such a security policy, in effect, everyone is an * operator as far as canceling jobs is concerned. This value should be * supported if the implementation permits canceling by someone other than * the owner of the job. */ public static final JobStateReason JOB_CANCELED_BY_OPERATOR = new JobStateReason(15); /** * The job was canceled by an unidentified local user, i.e., a user at a * console at the device. This value should be supported if the * implementation supports canceling jobs at the console. */ public static final JobStateReason JOB_CANCELED_AT_DEVICE = new JobStateReason(16); /** * The job was aborted by the system. Either the job (1) is in the process * of being aborted, (2) has been aborted by the system and placed in the * {@code ABORTED} state, or (3) has been aborted by the system and placed * in the {@code PENDING_HELD} state, so that a user or operator can * manually try the job again. This value should be supported. */ public static final JobStateReason ABORTED_BY_SYSTEM = new JobStateReason(17); /** * The job was aborted by the system because the printer determined while * attempting to decompress the document's data that the compression is * actually not among those supported by the printer. This value must be * supported, since {@link Compression Compression} is a required doc * description attribute. */ public static final JobStateReason UNSUPPORTED_COMPRESSION = new JobStateReason(18); /** * The job was aborted by the system because the printer encountered an * error in the document data while decompressing it. If the printer posts * this reason, the document data has already passed any tests that would * have led to the {@code UNSUPPORTED_COMPRESSION} job state reason. */ public static final JobStateReason COMPRESSION_ERROR = new JobStateReason(19); /** * The job was aborted by the system because the document data's document * format (doc flavor) is not among those supported by the printer. If the * client specifies a doc flavor with a MIME type of * {@code "application/octet-stream"}, the printer may abort the job if the * printer cannot determine the document data's actual format through * auto-sensing (even if the printer supports the document format if * specified explicitly). This value must be supported, since a doc flavor * is required to be specified for each doc. */ public static final JobStateReason UNSUPPORTED_DOCUMENT_FORMAT = new JobStateReason(20); /** * The job was aborted by the system because the printer encountered an * error in the document data while processing it. If the printer posts this * reason, the document data has already passed any tests that would have * led to the {@code UNSUPPORTED_DOCUMENT_FORMAT} job state reason. */ public static final JobStateReason DOCUMENT_FORMAT_ERROR = new JobStateReason(21); /** * The requester has canceled the job or the printer has aborted the job, * but the printer is still performing some actions on the job until a * specified stop point occurs or job termination/cleanup is completed. *
* If the implementation requires some measurable time to cancel the job in * the {@code PROCESSING} or {@code PROCESSING_STOPPED} job states, the * printer must use this reason to indicate that the printer is still * performing some actions on the job while the job remains in the * {@code PROCESSING} or {@code PROCESSING_STOPPED} state. After all the * job's job description attributes have stopped incrementing, the printer * moves the job from the PROCESSING state to the {@code CANCELED} or * {@code ABORTED} job states. */ public static final JobStateReason PROCESSING_TO_STOP_POINT = new JobStateReason(22); /** * The printer is off-line and accepting no jobs. All {@code PENDING} jobs * are put into the {@code PENDING_HELD} state. This situation could be true * if the service's or document transform's input is impaired or broken. */ public static final JobStateReason SERVICE_OFF_LINE = new JobStateReason(23); /** * The job completed successfully. This value should be supported. */ public static final JobStateReason JOB_COMPLETED_SUCCESSFULLY = new JobStateReason(24); /** * The job completed with warnings. This value should be supported if the * implementation detects warnings. */ public static final JobStateReason JOB_COMPLETED_WITH_WARNINGS = new JobStateReason(25); /** * The job completed with errors (and possibly warnings too). This value * should be supported if the implementation detects errors. */ public static final JobStateReason JOB_COMPLETED_WITH_ERRORS = new JobStateReason(26); /** * This job is retained and is currently able to be restarted. If * {@code JOB_RESTARTABLE} is contained in the job's * {@link JobStateReasons JobStateReasons} attribute, then the printer must * accept a request to restart that job. This value should be supported if * restarting jobs is supported. [The capability for restarting jobs is * not in the Java Print Service API at present.] */ public static final JobStateReason JOB_RESTARTABLE = new JobStateReason(27); /** * The job has been forwarded to a device or print system that is unable to * send back status. The printer sets the job's {@link JobState JobState} * attribute to {@code COMPLETED} and adds the {@code QUEUED_IN_DEVICE} * reason to the job's {@link JobStateReasons JobStateReasons} attribute to * indicate that the printer has no additional information about the job and * never will have any better information. */ public static final JobStateReason QUEUED_IN_DEVICE = new JobStateReason(28); /** * Construct a new job state reason enumeration value with the given integer * value. * * @param value Integer value */ protected JobStateReason(int value) { super (value); } /** * The string table for class {@code JobStateReason}. */ private static final String[] myStringTable = { "job-incoming", "job-data-insufficient", "document-access-error", "submission-interrupted", "job-outgoing", "job-hold-until-specified", "resources-are-not-ready", "printer-stopped-partly", "printer-stopped", "job-interpreting", "job-queued", "job-transforming", "job-queued-for-marker", "job-printing", "job-canceled-by-user", "job-canceled-by-operator", "job-canceled-at-device", "aborted-by-system", "unsupported-compression", "compression-error", "unsupported-document-format", "document-format-error", "processing-to-stop-point", "service-off-line", "job-completed-successfully", "job-completed-with-warnings", "job-completed-with-errors", "job-restartable", "queued-in-device"}; /** * The enumeration value table for class {@code JobStateReason}. */ private static final JobStateReason[] myEnumValueTable = { JOB_INCOMING, JOB_DATA_INSUFFICIENT, DOCUMENT_ACCESS_ERROR, SUBMISSION_INTERRUPTED, JOB_OUTGOING, JOB_HOLD_UNTIL_SPECIFIED, RESOURCES_ARE_NOT_READY, PRINTER_STOPPED_PARTLY, PRINTER_STOPPED, JOB_INTERPRETING, JOB_QUEUED, JOB_TRANSFORMING, JOB_QUEUED_FOR_MARKER, JOB_PRINTING, JOB_CANCELED_BY_USER, JOB_CANCELED_BY_OPERATOR, JOB_CANCELED_AT_DEVICE, ABORTED_BY_SYSTEM, UNSUPPORTED_COMPRESSION, COMPRESSION_ERROR, UNSUPPORTED_DOCUMENT_FORMAT, DOCUMENT_FORMAT_ERROR, PROCESSING_TO_STOP_POINT, SERVICE_OFF_LINE, JOB_COMPLETED_SUCCESSFULLY, JOB_COMPLETED_WITH_WARNINGS, JOB_COMPLETED_WITH_ERRORS, JOB_RESTARTABLE, QUEUED_IN_DEVICE}; /** * Returns the string table for class {@code JobStateReason}. */ protected String[] getStringTable() { return myStringTable.clone(); } /** * Returns the enumeration value table for class {@code JobStateReason}. */ protected EnumSyntax[] getEnumValueTable() { return (EnumSyntax[])myEnumValueTable.clone(); } /** * Get the printing attribute class which is to be used as the "category" * for this printing attribute value. *
* For class {@code JobStateReason} and any vendor-defined subclasses, the * category is class {@code JobStateReason} itself. * * @return printing attribute class (category), an instance of class * {@link Class java.lang.Class} */ public final Class getCategory() { return JobStateReason.class; } /** * Get the name of the category of which this attribute value is an * instance. *
* For class {@code JobStateReason} and any vendor-defined subclasses, the * category name is {@code "job-state-reason"}. * * @return attribute category name */ public final String getName() { return "job-state-reason"; } }