protected ConfigKeyAttribute( ConfigSection section, [NotNull] Type valueType, object defaultValue, [NotNull] string description )
     : base( description ) {
     if( valueType == null ) throw new ArgumentNullException( "valueType" );
     if( description == null ) throw new ArgumentNullException( "description" );
     ValueType = valueType;
     DefaultValue = defaultValue;
     Section = section;
     NotBlank = false;
 }

        public static ComponentBase Create(IDictionary<string, string> globalValues, ConfigSection section, int index)
        {
            if (!section.ContainsKey(ComponentTypeString))
            {
                throw new ArgumentException("No ComponentType given for section: " + section.Name);
            }

            //assign all global values to the local configSection.
            IDictionary<string, string> localValues = section.ValuesAsDictionary;
            foreach (KeyValuePair<string, string> globalValue in globalValues)
            {
                if (!localValues.ContainsKey(globalValue.Key))
                {
                    localValues.Add(globalValue.Key, globalValue.Value);
                }
            }

            ComponentBase item = null;

            switch (ParseToComponentType(section[ComponentTypeString]))
            {
                case ComponentType.FileInstaller:
                    item = new  FileInstallerComponentGraph(section.Name, localValues);
                    break;
                case ComponentType.FileRemover:
                    item = new FileRemoverComponentGraph(section.Name, localValues);
                    break;
                case ComponentType.AppPoolInstaller:
                    item = new AppPoolInstallerComponentGraph(section.Name, localValues);
                    break;
                case ComponentType.WebSiteInstaller:
                case ComponentType.ApplicationInstaller:
                    item =  null;
                    break;
                case ComponentType.RemoteExecutionComponent:
                    item = new RemoteExecutionComponentGraph(section.Name, localValues);
                    break;
                case ComponentType.AppPoolRemover:
                    item = new IisRemoverComponentGraph(section.Name, localValues, ComponentType.AppPoolRemover);
                    break;
                case ComponentType.WebSiteRemover:
                    item = new IisRemoverComponentGraph(section.Name, localValues, ComponentType.WebSiteRemover);
                    break;
                case ComponentType.ApplicationRemover:
                    item = new IisRemoverComponentGraph(section.Name, localValues, ComponentType.ApplicationRemover);
                    break;
                default:
                    throw new ArgumentException("unknown installer section: " + section[ComponentTypeString]);
            }

            if (item != null)
            {
                item.Index = index;
            }

            return item;
        }

        internal CollectionsGroup(CollectionsGroupCollection collections, ConfigSection parent)
        {
            if (collections == null)
            {
                throw new ArgumentException("CollectionsGroupCollection object was null.");
            }
            Collections = collections;

            foreach (ConfigurationGroupElement configGroup in collections)
            {
                collectionNames.Add(configGroup.Name);
            }

            Parent = parent;
        }

        internal CollectionsGroup(CollectionsGroupCollection collections, ConfigSection parent, bool allowValueInheritance)
        {
            AllowValueInheritance = allowValueInheritance;
            if (collections == null)
            {
                throw new ArgumentException("CollectionsGroupCollection object was null.");
            }
            Collections = collections;

            foreach (ConfigurationGroupElement configGroup in collections)
            {
                collectionNames.Add(configGroup.Name);
            }

            Parent = parent;
        }

		public static Configuration ProtectedConfiguration( string connectionProvider, ConfigSection configSection, Configuration configuration )
		{
			switch( configSection )
			{
				case ConfigSection.AppSettings:
					configuration = ProtectAppSettings( connectionProvider, configuration );
					break;
				case ConfigSection.ConnectionStrings:
					configuration = ProtectConnectionStrings( connectionProvider, configuration );
					break;
				default:
					configuration = ProtectAppSettings( connectionProvider, configuration );
					configuration = ProtectConnectionStrings( connectionProvider, configuration );
					break;
			}
			return configuration;
		}

        public override void Initialise(IBuilderContext builderContext)
        {
            var configMain = builderContext.ConfigurationResolver
                                 .GetConfigSection(HiveConfigSection.ConfigXmlKey) as HiveConfigSection;

            if (configMain == null)
                throw new ConfigurationErrorsException(
                    string.Format("Configuration section '{0}' not found when building packaging provider '{1}'",
                                  HiveConfigSection.ConfigXmlKey, ProviderKey));

            var readWriteConfig = configMain.Providers.ReadWriters[ProviderKey] ?? configMain.Providers.Readers[ProviderKey];

            if (readWriteConfig == null)
                throw new ConfigurationErrorsException(
                    string.Format("No configuration found for persistence provider '{0}'", ProviderKey));

            var deepConfigManager = DeepConfigManager.Default;
            var localConfig = !string.IsNullOrEmpty(readWriteConfig.ConfigSectionKey)
                              ? deepConfigManager.GetFirstWebSetting<ConfigSection, ConfigSection>(readWriteConfig.ConfigSectionKey, x => x, "~/App_Plugins")
                                ??
                                readWriteConfig.GetLocalProviderConfig() as ConfigSection
                              : null;

            _configSection = localConfig;

            // ElementInformation.Source appears to be one of few ways to determine if the config-section exists or was returned on-demand with default values
            if (_configSection != null && !string.IsNullOrEmpty(_configSection.ElementInformation.Source))
            {
                CanBuild = true;
                var supportedExtensions = deepConfigManager.GetFirstWebSetting<ConfigSection, string>(readWriteConfig.ConfigSectionKey, x => x.SupportedExtensions, "~/App_Plugins");
                var rootPath = deepConfigManager.GetFirstWebSetting<ConfigSection, string>(readWriteConfig.ConfigSectionKey, x => x.RootPath, "~/App_Plugins");
                var excludedExtensions = deepConfigManager.GetFirstWebSetting<ConfigSection, string>(readWriteConfig.ConfigSectionKey, x => x.ExcludedExetensions, "~/App_Plugins");
                var excludedDirectories = deepConfigManager.GetFirstWebSetting<ConfigSection, string>(readWriteConfig.ConfigSectionKey, x => x.ExcludedDirectories, "~/App_Plugins");
                var rootPublicDomain = deepConfigManager.GetFirstWebSetting<ConfigSection, string>(readWriteConfig.ConfigSectionKey, x => x.RootPublicDomain, "~/App_Plugins");
                rootPath = rootPath.TrimEnd("/") + "/";
                _settings = new Settings(supportedExtensions, "", rootPath, excludedExtensions, excludedDirectories, rootPublicDomain);
            }
            else
            {
                LogHelper.Warn<ProviderDemandBuilder>("Cannot register dependencies for provider {0} because ProviderConfigurationSection was specified with key '{1}' but no matching configSection was found. The provider may not be installed correctly.",
                    ProviderKey,
                    readWriteConfig.ConfigSectionKey);
            }
        }

 /// <summary>
 /// Returns a TreeNode created from a SettingBase.
 /// </summary>
 /// <param name="section">Setting to create TreeNode from.</param>
 /// <returns></returns>
 private TreeNode CreateTreeNode(ConfigSection section)
 {
   TreeNode node = new TreeNode();
   SectionDetails sectionTag = new SectionDetails();
   sectionTag.Section = section;
   node.Tag = sectionTag;
   node.Text = section.Text.Evaluate();
   node.ImageIndex = _treeSections.ImageList.Images.Count;
   node.SelectedImageIndex = _treeSections.ImageList.Images.Count;
   AddPNGToImageList(_treeSections.ImageList, section.SectionMetadata.IconSmallFilePath);
   return node;
 }

        static MenuState ShowSectionList()
        {
            ShowSeparator();
            Console.ForegroundColor = ConsoleColor.White;
            Console.WriteLine("Config sections:");
            Console.ResetColor();
            for (int i = 0; i < sections.Length; i++)
            {
                Console.WriteLine("  {0}. {1}", i + 1, sections[i]);
            }
            //Console.WriteLine( "  Q. Quit" );
            //Console.WriteLine( "  R. Reset All" );
            //Console.WriteLine( "  S. Save" );

            string replyString;
            int reply;
            do
            {
                Console.Write("Enter your selection: "); // TODO
                replyString = Console.ReadLine();
                //!replyString.Equals("Q", StringComparison.OrdinalIgnoreCase) &&
                //     !replyString.Equals( "R", StringComparison.OrdinalIgnoreCase ) &&
                //     !replyString.Equals( "S", StringComparison.OrdinalIgnoreCase ) &&
            } while (!Int32.TryParse(replyString, out reply) &&
                     !Enum.IsDefined(typeof(ConfigSection), reply - 1));

            currentSection = (ConfigSection)(reply - 1);

            return MenuState.KeyList;
        }

 static private ConfigSection GetSectionForPlugin(ModToolPlugin tool)
 {
     string sectionName = tool.GetType().Name;
     
     if (!s_pluginsConfig.ContainsValue(sectionName))
         s_pluginsConfig[sectionName] = new ConfigSection(sectionName);
     return s_pluginsConfig[sectionName];
 }

        private static RemoteDetailsComponentGraph GetRemoteDetails(ConfigSection deployment)
        {
            //see if there are any remote details specified
            if (deployment.Collections.SectionNames.Contains("RemoteDetails"))
            {
                var details = deployment.Collections.GetCollection("RemoteDetails");
                return details.Create<RemoteDetailsComponentGraph>();
            }

            return null;
        }

 public BoolKeyAttribute( ConfigSection section, bool defaultValue, string description )
     : base( section, typeof( bool ), defaultValue.ToString( CultureInfo.InvariantCulture ), description ) {
 }

 public BoolKeyAttribute( ConfigSection section, bool defaultValue, string description )
     : base( section, typeof( bool ), defaultValue, description ) {
 }

 public SectionDetails()
 {
   _section = new ConfigSection();
   _control = new FormControl();
   _designed = false;
   _rightToLeft = false;
   _width = -1;
 }

        public static ReleaseVersion FromSection(ConfigSection section)
        {
            Version ver;
            try
            {
                ver = new Version(section.SubSection);
            }
            catch (Exception e)
            {
                System.Diagnostics.Debug.WriteLine(e);
                return null;
            }

            var version = new ReleaseVersion()
            {
                Version = ver,
                ReleaseType = ReleaseType.Major,
                DownloadPage = section.GetValue("DownloadPage")
            };

            Enum.TryParse<ReleaseType>(section.GetValue("ReleaseType"), true, out version.ReleaseType);

            return version;

        }

        static MenuState ShowSectionList() {
            Refresh( "Editing {0}", Paths.ConfigFileName );

            TextMenu menu = new TextMenu();

            ConfigSection[] sections = (ConfigSection[])Enum.GetValues( typeof( ConfigSection ) );
            for( int i = 0; i < sections.Length; i++ ) {
                menu.AddOption( i + 1,
                                sections[i].ToString(),
                                sections[i] );
            }
            TextOption optionRanks = menu.AddOption( sections.Length + 1, "Ranks" );

            menu.Column = Column.Right;
            TextOption optionSaveAndExit = menu.AddOption( "S", "Save and exit" );
            TextOption optionQuit = menu.AddOption( "Q", "Quit without saving" );
            TextOption optionResetEverything = menu.AddOption( "D", "Use defaults" );
            TextOption optionReloadConfig = menu.AddOption( "R", "Reload config" );

            var choice = menu.Show();

            if( choice == optionSaveAndExit ) {
                if( TextMenu.ShowYesNo( "Save and exit?" ) && Config.Save() ) {
                    return MenuState.Done;
                }

            } else if( choice == optionQuit ) {
                if( TextMenu.ShowYesNo( "Exit without saving?" ) ) {
                    return MenuState.Done;
                }

            } else if( choice == optionResetEverything ) {
                if( TextMenu.ShowYesNo( "Reset everything to defaults?" ) ) {
                    Config.LoadDefaults();
                    RankManager.ResetToDefaults();
                    Config.ResetLogOptions();
                }

            } else if( choice == optionReloadConfig ) {
                if( File.Exists( Paths.ConfigFileName ) ) {
                    if( TextMenu.ShowYesNo( "Reload configuration from \"{0}\"?",
                                            Paths.ConfigFileName ) ) {
                        Config.Reload( true );
                        Console.WriteLine( "Configuration file \"{0}\" reloaded.", Paths.ConfigFileName );
                    }
                } else {
                    Console.WriteLine( "Configuration file \"{0}\" does not exist.", Paths.ConfigFileName );
                }

            } else if( choice == optionRanks ) {
                return MenuState.Ranks;

            } else {
                currentSection = (ConfigSection)choice.Tag;
                return MenuState.KeyList;
            }

            return MenuState.SectionList;
        }

 public ColorKeyAttribute(ConfigSection section, [NotNull] string defaultColor, [NotNull] string description)
     : base(section, typeof(string), ChatColor.White, description) {
     if (defaultColor == null) throw new ArgumentNullException("defaultColor");
     string defaultColorName = ChatColor.GetName(defaultColor);
     if (defaultColorName == null) {
         throw new ArgumentException("Default color must be a valid color name.");
     }
     DefaultValue = defaultColorName;
 }

 public IntKeyAttribute(ConfigSection section, int defaultValue, [NotNull] string description)
     : base(section, typeof(int), defaultValue, description) {
     MinValue = int.MinValue;
     MaxValue = int.MaxValue;
 }

 public SqlPlusConfiguration()
 {
     const string sectionName = "sqlPlus";
     _configuration = new ConfigSection(sectionName);
 }

 public RankKeyAttribute( ConfigSection section, BlankValueMeaning blankMeaning, string description )
     : base( section, typeof( Rank ), "", description ) {
     CanBeLowest = true;
     CanBeHighest = true;
     BlankMeaning = blankMeaning;
     NotBlank = false;
 }

 public ColorKeyAttribute( ConfigSection section, string defaultColor, string description )
     : base( section, typeof( string ), Color.GetName( defaultColor ), description ) {
 }