cs/src/Ice/EndpointFactoryManager.cs

   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 namespace IceInternal
  11 {
  12
  13     using System.Collections;
  14     using System.Diagnostics;
  15     using System.Text.RegularExpressions;
  16
  17     public sealed class EndpointFactoryManager
  18     {
  19         internal EndpointFactoryManager(Instance instance)
  20         {
  21             instance_ = instance;
  22             _factories = new ArrayList();
  23         }
  24
  25         public void add(EndpointFactory factory)
  26         {
  27             lock(this)
  28             {
  29                 for(int i = 0; i < _factories.Count; i++)
  30                 {
  31                     EndpointFactory f = (EndpointFactory)_factories[i];
  32                     if(f.type() == factory.type())
  33                     {
  34                         Debug.Assert(false);
  35                     }
  36                 }
  37                 _factories.Add(factory);
  38             }
  39         }
  40
  41         public EndpointFactory get(short type)
  42         {
  43             lock(this)
  44             {
  45                 for(int i = 0; i < _factories.Count; i++)
  46                 {
  47                     EndpointFactory f = (EndpointFactory)_factories[i];
  48                     if(f.type() == type)
  49                     {
  50                         return f;
  51                     }
  52                 }
  53                 return null;
  54             }
  55         }
  56
  57         public EndpointI create(string str, bool oaEndpoint)
  58         {
  59             lock(this)
  60             {
  61                 string s = str.Trim();
  62                 if(s.Length == 0)
  63                 {
  64                     Ice.EndpointParseException e = new Ice.EndpointParseException();
  65                     e.str = "value has no non-whitespace characters";
  66                     throw e;
  67                 }
  68
  69                 Regex p = new Regex("([ \t\n\r]+)|$");
  70                 Match m = p.Match(s);
  71                 Debug.Assert(m.Success);
  72
  73                 string protocol = s.Substring(0, m.Index);
  74
  75                 if(protocol.Equals("default"))
  76                 {
  77                     protocol = instance_.defaultsAndOverrides().defaultProtocol;
  78                 }
  79
  80                 for(int i = 0; i < _factories.Count; i++)
  81                 {
  82                     EndpointFactory f = (EndpointFactory)_factories[i];
  83                     if(f.protocol().Equals(protocol))
  84                     {
  85                         return f.create(s.Substring(m.Index + m.Length), oaEndpoint);
  86
  87                         // Code below left in place for debugging.
  88
  89                         /*
  90                         EndpointI e = f.create(s.Substring(m.Index + m.Length), oaEndpoint);
  91                         BasicStream bs = new BasicStream(instance_, true);
  92                         e.streamWrite(bs);
  93                         Buffer buf = bs.getBuffer();
  94                         buf.b.position(0);
  95                         short type = bs.readShort();
  96                         EndpointI ue = new IceInternal.OpaqueEndpointI(type, bs);
  97                         System.Console.Error.WriteLine("Normal: " + e);
  98                         System.Console.Error.WriteLine("Opaque: " + ue);
  99                         return e;
 100                         */
 101                     }
 102                 }
 103
 104                 //
 105                 // If the stringified endpoint is opaque, create an unknown endpoint,
 106                 // then see whether the type matches one of the known endpoints.
 107                 //
 108                 if(protocol.Equals("opaque"))
 109                 {
 110                     EndpointI ue = new OpaqueEndpointI(s.Substring(m.Index + m.Length));
 111                     for(int i = 0; i < _factories.Count; i++)
 112                     {
 113                         EndpointFactory f = (EndpointFactory)_factories[i];
 114                         if(f.type() == ue.type())
 115                         {
 116                             //
 117                             // Make a temporary stream, write the opaque endpoint data into the stream,
 118                             // and ask the factory to read the endpoint data from that stream to create
 119                             // the actual endpoint.
 120                             //
 121                             BasicStream bs = new BasicStream(instance_, true);
 122                             ue.streamWrite(bs);
 123                             Buffer buf = bs.getBuffer();
 124                             buf.b.position(0);
 125                             bs.readShort(); // type
 126                             return f.read(bs);
 127                         }
 128                     }
 129                     return ue; // Endpoint is opaque, but we don't have a factory for its type.
 130                 }
 131                 return null;
 132             }
 133         }
 134
 135         public EndpointI read(BasicStream s)
 136         {
 137             lock(this)
 138             {
 139                 short type = s.readShort();
 140
 141                 for(int i = 0; i < _factories.Count; i++)
 142                 {
 143                     EndpointFactory f = (EndpointFactory)_factories[i];
 144                     if(f.type() == type)
 145                     {
 146                         return f.read(s);
 147                     }
 148                 }
 149
 150                 return new OpaqueEndpointI(type, s);
 151             }
 152         }
 153
 154         internal void destroy()
 155         {
 156             for(int i = 0; i < _factories.Count; i++)
 157             {
 158                 EndpointFactory f = (EndpointFactory)_factories[i];
 159                 f.destroy();
 160             }
 161             _factories.Clear();
 162         }
 163
 164         private readonly Instance instance_;
 165         private readonly ArrayList _factories;
 166     }
 167
 168 }