Source code: com/fetish/directory/FadaProxy.java

   package com.fetish.directory;
   
   import net.jini.lease.*;
   import net.jini.core.lease.*;
   import net.jini.lookup.*;
   import net.jini.core.lookup.*;
   import net.jini.discovery.*;
   import net.jini.core.discovery.*;
   import net.jini.event.*;
  import net.jini.core.event.*;
  import net.jini.core.entry.Entry;
  import java.rmi.*;
  import java.io.*;
  import com.fetish.directory.tool.*;
  
  /**
   * The proxy class for the FADA node.
   */
  
  public class FadaProxy implements java.io.Serializable, FadaInterface,
  LUSManager, Directory {
  
    Remote ref;
    String url;
    transient ServiceID id;
    transient Directory dir;
    transient LUSManager lusm;
  
    private void writeObject( ObjectOutputStream o ) throws IOException {
      o.writeObject( ( Object )this.ref );
      o.writeObject( ( Object )this.url );
    }
  
    private void readObject( ObjectInputStream i ) throws IOException,
    ClassNotFoundException  {
      this.ref = ( Remote )i.readObject();
      this.url = ( String )i.readObject();
      this.dir = ( Directory )ref;
      this.lusm = ( LUSManager )ref;
      this.id = lusm.getServiceID();
    }
  
    public FadaProxy() {
    }
  
    public FadaProxy( Remote ref, String url ) throws RemoteException {
      this.ref = ref;
      this.dir = ( Directory )ref;
      this.lusm = ( LUSManager )ref;
      this.id = null;
      this.url = url;
    }
  
    public ServiceMatches lookup(
      SearchCriteriaInterface criteria,
      int nHops,
      long timeout,
      int maxResponses
    ) throws java.rmi.RemoteException {
      return dir.lookup( criteria, nHops, timeout, maxResponses );
    }
  
      /**
       * Returns all services registered in this node.
       */
       public ServiceMatches getServices() throws RemoteException {
      return dir.getServices();
       }
  
       public String getUrl() throws RemoteException {
         return this.url;
       }
  
    public boolean lookup(
      SearchCriteriaInterface criteria,
      SearchIDInterface searchID,
      String target,
      String excluded,
      int nHops,
      long timeout,
      int maxResponses
    ) throws java.rmi.RemoteException {
        return dir.lookup(
        criteria,
        searchID,
        target,
        excluded,
        nHops,
        timeout,
        maxResponses
      );
      }
  
  
      public void addLookupResult( SearchIDInterface id, ServiceMatches sm )
    throws java.rmi.RemoteException {
          dir.addLookupResult( id, sm );
      }
  
     public void startedSearches( SearchIDInterface id, int numSearches )
   throws java.rmi.RemoteException {
         dir.startedSearches( id, numSearches );
     }
 
   public ServiceRegistration register( ServiceItem item, long leaseDuration )
   throws java.rmi.RemoteException {
         // Fiddle with the ServiceItem
     InterfaceEntry intEnt[] = InterfaceGetter.getInterfaces(
       item.service.getClass()
     );
     Entry[] newEntries = new Entry[ item.attributeSets.length +
                     intEnt.length ];
     for( int i = 0; i < item.attributeSets.length; i++ ) {
       newEntries[ i ] = item.attributeSets[ i ];
     }
     for( int j = 0; j < intEnt.length; j++ ) {
       newEntries[ item.attributeSets.length + j ] = intEnt[ j ];
     }
     item.attributeSets = newEntries;
     return dir.register( item, leaseDuration );
   }
 
   public void unregister( ServiceID sid ) throws java.rmi.RemoteException {
     dir.unregister( sid );
   }
 
   public EventRegistration notify(
     ServiceTemplate tmpl,
     int transitions,
     RemoteEventListener listener,
     MarshalledObject handback,
     long leaseDuration
   ) throws java.rmi.RemoteException {
     return null;
   }
 
     public void setMaxTime( int maxTime ) throws RemoteException {
       lusm.setMaxTime( maxTime );
     }
 
     public int getMaxTime() throws RemoteException {
       return lusm.getMaxTime();
     }
 
   public ServiceID getServiceID() throws RemoteException {
       return this.id;
     }
 
   public LookupLocator getLocator() throws java.rmi.RemoteException {
     return lusm.getLocator();
     }
 
   public void isolate() throws RemoteException {
     lusm.isolate();
     }
 
     public boolean isAlone() throws RemoteException {
       return lusm.isAlone();
     }
 
     public boolean connect( LUSManager node ) throws RemoteException {
       return lusm.connect( node );
     }
 
     public boolean justConnect( LUSManager node ) throws RemoteException {
       return lusm.justConnect( node );
     }
 
     public boolean disconnect( LUSManager node ) throws RemoteException {
       return lusm.disconnect( node );
     }
 
     public boolean justDisconnect( LUSManager node ) throws RemoteException {
       return lusm.justDisconnect( node );
     }
 
     public boolean disconnect( String node ) throws RemoteException {
       return lusm.disconnect( node );
     }
 
     public boolean justDisconnect( String node ) throws RemoteException {
       return lusm.justDisconnect( node );
     }
 
     public LUSManager[] getNeighbors() throws RemoteException {
       return lusm.getNeighbors();
     }
 
   public void setLease( Lease lease ) throws RemoteException {
     ( ( FadaInterface )ref ).setLease( lease );
   }
 
   public void setServiceID( ServiceID id ) throws RemoteException {
     this.id = id;
     ( ( FadaInterface )ref ).setServiceID( id );
   }
 
   public void setRegistrar( String registrar )
   throws RemoteException {
     ( ( FadaInterface )ref ).setRegistrar( registrar );
   }
 
   public void stop( String passwd ) {
     //System.out.println( "Stopping the node..." );
     //try {
       //lusm.stop( passwd );
       //System.out.println( "Stopped" );
       //this.ref = null;
       //this.lusm = null;
       //this.dir = null;
     //} catch( Exception e ) {
     //}
   }
 
 }