1. /*

  2.  * @(#)DynAnyUtil.java	1.9 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.DynamicAny;

  9. 

  10. import org.omg.CORBA.ORB;

  11. import org.omg.CORBA.Any;

  12. import org.omg.CORBA.TypeCode;

  13. import org.omg.CORBA.TCKind;

  14. import org.omg.CORBA.portable.OutputStream;

  15. import org.omg.CORBA.NO_IMPLEMENT;

  16. //import org.omg.CORBA.ORBPackage.*;

  17. import org.omg.CORBA.TypeCodePackage.BadKind;

  18. import org.omg.CORBA.TypeCodePackage.Bounds;

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

  20. import org.omg.DynamicAny.*;

  21. import org.omg.DynamicAny.DynAnyPackage.TypeMismatch;

  22. import org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCode;

  23. import java.math.BigDecimal;

  24. import com.sun.corba.se.internal.corba.AnyImpl;

  25. 

  26. public class DynAnyUtil

  27. {

  28.     static boolean isConsistentType(TypeCode typeCode) {

  29.         int kind = typeCode.kind().value();

  30.         return (kind != TCKind._tk_Principal &&

  31.                 kind != TCKind._tk_native &&

  32.                 kind != TCKind._tk_abstract_interface);

  33.     }

  34. 

  35.     static boolean isConstructedDynAny(DynAny dynAny) {

  36.         // DynFixed is constructed but not a subclass of DynAnyConstructedImpl

  37.         //return (dynAny instanceof DynAnyConstructedImpl);

  38.         int kind = dynAny.type().kind().value();

  39.         return (kind == TCKind._tk_sequence ||

  40.                 kind == TCKind._tk_struct ||

  41.                 kind == TCKind._tk_array ||

  42.                 kind == TCKind._tk_union ||

  43.                 kind == TCKind._tk_enum ||

  44.                 kind == TCKind._tk_fixed ||

  45.                 kind == TCKind._tk_value ||

  46.                 kind == TCKind._tk_value_box);

  47.     }

  48. 

  49.     static DynAny createMostDerivedDynAny(Any any, ORB orb, boolean copyValue)

  50.         throws org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCode

  51.     {

  52.         if (any == null || ! DynAnyUtil.isConsistentType(any.type()))

  53.             throw new org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCode();

  54. 

  55.         switch (any.type().kind().value()) {

  56.             case TCKind._tk_sequence:

  57.                 return new DynSequenceImpl(orb, any, copyValue);

  58.             case TCKind._tk_struct:

  59.                 return new DynStructImpl(orb, any, copyValue);

  60.             case TCKind._tk_array:

  61.                 return new DynArrayImpl(orb, any, copyValue);

  62.             case TCKind._tk_union:

  63.                 return new DynUnionImpl(orb, any, copyValue);

  64.             case TCKind._tk_enum:

  65.                 return new DynEnumImpl(orb, any, copyValue);

  66.             case TCKind._tk_fixed:

  67.                 return new DynFixedImpl(orb, any, copyValue);

  68.             case TCKind._tk_value:

  69.                 return new DynValueImpl(orb, any, copyValue);

  70.             case TCKind._tk_value_box:

  71.                 return new DynValueBoxImpl(orb, any, copyValue);

  72.             default:

  73.                 return new DynAnyBasicImpl(orb, any, copyValue);

  74.         }

  75.     }

  76. 

  77.     static DynAny createMostDerivedDynAny(TypeCode typeCode, ORB orb)

  78.         throws org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCode

  79.     {

  80.         if (typeCode == null || ! DynAnyUtil.isConsistentType(typeCode))

  81.             throw new org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCode();

  82. 

  83.         switch (typeCode.kind().value()) {

  84.             case TCKind._tk_sequence:

  85.                 return new DynSequenceImpl(orb, typeCode);

  86.             case TCKind._tk_struct:

  87.                 return new DynStructImpl(orb, typeCode);

  88.             case TCKind._tk_array:

  89.                 return new DynArrayImpl(orb, typeCode);

  90.             case TCKind._tk_union:

  91.                 return new DynUnionImpl(orb, typeCode);

  92.             case TCKind._tk_enum:

  93.                 return new DynEnumImpl(orb, typeCode);

  94.             case TCKind._tk_fixed:

  95.                 return new DynFixedImpl(orb, typeCode);

  96.             case TCKind._tk_value:

  97.                 return new DynValueImpl(orb, typeCode);

  98.             case TCKind._tk_value_box:

  99.                 return new DynValueBoxImpl(orb, typeCode);

  100.             default:

  101.                 return new DynAnyBasicImpl(orb, typeCode);

  102.         }

  103.     }

  104. 

  105.     // Extracts a member value according to the given TypeCode from the given complex Any

  106.     // (at the Anys current internal stream position, consuming the anys stream on the way)

  107.     // and returns it wrapped into a new Any

  108. /*

  109.     static Any extractAnyFromAny(TypeCode memberType, Any any, ORB orb) {

  110.         // Moved this functionality into AnyImpl because it is needed for Any.equal()

  111.         return ((AnyImpl)any).extractAny(memberType, orb);

  112.     }

  113. */

  114. 

  115.     // Extracts a member value according to the given TypeCode from the given complex Any

  116.     // (at the Anys current internal stream position, consuming the anys stream on the way)

  117.     // and returns it wrapped into a new Any

  118.     static Any extractAnyFromStream(TypeCode memberType, InputStream input, ORB orb) {

  119.         return AnyImpl.extractAnyFromStream(memberType, input, orb);

  120.     }

  121. 

  122.     // Creates a default Any of the given type.

  123.     static Any createDefaultAnyOfType(TypeCode typeCode, ORB orb) {

  124.         Any returnValue = orb.create_any();

  125.         // The spec for DynAny differs from Any on initialization via type code:

  126.         // ? false for boolean

  127.         // ? zero for numeric types

  128.         // ? zero for types octet, char, and wchar

  129.         // ? the empty string for string and wstring

  130.         // ? nil for object references

  131.         // ? a type code with a TCKind value of tk_null for type codes

  132.         // ? for Any values, an Any containing a type code with a TCKind value of tk_null

  133.         //   type and no value

  134.         switch (typeCode.kind().value()) {

  135.             case TCKind._tk_boolean:

  136.                 // false for boolean

  137.                 returnValue.insert_boolean(false);

  138.                 break;

  139.             case TCKind._tk_short:

  140.                 // zero for numeric types

  141.                 returnValue.insert_short((short)0);

  142.                 break;

  143.             case TCKind._tk_ushort:

  144.                 // zero for numeric types

  145.                 returnValue.insert_ushort((short)0);

  146.                 break;

  147.             case TCKind._tk_long:

  148.                 // zero for numeric types

  149.                 returnValue.insert_long(0);

  150.                 break;

  151.             case TCKind._tk_ulong:

  152.                 // zero for numeric types

  153.                 returnValue.insert_ulong(0);

  154.                 break;

  155.             case TCKind._tk_longlong:

  156.                 // zero for numeric types

  157.                 returnValue.insert_longlong((long)0);

  158.                 break;

  159.             case TCKind._tk_ulonglong:

  160.                 // zero for numeric types

  161.                 returnValue.insert_ulonglong((long)0);

  162.                 break;

  163.             case TCKind._tk_float:

  164.                 // zero for numeric types

  165.                 returnValue.insert_float((float)0.0);

  166.                 break;

  167.             case TCKind._tk_double:

  168.                 // zero for numeric types

  169.                 returnValue.insert_double((double)0.0);

  170.                 break;

  171.             case TCKind._tk_octet:

  172.                 // zero for types octet, char, and wchar

  173.                 returnValue.insert_octet((byte)0);

  174.                 break;

  175.             case TCKind._tk_char:

  176.                 // zero for types octet, char, and wchar

  177.                 returnValue.insert_char((char)0);

  178.                 break;

  179.             case TCKind._tk_wchar:

  180.                 // zero for types octet, char, and wchar

  181.                 returnValue.insert_wchar((char)0);

  182.                 break;

  183.             case TCKind._tk_string:

  184.                 // the empty string for string and wstring

  185.                 // Make sure that type code for bounded strings gets respected

  186.                 returnValue.type(typeCode);

  187.                 // Doesn't erase the type of bounded string

  188.                 returnValue.insert_string("");

  189.                 break;

  190.             case TCKind._tk_wstring:

  191.                 // the empty string for string and wstring

  192.                 // Make sure that type code for bounded strings gets respected

  193.                 returnValue.type(typeCode);

  194.                 // Doesn't erase the type of bounded string

  195.                 returnValue.insert_wstring("");

  196.                 break;

  197.             case TCKind._tk_objref:

  198.                 // nil for object references

  199.                 returnValue.insert_Object(null);

  200.                 break;

  201.             case TCKind._tk_TypeCode:

  202.                 // a type code with a TCKind value of tk_null for type codes

  203.                 // We can reuse the type code that's already in the any.

  204.                 returnValue.insert_TypeCode(returnValue.type());

  205.                 break;

  206.             case TCKind._tk_any:

  207.                 // for Any values, an Any containing a type code with a TCKind value

  208.                 // of tk_null type and no value.

  209.                 // This is exactly what the default AnyImpl constructor provides.

  210.                 // _REVISIT_ Note that this inner Any is considered uninitialized.

  211.                 returnValue.insert_any(orb.create_any());

  212.                 break;

  213.             case TCKind._tk_struct:

  214.             case TCKind._tk_union:

  215.             case TCKind._tk_enum:

  216.             case TCKind._tk_sequence:

  217.             case TCKind._tk_array:

  218.             case TCKind._tk_except:

  219.             case TCKind._tk_value:

  220.             case TCKind._tk_value_box:

  221.                 // There are no default value for complex types since there is no

  222.                 // concept of a hierarchy of Anys. Only DynAnys can be arrange in

  223.                 // a hierarchy to mirror the TypeCode hierarchy.

  224.                 // See DynAnyConstructedImpl.initializeComponentsFromTypeCode()

  225.                 // on how this DynAny hierarchy is created from TypeCodes.

  226.                 returnValue.type(typeCode);

  227.                 break;

  228.             case TCKind._tk_fixed:

  229.                 returnValue.insert_fixed(new BigDecimal("0.0"), typeCode);

  230.                 break;

  231.             case TCKind._tk_native:

  232.             case TCKind._tk_alias:

  233.             case TCKind._tk_void:

  234.             case TCKind._tk_Principal:

  235.             case TCKind._tk_abstract_interface:

  236.                 returnValue.type(typeCode);

  237.                 break;

  238.             case TCKind._tk_null:

  239.                 // Any is already initialized to null

  240.                 break;

  241.             case TCKind._tk_longdouble:

  242.                 // Unspecified for Java

  243.                 throw new org.omg.CORBA.NO_IMPLEMENT();

  244.             default:

  245.                 throw new org.omg.CORBA.BAD_PARAM();

  246.         }

  247.         return returnValue;

  248.     }

  249. /*

  250.     static Any setTypeOfAny(TypeCode typeCode, Any value) {

  251.         if (value != null) {

  252.             value.read_value(value.create_input_stream(), typeCode);

  253.         }

  254.         return value;

  255.     }

  256. */

  257.     static Any copy(Any inAny, ORB orb) {

  258.         return new AnyImpl(orb, inAny);

  259.     }

  260. 

  261. /*

  262.     static Any copy(Any inAny, ORB orb) {

  263.         Any outAny = null;

  264.         if (inAny != null && orb != null) {

  265.             outAny = orb.create_any();

  266.             outAny.read_value(inAny.create_input_stream(), inAny.type());

  267.             // isInitialized is set to true

  268.         }

  269.         return outAny;

  270.     }

  271. */

  272. 

  273.     static DynAny convertToNative(DynAny dynAny, ORB orb) {

  274.         if (dynAny instanceof DynAnyImpl) {

  275.             return dynAny;

  276.         } else {

  277.             // if copy flag wasn't true we would be using our DynAny with

  278.             // a foreign Any in it.

  279.             try {

  280.                 return createMostDerivedDynAny(dynAny.to_any(), orb, true);

  281.             } catch (InconsistentTypeCode ictc) {

  282.                 return null;

  283.             }

  284.         }

  285.     }

  286. 

  287.     static boolean isInitialized(Any any) {

  288.         // Returning simply the value of Any.isInitialized() is not enough.

  289.         // The DynAny spec says that Anys containing null strings do not contain

  290.         // a "legal value" (see ptc 99-10-07, 9.2.3.3)

  291.         boolean isInitialized = ((AnyImpl)any).isInitialized();

  292.         switch (any.type().kind().value()) {

  293.             case TCKind._tk_string:

  294.                 return (isInitialized && (any.extract_string() != null));

  295.             case TCKind._tk_wstring:

  296.                 return (isInitialized && (any.extract_wstring() != null));

  297.         }

  298.         return isInitialized;

  299.     }

  300. 

  301.     // This is a convenient method to reset the current component to where it was

  302.     // before we changed it. See DynAnyConstructedImpl.equal for use.

  303.     static boolean set_current_component(DynAny dynAny, DynAny currentComponent) {

  304.         if (currentComponent != null) {

  305.             try {

  306.                 dynAny.rewind();

  307.                 do {

  308.                     if (dynAny.current_component() == currentComponent)

  309.                         return true;

  310.                 } while (dynAny.next());

  311.             } catch (TypeMismatch tm) { /* impossible */ }

  312.         }

  313.         return false;

  314.     }

  315. }