1. /*

  2.  * @(#)CDROutputStream.java	1.24 03/01/23

  3.  *

  4.  * Copyright 2003 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. package com.sun.corba.se.internal.iiop;

  8. 

  9. import java.io.IOException;

  10. import java.io.Serializable;

  11. import java.math.BigDecimal;

  12. 

  13. import org.omg.CORBA.TypeCode;

  14. import org.omg.CORBA.Principal;

  15. import org.omg.CORBA.Any;

  16. import org.omg.CORBA.INTERNAL;

  17. import org.omg.CORBA.BAD_PARAM;

  18. import org.omg.CORBA.CompletionStatus;

  19. 

  20. import com.sun.corba.se.internal.core.GIOPVersion;

  21. import com.sun.corba.se.internal.core.CodeSetConversion;

  22. import com.sun.corba.se.internal.core.OSFCodeSetRegistry;

  23. import com.sun.corba.se.internal.orbutil.ORBConstants;

  24. import com.sun.corba.se.internal.orbutil.MinorCodes;

  25. 

  26. /**

  27.  * This is delegates to the real implementation.

  28.  */

  29. public abstract class CDROutputStream

  30.     extends org.omg.CORBA_2_3.portable.OutputStream

  31.     implements com.sun.corba.se.internal.core.MarshalOutputStream,

  32.                org.omg.CORBA.DataOutputStream

  33. {

  34.     private CDROutputStreamBase impl;

  35. 

  36.     // We can move this out somewhere later.  For now, it serves its purpose

  37.     // to create a concrete CDR delegate based on the GIOP version.

  38.     private static class OutputStreamFactory {

  39.         

  40.         public static CDROutputStreamBase newOutputStream(GIOPVersion version)

  41.         {

  42.             switch(version.intValue())

  43.             {

  44.                 case GIOPVersion.VERSION_1_0:

  45.                     return new CDROutputStream_1_0();

  46.                 case GIOPVersion.VERSION_1_1:

  47.                     return new CDROutputStream_1_1();

  48.                 case GIOPVersion.VERSION_1_2:

  49.                     return new CDROutputStream_1_2();

  50.                 default:

  51.                     // REVISIT - what is appropriate?  INTERNAL exceptions

  52.                     // are really hard to track later.

  53.                     throw new org.omg.CORBA.INTERNAL();

  54.             }

  55.         }

  56.     }

  57. 

  58.     // Called by IIOPOutputStream

  59.     public CDROutputStream(org.omg.CORBA.ORB orb,

  60.                            GIOPVersion version) 

  61.     {

  62.         impl = OutputStreamFactory.newOutputStream(version);

  63. 

  64.         BufferManagerWrite bufMgr

  65.             = BufferManagerFactory.newBufferManagerWrite(version, orb);

  66. 

  67.         impl.init(orb, bufMgr);

  68.         impl.setParent(this);

  69.     }

  70. 

  71.     // Required by EncapsOutputStream

  72.     public CDROutputStream(org.omg.CORBA.ORB orb,

  73.                            GIOPVersion version,

  74.                            boolean allowFragmentation,

  75.                            boolean littleEndian) {

  76.         

  77.         int size;

  78.         if (orb != null)

  79.             size = ((com.sun.corba.se.internal.corba.ORB)orb).getGIOPBufferSize();

  80.         else

  81.             size = ORBConstants.GIOP_DEFAULT_BUFFER_SIZE;

  82. 

  83.         BufferManagerWrite bufMgr;

  84.         if (!allowFragmentation)

  85.             bufMgr = new BufferManagerWriteGrow(size);

  86.         else

  87.             bufMgr = BufferManagerFactory.newBufferManagerWrite(version, orb, size);

  88. 

  89.         impl = OutputStreamFactory.newOutputStream(version);

  90.         

  91.         impl.init(orb, littleEndian, bufMgr.getInitialBufferSize(), bufMgr);

  92.         impl.setParent(this);

  93.     }

  94. 

  95.     public CDROutputStream(org.omg.CORBA.ORB orb,

  96.                            GIOPVersion version,

  97.                            int size,

  98.                            boolean allowFragmentation) {

  99. 

  100.         BufferManagerWrite bufMgr;

  101.         if (!allowFragmentation)

  102.             bufMgr = new BufferManagerWriteGrow(size);

  103.         else

  104.             bufMgr = BufferManagerFactory.newBufferManagerWrite(version, orb, size);

  105. 

  106.         impl = OutputStreamFactory.newOutputStream(version);

  107.         

  108.         impl.init(orb, bufMgr);

  109.         impl.setParent(this);

  110.     }

  111.         

  112.     // This is used by 

  113.     // ServiceContext for creating encapsulations of correct version encoding.

  114.     // ADDED (Ram J) (05/20/2000)

  115.     public CDROutputStream(org.omg.CORBA.ORB orb, GIOPVersion version,

  116.             boolean allowFragmentation) {

  117. 

  118.         if (allowFragmentation == false) {

  119.             impl = OutputStreamFactory.newOutputStream(version);

  120. 

  121.             // A grow strategy is used for encoding encapsulations.

  122.             // streaming behaviour is incorrect.

  123.             BufferManagerWrite bufMgr = null;

  124.             if (orb == null || !(orb instanceof com.sun.corba.se.internal.corba.ORB)) {

  125.                 bufMgr = new BufferManagerWriteGrow(ORBConstants.GIOP_DEFAULT_BUFFER_SIZE);

  126.             } else {

  127.                 int defaultBufSize = ((com.sun.corba.se.internal.corba.ORB) orb).getGIOPBufferSize();

  128.                 bufMgr = new BufferManagerWriteGrow(defaultBufSize);

  129.             }

  130. 

  131.             impl.init(orb, bufMgr);

  132.             impl.setParent(this);

  133.         } else {

  134.             impl = OutputStreamFactory.newOutputStream(version);

  135. 

  136.             BufferManagerWrite bufMgr

  137.                 = BufferManagerFactory.newBufferManagerWrite(version, orb);

  138. 

  139.             impl.init(orb, bufMgr);

  140.             impl.setParent(this);

  141.         }

  142.     }

  143. 

  144.     // org.omg.CORBA.portable.OutputStream

  145. 

  146.     // Provided by IIOPOutputStream and EncapsOutputStream

  147.     public abstract org.omg.CORBA.portable.InputStream create_input_stream();

  148. 

  149.     public final void write_boolean(boolean value) {

  150.         impl.write_boolean(value);

  151.     }

  152.     public final void write_char(char value) {

  153.         impl.write_char(value);

  154.     }

  155.     public final void write_wchar(char value) {

  156.         impl.write_wchar(value);

  157.     }

  158.     public final void write_octet(byte value) {

  159.         impl.write_octet(value);

  160.     }

  161.     public final void write_short(short value) {

  162.         impl.write_short(value);

  163.     }

  164.     public final void write_ushort(short value) {

  165.         impl.write_ushort(value);

  166.     }

  167.     public final void write_long(int value) {

  168.         impl.write_long(value);

  169.     }

  170.     public final void write_ulong(int value) {

  171.         impl.write_ulong(value);

  172.     }

  173.     public final void write_longlong(long value) {

  174.         impl.write_longlong(value);

  175.     }

  176.     public final void write_ulonglong(long value) {

  177.         impl.write_ulonglong(value);

  178.     }

  179.     public final void write_float(float value) {

  180.         impl.write_float(value);

  181.     }

  182.     public final void write_double(double value) {

  183.         impl.write_double(value);

  184.     }

  185.     public final void write_string(String value) {

  186.         impl.write_string(value);

  187.     }

  188.     public final void write_wstring(String value) {

  189.         impl.write_wstring(value);

  190.     }

  191. 

  192.     public final void write_boolean_array(boolean[] value, int offset, int length) {

  193.         impl.write_boolean_array(value, offset, length);

  194.     }

  195.     public final void write_char_array(char[] value, int offset, int length) {

  196.         impl.write_char_array(value, offset, length);

  197.     }

  198.     public final void write_wchar_array(char[] value, int offset, int length) {

  199.         impl.write_wchar_array(value, offset, length);

  200.     }

  201.     public final void write_octet_array(byte[] value, int offset, int length) {

  202.         impl.write_octet_array(value, offset, length);

  203.     }

  204.     public final void write_short_array(short[] value, int offset, int length) {

  205.         impl.write_short_array(value, offset, length);

  206.     }

  207.     public final void write_ushort_array(short[] value, int offset, int length) {

  208.         impl.write_ushort_array(value, offset, length);

  209.     }

  210.     public final void write_long_array(int[] value, int offset, int length) {

  211.         impl.write_long_array(value, offset, length);

  212.     }

  213.     public final void write_ulong_array(int[] value, int offset, int length) {

  214.         impl.write_ulong_array(value, offset, length);

  215.     }

  216.     public final void write_longlong_array(long[] value, int offset, int length) {

  217.         impl.write_longlong_array(value, offset, length);

  218.     }

  219.     public final void write_ulonglong_array(long[] value, int offset, int length) {

  220.         impl.write_ulonglong_array(value, offset, length);

  221.     }

  222.     public final void write_float_array(float[] value, int offset, int length) {

  223.         impl.write_float_array(value, offset, length);

  224.     }

  225.     public final void write_double_array(double[] value, int offset, int length) {

  226.         impl.write_double_array(value, offset, length);

  227.     }

  228.     public final void write_Object(org.omg.CORBA.Object value) {

  229.         impl.write_Object(value);

  230.     }

  231.     public final void write_TypeCode(TypeCode value) {

  232.         impl.write_TypeCode(value);

  233.     }

  234.     public final void write_any(Any value) {

  235.         impl.write_any(value);

  236.     }

  237. 

  238.     public final void write_Principal(Principal value) {

  239.         impl.write_Principal(value);

  240.     }

  241. 

  242.     public final void write(int b) throws java.io.IOException {

  243.         impl.write(b);

  244.     }

  245.     

  246.     public final void write_fixed(java.math.BigDecimal value) {

  247.         impl.write_fixed(value);

  248.     }

  249. 

  250.     public final void write_Context(org.omg.CORBA.Context ctx,

  251. 			      org.omg.CORBA.ContextList contexts) {

  252.         impl.write_Context(ctx, contexts);

  253.     }

  254. 

  255.     public final org.omg.CORBA.ORB orb() {

  256.         return impl.orb();

  257.     }

  258. 

  259.     // org.omg.CORBA_2_3.portable.OutputStream

  260.     public final void write_value(java.io.Serializable value) {

  261.         impl.write_value(value);

  262.     }

  263. 

  264.     public final void write_value(java.io.Serializable value, java.lang.Class clz) {

  265.         impl.write_value(value, clz);

  266.     }

  267. 

  268.     public final void write_value(java.io.Serializable value, String repository_id) {

  269.         impl.write_value(value, repository_id);

  270.     }

  271. 

  272.     public final void write_value(java.io.Serializable value, 

  273.                             org.omg.CORBA.portable.BoxedValueHelper factory) {

  274.         impl.write_value(value, factory);

  275.     }

  276. 

  277.     public final void write_abstract_interface(java.lang.Object obj) {

  278.         impl.write_abstract_interface(obj);

  279.     }

  280. 

  281.     // java.io.OutputStream

  282.     public final void write(byte b[]) throws IOException {

  283.         impl.write(b);

  284.     }

  285. 

  286.     public final void write(byte b[], int off, int len) throws IOException {

  287.         impl.write(b, off, len);

  288.     }

  289. 

  290.     public final void flush() throws IOException {

  291.         impl.flush();

  292.     }

  293. 

  294.     public final void close() throws IOException {

  295.         impl.close();

  296.     }

  297. 

  298.     // com.sun.corba.se.internal.core.MarshalOutputStream

  299.     public final void start_block() {

  300.         impl.start_block();

  301.     }

  302. 

  303.     public final void end_block() {

  304.         impl.end_block();

  305.     }

  306. 

  307.     public final void putEndian() {

  308.         impl.putEndian();

  309.     }

  310. 

  311.     // Overridden by IIOPOutputStream

  312.     public void writeTo(java.io.OutputStream stream) throws IOException {

  313.         impl.writeTo(stream);

  314.     }

  315. 

  316.     public final byte[] toByteArray() {

  317.         return impl.toByteArray();

  318.     }

  319. 

  320.     // org.omg.CORBA.DataOutputStream

  321.     public final void write_Abstract (java.lang.Object value) {

  322.         impl.write_Abstract(value);

  323.     }

  324. 

  325.     public final void write_Value (java.io.Serializable value) {

  326.         impl.write_Value(value);

  327.     }

  328. 

  329.     public final void write_any_array(org.omg.CORBA.Any[] seq, int offset, int length) {

  330.         impl.write_any_array(seq, offset, length);

  331.     }

  332. 

  333.     // org.omg.CORBA.portable.ValueBase

  334.     public final String[] _truncatable_ids() {

  335.         return impl._truncatable_ids();

  336.     }

  337. 

  338.     // Other

  339.     protected final int getSize() {

  340.         return impl.getSize();

  341.     }

  342. 

  343.     protected final int getIndex() {

  344.         return impl.getIndex();

  345.     }

  346. 

  347.     protected int getRealIndex(int index) {

  348.         // Used in indirections. Overridden by TypeCodeOutputStream.

  349.         return index;

  350.     }

  351. 

  352.     protected final void setIndex(int value) {

  353.         impl.setIndex(value);

  354.     }

  355. 

  356.     protected final byte[] getByteBuffer() {

  357.         return impl.getByteBuffer();

  358.     }

  359. 

  360.     protected final void setByteBuffer(byte value[]) {

  361.         impl.setByteBuffer(value);

  362.     }

  363. 

  364.     public final boolean isLittleEndian() {

  365.         return impl.isLittleEndian();

  366.     }

  367. 

  368.     protected final ByteBufferWithInfo getByteBufferWithInfo() {

  369.         return impl.getByteBufferWithInfo();

  370.     }

  371. 

  372.     protected final void setByteBufferWithInfo(ByteBufferWithInfo bbwi) {

  373.         impl.setByteBufferWithInfo(bbwi);

  374.     }

  375. 

  376.     protected final BufferManagerWrite getBufferManager() {

  377.         return impl.getBufferManager();

  378.     }

  379. 

  380.     public final void write_fixed(java.math.BigDecimal bigDecimal, short digits, short scale) {

  381.         impl.write_fixed(bigDecimal, digits, scale);

  382.     }

  383. 

  384.     public final void writeOctetSequenceTo(org.omg.CORBA.portable.OutputStream s) {

  385.         impl.writeOctetSequenceTo(s);

  386.     }

  387. 

  388.     public final GIOPVersion getGIOPVersion() {

  389.         return impl.getGIOPVersion();

  390.     }

  391. 

  392.     public final void writeIndirection(int tag, int posIndirectedTo) {

  393.         impl.writeIndirection(tag, posIndirectedTo);

  394.     }

  395. 

  396.     // Use Latin-1 for GIOP 1.0 or when code set negotiation was not

  397.     // performed.

  398.     protected CodeSetConversion.CTBConverter createCharCTBConverter() {

  399.         return CodeSetConversion.impl().getCTBConverter(OSFCodeSetRegistry.ISO_8859_1);

  400.     }

  401. 

  402.     // Subclasses must decide what to do here.  It's inconvenient to

  403.     // make the class and this method abstract because of dup().

  404.     protected abstract CodeSetConversion.CTBConverter createWCharCTBConverter();

  405. 

  406.     protected final void freeInternalCaches() {

  407.         impl.freeInternalCaches();

  408.     }

  409. 

  410.     void printBuffer() {

  411.         impl.printBuffer();

  412.     }

  413. 

  414.     public void alignOnBoundary(int octetBoundary) {

  415.         impl.alignOnBoundary(octetBoundary);

  416.     }

  417. }