---

EBinder.java

Go to the documentation of this file.

/***
 * Jonathan: an Open Distributed Processing Environment 
 * Copyright (C) 1999-2000 France Telecom R&D
 * 
 * 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: 2.0
 *
 * Contact: jonathan@objectweb.org
 *
 * Author: Frédéric Dang Tran
 *
 */

package org.objectweb.jonathan.libs.binding.echannel;


import org.objectweb.jonathan.apis.presentation.*;
import org.objectweb.jonathan.apis.protocols.*;
import org.objectweb.jonathan.apis.binding.*;
import org.objectweb.jonathan.apis.kernel.*;
import org.objectweb.jonathan.apis.stub_factories.*;
import org.objectweb.jonathan.apis.resources.*;

import org.objectweb.jonathan.libs.kernel.JContextFactory;
import org.objectweb.jonathan.libs.protocols.multicast_ip.*;
import org.objectweb.jonathan.libs.protocols.rtp.*;
import org.objectweb.jonathan.libs.helpers.MessageHelpers;


public class EBinder implements NamingContext {
   
   static JContextFactory context_factory = new JContextFactory();

   ChunkFactory chunk_factory;
   MarshallerFactory marshaller_factory;
        
        RTPProtocol rtp_protocol;       
   MulticastIpProtocol mcast_protocol;
        NamingContext context;
   StubFactory stub_factory;

   public EBinder(ChunkFactory chunk_factory,
                  MarshallerFactory marshaller_factory,
                  NamingContext context,
                  StubFactory stub_factory) {
                this.chunk_factory=chunk_factory;
                this.marshaller_factory=marshaller_factory;
                this.context=context;
      this.stub_factory = stub_factory;
        
                mcast_protocol=new MulticastIpProtocol(marshaller_factory);
                rtp_protocol=new RTPProtocol(mcast_protocol.getMtu());
        }

   public Identifier export(Object itf, Context hints) {
      throw new InternalException("Meaningless operation.");
   }

   public void bindConsumer(Session_Low consumer,EId channel) 
      throws JonathanException  {
                ProtocolGraph protocol_graph = channel.getProtocolGraph();
                protocol_graph.export(consumer);
        }

   public Identifier decode(byte[] data,int offset,int length) 
      throws JonathanException {
                return new EId(data, offset, length);
        }

   public Identifier decode(UnMarshaller u)
      throws JonathanException {
                return new EId(u);
        }

   public EId newId(String address, int port, String type)      
      throws JonathanException  {
                return new EId(address,port,type);
        }

   public class EId implements Identifier {
                String address;
                int port;
                String type;

                SessionIdentifier session_id;
      ProtocolGraph protocol_graph;
      
      public EId(String address, int port, String type) {
                        this.address=address;
                        this.port=port;
                        this.type=type;
                }

      public EId(byte[] encoded,int offset,int length)
         throws JonathanException {
         Chunk chunk = new Chunk(encoded,offset,offset + length);
         UnMarshaller unmarshaller =
            marshaller_factory.newUnMarshaller(chunk,0);
         boolean little_endian = unmarshaller.readBoolean();
         unmarshaller.setByteOrder(little_endian);
         init(unmarshaller);
         unmarshaller.close();
                }
      
      public EId(UnMarshaller unmarshaller)
         throws JonathanException {
         init(unmarshaller);
                }

      private void init(UnMarshaller unmarshaller) 
         throws JonathanException {
         address = unmarshaller.readString8();
         port = unmarshaller.readInt();
                        type= unmarshaller.readString8();
      }

      public SessionIdentifier getSessionIdentifier() throws JonathanException {
                        if(session_id==null) {
                                SessionIdentifier mcast_session_id = 
               mcast_protocol.newSessionIdentifier(address,port);
                                session_id = rtp_protocol.newSessionIdentifier(mcast_session_id);
                        }
                        return session_id;
                }

      public ProtocolGraph getProtocolGraph() throws JonathanException {
                        if(protocol_graph==null) {
                                ProtocolGraph mcast_protocol_graph = 
               mcast_protocol.newProtocolGraph(address,port);
                                protocol_graph = rtp_protocol.newProtocolGraph(mcast_protocol_graph);
                        }
                        return protocol_graph;
                }

                public Object bind(Identifier[] ref,Context hints)
                        throws JonathanException {
         boolean new_hints = false;
         if (hints == null) {
            hints = context_factory.newContext();
            new_hints = true;
         }
         hints.addElement("interface_type",String.class,type,(char) 0);
         Object stub = stub_factory.newStub(getSessionIdentifier(),ref,hints);
         if (new_hints) {
            hints.release();
         }
         return stub;
      }
      
                
                public NamingContext getContext() {
                        return EBinder.this.context;
                }
                
                public byte[] encode() throws JonathanException {
         Marshaller marshaller = marshaller_factory.newMarshaller();
         marshaller.writeBoolean(marshaller.isLittleEndian());
         encode(marshaller);
         byte[] encoded = MessageHelpers.copy(marshaller);
         marshaller.close();
         return encoded;
      }
      
      public void encode(Marshaller marshaller) throws JonathanException {
         marshaller.writeString8(address);
         marshaller.writeInt(port);
         marshaller.writeString8(type);
      }
   
                public Object resolve() {
                        return null;
                }       
                
                public boolean isValid() {
                        return true; 
                }
                
                public void unexport() {
                }
        }
}

---