1. /*

  2.  * @(#)ValueHandlerImpl_1_3.java	1.8 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. /*

  8.  * Licensed Materials - Property of IBM

  9.  * RMI-IIOP v1.0

  10.  * Copyright IBM Corp. 1998 1999  All Rights Reserved

  11.  *

  12.  * US Government Users Restricted Rights - Use, duplication or

  13.  * disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

  14.  */

  15. 

  16. package com.sun.corba.se.internal.orbutil;

  17. 

  18. import javax.rmi.CORBA.Util;

  19. import javax.rmi.PortableRemoteObject;

  20. 

  21. import java.util.Hashtable;

  22. import java.util.Stack;

  23. import java.io.IOException;

  24. import java.util.EmptyStackException;

  25. 

  26. import com.sun.corba.se.internal.util.Utility;

  27. import com.sun.corba.se.internal.io.IIOPInputStream;

  28. import com.sun.corba.se.internal.io.IIOPOutputStream;

  29. import com.sun.corba.se.internal.util.MinorCodes;

  30. import com.sun.corba.se.internal.util.RepositoryId;

  31. import com.sun.corba.se.internal.util.Utility;

  32. 

  33. import org.omg.CORBA.TCKind;

  34. import org.omg.CORBA.MARSHAL;

  35. import org.omg.CORBA.CompletionStatus;

  36. import org.omg.CORBA.portable.IndirectionException;

  37. import com.sun.org.omg.SendingContext.CodeBase;

  38. 

  39. import java.security.AccessController;

  40. import java.security.PrivilegedAction;

  41. 

  42. /**

  43.  * This class overrides behavior of our current ValueHandlerImpl to

  44.  * provide backwards compatibility with JDK 1.3.0.

  45.  */

  46. public class ValueHandlerImpl_1_3 extends com.sun.corba.se.internal.io.ValueHandlerImpl {

  47. 

  48.     public ValueHandlerImpl_1_3(){

  49. 	super();

  50.     }

  51. 

  52.     public ValueHandlerImpl_1_3(boolean isInputStream) {

  53. 	super(isInputStream);

  54.     }

  55. 

  56.     /**

  57.      * Writes the value to the stream using java semantics.

  58.      * @param out The stream to write the value to

  59.      * @param value The value to be written to the stream

  60.      **/

  61.     public void writeValue(org.omg.CORBA.portable.OutputStream _out, java.io.Serializable value) {

  62. 	super.writeValue(_out, value);

  63.     }

  64. 

  65.     /**

  66.      * Reads a value from the stream using java semantics.

  67.      * @param in The stream to read the value from

  68.      * @param clazz The type of the value to be read in

  69.      * @param sender The sending context runtime

  70.      **/

  71.     public java.io.Serializable readValue(org.omg.CORBA.portable.InputStream _in,

  72. 					  int offset, 

  73. 					  java.lang.Class clazz, 

  74. 					  String repositoryID,

  75. 					  org.omg.SendingContext.RunTime _sender)

  76.     {

  77. 	return super.readValue(_in, offset, clazz, repositoryID, _sender);

  78.     }

  79. 

  80.     /**

  81.      * Returns the repository ID for the given RMI value Class.

  82.      * @param clz The class to return a repository ID for.

  83.      * @return the repository ID of the Class.

  84.      **/

  85.     public java.lang.String getRMIRepositoryID(java.lang.Class clz) {

  86. 	return RepositoryId_1_3.createForJavaType(clz);

  87.     }

  88. 

  89.     /**

  90.      * Indicates whether the given Class performs custom or

  91.      * default marshaling.

  92.      * @param clz The class to test for custom marshaling.

  93.      * @return True if the class performs custom marshaling, false

  94.      * if it does not.

  95.      **/

  96.     public boolean isCustomMarshaled(java.lang.Class clz) {

  97. 	return super.isCustomMarshaled(clz);

  98.     }

  99. 

  100.     /**

  101.      * Returns the CodeBase for this ValueHandler.  This is used by

  102.      * the ORB runtime.  The server sends the service context containing

  103.      * the IOR for this CodeBase on the first GIOP reply.  The clients

  104.      * do the same on the first GIOP request.

  105.      * @return the SendingContext.CodeBase of this ValueHandler.

  106.      **/

  107.     public org.omg.SendingContext.RunTime getRunTimeCodeBase() {

  108. 	return super.getRunTimeCodeBase();

  109.     }

  110. 

  111.     /**

  112.      * If the value contains a writeReplace method then the result

  113.      * is returned.  Otherwise, the value itself is returned.

  114.      * @return the true value to marshal on the wire.

  115.      **/

  116.     public java.io.Serializable writeReplace(java.io.Serializable value) {

  117. 	return super.writeReplace(value);

  118.     }

  119. 

  120.     // methods supported for backward compatability so that the appropriate

  121.     // Rep-id calculations take place based on the ORB version

  122. 

  123.     /**

  124.      *  Returns a boolean of whether or not RepositoryId indicates

  125.      *  FullValueDescriptor.

  126.      *  used for backward compatability

  127.      */

  128. 

  129.      public boolean useFullValueDescription(Class clazz, String repositoryID) 

  130. 	throws IOException

  131. 	

  132.      {        

  133.         return RepositoryId_1_3.useFullValueDescription(clazz, repositoryID);

  134.      }

  135. 

  136.      public String getClassName(String id)

  137.      {

  138.         RepositoryId_1_3 repID = RepositoryId_1_3.cache.getId(id);

  139.         return repID.getClassName();

  140.      }

  141. 

  142.      public Class getClassFromType(String id)

  143.         throws ClassNotFoundException

  144.      {

  145.         RepositoryId_1_3 repId = RepositoryId_1_3.cache.getId(id);

  146.         return repId.getClassFromType();

  147.      }

  148. 

  149.      public Class getAnyClassFromType(String id)

  150.         throws ClassNotFoundException

  151.      {

  152.         RepositoryId_1_3 repId = RepositoryId_1_3.cache.getId(id);

  153.         return repId.getAnyClassFromType();

  154.      }

  155. 

  156.      public String createForAnyType(Class cl)

  157.      {

  158.         return RepositoryId_1_3.createForAnyType(cl);

  159.      }

  160.        

  161.      public String getDefinedInId(String id)

  162.      {

  163.         RepositoryId_1_3 repId = RepositoryId_1_3.cache.getId(id);

  164.         return repId.getDefinedInId();

  165.      }

  166. 

  167.      public String getUnqualifiedName(String id)

  168.      {

  169.         RepositoryId_1_3 repId = RepositoryId_1_3.cache.getId(id);

  170.         return repId.getUnqualifiedName();

  171.      }

  172. 

  173.      public String getSerialVersionUID(String id)

  174.      {

  175.         RepositoryId_1_3 repId = RepositoryId_1_3.cache.getId(id);

  176.         return repId.getSerialVersionUID();

  177.      }

  178. 

  179.      public boolean isAbstractBase(Class clazz)

  180.      {

  181.         return RepositoryId_1_3.isAbstractBase(clazz);

  182.      }

  183. 

  184.      public boolean isSequence(String id)

  185.      {

  186.         RepositoryId_1_3 repId = RepositoryId_1_3.cache.getId(id);

  187.         return repId.isSequence();

  188.      }

  189. 

  190.     /**

  191.      * Preserves the incorrect 1.3 behavior which truncates Java chars in

  192.      * arrays to 8-bit CORBA chars.  Bug 4367783.  This enables us to

  193.      * continue interoperating with our legacy ORBs.  If this goes into

  194.      * Ladybird, then Ladybird and Kestrel will interoperate as long as

  195.      * people don't use chars greater than 8-bits.

  196.      */

  197.     protected void writeCharArray(org.omg.CORBA_2_3.portable.OutputStream out,

  198.                                 char[] array,

  199.                                 int offset,

  200.                                 int length)

  201.     {

  202.         out.write_char_array(array, offset, length);

  203.     }

  204. 

  205.     /**

  206.      * Preserves the incorrect 1.3 behavior which truncates Java chars in

  207.      * arrays to 8-bit CORBA chars.  Bug 4367783.  This enables us to

  208.      * continue interoperating with our legacy ORBs.  If this goes into

  209.      * Ladybird, then Ladybird and Kestrel will interoperate as long as

  210.      * people don't use chars greater than 8-bits.

  211.      */

  212.     protected void readCharArray(org.omg.CORBA_2_3.portable.InputStream in,

  213.                                  char[] array,

  214.                                  int offset,

  215.                                  int length)

  216.     {

  217.         in.read_char_array(array, offset, length);

  218.     }

  219. 

  220.     protected final String getOutputStreamClassName() {

  221.         return "com.sun.corba.se.internal.orbutil.IIOPOutputStream_1_3";

  222.     }

  223. 

  224.     protected final String getInputStreamClassName() {

  225.         return "com.sun.corba.se.internal.orbutil.IIOPInputStream_1_3";

  226.     }

  227. 

  228.     /**

  229.      * Our JDK 1.3 and JDK 1.3.1 behavior subclasses override this.

  230.      * The correct behavior is for a Java char to map to a CORBA wchar,

  231.      * but our older code mapped it to a CORBA char.

  232.      */

  233.     protected TCKind getJavaCharTCKind() {

  234.         return TCKind.tk_char;

  235.     }

  236. }