1 files changed, 76 insertions, 1 deletions
diff --git a/csharp/src/Ice/EndpointFactory.cs b/csharp/src/Ice/EndpointFactory.cs
index 3bc4e979ea4..225cf374a15 100644
--- a/csharp/src/Ice/EndpointFactory.cs
+++ b/csharp/src/Ice/EndpointFactory.cs
@@ -13,13 +13,88 @@ namespace IceInternal
 
     public interface EndpointFactory
     {
+        void initialize();
         short type();
         string protocol();
         EndpointI create(List<string> args, bool oaEndpoint);
         EndpointI read(Ice.InputStream s);
         void destroy();
 
-        EndpointFactory clone(ProtocolInstance instance, EndpointFactory del);
+        EndpointFactory clone(ProtocolInstance instance);
     }
 
+    abstract public class EndpointFactoryWithUnderlying : EndpointFactory
+    {
+        public EndpointFactoryWithUnderlying(ProtocolInstance instance, short type)
+        {
+            instance_ = instance;
+            _type = type;
+        }
+
+        public void initialize()
+        {
+            //
+            // Get the endpoint factory for the underlying type and clone it with
+            // our protocol instance.
+            //
+            EndpointFactory factory = instance_.getEndpointFactory(_type);
+            if(factory != null)
+            {
+                _underlying = factory.clone(instance_);
+                _underlying.initialize();
+            }
+        }
+
+        public short type()
+        {
+            return instance_.type();
+        }
+
+        public string protocol()
+        {
+            return instance_.protocol();
+        }
+
+        public EndpointI create(List<string> args, bool oaEndpoint)
+        {
+            if(_underlying == null)
+            {
+                return null; // Can't create an endpoint without underlying factory.
+            }
+            return createWithUnderlying(_underlying.create(args, oaEndpoint), args, oaEndpoint);
+        }
+
+        public EndpointI read(Ice.InputStream s)
+        {
+            if(_underlying == null)
+            {
+                return null; // Can't create an endpoint without underlying factory.
+            }
+            return readWithUnderlying(_underlying.read(s), s);
+        }
+
+        public void destroy()
+        {
+            if(_underlying != null)
+            {
+                _underlying.destroy();
+            }
+            instance_ = null;
+        }
+
+        public EndpointFactory clone(ProtocolInstance instance)
+        {
+            return cloneWithUnderlying(instance, _type);
+        }
+
+        abstract public EndpointFactory cloneWithUnderlying(ProtocolInstance instance, short type);
+
+        abstract protected EndpointI createWithUnderlying(EndpointI underlying, List<string> args, bool oaEndpoint);
+        abstract protected EndpointI readWithUnderlying(EndpointI underlying, Ice.InputStream s);
+
+        protected ProtocolInstance instance_;
+
+        private readonly short _type;
+        private EndpointFactory _underlying;
+    }
 }