src.com.ibm.as400.access.SpooledFileImplRemote Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jt400 Show documentation
Show all versions of jt400 Show documentation
The Open Source version of the IBM Toolbox for Java
///////////////////////////////////////////////////////////////////////////////
//
// JTOpen (IBM Toolbox for Java - OSS version)
//
// Filename: SpooledFileImplRemote.java
//
// The source code contained herein is licensed under the IBM Public License
// Version 1.0, which has been approved by the Open Source Initiative.
// Copyright (C) 1997-2003 International Business Machines Corporation and
// others. All rights reserved.
//
///////////////////////////////////////////////////////////////////////////////
package com.ibm.as400.access;
import java.io.IOException;
/**
* The SpooledFile class represents a server spooled file.
* You can use an instance of this class to manipulate an individual
* server spooled file (hold, release, delete, send, read, and so on).
* To create new spooled files on the server, use the
* SpooledFileOutputStream class.
*
* See Spooled File Attributes for
* valid attributes.
*
* @see PrintObjectInputStream
* @see PrintObjectPageInputStream
* @see PrintObjectTransformedInputStream
**/
class SpooledFileImplRemote extends PrintObjectImplRemote
implements SpooledFileImpl
{
private static final NPCPAttributeIDList attrsToRetrieve_ = new NPCPAttributeIDList();
private static boolean fAttrIDsToRtvBuilt_ = false;
private static final int CMD_SEND_NET = 1;
private static final int CMD_SEND_TCP = 2;
transient NPCPMsgHandle cpMsgHandle_ = null;
transient boolean fMsgRetrieved_ = false;
// We have decide that spooled files are too transient to
// be JavaBeans
/** Replies to the message that caused the spooled file to wait.
*
* @param reply The string that contains the reply for the message.
* The default reply can be obtained by calling
* the getMessage() method, and then calling the
* getDefaultReply() method on the message object that is returned.
* Other possible replies are given in the message help,
* which can also be retrieved from the message object returned
* on the getMessage() method.
*
* @exception AS400Exception If the system returns an error message.
* @exception AS400SecurityException If a security or authority error occurs.
* @exception ErrorCompletingRequestException If an error occurs before the request is
* completed.
* @exception IOException If an error occurs while communicating with the server.
* @exception InterruptedException If this thread is interrupted.
* @exception RequestNotSupportedException If the requested function is not supported because the
* system is not at the correct level.
**/
public void answerMessage(String reply)
throws AS400Exception,
AS400SecurityException,
ErrorCompletingRequestException,
IOException,
InterruptedException,
RequestNotSupportedException
{
synchronized( this )
{
if (reply == null)
{
Trace.log(Trace.ERROR, "Parameter 'reply' is null.");
throw new NullPointerException("reply");
}
if (!fMsgRetrieved_)
{
// retrieve just the message handle
retrieveMessage(null, null);
}
NPDataStream sendDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPDataStream returnDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPSystem npSystem = NPSystem.getSystem(getSystem());
NPCPAttribute cpCPFMessage = new NPCPAttribute();
NPCPAttribute cpMsgReply = new NPCPAttribute();
// set up the send data stream - we set the action to
// retrieve message and we set the code points of
// the message handle along with what attribute code point for
// the answer
sendDS.setAction(NPDataStream.ANSWER_MESSAGE);
sendDS.addCodePoint(cpMsgHandle_);
cpMsgReply.setAttrValue(PrintObject.ATTR_MSGREPLY, reply);
sendDS.addCodePoint(cpMsgReply);
// setup the return datastream - we get back a cpf message maybe
returnDS.addCodePoint(cpCPFMessage);
int rc = npSystem.makeRequest(sendDS, returnDS);
switch(rc)
{
case 0:
fMsgRetrieved_ = false; // we just answered the message
// update the spooled file attributes
updateAttrs(getAttrIDsToRetrieve());
break;
case NPDataStream.RET_SPLF_NO_MESSAGE:
// this should not be a runtime exception
Trace.log(Trace.ERROR, "No spooled file message waiting.");
throw new ErrorCompletingRequestException(
ErrorCompletingRequestException.SPOOLED_FILE_NO_MESSAGE_WAITING);
default:
// Throw some other internal/unexpected error or something here
// create new RC for this
//throw new InternalErrorException(InternalErrorException.UNKNOWN,
// "NPServer Error RC = " + rc);
Trace.log(Trace.ERROR, "Unexpected Error.");
throw new InternalErrorException(InternalErrorException.UNKNOWN);
}
}
} // answerMessage()
private synchronized void buildAttrIDsToRtv()
{
if (!fAttrIDsToRtvBuilt_)
{
fAttrIDsToRtvBuilt_ = true;
attrsToRetrieve_.addAttrID(PrintObject.ATTR_3812SCS); // 3812 SCS (fonts)
attrsToRetrieve_.addAttrID(PrintObject.ATTR_ACCOUNT_CODE); // Accounting code
attrsToRetrieve_.addAttrID(PrintObject.ATTR_AFP); // AFP resources used
attrsToRetrieve_.addAttrID(PrintObject.ATTR_AFPRESOURCE); // AFP Resource
attrsToRetrieve_.addAttrID(PrintObject.ATTR_ALIGN); // Align page
attrsToRetrieve_.addAttrID(PrintObject.ATTR_ASCIITRANS); // ASCII transparency
attrsToRetrieve_.addAttrID(PrintObject.ATTR_ASPDEVICE); // Auxiliary storage pool device name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_AUX_POOL); // Auxiliary storage pool
attrsToRetrieve_.addAttrID(PrintObject.ATTR_BARCODE); // Barcode
attrsToRetrieve_.addAttrID(PrintObject.ATTR_BKMGN_ACR); // Back margin across
attrsToRetrieve_.addAttrID(PrintObject.ATTR_BKMGN_DWN); // Back margin down
attrsToRetrieve_.addAttrID(PrintObject.ATTR_BKOVL_ACR); // Back overlay offset across
attrsToRetrieve_.addAttrID(PrintObject.ATTR_BKOVL_DWN); // Back overlay offset down
attrsToRetrieve_.addAttrID(PrintObject.ATTR_BKOVRLAY); // Back side overlay name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_BKOVRLLIB); // Back side overlay library
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CHAR_ID); // Graphic character set
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CHARID); // Character ID
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CHR_RTT_CMDS); // DBCS character rotation commands
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CHRSET); // Character set name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CHRSET_LIB); // Character set library name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CHRSET_SIZE); // Character set point size
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CODEDFNT); // *Coded font name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CODEDFNTLIB); // *Coded font library name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CODEDFONT_SIZE); // Coded font point size
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CODEPAGE); // Code page
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CODEPAGE_NAME); // Code page name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CODEPAGE_NAME_LIB); // Code page library name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CODFNT_ARRAY); // Coded font array
attrsToRetrieve_.addAttrID(PrintObject.ATTR_COLOR); // Color
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CONSTBCK_OVL); // Constant back overlay
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CONTROLCHAR); // Control character
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CONVERT_LINEDATA); // Convert line data
attrsToRetrieve_.addAttrID(PrintObject.ATTR_COPIES); // Copies (total)
attrsToRetrieve_.addAttrID(PrintObject.ATTR_COPIESLEFT); // Copies left to produce
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CORNER_STAPLE); // Corner staple
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CPI); // Characters per inch
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CPI_CHANGES); // Characters per inch changes
attrsToRetrieve_.addAttrID(PrintObject.ATTR_CURPAGE); // Current page
attrsToRetrieve_.addAttrID(PrintObject.ATTR_DATE); // Date file opened (created)
attrsToRetrieve_.addAttrID(PrintObject.ATTR_DATE_USED); // Date file last used
attrsToRetrieve_.addAttrID(PrintObject.ATTR_DATE_WTR_BEGAN_FILE); // Date writer began processing file
attrsToRetrieve_.addAttrID(PrintObject.ATTR_DATE_WTR_CMPL_FILE); // Date writer finished processing file
attrsToRetrieve_.addAttrID(PrintObject.ATTR_DBCS_FNT); // DBCS coded font name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_DBCS_FNT_LIB); // DBCS coded font library name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_DBCS_FNT_SIZE); // DBCS coded font point size
attrsToRetrieve_.addAttrID(PrintObject.ATTR_DBCSCPI); // DBCS characters per inch
attrsToRetrieve_.addAttrID(PrintObject.ATTR_DBCSDATA); // Contains DBCS character set data
attrsToRetrieve_.addAttrID(PrintObject.ATTR_DBCSEXTENSN); // Process DBCS extension characters
attrsToRetrieve_.addAttrID(PrintObject.ATTR_DBCSROTATE); // Rotate DBCS characters before printing
attrsToRetrieve_.addAttrID(PrintObject.ATTR_DBCSSISO); // DBCS SI/SO space requirements
attrsToRetrieve_.addAttrID(PrintObject.ATTR_DDS); // DDS
attrsToRetrieve_.addAttrID(PrintObject.ATTR_DECIMAL_FMT); // Decimal format used
attrsToRetrieve_.addAttrID(PrintObject.ATTR_DOUBLEWIDE); // Double wide characters
attrsToRetrieve_.addAttrID(PrintObject.ATTR_DRAWERCHANGE); // Drawer change
attrsToRetrieve_.addAttrID(PrintObject.ATTR_DUPLEX); // Print on both sides (duplex)
attrsToRetrieve_.addAttrID(PrintObject.ATTR_EDGESTITCH_NUMSTAPLES); // Edge stitch number of staples
attrsToRetrieve_.addAttrID(PrintObject.ATTR_EDGESTITCH_REF); // Edge stitch reference edge
attrsToRetrieve_.addAttrID(PrintObject.ATTR_EDGESTITCH_REFOFF); // Offset from edge stitch reference edge
attrsToRetrieve_.addAttrID(PrintObject.ATTR_ENDPAGE); // Ending page
attrsToRetrieve_.addAttrID(PrintObject.ATTR_EXPIRATION_DATE); // Spool file expiration date
attrsToRetrieve_.addAttrID(PrintObject.ATTR_FIDELITY); // Print fidelity
attrsToRetrieve_.addAttrID(PrintObject.ATTR_FIELD_OUTLIN); // Field outlining
attrsToRetrieve_.addAttrID(PrintObject.ATTR_FILESEP); // Number of file separators
attrsToRetrieve_.addAttrID(PrintObject.ATTR_FOLDREC); // Fold records
attrsToRetrieve_.addAttrID(PrintObject.ATTR_FONT_CHANGES); // Font changes
attrsToRetrieve_.addAttrID(PrintObject.ATTR_FONTID); // Font identifier
attrsToRetrieve_.addAttrID(PrintObject.ATTR_FONTRESFMT); // Font resolution for formatting
attrsToRetrieve_.addAttrID(PrintObject.ATTR_FORMDEF); // Form definition name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_FORMDEFLIB); // Form definition library
attrsToRetrieve_.addAttrID(PrintObject.ATTR_FORMFEED); // Form feed
attrsToRetrieve_.addAttrID(PrintObject.ATTR_FORMTYPE); // Form type
attrsToRetrieve_.addAttrID(PrintObject.ATTR_FTMGN_ACR); // Front margin across
attrsToRetrieve_.addAttrID(PrintObject.ATTR_FTMGN_DWN); // Front margin down
attrsToRetrieve_.addAttrID(PrintObject.ATTR_FTOVL_ACR); // Front overlay offset across
attrsToRetrieve_.addAttrID(PrintObject.ATTR_FTOVL_DWN); // Front overlay offset down
attrsToRetrieve_.addAttrID(PrintObject.ATTR_FTOVRLAY); // Front overlay name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_FTOVRLLIB); // Front overlay library
attrsToRetrieve_.addAttrID(PrintObject.ATTR_GRAPHICS); // Graphics in spooled file
attrsToRetrieve_.addAttrID(PrintObject.ATTR_GRAPHICS_TOK); // Graphics token
attrsToRetrieve_.addAttrID(PrintObject.ATTR_GRPLVL_IDXTAG); // Group level index tags
attrsToRetrieve_.addAttrID(PrintObject.ATTR_HIGHLIGHT); // Highlight
attrsToRetrieve_.addAttrID(PrintObject.ATTR_HOLD); // Hold the spool file before written
attrsToRetrieve_.addAttrID(PrintObject.ATTR_IPDSPASSTHRU); // IPDS pass-through
attrsToRetrieve_.addAttrID(PrintObject.ATTR_IPP_ATTR_CCSID); // IPP attributes-charset
attrsToRetrieve_.addAttrID(PrintObject.ATTR_IPP_ATTR_NL); // IPP natural language
attrsToRetrieve_.addAttrID(PrintObject.ATTR_IPP_JOB_ID); // IPP job ID
attrsToRetrieve_.addAttrID(PrintObject.ATTR_IPP_JOB_NAME); // IPP job name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_IPP_JOB_NAME_NL); // IPP job name NL
attrsToRetrieve_.addAttrID(PrintObject.ATTR_IPP_JOB_ORIGUSER); // IPP job original user
attrsToRetrieve_.addAttrID(PrintObject.ATTR_IPP_JOB_ORIGUSER_NL); // IPP job original user NL
attrsToRetrieve_.addAttrID(PrintObject.ATTR_IPP_PRINTER_NAME); // IPP printer name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_JOBCCSID); // ccsid of the job that created file
attrsToRetrieve_.addAttrID(PrintObject.ATTR_JOBNAME); // name of the job that created file
attrsToRetrieve_.addAttrID(PrintObject.ATTR_JOBNUMBER); // number of the job that created file
attrsToRetrieve_.addAttrID(PrintObject.ATTR_JOBSYSTEM); // System which job that created splf ran
attrsToRetrieve_.addAttrID(PrintObject.ATTR_JOBUSER); // name of the user that created file
attrsToRetrieve_.addAttrID(PrintObject.ATTR_JUSTIFY); // Justification
attrsToRetrieve_.addAttrID(PrintObject.ATTR_LASTPAGE); // Last page that printed
attrsToRetrieve_.addAttrID(PrintObject.ATTR_LINESPACING); // Line spacing
attrsToRetrieve_.addAttrID(PrintObject.ATTR_LPI); // Lines per inch
attrsToRetrieve_.addAttrID(PrintObject.ATTR_LPI_CHANGES); // Lines per inch changes
attrsToRetrieve_.addAttrID(PrintObject.ATTR_MAXRCDS); // Maximum records
attrsToRetrieve_.addAttrID(PrintObject.ATTR_MEASMETHOD); // Measurement method (*ROWCOL or *UOM)
attrsToRetrieve_.addAttrID(PrintObject.ATTR_MULTIUP); // logical pages per physical side
attrsToRetrieve_.addAttrID(PrintObject.ATTR_NETWORK); // network were output was created
attrsToRetrieve_.addAttrID(PrintObject.ATTR_NUMBYTES_SPLF); // number of bytes contained w/in splf
attrsToRetrieve_.addAttrID(PrintObject.ATTR_NUMRSC_LIB_ENT);// Number of user resource library list entries
attrsToRetrieve_.addAttrID(PrintObject.ATTR_OFFICEVISION); // OfficeVision
attrsToRetrieve_.addAttrID(PrintObject.ATTR_OS4_CRT_AFP); // IBM i created AFPDS
attrsToRetrieve_.addAttrID(PrintObject.ATTR_OUTPTY); // Output priority
attrsToRetrieve_.addAttrID(PrintObject.ATTR_OUTPUTBIN); // Output bin
attrsToRetrieve_.addAttrID(PrintObject.ATTR_OUTQUE); // Output queue
attrsToRetrieve_.addAttrID(PrintObject.ATTR_OUTQUELIB); // Output queue library
attrsToRetrieve_.addAttrID(PrintObject.ATTR_OVERFLOW); // Overflow line number
attrsToRetrieve_.addAttrID(PrintObject.ATTR_PAGDFN); // Page definition library
attrsToRetrieve_.addAttrID(PrintObject.ATTR_PAGDFNLIB); // Page definition library name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_PAGE_GROUPS); // Spooled File contains Page groups
attrsToRetrieve_.addAttrID(PrintObject.ATTR_PAGE_ROTATE); // Page rotation used
attrsToRetrieve_.addAttrID(PrintObject.ATTR_PAGELEN); // page length in measurement method
attrsToRetrieve_.addAttrID(PrintObject.ATTR_PAGELVLIDXTAG); // Page level index tags
attrsToRetrieve_.addAttrID(PrintObject.ATTR_PAGES); // Number of pages in spool file
attrsToRetrieve_.addAttrID(PrintObject.ATTR_PAGES_EST); // Number of pages is estimated
attrsToRetrieve_.addAttrID(PrintObject.ATTR_PAGEWIDTH); // Page width in measurement method
attrsToRetrieve_.addAttrID(PrintObject.ATTR_PAGRTT); // Degree of page rotation
attrsToRetrieve_.addAttrID(PrintObject.ATTR_PGM_OPN_FILE); // Program that opened file name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_PGM_OPN_LIB); // Program that opened the file library name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_POINTSIZE); // the default font's point size
attrsToRetrieve_.addAttrID(PrintObject.ATTR_PRINTER); // Printer (device name)
attrsToRetrieve_.addAttrID(PrintObject.ATTR_PRTASSIGNED); // Printer assigned
attrsToRetrieve_.addAttrID(PrintObject.ATTR_PRTDEVTYPE); // Printer dev type (data stream type (*SCS, *AFPDS, etc))
attrsToRetrieve_.addAttrID(PrintObject.ATTR_PRTFILE); // Printer file
attrsToRetrieve_.addAttrID(PrintObject.ATTR_PRTFLIB); // Printer file library
attrsToRetrieve_.addAttrID(PrintObject.ATTR_PRTQUALITY); // Print quality
attrsToRetrieve_.addAttrID(PrintObject.ATTR_PRTTEXT); // Text printed at bottom of each page
attrsToRetrieve_.addAttrID(PrintObject.ATTR_RCDFMT_DATA); // Record format name present in data stream
attrsToRetrieve_.addAttrID(PrintObject.ATTR_RECLENGTH); // Record length
attrsToRetrieve_.addAttrID(PrintObject.ATTR_REDUCE); // Reduce output
attrsToRetrieve_.addAttrID(PrintObject.ATTR_RESTART); // where to restart printing at
attrsToRetrieve_.addAttrID(PrintObject.ATTR_RPLCHAR); // character to replace unprintables with
attrsToRetrieve_.addAttrID(PrintObject.ATTR_RPLUNPRT); // replace unprintable characters
attrsToRetrieve_.addAttrID(PrintObject.ATTR_RSC_LIB_LIST); // User resource library list
attrsToRetrieve_.addAttrID(PrintObject.ATTR_RSCLIB); // Resource library
attrsToRetrieve_.addAttrID(PrintObject.ATTR_RSCNAME); // Resource name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_RSCTYPE); // Resource object type
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SADDLESTITCH_NUMSTAPLES); // Saddle stitch number of staples
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SADDLESTITCH_REF); // Saddle stitch reference edge
//attrsToRetrieve_.addAttrID(PrintObject.ATTR_SADDLESTITCH_STPL_OFFSEINFO); // saddle stitch offset distance
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SAVE); // whether to save after printing or not
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SAVE_COMMAND); // Save command
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SAVE_DEVICE); // Save device
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SAVEFILE); // Save file name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SAVEFILELIB); // Save file library
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SAVE_LABEL); // Save label
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SAVE_SEQUENCE_NUMBER); // Save sequence number
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SAVE_VOLUME_FORMAT); // Save volume format
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SAVE_VOLUME_ID);// Save volume ID
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SCHEDULE); // File available (schedule)
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SPLF_AUTH_METHOD); // Spooled file authentication method
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SPLF_CREATOR); // Spooled file creator
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SPLF_RESTORED_DATE); // Spooled file restored date
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SPLF_RESTORED_TIME); // Spooled file restored time
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SPLF_SAVED_DATE); // Spooled file saved date
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SPLF_SAVED_TIME); // Spooled file saved time
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SPLF_SECURITY_METHOD); // Spooled file security method
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SPLF_SIZE); // Spooled file size
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SPLF_SIZE_MULT);// Spooled file size multiplier
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SPLFNUM); // Spooled file number
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SPLFSTATUS); // Spooled file status
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SPOOLFILE); // Spooled file name
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SRCDRWR); // Source drawer
attrsToRetrieve_.addAttrID(PrintObject.ATTR_STARTPAGE); // Starting page
attrsToRetrieve_.addAttrID(PrintObject.ATTR_SYSTEM); // System where output was created
attrsToRetrieve_.addAttrID(PrintObject.ATTR_TIME); // Time spooled file was opened at
attrsToRetrieve_.addAttrID(PrintObject.ATTR_TIME_WTR_BEGAN_FILE); // Time writer began processing file
attrsToRetrieve_.addAttrID(PrintObject.ATTR_TIME_WTR_CMPL_FILE); // Time writer finished processing file
attrsToRetrieve_.addAttrID(PrintObject.ATTR_TRC1403); // Trc for 1403
attrsToRetrieve_.addAttrID(PrintObject.ATTR_UNITOFMEAS); // Unit of measure
attrsToRetrieve_.addAttrID(PrintObject.ATTR_USER_DFN_TXT); // User defined text
attrsToRetrieve_.addAttrID(PrintObject.ATTR_USERCMT); // User comment
attrsToRetrieve_.addAttrID(PrintObject.ATTR_USERDATA); // User data
attrsToRetrieve_.addAttrID(PrintObject.ATTR_USERGEN_DATA); // System Validated data stream
attrsToRetrieve_.addAttrID(PrintObject.ATTR_USRDEFDATA); // User define data
attrsToRetrieve_.addAttrID(PrintObject.ATTR_USRDEFFILE); // User define file
attrsToRetrieve_.addAttrID(PrintObject.ATTR_USRDEFOBJ); // *User defined object
attrsToRetrieve_.addAttrID(PrintObject.ATTR_USRDEFOBJLIB); // *User defined object library
attrsToRetrieve_.addAttrID(PrintObject.ATTR_USRDEFOBJTYP); // *User defined object type
attrsToRetrieve_.addAttrID(PrintObject.ATTR_USRDEFOPT); // User defined options
}
}
/**
* Creates a copy of the spooled file this object represents. The
* new spooled file is created on the specified output queue.
* A reference to the new spooled file is returned.
*
* @param outputQueue The output queue location to create the new version of the
* original spooled file. The spooled file will be created to the first
* position on this output queue. The output queue and this spooled
* file must reside on the same system.
*
* @exception AS400Exception If the system returns an error message.
* @exception AS400SecurityException If a security or authority error occurs.
* @exception ErrorCompletingRequestException If an error occurs before the request is completed.
* @exception IOException If an error occurs while communicating with the server.
* @exception InterruptedException If this thread is interrupted.
* @exception RequestNotSupportedException If the requested function is not supported because the
* system is not at the correct level.
**/
public NPCPIDSplF copy(OutputQueueImpl outputQueue)
throws AS400Exception,
AS400SecurityException,
ErrorCompletingRequestException,
IOException,
InterruptedException,
RequestNotSupportedException
{
NPDataStream sendDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPDataStream returnDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPSystem npSystem = NPSystem.getSystem(getSystem());
NPCPAttribute cpCPFMessage = new NPCPAttribute();
NPCPIDOutQ tgtOutQID = (NPCPIDOutQ)((OutputQueueImplRemote)outputQueue).getIDCodePoint();
sendDS.setAction(NPDataStream.COPY);
sendDS.addCodePoint(getIDCodePoint());
sendDS.addCodePoint(tgtOutQID);
NPCPIDSplF splfID = new NPCPIDSplF();
returnDS.addCodePoint(splfID);
returnDS.addCodePoint(cpCPFMessage);
int rc = npSystem.makeRequest(sendDS, returnDS);
if (rc == 0) {
return splfID;
}
else {
NPConversation conversation = npSystem.getConversation();
String curLevel = conversation.getAttribute(PrintObject.ATTR_NPSLEVEL);
npSystem.returnConversation(conversation);
switch(rc) {
// we get back RET_INV_REQ_ACT on pre-V5R3 systems if we try
// to copy a spooled file, so throw a requestNotSupportedException
// here.
case NPDataStream.RET_INV_REQ_ACT:
throw new RequestNotSupportedException(curLevel,
RequestNotSupportedException.SYSTEM_LEVEL_NOT_CORRECT);
// any other error is either an unexpected error or an error
// completing request
default:
Trace.log(Trace.ERROR, "SpooledFileImplRemote::copy - An exception was thrown attempting to " +
"copy the spooled file. RC = " + rc);
break;
}
return null;
}
}
/**
* Deletes the spooled file on the server.
*
* @exception AS400Exception If the system returns an error message.
* @exception AS400SecurityException If a security or authority error occurs.
* @exception ErrorCompletingRequestException If an error occurs before the request is completed.
* @exception IOException If an error occurs while communicating with the server.
* @exception InterruptedException If this thread is interrupted.
**/
public void delete()
throws AS400Exception,
AS400SecurityException,
ErrorCompletingRequestException,
IOException,
InterruptedException
{
NPDataStream sendDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPDataStream returnDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPSystem npSystem = NPSystem.getSystem(getSystem());
NPCPAttribute cpCPFMessage = new NPCPAttribute();
sendDS.setAction(NPDataStream.DELETE);
sendDS.addCodePoint(getIDCodePoint());
returnDS.addCodePoint(cpCPFMessage);
npSystem.makeRequest(sendDS, returnDS);
}
/**
* Creates the message handle codepoint. It is
* a synchonized method so that we don't get 2 threads creating
* the code point at once.
**/
synchronized void generateMsgHandle()
{
if (cpMsgHandle_ == null)
{
cpMsgHandle_ = new NPCPMsgHandle();
}
}
// retrieve only one attribute
NPCPAttributeIDList getAttrIDsToRetrieve(int attrToRtv)
{
if (!fAttrIDsToRtvBuilt_) {
attrsToRetrieve_.addAttrID(attrToRtv);
}
return attrsToRetrieve_;
}
NPCPAttributeIDList getAttrIDsToRetrieve()
{
if (!fAttrIDsToRtvBuilt_) {
buildAttrIDsToRtv();
}
return attrsToRetrieve_;
}
// method for synchronization with base class.
public boolean getFMsgRetrieved()
{
return fMsgRetrieved_;
}
/**
* Returns the message that is associated with this spooled file.
* A spooled file has a message associated with it if its
* ATTR_SPLFSTATUS attribute returns *MESSAGE.
*
* @return The AS400Message object that contains the message text,
* type, severity, id, date, time, and default reply.
* @exception AS400Exception If the system returns an error message.
* @exception AS400SecurityException If a security or authority error occurs.
* @exception ErrorCompletingRequestException If an error occurs before the request is completed.
* @exception IOException If an error occurs while communicating with the server.
* @exception InterruptedException If this thread is interrupted.
**/
public AS400Message getMessage()
throws AS400Exception,
AS400SecurityException,
ErrorCompletingRequestException,
IOException,
InterruptedException
{
AS400Message msg = null;
NPCPAttributeIDList cpAttrsToRetrieve = new NPCPAttributeIDList();
NPCPAttribute cpMessage = new NPCPAttribute();
// set which attributes we want to retrieve
cpAttrsToRetrieve.addAttrID(PrintObject.ATTR_MSGTEXT);
cpAttrsToRetrieve.addAttrID(PrintObject.ATTR_MSGTYPE);
cpAttrsToRetrieve.addAttrID(PrintObject.ATTR_MSGHELP);
cpAttrsToRetrieve.addAttrID(PrintObject.ATTR_MSGREPLY);
cpAttrsToRetrieve.addAttrID(PrintObject.ATTR_MSGID);
cpAttrsToRetrieve.addAttrID(PrintObject.ATTR_MSGSEV);
cpAttrsToRetrieve.addAttrID(PrintObject.ATTR_DATE);
cpAttrsToRetrieve.addAttrID(PrintObject.ATTR_TIME);
// call to synchoronized method to make the request. This
// serves 2 purposes:
// 1) synchonizes access to instance variable cpMsgHandle
// 2) synchronizes accsss to instance variable fMsgRetrieved
retrieveMessage(cpAttrsToRetrieve, cpMessage);
// create an AS400Message and set appropriate values
msg = new AS400Message(cpMessage.getStringValue(PrintObject.ATTR_MSGID),
cpMessage.getStringValue(PrintObject.ATTR_MSGTEXT));
msg.setDate(cpMessage.getStringValue(PrintObject.ATTR_DATE),cpMessage.getStringValue(PrintObject.ATTR_TIME));
msg.setDefaultReply(cpMessage.getStringValue(PrintObject.ATTR_MSGREPLY));
msg.setHelp(cpMessage.getStringValue(PrintObject.ATTR_MSGHELP));
msg.setSeverity((cpMessage.getIntValue(PrintObject.ATTR_MSGSEV)).intValue());
msg.setType(Integer.parseInt(cpMessage.getStringValue(PrintObject.ATTR_MSGTYPE)));
return msg;
} // getMessage
/**
* Holds the spooled file.
* @param holdType When to hold the spooled file.
* May be any of the following values:
*
* - *IMMED - The spooled file is held immediately.
*
- *PAGEEND - The spooled file is held at the end of the current page.
*
* holdType may be null. If holdType is not specified, the default is
* *IMMED.
*
* @exception AS400Exception If the system returns an error message.
* @exception AS400SecurityException If a security or authority error occurs.
* @exception ErrorCompletingRequestException If an error occurs before the request is completed.
* @exception IOException If an error occurs while communicating with the server.
* @exception InterruptedException If this thread is interrupted.
* @exception RequestNotSupportedException If the requested function is not supported because the
* system is not at the correct level.
**/
public void hold(String holdType)
throws AS400Exception,
AS400SecurityException,
ErrorCompletingRequestException,
IOException,
InterruptedException,
RequestNotSupportedException
{
NPDataStream sendDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPDataStream returnDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPSystem npSystem = NPSystem.getSystem(getSystem());
NPCPAttribute cpCPFMessage = new NPCPAttribute();
sendDS.setAction(NPDataStream.HOLD);
sendDS.addCodePoint(getIDCodePoint());
if (holdType != null)
{
NPCPAttribute cpAttr = new NPCPAttribute();
cpAttr.setAttrValue(PrintObject.ATTR_HOLDTYPE, holdType);
sendDS.addCodePoint(cpAttr);
}
returnDS.addCodePoint(cpCPFMessage);
npSystem.makeRequest(sendDS, returnDS);
// update the spooled file attributes
updateAttrs(getAttrIDsToRetrieve());
}
/**
* Moves the spooled file to another output queue or to another
* position on the same output queue.
*
* @param targetSpooledFile The spooled file to move this
* spooled file after. The targetSpooledFile and this spooled file
* must reside on the same system.
*
* @exception AS400Exception If the system returns an error message.
* @exception AS400SecurityException If a security or authority error occurs.
* @exception ErrorCompletingRequestException If an error occurs before the request is completed.
* @exception IOException If an error occurs while communicating with the server.
* @exception InterruptedException If this thread is interrupted.
* @exception RequestNotSupportedException If the requested function is not supported because the
* system is not at the correct level.
**/
public void move(SpooledFileImpl targetSpooledFile)
throws AS400Exception,
AS400SecurityException,
ErrorCompletingRequestException,
IOException,
InterruptedException,
RequestNotSupportedException
{
NPDataStream sendDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPDataStream returnDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPSystem npSystem = NPSystem.getSystem(getSystem());
NPCPAttribute cpCPFMessage = new NPCPAttribute();
// make a copy of the target spooled file ID codepoint so we can
// change its ID
NPCPIDSplF tgtSplfID = new NPCPIDSplF((NPCPIDSplF)((SpooledFileImplRemote)targetSpooledFile).getIDCodePoint());
// must change the ID of the target splf ID from a SPOOLED_FILE_ID codepoint
// to a TARGET_SPOOLED_FILE_ID codpoint
tgtSplfID.setID(NPCodePoint.TARGET_SPOOLED_FILE_ID);
sendDS.setAction(NPDataStream.MOVE);
sendDS.addCodePoint(getIDCodePoint());
sendDS.addCodePoint(tgtSplfID);
returnDS.addCodePoint(cpCPFMessage);
npSystem.makeRequest(sendDS, returnDS);
// update the spooled file attributes
updateAttrs(getAttrIDsToRetrieve());
}
/**
* Moves the spooled file to another output queue.
*
* @param targetOutputQueue The output queue to move the
* spooled file to. The spooled file will be moved to the first
* position on this output queue. The output queue and this spooled
* file must reside on the same system.
*
* @exception AS400Exception If the system returns an error message.
* @exception AS400SecurityException If a security or authority error occurs.
* @exception ErrorCompletingRequestException If an error occurs before the request is completed.
* @exception IOException If an error occurs while communicating with the server.
* @exception InterruptedException If this thread is interrupted.
* @exception RequestNotSupportedException If the requested function is not supported because the
* system is not at the correct level.
**/
public void move(OutputQueueImpl targetOutputQueue)
throws AS400Exception,
AS400SecurityException,
ErrorCompletingRequestException,
IOException,
InterruptedException,
RequestNotSupportedException
{
NPDataStream sendDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPDataStream returnDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPSystem npSystem = NPSystem.getSystem(getSystem());
NPCPAttribute cpCPFMessage = new NPCPAttribute();
NPCPIDOutQ tgtOutQID = (NPCPIDOutQ)((OutputQueueImplRemote)targetOutputQueue).getIDCodePoint();
sendDS.setAction(NPDataStream.MOVE);
sendDS.addCodePoint(getIDCodePoint());
sendDS.addCodePoint(tgtOutQID);
returnDS.addCodePoint(cpCPFMessage);
npSystem.makeRequest(sendDS, returnDS);
// update the spooled file attributes
updateAttrs(getAttrIDsToRetrieve());
}
/**
* Moves the spooled file to the first position on the output queue.
* @exception AS400Exception If the system returns an error message.
* @exception AS400SecurityException If a security or authority error occurs.
* @exception ErrorCompletingRequestException If an error occurs before the request is completed.
* @exception IOException If an error occurs while communicating with the server.
* @exception InterruptedException If this thread is interrupted.
* @exception RequestNotSupportedException If the requested function is not supported because the
* system is not at the correct level.
**/
public void moveToTop()
throws AS400Exception,
AS400SecurityException,
ErrorCompletingRequestException,
IOException,
InterruptedException,
RequestNotSupportedException
{
NPDataStream sendDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPDataStream returnDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPSystem npSystem = NPSystem.getSystem(getSystem());
NPCPAttribute cpCPFMessage = new NPCPAttribute();
sendDS.setAction(NPDataStream.MOVE);
sendDS.addCodePoint(getIDCodePoint());
returnDS.addCodePoint(cpCPFMessage);
npSystem.makeRequest(sendDS, returnDS);
// update the spooled file attributes
updateAttrs(getAttrIDsToRetrieve());
}
/**
* Releases a held spooled file on the server.
* @exception AS400Exception If the system returns an error message.
* @exception AS400SecurityException If a security or authority error occurs.
* @exception ErrorCompletingRequestException If an error occurs before the request is completed.
* @exception IOException If an error occurs while communicating with the server.
* @exception InterruptedException If this thread is interrupted.
* @exception RequestNotSupportedException If the requested function is not supported because the
* system is not at the correct level.
**/
public void release()
throws AS400Exception,
AS400SecurityException,
ErrorCompletingRequestException,
IOException,
InterruptedException,
RequestNotSupportedException
{
NPDataStream sendDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPDataStream returnDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPSystem npSystem = NPSystem.getSystem(getSystem());
NPCPAttribute cpCPFMessage = new NPCPAttribute();
sendDS.setAction(NPDataStream.RELEASE);
sendDS.addCodePoint(getIDCodePoint());
returnDS.addCodePoint(cpCPFMessage);
npSystem.makeRequest(sendDS, returnDS);
// update the spooled file attributes
updateAttrs(getAttrIDsToRetrieve());
}
// synchronized method to retrieve the message for this spooled file -
// we'll keep the message handle for answering it later
synchronized void retrieveMessage(NPCPAttributeIDList cpAttrsToRetrieve,
NPCPAttribute cpMessage)
throws AS400Exception,
AS400SecurityException,
ErrorCompletingRequestException,
IOException,
InterruptedException
{
NPDataStream sendDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPDataStream returnDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPSystem npSystem = NPSystem.getSystem(getSystem());
if (cpMessage == null)
{
cpMessage = new NPCPAttribute();
}
generateMsgHandle(); // create message handle code point if
// not already created
// set up the send data stream - we set the action to
// retrieve message and we set the code points of
// this spooled files ID along with what attributes we want for
// the message
sendDS.setAction(NPDataStream.RETRIEVE_MESSAGE);
sendDS.addCodePoint(getIDCodePoint());
// if we did not get some attributes then
// generate them.
if (cpAttrsToRetrieve == null)
{
NPCPAttributeIDList cpGenAttrsToRetrieve = new NPCPAttributeIDList();
// set which attributes we want to retrieve
cpGenAttrsToRetrieve.addAttrID(PrintObject.ATTR_MSGTEXT);
cpGenAttrsToRetrieve.addAttrID(PrintObject.ATTR_MSGTYPE);
cpGenAttrsToRetrieve.addAttrID(PrintObject.ATTR_MSGHELP);
cpGenAttrsToRetrieve.addAttrID(PrintObject.ATTR_MSGREPLY);
cpGenAttrsToRetrieve.addAttrID(PrintObject.ATTR_MSGID);
cpGenAttrsToRetrieve.addAttrID(PrintObject.ATTR_MSGSEV);
cpGenAttrsToRetrieve.addAttrID(PrintObject.ATTR_DATE);
cpGenAttrsToRetrieve.addAttrID(PrintObject.ATTR_TIME);
sendDS.addCodePoint(cpGenAttrsToRetrieve);
}
else
sendDS.addCodePoint(cpAttrsToRetrieve);
// setup the return datastream - we get back a message handle
// code point and an attribues/attributes value code point.
// We will get back either a CPF message or the spooled file message
// in the cpMessage code point
returnDS.addCodePoint(cpMessage);
returnDS.addCodePoint(cpMsgHandle_);
int rc = npSystem.makeRequest(sendDS, returnDS);
switch(rc)
{
case 0:
fMsgRetrieved_ = true;
break;
case NPDataStream.RET_SPLF_NO_MESSAGE:
// This should throw a non-runtime exception so the caller may
// catch it.
Trace.log(Trace.ERROR, "No spooled file message waiting.");
throw new ErrorCompletingRequestException(
ErrorCompletingRequestException.SPOOLED_FILE_NO_MESSAGE_WAITING);
default:
// Throw some other internal/unexpected error or something here
// create new RC for this
//throw new InternalErrorException(InternalErrorException.UNKNOWN,
// "NPServer Error RC = " + rc);
Trace.log(Trace.ERROR, "Unexpected Error.");
throw new InternalErrorException(InternalErrorException.UNKNOWN);
}
} // retrieveMessage()
/**
* Sends the spooled file to another user on the same system or to
* a remote system on the network. The equivalent of the server
* Send Network Spooled File
* (SNDNETSPLF) command will be issued against the spooled file.
*
* @param sendOptions A print parameter list that contains the
* parameters for the send. The following attributes MUST be set:
*
* - ATTR_TOUSERID - Specifies the user ID to send the spooled file to.
*
- ATTR_TOADDRESS - Specifies the remote system to send the spooled file to.
*
* The following attributes are optional:
*
* - ATTR_DATAFORMAT - Specifies the data format in which to transmit the
* spooled file. May be either of *RCDDATA or
* *ALLDATA. *RCDDATA is the default.
*
- ATTR_VMMVSCLASS - Specifies the VM/MVS SYSOUT class for distributions
* sent to a VM host system or to an MVS host system.
* May be A to Z or 0 to 9. A is the default.
*
- ATTR_SENDPTY - Specifies the queueing priority used for this spooled file
* when it is being routed through a SNADS network. May be
* *NORMAL or *HIGH. *NORMAL is the default.
*
*
* @exception AS400Exception If the system returns an error message.
* @exception AS400SecurityException If a security or authority error occurs.
* @exception ErrorCompletingRequestException If an error occurs before the request is completed.
* @exception IOException If an error occurs while communicating with the server.
* @exception InterruptedException If this thread is interrupted.
**/
public void sendNet(PrintParameterList sendOptions)
throws AS400Exception,
AS400SecurityException,
ErrorCompletingRequestException,
IOException,
InterruptedException
{
NPDataStream sendDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPDataStream returnDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPSystem npSystem = NPSystem.getSystem(getSystem());
NPCPAttribute cpCPFMessage = new NPCPAttribute();
NPCPAttribute cpSendOptions;
// if the user has given us any options,
// send them
// else
// create our own attribute/value codepoint to put in the type of
// send to do.
// endif
if (sendOptions != null)
{
cpSendOptions = sendOptions.getAttrCodePoint();
} else {
cpSendOptions = new NPCPAttribute();
}
// set the type of send we want to do here (1=SNDNETSPLF)
cpSendOptions.setAttrValue(PrintObject.ATTR_SPLFSENDCMD, CMD_SEND_NET);
sendDS.setAction(NPDataStream.SEND);
sendDS.addCodePoint(getIDCodePoint());
sendDS.addCodePoint(cpSendOptions);
returnDS.addCodePoint(cpCPFMessage);
npSystem.makeRequest(sendDS, returnDS);
}
/**
* Sends a spooled file to be printed on a remote system.
* The equivalent of the server Send TCP/IP Spooled File
* (SNDTCPSPLF) command will be issued against the spooled file.
* This is the server version of the TCP/IP LPR command.
*
* @param sendOptions A print parameter list that contains the
* parameters for the send. The following attributes MUST be set:
*
* - ATTR_RMTSYSTEM - Specifies the remote system to which the print
* request will be sent. May be a remote system
* name or the special value *INTNETADR.
*
- ATTR_RMTPRTQ - Specifies the name of the destination print queue.
*
* The following attributes are optional:
*
* - ATTR_DELETESPLF - Specifies whether or not to delete the spooled file
* after it has been successfully sent. May be *NO
* or *YES. *NO is the default.
*
- ATTR_DESTOPTION - Specifies a destination-dependant option. These options will
* be sent to the remote system with the spooled file.
*
- ATTR_DESTINATION - Specifies the type of system to which the spooled file is
* being sent. When sending to other systems, this value
* should be *AS/400. May also be *OTHER or *PSF/2.
* *OTHER is the default.
*
- ATTR_INTERNETADDR - Specifies the Internet address of the receiving system.
*
- ATTR_MFGTYPE - Specifies the manufacturer, type, and model when transforming print
* data from SCS or AFP to ASCII.
*
- ATTR_SCS2ASCII - Specifies whether the print data is to be transformed to
* ASCII. May be *NO or *YES. *NO is the default.
*
- ATTR_WSCUSTMOBJ - Specifies the name of the workstation customization object.
*
- ATTR_WSCUSTMOBJL - Specifies the name of the workstation customization object library.
*
- ATTR_SEPPAGE - Specifies whether to print the separator page. May be
* *NO or *YES. *YES is the default.
*
- ATTR_USRDTATFMLIB - Specifies the name of the user data transform library.
*
- ATTR_USRDTATFM - Specifies the name of the user data transform.
*
*
* @exception AS400Exception If the system returns an error message.
* @exception AS400SecurityException If a security or authority error occurs.
* @exception ErrorCompletingRequestException If an error occurs before the request is completed.
* @exception IOException If an error occurs while communicating with the server.
* @exception InterruptedException If this thread is interrupted.
**/
public void sendTCP(PrintParameterList sendOptions)
throws AS400Exception,
AS400SecurityException,
ErrorCompletingRequestException,
IOException,
InterruptedException
{
NPDataStream sendDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPDataStream returnDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPSystem npSystem = NPSystem.getSystem(getSystem());
NPCPAttribute cpCPFMessage = new NPCPAttribute();
NPCPAttribute cpSendOptions;
// if the user has given us any options,
// send them
// else
// create our own attribute/value codepoint to put in
// the type of send to do.
// endif
if (sendOptions != null)
{
cpSendOptions = sendOptions.getAttrCodePoint();
} else {
cpSendOptions = new NPCPAttribute();
}
// set the type of send we want to do here (2=SNDTCPSPLF)
cpSendOptions.setAttrValue(PrintObject.ATTR_SPLFSENDCMD, CMD_SEND_TCP);
sendDS.setAction(NPDataStream.SEND);
sendDS.addCodePoint(getIDCodePoint());
sendDS.addCodePoint(cpSendOptions);
returnDS.addCodePoint(cpCPFMessage);
npSystem.makeRequest(sendDS, returnDS);
}
/**
* Sets one or more attributes of the object. See
* Spooled File Attributes for
* a list of valid attributes that can be changed.
*
* @param attributes A print parameter list that contains the
* attributes to be changed.
*
* @exception AS400Exception If the system returns an error message.
* @exception AS400SecurityException If a security or authority error occurs.
* @exception ErrorCompletingRequestException If an error occurs before the request is completed.
* @exception IOException If an error occurs while communicating with the server
* @exception InterruptedException If this thread is interrupted.
* @exception RequestNotSupportedException If the requested function is not supported because the
* system is not at the correct level.
**/
public void setAttributes(PrintParameterList attributes)
throws AS400Exception,
AS400SecurityException,
ErrorCompletingRequestException,
IOException,
InterruptedException,
RequestNotSupportedException
{
if (attributes == null)
{
Trace.log(Trace.ERROR, "Parameter 'attributes' is null.");
throw new NullPointerException("attributes");
}
NPDataStream sendDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPDataStream returnDS = new NPDataStream(NPConstants.SPOOLED_FILE);
NPSystem npSystem = NPSystem.getSystem(getSystem());
NPCPAttribute cpCPFMessage = new NPCPAttribute();
NPCPAttribute cpNewAttrs = attributes.getAttrCodePoint();
sendDS.setAction(NPDataStream.CHANGE_ATTRIBUTES);
sendDS.addCodePoint(getIDCodePoint());
sendDS.addCodePoint(cpNewAttrs);
returnDS.addCodePoint(cpCPFMessage);
npSystem.makeRequest(sendDS, returnDS);
// we changed the spooled file attributes on the server,
// merge those changed attributes into our current attributes
// here.
if (attrs == null)
{
attrs = new NPCPAttribute();
}
attrs.addUpdateAttributes(cpNewAttrs);
}
} // SpooledFile class