//------------------------------------------------------------------------------
// <copyright file="DelegatingConfigHost.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
 
namespace System.Configuration.Internal {
    using System.Configuration;
    using System.IO;
    using System.Security.Permissions;
    using System.Reflection;
    using System.Threading;
    using System.Security;
    using System.CodeDom.Compiler;
    using System.Xml;
 
    //
    // A public implementation of IInternalConfigHost that simply 
    // delegates all members of the IInternalConfigHost interface to 
    // another instance of a host. All interface members are marked virtual
    // so that a derived class can override just the ones needed to
    // implement that specific host, while all others are delegated to
    // another implementation such as InternalConfigHost.
    //
    // The advantages of this arrangement are:
    //  * The IInternalConfigHost interface can be extended without
    //    requiring other hosts to be updated.
    //  * This class that we are making public has no implementation
    //    of its own that can be exploited. All the hosts with meaningful
    //    implementation can remain internal.
    //  * It allows straightforward chaining of host functionality,
    //    see UpdateConfigHost as an example.
    //
    public class DelegatingConfigHost : IInternalConfigHost, IInternalConfigurationBuilderHost {
        IInternalConfigHost _host;
        IInternalConfigurationBuilderHost _configBuilderHost;
 
        protected DelegatingConfigHost() {}
 
        // The host that is delegated to.
        protected IInternalConfigHost Host {
            get {return _host;}
            set {
                _host = value;
                _configBuilderHost = _host as IInternalConfigurationBuilderHost;
            }
        }
 
        protected IInternalConfigurationBuilderHost ConfigBuilderHost {
            get { return _configBuilderHost; }
        }
 
        public virtual void Init(IInternalConfigRoot configRoot, params object[] hostInitParams) {
            Host.Init(configRoot, hostInitParams);
        }
 
        public virtual void InitForConfiguration(ref string locationSubPath, out string configPath, out string locationConfigPath, 
                IInternalConfigRoot configRoot, params object[] hostInitConfigurationParams) {
 
            Host.InitForConfiguration(ref locationSubPath, out configPath, out locationConfigPath, configRoot, hostInitConfigurationParams);
        }
 
        public virtual bool IsConfigRecordRequired(string configPath) {
            return Host.IsConfigRecordRequired(configPath);
        }
 
        public virtual bool IsInitDelayed(IInternalConfigRecord configRecord) {
            return Host.IsInitDelayed(configRecord);
        }
 
        public virtual void RequireCompleteInit(IInternalConfigRecord configRecord) {
            Host.RequireCompleteInit(configRecord);
        }
 
        // IsSecondaryRoot
        //
        // Is this a secondary root.  This means that it is a node in which
        // everything that is defined in it should also be treated as a root.
        // So...if a factory record is defined that was already defined above
        // then throw since it is not allowed.
        //
        public virtual bool IsSecondaryRoot(string configPath) {
            return Host.IsSecondaryRoot(configPath);
        }
 
        public virtual string GetStreamName(string configPath) {
            return Host.GetStreamName(configPath);
        }
 
        public virtual string GetStreamNameForConfigSource(string streamName, string configSource) {
            return Host.GetStreamNameForConfigSource(streamName, configSource);
        }
 
        public virtual object GetStreamVersion(string streamName) {
            return Host.GetStreamVersion(streamName);
        }
 
        public virtual Stream OpenStreamForRead(string streamName) {
            return Host.OpenStreamForRead(streamName);
        }
 
        public virtual Stream OpenStreamForRead(string streamName, bool assertPermissions) {
            return Host.OpenStreamForRead(streamName, assertPermissions);
        }
 
        public virtual Stream OpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext) {
            return Host.OpenStreamForWrite(streamName, templateStreamName, ref writeContext);
        }
 
        public virtual Stream OpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext, bool assertPermissions) {
            return Host.OpenStreamForWrite(streamName, templateStreamName, ref writeContext, assertPermissions);
        }
 
        public virtual void WriteCompleted(string streamName, bool success, object writeContext) {
            Host.WriteCompleted(streamName, success, writeContext);
        }
 
        public virtual void WriteCompleted(string streamName, bool success, object writeContext, bool assertPermissions) {
            Host.WriteCompleted(streamName, success, writeContext, assertPermissions);
        }
 
        public virtual void DeleteStream(string streamName) {
            Host.DeleteStream(streamName);
        }
 
        public virtual bool IsFile(string streamName) {
            return Host.IsFile(streamName);
        }
 
        public virtual bool SupportsChangeNotifications {
            get {
                return Host.SupportsChangeNotifications;
            }
        }
 
        public virtual object StartMonitoringStreamForChanges(string streamName, StreamChangeCallback callback) {
            return Host.StartMonitoringStreamForChanges(streamName, callback);
        }
 
        public virtual void StopMonitoringStreamForChanges(string streamName, StreamChangeCallback callback) {
            Host.StopMonitoringStreamForChanges(streamName, callback);
        }
 
        public virtual bool SupportsRefresh {
            get {
                return Host.SupportsRefresh;
            }
        }
 
        public virtual bool SupportsPath {
            get {
                return Host.SupportsPath;
            }
        }
 
        public virtual bool SupportsLocation {
            get {
                return Host.SupportsLocation;
            }
        }
 
        public virtual bool IsAboveApplication(string configPath) {
            return Host.IsAboveApplication(configPath);
        }
 
        public virtual bool IsDefinitionAllowed(string configPath, ConfigurationAllowDefinition allowDefinition, ConfigurationAllowExeDefinition allowExeDefinition) {
            return Host.IsDefinitionAllowed(configPath, allowDefinition, allowExeDefinition);
        }
 
        public virtual void VerifyDefinitionAllowed(string configPath, ConfigurationAllowDefinition allowDefinition, ConfigurationAllowExeDefinition allowExeDefinition, IConfigErrorInfo errorInfo) {
            Host.VerifyDefinitionAllowed(configPath, allowDefinition, allowExeDefinition, errorInfo);
        }
 
        public virtual string GetConfigPathFromLocationSubPath(string configPath, string locationSubPath) {
            return Host.GetConfigPathFromLocationSubPath(configPath, locationSubPath);
        }
 
        public virtual bool IsLocationApplicable(string configPath) {
            return Host.IsLocationApplicable(configPath);
        }
 
        public virtual bool IsTrustedConfigPath(string configPath) {
            return Host.IsTrustedConfigPath(configPath);
        }
 
        public virtual bool IsFullTrustSectionWithoutAptcaAllowed(IInternalConfigRecord configRecord) {
            return Host.IsFullTrustSectionWithoutAptcaAllowed(configRecord);
        }
 
        public virtual void GetRestrictedPermissions(IInternalConfigRecord configRecord, out PermissionSet permissionSet, out bool isHostReady) {
            Host.GetRestrictedPermissions(configRecord, out permissionSet, out isHostReady);
        }
 
        public virtual IDisposable Impersonate() {
            return Host.Impersonate();
        }
 
        public virtual bool PrefetchAll(string configPath, string streamName) {
            return Host.PrefetchAll(configPath, streamName);
        }
 
        public virtual bool PrefetchSection(string sectionGroupName, string sectionName) {
            return Host.PrefetchSection(sectionGroupName, sectionName);
        }
 
        public virtual object CreateDeprecatedConfigContext(string configPath) {
            return Host.CreateDeprecatedConfigContext(configPath);
        }
 
        public virtual object 
        CreateConfigurationContext( string configPath, string locationSubPath ) 
        {
            return Host.CreateConfigurationContext( configPath, locationSubPath );
        }
 
        public virtual string DecryptSection(string encryptedXml, ProtectedConfigurationProvider protectionProvider, ProtectedConfigurationSection protectedConfigSection) {
            return Host.DecryptSection(encryptedXml, protectionProvider, protectedConfigSection);
        }
 
        public virtual string EncryptSection(string clearTextXml, ProtectedConfigurationProvider protectionProvider, ProtectedConfigurationSection protectedConfigSection) {
            return Host.EncryptSection(clearTextXml, protectionProvider, protectedConfigSection);
        }
 
        public virtual Type GetConfigType(string typeName, bool throwOnError) {
            return Host.GetConfigType(typeName, throwOnError);
        }
 
        public virtual string GetConfigTypeName(Type t) {
            return Host.GetConfigTypeName(t);
        }
 
        public virtual bool IsRemote {
            get {
                return Host.IsRemote;
            }
        }
 
        public virtual XmlNode ProcessRawXml(XmlNode rawXml, ConfigurationBuilder builder) {
            if (ConfigBuilderHost != null) {
                return ConfigBuilderHost.ProcessRawXml(rawXml, builder);
            }
 
            return rawXml;
        }
 
        public virtual ConfigurationSection ProcessConfigurationSection(ConfigurationSection configSection, ConfigurationBuilder builder) {
            if (ConfigBuilderHost != null) {
                return ConfigBuilderHost.ProcessConfigurationSection(configSection, builder);
            }
 
            return configSection;
        }
 
    }
}