import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
public CDROutputObject(ORB orb,
                       MessageMediator messageMediator,
                       Message header,
                       byte streamFormatVersion)
{
    this(
        orb,
        ((CorbaMessageMediator)messageMediator).getGIOPVersion(),
        header,
        BufferManagerFactory.newBufferManagerWrite(
            ((CorbaMessageMediator)messageMediator).getGIOPVersion(),
            header.getEncodingVersion(),
            orb),
        streamFormatVersion,
        (CorbaMessageMediator)messageMediator);
}
 

import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
public CDROutputObject(ORB orb,
                       MessageMediator messageMediator,
                       Message header,
                       byte streamFormatVersion,
                       int strategy)
{
    this(
        orb,
        ((CorbaMessageMediator)messageMediator).getGIOPVersion(),
        header,
        BufferManagerFactory.
            newBufferManagerWrite(strategy,
                                  header.getEncodingVersion(),
                                  orb),
        streamFormatVersion,
        (CorbaMessageMediator)messageMediator);
}
 

import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
public MessageMediator createMessageMediator(Broker broker,
                                             ContactInfo contactInfo,
                                             Connection connection,
                                             String methodName,
                                             boolean isOneWay)
{
    // REVISIT: Would like version, ior, requestid, etc., decisions
    // to be in client subcontract.  Cannot pass these to this
    // factory method because it breaks generic abstraction.
    // Maybe set methods on mediator called from subcontract
    // after creation?
    CorbaMessageMediator messageMediator =
        new CorbaMessageMediatorImpl(
            (ORB) broker,
            contactInfo,
            connection,
            GIOPVersion.chooseRequestVersion( (ORB)broker,
                 effectiveTargetIOR),
            effectiveTargetIOR,
            ((CorbaConnection)connection).getNextRequestId(),
            getAddressingDisposition(),
            methodName,
            isOneWay);

    return messageMediator;
}
 

import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
public MessageMediator createMessageMediator(Broker broker,
                                             ContactInfo contactInfo,
                                             Connection connection,
                                             String methodName,
                                             boolean isOneWay)
{
    if (connection != null) {
        /// XXX LOGGING
        throw new RuntimeException("connection is not null");
    }

    CorbaMessageMediator messageMediator =
        new CorbaMessageMediatorImpl(
            (ORB) broker,
            contactInfo,
            null, // Connection;
            GIOPVersion.chooseRequestVersion( (ORB)broker,
                 effectiveTargetIOR),
            effectiveTargetIOR,
            requestId++, // Fake RequestId
            getAddressingDisposition(),
            methodName,
            isOneWay);

    return messageMediator;
}
 

import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
public static CDROutputObject newCDROutputObject(
        final ORB orb, final MessageMediator messageMediator,
        final Message header, final byte streamFormatVersion) {
    return AccessController.doPrivileged(
        new PrivilegedAction<CDROutputObject>() {
            @Override
            public CDROutputObject run() {
                return new CDROutputObject(orb, messageMediator,
                    header, streamFormatVersion);
            }
    });
}
 

import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
public OutputObject createOutputObject(MessageMediator messageMediator)
{
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;

    OutputObject outputObject =
        sun.corba.OutputStreamFactory.newCDROutputObject(orb, messageMediator,
                            corbaMessageMediator.getRequestHeader(),
                            corbaMessageMediator.getStreamFormatVersion());

    messageMediator.setOutputObject(outputObject);
    return outputObject;
}
 

import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
public MessageMediator getMessageMediator(int requestId)
{
    Integer id = new Integer(requestId);
    OutCallDesc call = out_calls.get(id);
    if (call == null) {
        // This can happen when getting early reply fragments for a
        // request which has completed (e.g., client marshaling error).
        return null;
    }
    return call.messageMediator;
}
 

import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
public MessageMediator finishCreatingMessageMediator(Broker broker,
                           Connection conn, MessageMediator messageMediator)
{
    ORB orb = (ORB) broker;
    CorbaConnection connection = (CorbaConnection) conn;
    CorbaMessageMediator corbaMessageMediator =
                  (CorbaMessageMediator)messageMediator;

    if (orb.transportDebugFlag) {
        dprint(
        ".finishCreatingMessageMediator: waiting for message body on connection: "
            + connection);
    }

    Message msg = corbaMessageMediator.getDispatchHeader();
    msg.setByteBuffer(corbaMessageMediator.getDispatchBuffer());

    // read giop body only
    msg = MessageBase.readGIOPBody(orb, connection, msg);

    ByteBuffer byteBuffer = msg.getByteBuffer();
    msg.setByteBuffer(null);
    corbaMessageMediator.setDispatchHeader(msg);
    corbaMessageMediator.setDispatchBuffer(byteBuffer);

    return corbaMessageMediator;
}
 

import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
protected void unregisterWaiter(ORB orb)
{
    MessageMediator messageMediator =
        orb.getInvocationInfo().getMessageMediator();
    if (messageMediator!=null && messageMediator.getConnection() != null) {
        // REVISIT:
        // The messageMediator may be null if COMM_FAILURE before
        // it is created.
        messageMediator.getConnection().unregisterWaiter(messageMediator);
    }
}
 

import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
public InputObject createInputObject(Broker broker,
                                     MessageMediator messageMediator)
{
    // REVISIT: Duplicate of acceptor code.
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;
    return new CDRInputObject((ORB)broker,
                              (CorbaConnection)messageMediator.getConnection(),
                              corbaMessageMediator.getDispatchBuffer(),
                              corbaMessageMediator.getDispatchHeader());
}
 

import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
public void dispatch(MessageMediator mediator)
{
    CorbaMessageMediator request = (CorbaMessageMediator) mediator;
    // send a locate forward with the right IOR. If the insKey is not
    // registered then it will throw OBJECT_NOT_EXIST Exception
    String insKey = new String( request.getObjectKey().getBytes(orb) );
    request.getProtocolHandler()
        .createLocationForward(request, getINSReference( insKey ), null);
    return;
}
 

import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
public boolean handleRequest(MessageMediator messageMediator)
{
    try {
        dispatchHeader.callback(this);
    } catch (IOException e) {
        // REVISIT - this should be handled internally.
        ;
    }
    return isThreadDone;
}
 

import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
public OutputObject createOutputObject(Broker broker,
                                       MessageMediator messageMediator)
{
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;
    return sun.corba.OutputStreamFactory.newCDROutputObject((ORB) broker,
                   corbaMessageMediator, corbaMessageMediator.getReplyHeader(),
                   corbaMessageMediator.getStreamFormatVersion());
}
 

import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
public OutputObject createOutputObject(MessageMediator messageMediator)
{
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;
    // NOTE: GROW.
    OutputObject outputObject =
        sun.corba.OutputStreamFactory.newCDROutputObject(orb, messageMediator,
                            corbaMessageMediator.getRequestHeader(),
                            corbaMessageMediator.getStreamFormatVersion(),
                            BufferManagerFactory.GROW);
    messageMediator.setOutputObject(outputObject);
    return outputObject;
}
 

import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
public MessageMediator createMessageMediator(Broker broker,Connection conn)
{
    ORB orb = (ORB) broker;
    CorbaConnection connection = (CorbaConnection) conn;

    if (orb.transportDebugFlag) {
        if (connection.shouldReadGiopHeaderOnly()) {
            dprint(
            ".createMessageMediator: waiting for message header on connection: "
            + connection);
        } else {
            dprint(
            ".createMessageMediator: waiting for message on connection: "
            + connection);
        }
    }

    Message msg = null;

    if (connection.shouldReadGiopHeaderOnly()) {
        // read giop header only
        msg = MessageBase.readGIOPHeader(orb, connection);
    } else {
        // read entire giop message
        msg = MessageBase.readGIOPMessage(orb, connection);
    }

    ByteBuffer byteBuffer = msg.getByteBuffer();
    msg.setByteBuffer(null);
    CorbaMessageMediator messageMediator =
        new CorbaMessageMediatorImpl(orb, connection, msg, byteBuffer);

    return messageMediator;
}
 

import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
public MessageMediator createMessageMediator(Broker broker,
                                             Connection connection)
{
    // REVISIT - no factoring so cheat to avoid code dup right now.
    // REVISIT **** COUPLING !!!!
    ContactInfo contactInfo = new SocketOrChannelContactInfoImpl();
    return contactInfo.createMessageMediator(broker, connection);
}
 

import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
public void registerWaiter(MessageMediator mediator)
{
    CorbaMessageMediator messageMediator = (CorbaMessageMediator) mediator;

    if (orb.transportDebugFlag) {
        dprint(".registerWaiter: " + opAndId(messageMediator));
    }

    Integer requestId = messageMediator.getRequestIdInteger();

    OutCallDesc call = new OutCallDesc();
    call.thread = Thread.currentThread();
    call.messageMediator = messageMediator;
    out_calls.put(requestId, call);
}
 

import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
public MessageMediator finishCreatingMessageMediator(Broker broker,
                                                     Connection connection,
                                                     MessageMediator messageMediator)
{
    // REVISIT - no factoring so cheat to avoid code dup right now.
    // REVISIT **** COUPLING !!!!
    ContactInfo contactInfo = new SocketOrChannelContactInfoImpl();
    return contactInfo.finishCreatingMessageMediator(broker,
                                      connection, messageMediator);
}
 

import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
public InputObject createInputObject(Broker broker,
                                     MessageMediator messageMediator)
{
    CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator)
        messageMediator;
    return new CDRInputObject((ORB)broker,
                              (CorbaConnection)messageMediator.getConnection(),
                              corbaMessageMediator.getDispatchBuffer(),
                              corbaMessageMediator.getDispatchHeader());
}
 

import com.sun.corba.se.pept.protocol.MessageMediator; //导入依赖的package包/类
public void serverRequest_1_1_Put(MessageMediator x)
{
    serverRequest_1_1 = x;
}