---

JDomain.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.jonathan.libs.binding;

import org.objectweb.jonathan.apis.kernel.JonathanException;
import org.objectweb.jonathan.apis.kernel.Context;
import org.objectweb.jonathan.apis.kernel.Element;
import org.objectweb.jonathan.apis.binding.Identifier;
import org.objectweb.jonathan.apis.binding.NamingContext;
import org.objectweb.jonathan.apis.binding.ExportException;
import org.objectweb.jonathan.apis.presentation.Marshaller;
import org.objectweb.jonathan.apis.presentation.UnMarshaller;

import java.util.Properties;
import java.util.Vector;
import java.util.Enumeration;

public class JDomain implements NamingContext {

   private NamingContextElem contexts;
   
   Context initial_context = null;

   protected JDomain(Context _initial_context) {
      initial_context = _initial_context;
   }   

   public final Identifier export(Object id,Context hints) 
      throws JonathanException {
      Identifier identifier = null;
      try {
         identifier = (Identifier) id;
      } catch (ClassCastException e) {
         throw new ExportException(e);
      }
      NamingContext context = identifier.getContext();
      if (context.equals(this)) {
         return identifier;
      }
      synchronized(this) {
         while (context != null) {
            Class context_class = context.getClass();
            int jid = 0;
            NamingContextElem elem = contexts;
            while (elem != null) {
               if (context_class.equals(elem.type)) {
                  jid = elem.jid;
                  break;
               }
               elem = elem.next;
            }
            if (elem != null) {
               if (jid >= 0) {
                  return new JId(identifier,jid);
               }
            } else {
               try {
                  //System.err.println("searching: " + context_class.getName());
                  jid = initial_context.getIntValue(context_class.getName(),
                                                    (char) 0);
                  //System.err.println("found " + jid);
                  if (jid != Integer.MAX_VALUE){
                     contexts = new NamingContextElem(context,jid,contexts);
                     return new JId(identifier,jid);
                  } else {
                     contexts = new NamingContextElem(context,-1,contexts);
                  }
               } catch (NumberFormatException e) {
                  throw new ExportException(e);
               }
            }
            Object rid = identifier.resolve();
            if (rid instanceof Identifier) {
               identifier = (Identifier) rid; 
               context = identifier.getContext();
            } else {
               context = null;
            }
         }
         return null;
      }
   }
   
   final public Identifier decode(byte[] data,int offset,int len) {
      byte[] encoding;
      if (offset == 0 && len == data.length) {
         encoding = data;
      } else {
         encoding = new byte[len];
         System.arraycopy(data,offset,encoding,0,len);
      }
      int jid =
         ((encoding[0] & 0xFF) << 0) +
         ((encoding[1] & 0xFF) << 8) +
         ((encoding[2] & 0xFF) << 16) +
         ((encoding[3] & 0xFF) << 24);
      return new JId(encoding,jid);
   }

   final public Identifier decode(UnMarshaller unmarshaller)
      throws JonathanException {
      int jid = unmarshaller.readInt();
      int len = unmarshaller.readInt();
      if (len != 0) {
         byte[] b = new byte[len];
         unmarshaller.readByteArray(b,0,len);
         synchronized(this) {
            NamingContext context = null;
            NamingContextElem elem = contexts;
            while (elem != null && context == null) {
               if (elem.jid == jid) {
                  context = elem.context;
               }
               elem = elem.next;
            }
            if (context == null) {
               Object component = 
                  initial_context.getValue(Integer.toString(jid),(char) 0);
               if (component instanceof NamingContext) {
                  context = (NamingContext) component;
               }
            }    
            if (context != null) {
               return new JId(context.decode(b,0,len),jid);
            } else {
               return new FakeId(jid,b);
            }
         }
      } else {
         return new JId(jid);
      }
   }

   final public synchronized NamingContext bind(int jid) {
      NamingContextElem elem = contexts;
      while (elem != null) {
         if (elem.jid == jid) {
            return elem.context;
         }
         elem = elem.next;
      }
      return null;
   }
   
   final public synchronized void export(NamingContext context, int jid) 
      throws ExportException {
      NamingContextElem elem = contexts;
      NamingContextElem prev = null;
      while (elem != null) {
         if (elem.jid == jid) {
            if (elem.context == null) {
               elem.context = context;
               return;
            } else if (context.equals(elem.context)) {
               return;
            } else {
               throw new ExportException("Already used id");
            }
         } else if (context.equals(elem.context)) {
            if (elem.jid < 0) {
               elem.jid = jid;
               return;
            }
         }
         prev = elem;
         elem = elem.next;
      }
      contexts = new NamingContextElem(context,jid,contexts);
   }

   final public synchronized void unexport(int jid) {
      NamingContextElem elem = contexts;
      NamingContextElem prev = null;
      while (elem != null) {
         if (elem.jid == jid) {
            if (prev == null) {
               contexts = elem.next;
            } else {
               prev.next = contexts.next;
            }
         }
         prev = elem;
         elem = elem.next;
      }
   }
   
   final synchronized Object resolve(JId id) {
      try {
         NamingContextElem elem = contexts;
         NamingContextElem prev = null;
         int jid = id.jid;
         byte[] encoding = id.encoding;
         int len = encoding.length - 4;
         while (elem != null) {
            if (elem.jid == jid) {
               if (elem.context == null) {
                  return null;
               } else {
                  return elem.context.decode(encoding,4,len);
               }
            }
            prev = elem;
            elem = elem.next;
         }
         Object component = initial_context.getValue(Integer.toString(id.jid),(char) 0);
         NamingContext context = null;
         if (component != Context.NO_VALUE) {
             context = (NamingContext) component;
         }
         contexts = new NamingContextElem(context,jid,contexts);
         if (context != null) {
            return context.decode(encoding,4,len);
         } else {
            // contexts = new NamingContextElem(null,jid,contexts);
            return null;
         }
      } catch (JonathanException e) {
         //e.printStackTrace();
         return null;
      }
   }

   abstract class AJId implements Identifier {
      int jid;
      byte[] encoding;
      public NamingContext getContext() {
         return JDomain.this;
      }
      
      public boolean equals(Object other) {
         try {
            if (other instanceof AJId) {
               byte[] this_encoding = encode();
               byte[] other_encoding = ((AJId) other).encode();
               int len = this_encoding.length;
               if (len == other_encoding.length) {
                  for (int i = 0; i < len; i++) {
                     if (this_encoding[i] != other_encoding[i]) {
                        return false;
                     }
                  }
                  return true;
               }
            }
            return false;
         } catch (JonathanException e) {
            return this == other;
         }
      }
      
      public int hashCode() {
         try {
            int hashcode = 0;
            int g;
            byte[] enc = encode();
            int len = enc.length;
            for (int p = 0; p < len; p++) {
               hashcode = (hashcode << 4) + (enc[p] & 0xFF) ;
               g = hashcode & 0xF0000000;
               if (g != 0) {
                  hashcode = (hashcode ^ (g >>> 24)) ^ g;
               }
            }
            return hashcode;
         } catch (JonathanException e) {
            return System.identityHashCode(this);
         }
      }
   }
   
   
   
   final class FakeId extends AJId {   
      byte[] next_encoding;
      
      FakeId(int jid,byte[] next_encoding) {
         this.jid = jid;
         this.next_encoding = next_encoding;
      }
      
      public Object resolve() {
         return null;
      }
      
      public byte[] encode() {
         if (encoding == null) {
            int len = next_encoding.length;
            encoding = new byte[len + 4];
            System.arraycopy(next_encoding,0,encoding,4,len);
            encoding[0] = (byte) (jid >>> 0);
            encoding[1] = (byte) (jid >>> 8);
            encoding[2] = (byte) (jid >>> 16);
            encoding[3] = (byte) (jid >>> 24);
         }
         return encoding;
      }
      
      public Object bind(Identifier[] ids,Context hints) {
         return null;
      }
      
      public boolean isValid() {
         return true;
      }
      
      public void unexport() {}
      
      public void encode(Marshaller marshaller)
         throws JonathanException {
         marshaller.writeInt(jid);
         marshaller.writeInt(next_encoding.length);
         marshaller.writeByteArray(next_encoding,0,next_encoding.length);
      }
   }
   
   final class JId extends AJId {
      Identifier next;
      
      JId(Identifier next,int jid) {
         this.next = next;
         this.jid = jid;
      }
      
      JId(byte[] encoding,int jid) {
         this.encoding = encoding;
         this.jid = jid;
      }
      
      JId(int jid) {
         this.jid = jid;
      }
      
      public Object resolve() {
         if (next == null) {
            if (encoding == null) {
               return null;
            } else {
               next = (Identifier) JDomain.this.resolve(this);
            }
         }
         return next;
      }
      
      public byte[] encode() throws JonathanException {
         if (encoding == null) {
            byte[] enc = null;
            if (next != null) {
               enc = next.encode();
            }
            if (enc != null) {
               int len = enc.length;
               encoding = new byte[len + 4];
               System.arraycopy(enc,0,encoding,4,len);
            } else {
               encoding = new byte[4];
            }
            encoding[0] = (byte) (jid >>> 0);
            encoding[1] = (byte) (jid >>> 8);
            encoding[2] = (byte) (jid >>> 16);
            encoding[3] = (byte) (jid >>> 24);
         }
         return encoding;
      }
      
      public Object bind(Identifier[] ids,Context hints)
         throws JonathanException {
         Object next = resolve();
         if (next != null) {
            return ((Identifier) next).bind(ids,hints);
         } else {
            return JDomain.this.bind(jid);
         }
      }
      public boolean isValid() {
         return true;
      }
      
      // sémantique ?
      public void unexport() {
         if (next != null) {
            next.unexport();
         } else if (encoding == null) {
            JDomain.this.unexport(jid);
         }
      }

      public void encode(Marshaller marshaller)
         throws JonathanException {
         marshaller.writeInt(jid);
         Identifier next = (Identifier) resolve();
         if (next != null) {
            byte[] nb = next.encode();
            marshaller.writeInt(nb.length);
            marshaller.writeByteArray(nb,0,nb.length);
         } else {
            marshaller.writeInt(0);
         }
      }

      public boolean equals(Object obj) {
         if (obj instanceof JId) {
            JId other = (JId) obj;
            if (jid == other.jid) {
               resolve();
               Object other_next = other.resolve();
               if (next != null) {
                  return next.equals(other_next);
               } else {
                  return super.equals(obj);
               }
            }
         }
         return false;
      }
      
      public int hashCode() {
         resolve();
         if (next== null) {
            return super.hashCode();
         } else {
            return jid + next.hashCode();
         }
      }         
   }

   final static class NamingContextElem {
      NamingContextElem next;
      int jid;
      NamingContext context;
      Class type;
      
      NamingContextElem(NamingContext context,int jid,NamingContextElem next) {
         this.context = context;
         this.jid = jid;
         this.next = next;
         if (context != null) {
            type = context.getClass();
         }
      }
   }
}

---