java/src/IceInternal/EndpointFactoryManager.java

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 package IceInternal;
  11
  12 public final class EndpointFactoryManager
  13 {
  14     EndpointFactoryManager(Instance instance)
  15     {
  16         _instance = instance;
  17     }
  18
  19     public synchronized void
  20     add(EndpointFactory factory)
  21     {
  22         for(int i = 0; i < _factories.size(); i++)
  23         {
  24             EndpointFactory f = _factories.get(i);
  25             if(f.type() == factory.type())
  26             {
  27                 assert(false);
  28             }
  29         }
  30         _factories.add(factory);
  31     }
  32
  33     public synchronized EndpointFactory
  34     get(short type)
  35     {
  36         for(int i = 0; i < _factories.size(); i++)
  37         {
  38             EndpointFactory f = _factories.get(i);
  39             if(f.type() == type)
  40             {
  41                 return f;
  42             }
  43         }
  44         return null;
  45     }
  46
  47     public synchronized EndpointI
  48     create(String str, boolean oaEndpoint)
  49     {
  50         String s = str.trim();
  51         if(s.length() == 0)
  52         {
  53             Ice.EndpointParseException e = new Ice.EndpointParseException();
  54             e.str = "value has no non-whitespace characters";
  55             throw e;
  56         }
  57
  58         java.util.regex.Pattern p = java.util.regex.Pattern.compile("([ \t\n\r]+)|$");
  59         java.util.regex.Matcher m = p.matcher(s);
  60         boolean b = m.find();
  61         assert(b);
  62
  63         String protocol = s.substring(0, m.start());
  64
  65         if(protocol.equals("default"))
  66         {
  67             protocol = _instance.defaultsAndOverrides().defaultProtocol;
  68         }
  69
  70         for(int i = 0; i < _factories.size(); i++)
  71         {
  72             EndpointFactory f = _factories.get(i);
  73             if(f.protocol().equals(protocol))
  74             {
  75                 return f.create(s.substring(m.end()), oaEndpoint);
  76
  77                 // Code below left in place for debugging.
  78
  79                 /*
  80                 EndpointI e = f.create(s.substring(m.end()), oaEndpoint);
  81                 BasicStream bs = new BasicStream(_instance, true, false);
  82                 e.streamWrite(bs);
  83                 java.nio.ByteBuffer buf = bs.getBuffer();
  84                 buf.position(0);
  85                 short type = bs.readShort();
  86                 EndpointI ue = new IceInternal.OpaqueEndpointI(type, bs);
  87                 System.err.println("Normal: " + e);
  88                 System.err.println("Opaque: " + ue);
  89                 return e;
  90                 */
  91             }
  92         }
  93
  94         //
  95         // If the stringified endpoint is opaque, create an unknown endpoint,
  96         // then see whether the type matches one of the known endpoints.
  97         //
  98         if(protocol.equals("opaque"))
  99         {
 100             EndpointI ue = new OpaqueEndpointI(s.substring(m.end()));
 101             for(int i = 0; i < _factories.size(); i++)
 102             {
 103                 EndpointFactory f = _factories.get(i);
 104                 if(f.type() == ue.type())
 105                 {
 106                     //
 107                     // Make a temporary stream, write the opaque endpoint data into the stream,
 108                     // and ask the factory to read the endpoint data from that stream to create
 109                     // the actual endpoint.
 110                     //
 111                     BasicStream bs = new BasicStream(_instance, true, false);
 112                     ue.streamWrite(bs);
 113                     Buffer buf = bs.getBuffer();
 114                     buf.b.position(0);
 115                     bs.readShort(); // type
 116                     return f.read(bs);
 117                 }
 118             }
 119             return ue; // Endpoint is opaque, but we don't have a factory for its type.
 120         }
 121
 122         return null;
 123     }
 124
 125     public synchronized EndpointI
 126     read(BasicStream s)
 127     {
 128         short type = s.readShort();
 129
 130         for(int i = 0; i < _factories.size(); i++)
 131         {
 132             EndpointFactory f = _factories.get(i);
 133             if(f.type() == type)
 134             {
 135                 return f.read(s);
 136             }
 137         }
 138         return new OpaqueEndpointI(type, s);
 139     }
 140
 141     void
 142     destroy()
 143     {
 144         for(int i = 0; i < _factories.size(); i++)
 145         {
 146             EndpointFactory f = _factories.get(i);
 147             f.destroy();
 148         }
 149         _factories.clear();
 150     }
 151
 152     private Instance _instance;
 153     private java.util.List<EndpointFactory> _factories = new java.util.ArrayList<EndpointFactory>();
 154 }