1. /*

  2.  * @(#)ORBUtility.java	1.18 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. package com.sun.corba.se.internal.orbutil;

  9. 

  10. import java.util.Hashtable;

  11. import java.util.Enumeration;

  12. import java.util.Properties;

  13. import java.lang.reflect.Field;

  14. 

  15. import javax.rmi.CORBA.ValueHandler;

  16. import javax.rmi.CORBA.Util;

  17. 

  18. import org.omg.CORBA.*;

  19. import org.omg.CORBA.portable.*;

  20. import org.omg.CORBA.TypeCodePackage.*;

  21. 

  22. import java.rmi.NoSuchObjectException;

  23. import java.util.NoSuchElementException;

  24. 

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

  26. import com.sun.corba.se.internal.core.ORBVersion ;

  27. import com.sun.corba.se.internal.core.ORBVersionImpl ;

  28. 

  29. /**

  30.  *  Handy class full of static functions that don't belong in util.Utility for pure ORB reasons.

  31.  */

  32. public final class ORBUtility {

  33.     private ORBUtility() {}

  34. 

  35.     private static StructMember[] members = null;

  36. 

  37.     private static StructMember[] systemExceptionMembers (ORB orb) {

  38.         if (members == null) {

  39.             members = new StructMember[3];

  40.             members[0] = new StructMember("id", orb.create_string_tc(0), null);

  41.             members[1] = new StructMember("minor", orb.get_primitive_tc(TCKind.tk_long), null);

  42.             members[2] = new StructMember("completed", orb.get_primitive_tc(TCKind.tk_long), null);

  43.         }

  44.         return members;

  45.     }

  46. 

  47.     private static TypeCode getSystemExceptionTypeCode(ORB orb, String repID, String name) {

  48.         synchronized (TypeCode.class) {

  49.             return orb.create_exception_tc(repID, name, systemExceptionMembers(orb));

  50.         }

  51.     }

  52. 

  53.     private static boolean isSystemExceptionTypeCode(TypeCode type, ORB orb) {

  54.         StructMember[] systemExceptionMembers = systemExceptionMembers(orb);

  55.         try {

  56.             return (type.kind().value() == TCKind._tk_except &&

  57.                     type.member_count() == 3 &&

  58.                     type.member_type(0).equal(systemExceptionMembers[0].type) &&

  59.                     type.member_type(1).equal(systemExceptionMembers[1].type) &&

  60.                     type.member_type(2).equal(systemExceptionMembers[2].type));

  61.         } catch (BadKind ex) {

  62.             return false;

  63.         } catch (org.omg.CORBA.TypeCodePackage.Bounds ex) {

  64.             return false;

  65.         }

  66.     }

  67. 

  68.     /**

  69.      * Static method for writing a CORBA standard exception to an Any.

  70.      * @param any The Any to write the SystemException into.

  71.      */

  72.     public static void insertSystemException(SystemException ex, Any any) {

  73.         OutputStream out = any.create_output_stream();

  74.         ORB orb = out.orb();

  75.         String name = ex.getClass().getName();

  76.         String repID = ORBUtility.repositoryIdOf(name);

  77.         out.write_string(repID);

  78.         out.write_long(ex.minor);

  79.         out.write_long(ex.completed.value());

  80.         any.read_value(out.create_input_stream(), 

  81. 	    getSystemExceptionTypeCode(orb, repID, name));

  82.     }

  83. 

  84.     public static SystemException extractSystemException(Any any) {

  85.         InputStream in = any.create_input_stream();

  86.         ORB orb = in.orb();

  87.         if ( ! isSystemExceptionTypeCode(any.type(), orb)) {

  88. 	    return new org.omg.CORBA.UNKNOWN(MinorCodes.UNKNOWN_DSI_SYSEX,

  89. 					     CompletionStatus.COMPLETED_MAYBE);

  90.         }

  91.         return ORBUtility.readSystemException(in);

  92.     }

  93. 

  94.     /**

  95.      * Creates the correct ValueHandler for the given ORB, 

  96.      * querying ORBVersion information.  If the ORB or

  97.      * ORBVersion is null, gets the ValueHandler from

  98.      * Util.createValueHandler.

  99.      */

  100.     public static ValueHandler createValueHandler(com.sun.corba.se.internal.corba.ORB orb) {

  101. 

  102.         if (orb == null)

  103.             return Util.createValueHandler();

  104. 

  105.         ORBVersion version = orb.getORBVersion();

  106. 

  107.         if (version == null)

  108.             return Util.createValueHandler();

  109. 

  110.         if (version.equals(ORBVersionImpl.OLD))

  111.             return new ValueHandlerImpl_1_3();

  112.         if (version.equals(ORBVersionImpl.NEW))

  113.             return new ValueHandlerImpl_1_3_1();

  114. 

  115.         return Util.createValueHandler();

  116.     }

  117. 

  118.     /**

  119.      * Returns true if the given ORB could accurately be determined to be a

  120.      * Kestrel or earlier ORB.  Note: If passed the ORBSingleton, this will return

  121.      * false.

  122.      */

  123.     public static boolean isLegacyORB(com.sun.corba.se.internal.corba.ORB orb) 

  124.     {

  125.         try {

  126.             ORBVersion currentORB = orb.getORBVersion();

  127.             return currentORB.equals( ORBVersionImpl.OLD ) ;

  128.         } catch (SecurityException se) {

  129.             return false;

  130.         }

  131.     }

  132. 

  133.     /**

  134.      * Returns true if it was accurately determined that the remote ORB is

  135.      * a foreign (non-JavaSoft) ORB.  Note:  If passed the ORBSingleton, this

  136.      * will return false.

  137.      */

  138.     public static boolean isForeignORB(com.sun.corba.se.internal.corba.ORB orb)

  139.     {

  140.         if (orb == null)

  141.             return false;

  142. 

  143.         try {

  144.             return orb.getORBVersion().equals(ORBVersionImpl.FOREIGN);

  145.         } catch (SecurityException se) {

  146.             return false;

  147.         }

  148.     }

  149. 

  150.     /** Unmarshal a byte array to an integer.

  151.         Assume the bytes are in BIGENDIAN order.

  152.         i.e. array[offset] is the most-significant-byte

  153.         and  array[offset+3] is the least-significant-byte.

  154.         @param array The array of bytes.

  155.         @param offset The offset from which to start unmarshalling.

  156.     */

  157.     public static int bytesToInt(byte[] array, int offset)

  158.     {

  159.         int b1, b2, b3, b4;

  160. 

  161.         b1 = (array[offset++] << 24) & 0xFF000000;

  162.         b2 = (array[offset++] << 16) & 0x00FF0000;

  163.         b3 = (array[offset++] << 8)  & 0x0000FF00;

  164.         b4 = (array[offset++] << 0)  & 0x000000FF;

  165. 

  166.         return (b1 | b2 | b3 | b4);

  167.     }

  168. 

  169.     /** Marshal an integer to a byte array.

  170.         The bytes are in BIGENDIAN order.

  171.         i.e. array[offset] is the most-significant-byte

  172.         and  array[offset+3] is the least-significant-byte.

  173.         @param array The array of bytes.

  174.         @param offset The offset from which to start marshalling.

  175.     */

  176.     public static void intToBytes(int value, byte[] array, int offset)

  177.     {

  178.         array[offset++] = (byte)((value >>> 24) & 0xFF);

  179.         array[offset++] = (byte)((value >>> 16) & 0xFF);

  180.         array[offset++] = (byte)((value >>> 8) & 0xFF);

  181.         array[offset++] = (byte)((value >>> 0) & 0xFF);

  182.     }

  183. 

  184.     /** Converts an Ascii Character into Hexadecimal digit

  185.      */

  186.     public static int hexOf( char x )

  187.     {

  188. 	int val;

  189. 

  190.         val = x - '0';

  191.         if (val >=0 && val <= 9)

  192.             return val;

  193. 

  194.         val = (x - 'a') + 10;

  195.         if (val >= 10 && val <= 15)

  196.             return val;

  197. 

  198.         val = (x - 'A') + 10;

  199.         if (val >= 10 && val <= 15)

  200.             return val;

  201. 

  202.         throw new DATA_CONVERSION(MinorCodes.BAD_HEX_DIGIT,

  203.                                   CompletionStatus.COMPLETED_NO);

  204.     }

  205. 

  206.     // method moved from util.Utility

  207. 

  208.     /**

  209.      * Static method for writing a CORBA standard exception to a stream.

  210.      * @param strm The OutputStream to use for marshaling.

  211.      */

  212.     public static void writeSystemException(SystemException ex, OutputStream strm)

  213.     {

  214. 	String s;

  215. 

  216. 	s = repositoryIdOf(ex.getClass().getName());

  217.         strm.write_string(s);

  218.         strm.write_long(ex.minor);

  219.         strm.write_long(ex.completed.value());

  220.     }

  221. 

  222.     /**

  223.      * Static method for reading a CORBA standard exception from a stream.

  224.      * @param strm The InputStream to use for unmarshaling.

  225.      */

  226.     public static SystemException readSystemException(InputStream strm)

  227.     {

  228. 	try {

  229. 	    String name = classNameOf(strm.read_string());

  230. 	    SystemException ex 

  231.                 = (SystemException)ORBClassLoader.loadClass(name).newInstance();

  232. 	    ex.minor = strm.read_long();

  233. 	    ex.completed = CompletionStatus.from_int(strm.read_long());

  234. 	    return ex;

  235. 	} catch ( Exception ex ) {

  236. 	    return new org.omg.CORBA.UNKNOWN(MinorCodes.UNKNOWN_SYSEX,

  237. 					     CompletionStatus.COMPLETED_MAYBE);

  238. 	}

  239.     }

  240. 

  241.     /**

  242.      * Get the class name corresponding to a particular repository Id.

  243.      * This is used by the system to unmarshal (instantiate) the

  244.      * appropriate exception class for an marshaled as the value of

  245.      * its repository Id.

  246.      * @param repositoryId The repository Id for which we want a class name.

  247.      */

  248.     public static String classNameOf(String repositoryId)

  249.     {

  250. 	String className=null;

  251. 

  252. 	className = (String) exceptionClassNames.get(repositoryId);

  253. 	if (className == null)

  254. 	    className = "org.omg.CORBA.UNKNOWN";

  255. 

  256. 	return className;

  257.     }

  258. 

  259.     /**

  260.      * Return true if this repositoryId is a SystemException.

  261.      * @param repositoryId The repository Id to check.

  262.      */

  263.     public static boolean isSystemException(String repositoryId)

  264.     {

  265. 	String className=null;

  266. 

  267. 	className = (String) exceptionClassNames.get(repositoryId);

  268. 	if (className == null)

  269. 	    return false;

  270. 	else

  271. 	    return true;

  272.     }

  273. 

  274.     /**

  275.      * Get the repository id corresponding to a particular class.

  276.      * This is used by the system to write the

  277.      * appropriate repository id for a system exception.

  278.      * @param name The class name of the system exception.

  279.      */

  280.     public static String repositoryIdOf(String name)

  281.     {

  282. 	String id;

  283. 

  284. 	id = (String) exceptionRepositoryIds.get(name);

  285. 	if (id == null)

  286. 	    id = "IDL:omg.org/CORBA/UNKNOWN:1.0";

  287. 

  288. 	return id;

  289.     }

  290. 

  291.     private static final Hashtable exceptionClassNames = new Hashtable();

  292.     private static final Hashtable exceptionRepositoryIds = new Hashtable();

  293. 

  294.     static {

  295. 

  296. 	//

  297. 	// construct repositoryId -> className hashtable

  298. 	//

  299. 	exceptionClassNames.put("IDL:omg.org/CORBA/BAD_CONTEXT:1.0",

  300. 				"org.omg.CORBA.BAD_CONTEXT");

  301. 	exceptionClassNames.put("IDL:omg.org/CORBA/BAD_INV_ORDER:1.0",

  302. 				"org.omg.CORBA.BAD_INV_ORDER");

  303. 	exceptionClassNames.put("IDL:omg.org/CORBA/BAD_OPERATION:1.0",

  304. 				"org.omg.CORBA.BAD_OPERATION");

  305. 	exceptionClassNames.put("IDL:omg.org/CORBA/BAD_PARAM:1.0",

  306. 				"org.omg.CORBA.BAD_PARAM");

  307. 	exceptionClassNames.put("IDL:omg.org/CORBA/BAD_TYPECODE:1.0",

  308. 				"org.omg.CORBA.BAD_TYPECODE");

  309. 	exceptionClassNames.put("IDL:omg.org/CORBA/COMM_FAILURE:1.0",

  310. 				"org.omg.CORBA.COMM_FAILURE");

  311. 	exceptionClassNames.put("IDL:omg.org/CORBA/DATA_CONVERSION:1.0",

  312. 				"org.omg.CORBA.DATA_CONVERSION");

  313. 	exceptionClassNames.put("IDL:omg.org/CORBA/IMP_LIMIT:1.0",

  314. 				"org.omg.CORBA.IMP_LIMIT");

  315. 	exceptionClassNames.put("IDL:omg.org/CORBA/INTF_REPOS:1.0",

  316. 				"org.omg.CORBA.INTF_REPOS");

  317. 	exceptionClassNames.put("IDL:omg.org/CORBA/INTERNAL:1.0",

  318. 				"org.omg.CORBA.INTERNAL");

  319. 	exceptionClassNames.put("IDL:omg.org/CORBA/INV_FLAG:1.0",

  320. 				"org.omg.CORBA.INV_FLAG");

  321. 	exceptionClassNames.put("IDL:omg.org/CORBA/INV_IDENT:1.0",

  322. 				"org.omg.CORBA.INV_IDENT");

  323. 	exceptionClassNames.put("IDL:omg.org/CORBA/INV_OBJREF:1.0",

  324. 				"org.omg.CORBA.INV_OBJREF");

  325. 	exceptionClassNames.put("IDL:omg.org/CORBA/MARSHAL:1.0",

  326. 				"org.omg.CORBA.MARSHAL");

  327. 	exceptionClassNames.put("IDL:omg.org/CORBA/NO_MEMORY:1.0",

  328. 				"org.omg.CORBA.NO_MEMORY");

  329. 	exceptionClassNames.put("IDL:omg.org/CORBA/FREE_MEM:1.0",

  330. 				"org.omg.CORBA.FREE_MEM");

  331. 	exceptionClassNames.put("IDL:omg.org/CORBA/NO_IMPLEMENT:1.0",

  332. 				"org.omg.CORBA.NO_IMPLEMENT");

  333. 	exceptionClassNames.put("IDL:omg.org/CORBA/NO_PERMISSION:1.0",

  334. 				"org.omg.CORBA.NO_PERMISSION");

  335. 	exceptionClassNames.put("IDL:omg.org/CORBA/NO_RESOURCES:1.0",

  336. 				"org.omg.CORBA.NO_RESOURCES");

  337. 	exceptionClassNames.put("IDL:omg.org/CORBA/NO_RESPONSE:1.0",

  338. 				"org.omg.CORBA.NO_RESPONSE");

  339. 	exceptionClassNames.put("IDL:omg.org/CORBA/OBJ_ADAPTER:1.0",

  340. 				"org.omg.CORBA.OBJ_ADAPTER");

  341. 	exceptionClassNames.put("IDL:omg.org/CORBA/INITIALIZE:1.0",

  342. 				"org.omg.CORBA.INITIALIZE");

  343. 	exceptionClassNames.put("IDL:omg.org/CORBA/PERSIST_STORE:1.0",

  344. 				"org.omg.CORBA.PERSIST_STORE");

  345. 	exceptionClassNames.put("IDL:omg.org/CORBA/TRANSIENT:1.0",

  346. 				"org.omg.CORBA.TRANSIENT");

  347. 	exceptionClassNames.put("IDL:omg.org/CORBA/UNKNOWN:1.0",

  348. 				"org.omg.CORBA.UNKNOWN");

  349. 	exceptionClassNames.put("IDL:omg.org/CORBA/OBJECT_NOT_EXIST:1.0",

  350. 				"org.omg.CORBA.OBJECT_NOT_EXIST");

  351. 

  352. 	// SystemExceptions from OMG Transactions Service Spec

  353. 	exceptionClassNames.put("IDL:omg.org/CORBA/INVALID_TRANSACTION:1.0",

  354. 				"org.omg.CORBA.INVALID_TRANSACTION");

  355. 	exceptionClassNames.put("IDL:omg.org/CORBA/TRANSACTION_REQUIRED:1.0",

  356. 				"org.omg.CORBA.TRANSACTION_REQUIRED");

  357. 	exceptionClassNames.put("IDL:omg.org/CORBA/TRANSACTION_ROLLEDBACK:1.0",

  358. 				"org.omg.CORBA.TRANSACTION_ROLLEDBACK");

  359. 

  360. 	// from portability RTF 98-07-01.txt

  361. 	exceptionClassNames.put("IDL:omg.org/CORBA/INV_POLICY:1.0",

  362. 				"org.omg.CORBA.INV_POLICY");

  363. 

  364. 	// from orbrev/00-09-01 (CORBA 2.4 Draft Specification)

  365. 	exceptionClassNames.

  366. 	    put("IDL:omg.org/CORBA/TRANSACTION_UNAVAILABLE:1.0",

  367. 				"org.omg.CORBA.TRANSACTION_UNAVAILABLE");

  368. 	exceptionClassNames.put("IDL:omg.org/CORBA/TRANSACTION_MODE:1.0",

  369. 				"org.omg.CORBA.TRANSACTION_MODE");

  370. 

  371. 	//

  372. 	// construct className -> repositoryId hashtable

  373. 	//

  374. 	Enumeration keys = exceptionClassNames.keys();

  375. 	java.lang.Object s;

  376. 	String rId;

  377. 	String cName;

  378. 

  379. 	try{

  380.             while (keys.hasMoreElements()) {

  381.                 s = keys.nextElement();

  382. 	        rId = (String) s;

  383. 	        cName = (String) exceptionClassNames.get(rId);

  384. 	        exceptionRepositoryIds.put (cName, rId);

  385. 	    }

  386. 	} catch (NoSuchElementException e) { }

  387.     }

  388. 

  389.     /** Parse a version string such as "1.1.6" or "jdk1.2fcs" into

  390. 	a version array of integers {1, 1, 6} or {1, 2}.

  391. 	A string of "n." or "n..m" is equivalent to "n.0" or "n.0.m" respectively.

  392.     */

  393.     public static int[] parseVersion(String version) {

  394. 	if (version == null)

  395. 	    return new int[0];

  396. 	char[] s = version.toCharArray();

  397. 	//find the maximum span of the string "n.n.n..." where n is an integer

  398. 	int start = 0;

  399. 	for (; start < s.length  && (s[start] < '0' || s[start] > '9'); ++start)

  400. 	    if (start == s.length)	//no digit found

  401. 		return new int[0];

  402. 	int end = start + 1;

  403. 	int size = 1;

  404. 	for (; end < s.length; ++end)

  405. 	    if (s[end] == '.')

  406. 		++size;

  407. 	    else if (s[end] < '0' || s[end] > '9')

  408. 		break;

  409. 	int[] val = new int[size];

  410. 	for (int i = 0; i < size; ++i) {

  411. 	    int dot = version.indexOf('.', start);

  412. 	    if (dot == -1 || dot > end)

  413. 		dot = end;

  414. 	    if (start >= dot)	//cases like "n." or "n..m"

  415. 		val[i] = 0;	//convert equivalent to "n.0" or "n.0.m"

  416. 	    else

  417. 		val[i] = Integer.parseInt(version.substring(start, dot));

  418. 	    start = dot + 1;

  419. 	}

  420. 	return val;

  421.     }

  422. 

  423.     /** Compare two version arrays.

  424. 	Return 1, 0 or -1 if v1 is greater than, equal to, or less than v2.

  425.     */

  426.     public static int compareVersion(int[] v1, int[] v2) {

  427. 	if (v1 == null)

  428. 	    v1 = new int[0];

  429. 	if (v2 == null)

  430. 	    v2 = new int[0];

  431. 	for (int i = 0; i < v1.length; ++i) {

  432. 	    if (i >= v2.length || v1[i] > v2[i])	//v1 is longer or greater than v2

  433. 		return 1;

  434. 	    if (v1[i] < v2[i])

  435. 		return -1;

  436. 	}

  437. 	return v1.length == v2.length ? 0 : -1;

  438.     }

  439. 

  440.     /** Compare two version strings.

  441. 	Return 1, 0 or -1 if v1 is greater than, equal to, or less than v2.

  442.     */

  443.     public static int compareVersion(String v1, String v2) {

  444. 	return compareVersion(parseVersion(v1), parseVersion(v2));

  445.     }

  446. 

  447.     /** A smarter toString that uses the built-in toString.

  448.      * If obj isA:

  449.      *	Object that supports toString() directly: call toString

  450.      *   array of objects: array[length]( toString results of non-null elements ) 

  451.      *   other: print the contents of the object's public fields.

  452.      * Note that this method is NOT SAFE FOR USE WITH CIRCULAR REFERENCES!

  453.      * It will go into an infinite recursion if handed the top level

  454.      * reference to a cyclic graph of objects.

  455.      */

  456.     public static String objectToString(java.lang.Object obj)

  457.     {

  458. 	if (obj==null)

  459. 	    return "null" ;

  460. 

  461. 	StringBuffer result = new StringBuffer() ;

  462. 	Class cls = obj.getClass() ;

  463. 	Class compClass = cls.getComponentType() ;

  464. 

  465. 	if (obj instanceof java.util.Properties) {

  466. 	    Properties props = (Properties)obj ;

  467. 	    result.append( cls.getName() ) ;

  468. 	    result.append( "(" ) ;

  469. 	    Enumeration keys = props.propertyNames() ;

  470. 	    while (keys.hasMoreElements()) {

  471. 		String key = (String)(keys.nextElement()) ;

  472. 		String value = props.getProperty( key ) ;

  473. 		result.append( " " ) ;

  474. 		result.append( key ) ;

  475. 		result.append( "=" ) ;

  476. 		result.append( value ) ;

  477. 	    }

  478. 

  479. 	    result.append( " )" ) ;

  480. 	    return result.toString() ;

  481. 	}

  482. 

  483. 	try {

  484. 	    // If class of obj directly declares toString(), use it.

  485. 	    cls.getDeclaredMethod( "toString", null ) ;

  486. 	    return obj.toString() ;

  487. 	} catch (Exception exc) {

  488. 	    if (compClass == null) {

  489. 		// Must be some reference type, so use reflection to print fields

  490. 		Field[] fields ;

  491. 

  492. 		try {

  493. 		    fields = cls.getFields() ;

  494. 		} catch (SecurityException sexc) {

  495. 		    // Can't get fields, so use default toString()

  496. 		    return obj.toString() ;

  497. 		}

  498. 

  499. 		result.append( cls.getName() ) ;

  500. 		result.append( "(" ) ;

  501. 

  502. 		for (int ctr=0; ctr<fields.length; ctr++ ) {

  503. 		    Field fld = fields[ctr] ;

  504. 		    result.append( " " ) ;

  505. 		    result.append( fld.getName() ) ;

  506. 		    result.append( "=" ) ;

  507. 

  508. 		    try {

  509. 			java.lang.Object value = fld.get( obj ) ;

  510. 			result.append( objectToString( value ) ) ;

  511. 		    } catch (Exception exc2) {

  512. 			result.append( "???" ) ;

  513. 		    }

  514. 		}

  515. 

  516. 		result.append( " )" ) ;

  517. 		return result.toString() ;

  518. 	    } else // we have an array

  519. 		result.append( compClass.getName() ) ;

  520. 	    result.append( "[" ) ;

  521. 	    if (compClass == boolean.class) {

  522. 		boolean[] arr = (boolean[])obj ;

  523. 		result.append( arr.length ) ;

  524. 		result.append( "](" ) ;

  525. 		for (int ctr=0; ctr<arr.length; ctr++) {

  526. 		    result.append( " " ) ;

  527. 		    result.append( arr[ctr] ) ;

  528. 		}

  529. 	    } else if (compClass == byte.class) {

  530. 		byte[] arr = (byte[])obj ;

  531. 		result.append( arr.length ) ;

  532. 		result.append( "](" ) ;

  533. 		for (int ctr=0; ctr<arr.length; ctr++) {

  534. 		    result.append( " " ) ;

  535. 		    result.append( arr[ctr] ) ;

  536. 		}

  537. 	    } else if (compClass == short.class) {

  538. 		short[] arr = (short[])obj ;

  539. 		result.append( arr.length ) ;

  540. 		result.append( "](" ) ;

  541. 		for (int ctr=0; ctr<arr.length; ctr++) {

  542. 		    result.append( " " ) ;

  543. 		    result.append( arr[ctr] ) ;

  544. 		}

  545. 	    } else if (compClass == int.class) {

  546. 		int[] arr = (int[])obj ;

  547. 		result.append( arr.length ) ;

  548. 		result.append( "](" ) ;

  549. 		for (int ctr=0; ctr<arr.length; ctr++) {

  550. 		    result.append( " " ) ;

  551. 		    result.append( arr[ctr] ) ;

  552. 		}

  553. 	    } else if (compClass == long.class) {

  554. 		long[] arr = (long[])obj ;

  555. 		result.append( arr.length ) ;

  556. 		result.append( "](" ) ;

  557. 		for (int ctr=0; ctr<arr.length; ctr++) {

  558. 		    result.append( " " ) ;

  559. 		    result.append( arr[ctr] ) ;

  560. 		}

  561. 	    } else if (compClass == char.class) {

  562. 		char[] arr = (char[])obj ;

  563. 		result.append( arr.length ) ;

  564. 		result.append( "](" ) ;

  565. 		for (int ctr=0; ctr<arr.length; ctr++) {

  566. 		    result.append( " " ) ;

  567. 		    result.append( arr[ctr] ) ;

  568. 		}

  569. 	    } else if (compClass == float.class) {

  570. 		float[] arr = (float[])obj ;

  571. 		result.append( arr.length ) ;

  572. 		result.append( "](" ) ;

  573. 		for (int ctr=0; ctr<arr.length; ctr++) {

  574. 		    result.append( " " ) ;

  575. 		    result.append( arr[ctr] ) ;

  576. 		}

  577. 	    } else if (compClass == double.class) {

  578. 		double[] arr = (double[])obj ;

  579. 		result.append( arr.length ) ;

  580. 		result.append( "](" ) ;

  581. 		for (int ctr=0; ctr<arr.length; ctr++) {

  582. 		    result.append( " " ) ;

  583. 		    result.append( arr[ctr] ) ;

  584. 		}

  585. 	    } else { // array of object

  586. 		java.lang.Object[] arr = (java.lang.Object[])obj ;

  587. 		result.append( arr.length ) ;

  588. 		result.append( "](" ) ;

  589. 		for (int ctr=0; ctr<arr.length; ctr++) {

  590. 		    result.append( " " ) ;

  591. 		    result.append( objectToString( arr[ctr] ) ) ;

  592. 		}

  593. 	    }

  594. 

  595. 	    result.append( " ]" ) ;

  596. 	    return result.toString() ;

  597. 	}

  598.     }

  599. 

  600.     //

  601.     // Implements all dprint calls in this package.

  602.     //

  603.     public static void dprint(java.lang.Object obj, String msg) {

  604. 	System.out.println(obj.getClass().getName() + "("  +

  605. 			   Thread.currentThread() + "): " + msg);

  606.     }

  607. 

  608.     public static void dprint(String className, String msg) {

  609. 	System.out.println(className + "("  +

  610. 			   Thread.currentThread() + "): " + msg);

  611.     }

  612. 

  613.     public void dprint(String msg) {

  614. 	ORBUtility.dprint(this, msg);

  615.     }

  616. 

  617.     public static void dprint(java.lang.Object caller,

  618.                               String msg,

  619.                               Throwable t) {

  620. 

  621.         System.out.println(caller.getClass().getName() + '('

  622.                            + Thread.currentThread() + "): "

  623.                            + msg);

  624. 

  625.         if (t != null)

  626.             t.printStackTrace();

  627.     }

  628. 

  629.     public static String[] concatenateStringArrays( String[] arr1, String[] arr2 ) 

  630.     {

  631. 	String[] result = new String[ 

  632. 	    arr1.length + arr2.length ] ;

  633. 

  634. 	for (int ctr = 0; ctr<arr1.length; ctr++)

  635. 	    result[ctr] = arr1[ctr] ;

  636. 

  637. 	for (int ctr = 0; ctr<arr2.length; ctr++)

  638. 	    result[ctr + arr1.length] = arr2[ctr] ;

  639. 

  640. 	return result ;

  641.     }

  642. 

  643.     /**

  644.      * Throws the CORBA equivalent of a java.io.NotSerializableException

  645.      *

  646.      * Duplicated from util/Utility for Pure ORB reasons.  There are two

  647.      * reasons for this:

  648.      *

  649.      * 1) We can't introduce dependencies on the util version from outside

  650.      * of the io/util packages since it will not exist in the pure ORB

  651.      * build running on JDK 1.3.x.

  652.      *

  653.      * 2) We need to pick up the correct minor code from orbutil.MinorCodes.

  654.      * If we picked it up from util.MinorCodes, then it would have the

  655.      * incorrect value when running the pure ORB on JDK 1.3.x.

  656.      */

  657.     public static void throwNotSerializableForCorba(String className) {

  658.         throw new BAD_PARAM(className,

  659.                             MinorCodes.NOT_SERIALIZABLE,

  660.                             CompletionStatus.COMPLETED_MAYBE);

  661.     }

  662. }