com.ibm.as400.access.DBConcatenatedRequestDS Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jt400 Show documentation
The Open Source version of the IBM Toolbox for Java
The newest version!
///////////////////////////////////////////////////////////////////////////////
//                                                                             
// JTOpen (IBM Toolbox for Java - OSS version)                                 
//                                                                             
// Filename: DBConcatenatedRequestDS.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-2001 International Business Machines Corporation and     
// others. All rights reserved.                                                
//                                                                             
///////////////////////////////////////////////////////////////////////////////

package com.ibm.as400.access;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Vector;



/**
The DBConcatenatedRequestDS class represents a datstream
whose contents are the concatenated contents of multiple
DBBaseRequestDS datastreams.
**/
class DBConcatenatedRequestDS 
extends ClientAccessDataStream
{
  private static final String copyright = "Copyright (C) 1997-2001 International Business Machines Corporation and others.";




    // Private data.
    private int                 count_;
    private int                 countMinusOne_;
    private DBBaseRequestDS[]   requests_;



/**
Constructs a DBConcatenatedRequestDS object.

@param heldRequests     A Vector of DBBaseRequestDS objects which have been held.
                        It is assumed that only the last request will have/need
                        a corresponding reply.
@param lastRequest      The most recent request.
**/
    public DBConcatenatedRequestDS(Vector heldRequests, DBBaseRequestDS lastRequest)
    {
        count_ = heldRequests.size() + 1;
        countMinusOne_ = count_ - 1;

        requests_ = new DBBaseRequestDS[count_];
        heldRequests.copyInto(requests_);
        requests_[countMinusOne_] = lastRequest;
    }




/**
Returns the correlation ID.

@return The correlation ID.
**/
    int getCorrelation()
    {
        // Since we only need a reply from the last request, then
        // we will use its correlation ID.
	    return requests_[countMinusOne_].getCorrelation();
    }



/**
Sets the correlation ID.

@param id The correlation ID.
**/
    protected void setCorrelation(int id)
    {
        // Since we only need a reply from the last request, then
        // we will set its correlation ID.  The rest will be 0.
        for(int i = 0; i < countMinusOne_; ++i)
            requests_[i].setCorrelation(0);
        requests_[countMinusOne_].setCorrelation(id);
    }



/**
Write the datastream.

@param out  The output stream.

@exception IOException If an I/O error occurs.
**/
    void write(OutputStream out) throws IOException
    {
        // I tried just writing the requests in succession to "out"
        // but that resulted in separate requests (which is exactly
        // what we are trying to avoid here).  
        //
        // This code writes each request to a temporary byte array
        // and then sends that byte array all at once.  This results
        // in a superfluous byte copy which would be nice to avoid.
        // In most cases, the size of this byte array will be small,
        // since its used mostly for close requests, so it is still
        // beneficial.
        //
        ByteArrayOutputStream concatenated = new ByteArrayOutputStream();
        for(int i = 0; i < countMinusOne_; ++i) //@P1C - Don't mark the last one free yet...
        {
            synchronized(requests_[i]) {  // @A7A  
              requests_[i].write(concatenated);
              requests_[i].returnToPool();    requests_[i]=null; 
            }
        }
        requests_[countMinusOne_].write(concatenated); //@P1A - ...the caller will mark it free, we just write it.
                                                
        synchronized(out)                                     // @W1a
        {                                                     // @W1a
           out.write(concatenated.toByteArray());
           out.flush();       
        }                                                     // @W1a
        if (Trace.traceOn_) Trace.log(Trace.DATASTREAM, "Data stream sent (connID="+connectionID_+") ...", concatenated.toByteArray()); //@A1A @P0C
	}


}