Imported Upstream version 4.2.0.179

Former-commit-id: 4610231f55806d2a05ed69e5ff3faa7336cc1479

external/referencesource/System.Configuration/System/Configuration/updateconfighost.cs

@@ -0,0 +1,157 @@
+//------------------------------------------------------------------------------
+// <copyright file="UpdateConfigHost.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Configuration {
+    using System.Collections.Specialized;
+    using System.Configuration.Internal;
+    using System.IO;
+
+    //
+    // Configuration host that intercepts calls to filename functions
+    // to support SaveAs to an alternate file stream.
+    //
+    internal class UpdateConfigHost : DelegatingConfigHost {
+        private HybridDictionary    _streams;       // oldStreamname -> StreamUpdate
+
+        internal UpdateConfigHost(IInternalConfigHost host) {
+            // Delegate to the host provided.
+            Host = host;
+        }
+
+        // Add a stream to the list of streams to intercept.
+        //
+        // Parameters:
+        //  alwaysIntercept -   If true, then don't check whether the old stream and the new stream are the same.
+        //                      SaveAs() will set this to true if oldStreamname is actually referring to a stream
+        //                      on a remote machine.
+        internal void AddStreamname(string oldStreamname, string newStreamname, bool alwaysIntercept) {
+            // 
+
+
+
+
+
+
+            Debug.Assert(!String.IsNullOrEmpty(oldStreamname));
+            
+            if (String.IsNullOrEmpty(oldStreamname)) {
+                return;
+            }
+            
+            if (!alwaysIntercept && StringUtil.EqualsIgnoreCase(oldStreamname, newStreamname)) {
+                return;
+            }
+
+            if (_streams == null) {
+                _streams = new HybridDictionary(true);
+            }
+
+            _streams[oldStreamname] = new StreamUpdate(newStreamname);
+        }
+
+        // Get the new stream name for a stream if a new name exists, otherwise
+        // return the original stream name.
+        internal string GetNewStreamname(string oldStreamname) {
+            StreamUpdate streamUpdate = GetStreamUpdate(oldStreamname, false);
+            if (streamUpdate != null) {
+                return streamUpdate.NewStreamname;
+            }
+
+            return oldStreamname;
+        }
+
+        //
+        // Get the StreamUpdate for a stream.
+        // If alwaysIntercept is true, then the StreamUpdate is 
+        // always returned if it exists.
+        // If alwaysIntercept is false, then only return the StreamUpdate
+        // if the new stream has been successfully written to.
+        //
+        private StreamUpdate GetStreamUpdate(string oldStreamname, bool alwaysIntercept) {
+            if (_streams == null)
+                return null;
+
+            StreamUpdate streamUpdate = (StreamUpdate) _streams[oldStreamname];
+            if (streamUpdate != null && !alwaysIntercept && !streamUpdate.WriteCompleted) {
+                streamUpdate = null;
+            }
+
+            return streamUpdate;
+        }
+
+        public override object GetStreamVersion(string streamName) {
+            StreamUpdate streamUpdate = GetStreamUpdate(streamName, false);
+            if (streamUpdate != null) {
+                return InternalConfigHost.StaticGetStreamVersion(streamUpdate.NewStreamname);
+            }
+            else {
+                return Host.GetStreamVersion(streamName);
+            }
+        }
+
+        public override Stream OpenStreamForRead(string streamName) {
+            StreamUpdate streamUpdate = GetStreamUpdate(streamName, false);
+            if (streamUpdate != null) {
+                return InternalConfigHost.StaticOpenStreamForRead(streamUpdate.NewStreamname);
+            }
+            else {
+                return Host.OpenStreamForRead(streamName);
+            }
+        }
+
+        public override Stream OpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext) {
+            // Always attempt to write to the new stream name if it exists.
+            StreamUpdate streamUpdate = GetStreamUpdate(streamName, true);
+            if (streamUpdate != null) {
+                return InternalConfigHost.StaticOpenStreamForWrite(streamUpdate.NewStreamname, templateStreamName, ref writeContext, false);
+            }
+            else {
+                return Host.OpenStreamForWrite(streamName, templateStreamName, ref writeContext);
+            }
+        }
+
+        public override void WriteCompleted(string streamName, bool success, object writeContext) {
+            StreamUpdate streamUpdate = GetStreamUpdate(streamName, true);
+            if (streamUpdate != null) {
+                InternalConfigHost.StaticWriteCompleted(streamUpdate.NewStreamname, success, writeContext, false);
+                //
+                // Mark the write as having successfully completed, so that subsequent calls 
+                // to Read() will use the new stream name.
+                //
+                if (success) {
+                    streamUpdate.WriteCompleted = true;
+                }
+            }
+            else {
+                Host.WriteCompleted(streamName, success, writeContext);
+            }
+        }
+
+        public override bool IsConfigRecordRequired(string configPath) {
+            return true;            
+        }
+
+        public override void DeleteStream(string streamName) {
+            StreamUpdate streamUpdate = GetStreamUpdate(streamName, false);
+            if (streamUpdate != null) {
+                InternalConfigHost.StaticDeleteStream(streamUpdate.NewStreamname);
+            }
+            else {
+                Host.DeleteStream(streamName);
+            }
+        }
+
+        public override bool IsFile(string streamName) {
+            StreamUpdate streamUpdate = GetStreamUpdate(streamName, false);
+            if (streamUpdate != null) {
+                return InternalConfigHost.StaticIsFile(streamUpdate.NewStreamname);
+            }
+            else {
+                return Host.IsFile(streamName);
+            }
+        }
+    }
+}