---

ORBClass.java

Go to the documentation of this file.

/***
 * Jonathan: an Open Distributed Processing Environment 
 * Copyright (C) 1999-2000 France Telecom R&D
 * Copyright (C) 2001 Kelua SA
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 * Release: 3.0
 *
 * Contact: jonathan@objectweb.org
 *
 * Author: Bruno Dumant
 * 
 */


package org.objectweb.david.libs.binding.orbs;

import org.objectweb.jonathan.apis.kernel.Context;
import org.objectweb.jonathan.apis.kernel.Kernel;
import org.objectweb.jonathan.apis.kernel.Element;
import org.objectweb.jonathan.apis.kernel.JonathanException;
import org.objectweb.jonathan.apis.kernel.InternalException;
import org.objectweb.jonathan.apis.binding.Reference;
import org.objectweb.jonathan.apis.binding.Identifier;
import org.objectweb.jonathan.apis.binding.NamingContext;
import org.objectweb.jonathan.apis.presentation.Marshaller;
import org.objectweb.jonathan.apis.presentation.UnMarshaller;
import org.objectweb.jonathan.apis.protocols.RequestSession;
import org.objectweb.jonathan.apis.stub_factories.StubFactory;
import org.objectweb.jonathan.apis.resources.Chunk;
import org.objectweb.david.apis.presentation.DavidOutputStream;
import org.objectweb.david.apis.presentation.DavidInputStream;
import org.objectweb.david.apis.presentation.DavidStreamFactory;
import org.objectweb.david.apis.presentation.DavidMarshallerFactory;
import org.objectweb.david.apis.presentation.DavidUnMarshaller;
import org.objectweb.david.apis.presentation.DavidMarshaller;
import org.objectweb.david.apis.binding.simpleoa.SimpleAdapter;
import org.objectweb.david.apis.binding.simpleoa.SimpleAdapterHelper;
import org.objectweb.jonathan.libs.kernel.JContextFactory;

import org.objectweb.david.libs.helpers.CORBAHelpers;
import org.objectweb.david.libs.helpers.IORHelpers;

import org.omg.CORBA.ORB;
import org.omg.CORBA.Any;
import org.omg.CORBA.Request;
import org.omg.CORBA.CompletionStatus;
import org.omg.CORBA.DATA_CONVERSION;
import org.omg.CORBA.MARSHAL;
import org.omg.CORBA.BAD_OPERATION;
import org.omg.CORBA.BAD_PARAM;
import org.omg.CORBA.BAD_TYPECODE;
import org.omg.CORBA.NO_IMPLEMENT;
import org.omg.CORBA.INITIALIZE;
import org.omg.CORBA.TypeCode;
import org.omg.CORBA.TypeCodePackage.BadKind;
import org.omg.CORBA.TypeCodePackage.Bounds;
import org.omg.CORBA.TCKind;
import org.omg.CORBA.ORBPackage.InvalidName;
import org.omg.CORBA.portable.OutputStream;
import org.omg.CORBA.portable.ObjectImpl;

import java.io.IOException;
import java.util.Properties;
import java.util.Enumeration;
import java.util.Vector;
import java.applet.Applet;

public abstract class ORBClass extends ORBSingletonClass
implements DavidMarshallerFactory {   
   static ORB singleton_orb = ORB.init();
   static final String null_type = "";

   static final JContextFactory context_factory = new JContextFactory();
   
   boolean waiting;
   
   // the specific orb context name
   protected String orb_context_name; 

   // the context used to initialize services
   protected Context orb_context;   
   protected StubFactory stub_factory;
   protected NamingContext domain;
   protected DavidStreamFactory marshaller_factory;
   
   // send_multiple_requests_deferred
   private DeferredRequest deferred_request = null;
   private DeferredRequest unused_request = null;

   SimpleAdapter adapter;

   protected ORBClass(String _orb_context_name) {
      super();
      orb_context_name = _orb_context_name;
      ORBSingletonClass.setDefault(this);
   }

   protected ORBClass() {
      super();
   }

   final protected void set_parameters(String[] args, Properties props) {
      set_parameters(ORBClass.class,args,props);
   }
   
   final protected void set_parameters(Applet app, Properties props) {
      set_parameters(app.getClass(),null,props);
   }
   
   final void set_parameters(Class classe, String[] args, Properties props) {
      if (orb_context == null) {
         try {
            Context boot_context = Kernel.newConfiguration(classe);
            Object component = boot_context.getValue(orb_context_name,'/');
            if (component instanceof Context) {
               orb_context = (Context) component;
            }
            initialize();
         } catch (JonathanException e) {
            e.printStackTrace();
            throw new INITIALIZE();
         }
      }
   }

   final protected void initialize(Context _orb_context) {
      orb_context_name = null;
      orb_context = _orb_context;
      ORBSingletonClass.setDefault(this);
   }      

   protected abstract void initialize() throws JonathanException;
   
   public synchronized void run() {
      try {
         waiting = true;
         while (waiting) {
            wait();
         } 
      } catch (InterruptedException ignored) {}
   }
   
   public void shutdown(boolean wait_for_completion) {
      if (wait_for_completion) {
         waiting = false;
         notify();
      } else {
         System.exit(0);
      }
   }

   public boolean work_pending() {
      return false;
   }
   
   public void perform_work() {}
   
   public String[] list_initial_services() {
      Object temp = orb_context.getValue("initial_services",(char) 0);
      Context initial_services_context = null; 
      if (temp != Context.NO_VALUE) {
         initial_services_context = (Context) temp;
      }
      if (initial_services_context != null) {
         Vector $vector = new Vector();
         String $name;
         
         Element $currentElement = null;
         for (Enumeration $e =initial_services_context.getElements() ; 
              $e.hasMoreElements() ;) {
            $currentElement = (Element) $e.nextElement();
            $vector.addElement($currentElement.getName());
         }
         String[] $array = new String[$vector.size()];
         $vector.copyInto($array);
         return $array;
      } else {
         return new String[0];
      }
   }
  
   public org.omg.CORBA.Object resolve_initial_references(String name) 
      throws InvalidName {
      Object $found = null;
      try {
         $found = orb_context.getValue("initial_services/" + name,'/');
         if ($found!=Context.NO_VALUE) {
            return (org.omg.CORBA.Object) $found;
         } else {
            throw new InvalidName("Requested service \"" + 
                                  name + "\" could not be found.");
         }
      } catch (ClassCastException ignored) {
         ignored.printStackTrace();
         throw new InvalidName("Requested service \""+name+
                               "\" is not a CORBA Object ("+$found.toString()+").");
      }
   }
   
   public String object_to_string(org.omg.CORBA.Object object) {
      DavidOutputStream stream = marshaller_factory.newOutputStream();
      stream.write_boolean(stream.isLittleEndian());
      stream.write_Object(object);
      Chunk state = stream.getState();
      Chunk c = state;
      int size = 0; 
      while (c != null) {
         size += c.top - c.offset;
         c = c.next;
      }
      byte[] array = new byte[size];
      c = state;
      int len = 0, offset = 0;
      while (c != null) {
         len = c.top - c.offset;
         System.arraycopy(c.data,c.offset,array,offset,len);
         offset += len;
         c = c.next;
      }
      stream.close();
      return IORHelpers.bytesToIORHexString(array);
   }
   
   public org.omg.CORBA.Object string_to_object(String ior) {
      byte[] octet_stream = IORHelpers.IORHexStringToBytes(ior);
      DavidInputStream stream =
         marshaller_factory.newInputStream(new Chunk(octet_stream,
                                                     0,
                                                     octet_stream.length),
                                    0);
      stream.setByteOrder(stream.read_boolean());
      org.omg.CORBA.Object object = stream.read_Object();
      stream.close();
      return object;
   }

   public org.omg.CORBA.portable.OutputStream create_output_stream() {
      return marshaller_factory.newOutputStream();
   }
   

   public void send_multiple_requests_oneway(Request[] requests) {
      for(int i = 0 ; i < requests.length ; i++) {
         requests[i].send_oneway();
      }
   }
   
   public synchronized void send_multiple_requests_deferred(Request[] requests) {
      for (int i = 0; i < requests.length; i++) {
         if (unused_request != null) {
            DeferredRequest dr = unused_request;
            unused_request = unused_request.next;
            dr.request = requests[i];
            dr.next = deferred_request;
            deferred_request = dr;
         } else {
            deferred_request = new DeferredRequest(requests[i],deferred_request);
         }
         requests[i].send_deferred();
      }
   }
   
   public synchronized boolean poll_next_response() {
      boolean answer = false;
      DeferredRequest current = deferred_request;
      while (current != null) {
         if (current.available) {
            answer = true;
         } else {
            if (current.request.poll_response()) {
               current.available = true;
               answer = true;
            }
         }
         current = current.next;
      }
      return answer;
   }
   
   public synchronized Request get_next_response() {
      DeferredRequest current = deferred_request;
      DeferredRequest prev = null;
      Request request;
      while (current != null) {
         if (current.available || current.request.poll_response()) {
            if (prev == null) {
               deferred_request = current.next;
            } else {
               prev.next = current.next;
            }
            current.next = unused_request;
            unused_request = current;
            unused_request.available = false;
            request = current.request;
            unused_request.request = null;
            return request;
         }
         prev = current;
         current = current.next;
      }
      return null;
   }

   public Any create_any() {
      return new AnyImpl(marshaller_factory);
   }

   public void connect(org.omg.CORBA.Object obj) {
      try {
         if (adapter == null) {
            adapter = 
               SimpleAdapterHelper.narrow(resolve_initial_references("Connecter"));
         }
         adapter.export(obj);
      } catch (InvalidName e) {
         throw new INITIALIZE("Invalid connecter name");
      }
   }
   

   public void disconnect(org.omg.CORBA.Object obj) {
      if (adapter == null) {
         throw new BAD_OPERATION("The provided object has not been connected " +
                                 "using this ORB.");  
      }
      adapter.unexport(obj);
   }

   public DavidMarshaller newMarshaller() {
      return new CORBAMarshaller();
   }
   
   public DavidUnMarshaller newUnMarshaller() {
      return new CORBAUnMarshaller();
   }

   final class CORBAMarshaller implements DavidMarshaller, Constants {

      CORBAMarshaller() {}
   
      public void write_Object(org.omg.CORBA.Object exp,
                               DavidOutputStream stream) {
         try {
            //System.err.println("ORBClass.write_Object " + exp);
            ObjectImpl impl = (ObjectImpl) exp;
            if (impl != null) {
               String[] rep_ids = impl._ids(); 
               if (rep_ids != null && rep_ids.length > 0) {
                  stream.writeString8(rep_ids[0]);
//                    System.err.println("ORBClass.write_Object rep_id " + rep_ids[0]);
               } else {
                  stream.writeString8(corba_object_id);
//                    System.err.println("ORBClass.write_Object rep_id " + corba_object_id);
               }
               Reference ref = (Reference) impl._get_delegate();
               Identifier[] ids = ref.getIdentifiers();
               int nb = 0;
               int offset = stream.getOffset();
               stream.writeInt(ids.length);
               Identifier fid;
               for (int i = 0; i < ids.length; i++) {
                  fid = domain.export(ids[i],null);
                  if (fid != null) {
                     fid.encode(stream);
                     nb++;
                  }
               }
               if (ids.length != nb) {
                  if (nb == 0) {
                     throw new MARSHAL("No valid identifier for object reference");
                  } else {
                     int c_offset = stream.getOffset();
                     stream.setOffset(offset);
                     stream.writeInt(nb);
                     stream.setOffset(c_offset);
                  }
               }
            } else {
               // null reference
               stream.writeString8(null_type);
               stream.writeInt(0);
            }
         } catch (JonathanException e) { 
            throw new MARSHAL(e.getMessage());
         }
      }
      
      public void write_TypeCode(TypeCode value,DavidOutputStream stream) {
         try {
            writeTypeCodeRec(value,null,stream);
         } catch (JonathanException e) {
            throw new MARSHAL(e.getMessage());
         }
      }
      
      public void write_any(Any value,DavidOutputStream stream) {
         write_TypeCode(value.type(),stream);
         value.write_value(stream);
      }
      
      void writeTypeCodeRec(TypeCode tc,
                            TypeCodeContext context,
                            DavidOutputStream stream)
         throws JonathanException {
            if(tc == null) {
               throw new BAD_TYPECODE();
            }
            int tc_kind = tc.kind().value();
            stream.writeInt(tc_kind);
            context = new TypeCodeContext(tc,context,stream.getOffset());
            
            try {
               switch(tc_kind) {
                  case TCKind._tk_null:
                  case TCKind._tk_void:
                  case TCKind._tk_short:
                  case TCKind._tk_long:
                  case TCKind._tk_ushort:
                  case TCKind._tk_ulong:
                  case TCKind._tk_float:
                  case TCKind._tk_double:
                  case TCKind._tk_boolean:
                  case TCKind._tk_char:
                  case TCKind._tk_wchar:
                  case TCKind._tk_octet:
                  case TCKind._tk_any:
                  case TCKind._tk_TypeCode:
                  case TCKind._tk_Principal:
                  case TCKind._tk_longlong:
                  case TCKind._tk_ulonglong:
                  case TCKind._tk_longdouble:
                     break;

                  case TCKind._tk_string:
                  case TCKind._tk_wstring:
                     stream.writeInt(tc.length());
                     break;
                     
                  case TCKind._tk_fixed:
                     throw new NO_IMPLEMENT();
                  
                  case TCKind._tk_sequence: {
                     int rec_start = context.start(tc.content_type());
                     if (rec_start >= 0) {
                        stream.writeInt(0xFFFFFFFF);
                        stream.writeInt(stream.getOffset() - rec_start);
                        break;
                     }
                  } // else continue.
                  
                  default:
                     writeEncapsulatedTypeCodeRec(tc,tc_kind,context,stream);
               }
            } catch(BadKind ex) {
               throw new InternalError();
            } catch(Bounds ex) {
               throw new InternalError();
            }
      }      
      void writeEncapsulatedTypeCodeRec(TypeCode tc,
                                        int tc_kind,
                                        TypeCodeContext context,
                                        DavidOutputStream stream)
         throws JonathanException, BadKind, Bounds {
         int spec = stream.startEncapsulation() ;
         switch(tc_kind) {
            case TCKind._tk_objref: {
//                 System.err.println("ORBClass.writeTypeCodeRec id \"" + 
//                                    tc.id() + "\"");
               stream.writeString8(tc.id());
//                 System.err.println("ORBClass.writeTypeCodeRec name " + tc.name());
               stream.writeString8(tc.name());
               break;
            }
            
            case TCKind._tk_struct:
            case TCKind._tk_except: {
               stream.writeString8(tc.id());
               stream.writeString8(tc.name());
               int count = tc.member_count();
               stream.writeInt(count);
               for(int i = 0 ; i < count ; i++) {
                  stream.writeString8(tc.member_name(i));
                  writeTypeCodeRec(tc.member_type(i), context,stream);
               }
               break;
            }
            
            case TCKind._tk_value: {
               stream.writeString8(tc.id());
               stream.writeString8(tc.name());
               stream.writeShort(tc.type_modifier());
               writeTypeCodeRec(tc.concrete_base_type(), context,stream);
               int count = tc.member_count();
               stream.writeInt(count);
               for(int i = 0 ; i < count ; i++) {
                  stream.writeString8(tc.member_name(i));
                  writeTypeCodeRec(tc.member_type(i), context,stream);
                  stream.writeShort(tc.member_visibility(i));
               }
               break;
            }
            
            case TCKind._tk_union: {
               stream.writeString8(tc.id());
               stream.writeString8(tc.name());
               writeTypeCodeRec(tc.discriminator_type(), context,stream);
               stream.writeInt(tc.default_index());
               int count = tc.member_count();
               stream.writeInt(count);
               for(int i = 0 ; i < count ; i++) {
                  tc.member_label(i).write_value(stream);
                  stream.writeString8(tc.member_name(i));
                  writeTypeCodeRec(tc.member_type(i), context,stream);
               }
               break;
            }
            
            case TCKind._tk_enum: {
               stream.writeString8(tc.id());
               stream.writeString8(tc.name());
               int count = tc.member_count();
               stream.writeInt(count);
               for(int i = 0; i < count; i++)
                  stream.writeString8(tc.member_name(i));
               break;
            }
            
            case TCKind._tk_sequence:
            case TCKind._tk_array: {
               writeTypeCodeRec(tc.content_type(), context,stream);
               stream.writeInt(tc.length());
            }
            break;
            case TCKind._tk_alias:
            case TCKind._tk_value_box: {
               stream.writeString8(tc.id());
               stream.writeString8(tc.name());
               writeTypeCodeRec(tc.content_type(), context,stream);
               break;
            }
            
            default:
               throw new InternalError();
         }
         stream.endEncapsulation(spec);
      }      
   }
   
   static class TypeCodeContext {
      TypeCode tc;
      int start;
      TypeCodeContext parent;
      
      TypeCodeContext(TypeCode tc, TypeCodeContext parent,int start) {
         this.tc = tc;
         this.parent = parent;
         this.start = start;
      }
      
      
      int start(TypeCode code) {
         if (code.equal(tc)) {
            return start;
         } else if (parent != null) {
            return parent.start(code);
         } else {
            return -1;
         }
      }
   }
   
   final class CORBAUnMarshaller implements DavidUnMarshaller, Constants {
      
      public CORBAUnMarshaller() {}   
   
      public org.omg.CORBA.Object read_Object(DavidInputStream stream,
                                              Class classe) {
         Context hints = null;
         try {
//              System.err.println("ORBClass.readObject " + classe);
            String repository_id = stream.readString8();
//              System.err.println("ORBClass.readObject rep id is \"" + repository_id + "\"");
            int len = stream.readInt();
            if (repository_id.equals("") && len == 0) {
               return null;
            }
            Identifier[] ids = new Identifier[len];
            for (int i = 0; i < ids.length; i++) {
//                 System.err.println("ORBClass.readObject read id " + i + "/" + ids.length);
               ids[i] = domain.decode(stream);
            }

            hints = context_factory.newContext();
            if (classe != null) {
               hints.addElement("stub_class",Class.class,classe,(char) 0);
            }
            if (repository_id != null) {
               hints.addElement("repository_id",String.class,repository_id,
                                (char) 0);
            }
            ObjectImpl ref = null;
            for (int i = 0; i < ids.length; i++) {
               ref = (ObjectImpl) ids[i].bind(ids,hints);
               if (ref != null) {
                  hints.release();
                  return ref;
               } 
            }
            ref = (ObjectImpl) stub_factory.newStub(null,ids,hints);
            hints.release();
            return ref;
         } catch (JonathanException e) {
            if (hints != null) {
               hints.release();
            }
            e.printStackTrace();
            throw new DATA_CONVERSION(e.getMessage());
         }
      }
   
      public Any read_any(DavidInputStream stream) {
         TypeCode tc = read_TypeCode(stream);
         Any any = new AnyImpl(marshaller_factory);
         any.read_value(stream,tc);
         return any;
      }
   
      public  TypeCode read_TypeCode(DavidInputStream stream) {
         try {
            ReadTC context = new ReadTC(stream.bytesRead(),null,null);
            readTypeCodeRec(context,stream);
            return context.tc;
         } catch (JonathanException e) {
            throw new DATA_CONVERSION(e.getMessage());
         }
      }

      ReadTC readTypeCodeRec(ReadTC context,DavidInputStream stream)
         throws JonathanException {
            int kind = stream.readInt();
            ReadTC result = context;         
            switch(kind) {
               case 0xFFFFFFFF:
                  int pos_offset = stream.readInt();
                  context.tc = context.find(stream.bytesRead() + pos_offset,
                                            context);
                  break;
               case TCKind._tk_null:
               case TCKind._tk_void:
               case TCKind._tk_short:
               case TCKind._tk_long:
               case TCKind._tk_ushort:
               case TCKind._tk_ulong:
               case TCKind._tk_float:
               case TCKind._tk_double:
               case TCKind._tk_boolean:
               case TCKind._tk_char:
               case TCKind._tk_wchar:
               case TCKind._tk_octet:
               case TCKind._tk_any:
               case TCKind._tk_TypeCode:
               case TCKind._tk_Principal:
               case TCKind._tk_longlong:
               case TCKind._tk_ulonglong:
               case TCKind._tk_longdouble:      
                  context.tc =
                     get_primitive_tc(TCKind.from_int(kind));
                  break;

               case TCKind._tk_string: {
                  int bound = stream.readInt();
                  if (bound > 0) {
                     context.tc = create_string_tc(bound);
                  } else {
                     context.tc = TC_string;
                  }
                  break;
               }
               case TCKind._tk_wstring: {
                  int bound = stream.readInt();
                  context.tc = create_wstring_tc(bound);
                  break;
               }

               default:
                  result = readEncapsulatedTypeCodeRec(context,kind,stream);
            }
            
            return result;
      }

      ReadTC readEncapsulatedTypeCodeRec(ReadTC context,int kind,
                                         DavidInputStream stream)
         throws JonathanException {
         ReadTC result = context;
         int spec = stream.startEncapsulation();
         switch(kind) {
            case TCKind._tk_objref: {
               String id = stream.readString8();
//                 System.err.println("ORBClass.readTypeCodeRec id \"" + id + "\"");
               String name = stream.readString8();
//                 System.err.println("ORBClass.readTypeCodeRec name " + name);
               context.tc = create_interface_tc(id, name);
               break;
            }
         
            case TCKind._tk_struct:
            case TCKind._tk_except: {
               String id = stream.readString8();
               String name = stream.readString8();
               StructTC tc = new StructTC(TCKind.from_int(kind),
                                          id,name);
               context.tc = tc;
               int num = stream.readInt();
               String[] member_names  = new String[num];
               TypeCode[] member_types = new TypeCode[num];
               ReadTC rtc;
               for(int i = 0 ; i < num ; i++) {
                  member_names[i] = stream.readString8();
                  rtc = new ReadTC(stream.bytesRead(),result,context);
                  result = readTypeCodeRec(rtc,stream);
                  member_types[i] = rtc.tc;
               }
               tc.init(member_names,member_types);
               break;
            }

            case TCKind._tk_value: {
               String id = stream.readString8();
               String name = stream.readString8();
               short modifier = stream.readShort();
               ValueTC tc = new ValueTC(id,name,modifier);
               context.tc = tc;
               
               ReadTC rtc = new ReadTC(stream.bytesRead(),result,context);
               result = readTypeCodeRec(rtc,stream);
               TypeCode concrete_base = rtc.tc;

               int num = stream.readInt();
               String[] member_names  = new String[num];
               TypeCode[] member_types = new TypeCode[num];
               short[] member_visibilities = new short[num];
               for(int i = 0 ; i < num ; i++) {
                  member_names[i] = stream.readString8();
                  rtc = new ReadTC(stream.bytesRead(),result,context);
                  result = readTypeCodeRec(rtc,stream);
                  member_types[i] = rtc.tc;
                  member_visibilities[i] = stream.readShort();
               }
               tc.init(concrete_base,member_names,member_types,member_visibilities);
               break;
            }               
            
            case TCKind._tk_union: {
               String id = stream.readString8();
               String name = stream.readString8();
               UnionTC tc = new UnionTC(id,name);
               context.tc = tc;
            
               ReadTC rtc = new ReadTC(stream.bytesRead(),result,context);
               result = readTypeCodeRec(rtc,stream);
               TypeCode discriminator_type = rtc.tc;
            
               int defaultIndex = stream.readInt();
               int num = stream.readInt();
               String[] member_names  = new String[num];
               TypeCode[] member_types = new TypeCode[num];
               Any[] labels = new Any[num];
            
               for(int i = 0 ; i < num ; i++) {
                  labels[i] = new AnyImpl(marshaller_factory);
                  if(i == defaultIndex) {
                     TypeCode otc = 
                        get_primitive_tc(TCKind.tk_octet);
                     labels[i].read_value(stream, otc);
                  } else {
                     labels[i].read_value(stream,discriminator_type);
                  }
                  member_names[i] = stream.readString8();
                  rtc = new ReadTC(stream.bytesRead(),result,context);
                  result = readTypeCodeRec(rtc,stream);
                  member_types[i] = rtc.tc;
               }
            
               tc.init(discriminator_type,labels,member_names,member_types);
               break;
            }
         
            case TCKind._tk_enum: {
               String id = stream.readString8();
               String name = stream.readString8();
               int num = stream.readInt();
               String[] members = new String[num];
               for(int i = 0 ; i < num ; i++)
                  members[i] = stream.readString8();
               context.tc = create_enum_tc(id, name, members);
               break;
            }
         
            case TCKind._tk_sequence:
            case TCKind._tk_array: {
               ArrayTC tc;
               if (kind == TCKind._tk_sequence) {
                  tc = new SequenceTC();
               } else {
                  tc = new ArrayTC(TCKind.from_int(kind));
               }
            
               context.tc = tc;
            
               ReadTC rtc = new ReadTC(stream.bytesRead(),result,context);
               result = readTypeCodeRec(rtc,stream);
               tc.init(stream.readInt(),rtc.tc);
               break;
            }
         
            case TCKind._tk_alias: {
               String id = stream.readString8();
               String name = stream.readString8();
            
               AliasTC tc = new AliasTC(id,name);
               context.tc = tc;
            
               ReadTC rtc = new ReadTC(stream.bytesRead(),result,context);
               result = readTypeCodeRec(rtc,stream);
               tc.init(rtc.tc);
               break;
            }
         
            case TCKind._tk_value_box: {
               String id = stream.readString8();
               String name = stream.readString8();
            
               ValueBoxTC tc = new ValueBoxTC(id,name);
               context.tc = tc;
            
               ReadTC rtc = new ReadTC(stream.bytesRead(),result,context);
               result = readTypeCodeRec(rtc,stream);
               tc.init(rtc.tc);
               break;
            }
         
            default:
               System.err.println("Unknown type kind: " + kind);
               throw new InternalError();
         }
         stream.endEncapsulation(spec);
         return result;   
      }
   } 

   static class ReadTC {
      
      public int offset;
      
      public ReadTC prev;
      
      public ReadTC parent;
      
      public TypeCode tc;   
      
      public ReadTC(int offset, ReadTC prev, ReadTC parent) {
         this.offset = offset;
         this.prev = prev;
         this.parent = parent;
      }
      
      public TypeCode find(int off,ReadTC original_context) {
         while (original_context != null) {
            if (off == original_context.offset) {
               return original_context.tc;
            } else if (original_context.offset >= off) {
               original_context = original_context.prev;
            } else {
               break;
            }
         }
         return null;
      }
   }
}

class DeferredRequest {
   Request request;
   boolean available;
   DeferredRequest next;
   DeferredRequest(Request request,DeferredRequest next) {
      this.request = request;
      this.next = next;
      available = false;
   }
}

---