|
//------------------------------------------------------------------------------
// <copyright file="ParsedAttributeCollection.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.UI {
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Globalization;
using System.Web.Util;
/// <devdoc>
/// Contains parsed attributes organized by filter.
/// The IDictionary implementation uses the combination of all filters using filter:attrName as the attribute names
/// </devdoc>
internal sealed class ParsedAttributeCollection : IDictionary {
private IDictionary _filterTable;
private IDictionary _allFiltersDictionary;
private IDictionary<String, Pair> _attributeValuePositionInfo;
internal ParsedAttributeCollection() {
_filterTable = new ListDictionary(StringComparer.OrdinalIgnoreCase);
}
/// <devdoc>
/// Returns the combination of all filters using filter:attrName as the attribute names
/// </devdoc>
private IDictionary AllFiltersDictionary {
get {
if (_allFiltersDictionary == null) {
_allFiltersDictionary = new ListDictionary(StringComparer.OrdinalIgnoreCase);
foreach (FilteredAttributeDictionary fac in _filterTable.Values) {
foreach (DictionaryEntry entry in fac) {
Debug.Assert(entry.Key != null);
_allFiltersDictionary[Util.CreateFilteredName(fac.Filter, entry.Key.ToString())] = entry.Value;
}
}
}
return _allFiltersDictionary;
}
}
/// <devdoc>
/// Adds a filtered attribute
/// </devdoc>
public void AddFilteredAttribute(string filter, string name, string value) {
if (String.IsNullOrEmpty(name)) {
throw ExceptionUtil.ParameterNullOrEmpty("name");
}
if (value == null) {
throw new ArgumentNullException("value");
}
if (filter == null) {
filter = String.Empty;
}
if (_allFiltersDictionary != null) {
_allFiltersDictionary.Add(Util.CreateFilteredName(filter, name), value);
}
FilteredAttributeDictionary filteredAttributes = (FilteredAttributeDictionary)_filterTable[filter];
if (filteredAttributes == null) {
filteredAttributes = new FilteredAttributeDictionary(this, filter);
_filterTable[filter] = filteredAttributes;
}
filteredAttributes.Data.Add(name, value);
}
/// <summary>
/// This adds an entry for the attribute name and the starting column of attribute value within the text.
/// This information is later used for generating line pragmas for intellisense to work.
/// </summary>
/// <param name="name">Name of the attribute.</param>
/// <param name="line">The line number where the attribute value expression is present.</param>
/// <param name="column">The column value where the attribute value expression begins. Note that this is actually after the attribute name itself.</param>
public void AddAttributeValuePositionInformation(string name, int line, int column) {
Debug.Assert(!String.IsNullOrEmpty(name));
Pair pair = new Pair(line, column);
AttributeValuePositionsDictionary[name] = pair;
}
public IDictionary<String, Pair> AttributeValuePositionsDictionary {
get {
if (_attributeValuePositionInfo == null) {
_attributeValuePositionInfo = new Dictionary<String, Pair>(StringComparer.OrdinalIgnoreCase);
}
return _attributeValuePositionInfo;
}
}
/// <devdoc>
/// Clears all attributes from the specified filter
/// </devdoc>
public void ClearFilter(string filter) {
if (filter == null) {
filter = String.Empty;
}
if (_allFiltersDictionary != null) {
ArrayList removeList = new ArrayList();
foreach (string key in _allFiltersDictionary.Keys) {
string attrName;
string currentFilter = Util.ParsePropertyDeviceFilter(key, out attrName);
if (StringUtil.EqualsIgnoreCase(currentFilter, filter)) {
removeList.Add(key);
}
}
foreach (string key in removeList) {
_allFiltersDictionary.Remove(key);
}
}
_filterTable.Remove(filter);
}
/// <devdoc>
/// Gets the collection of FilteredAttributeDictionaries used by this collection.
/// </devdoc>
public ICollection GetFilteredAttributeDictionaries() {
return _filterTable.Values;
}
/// <devdoc>
/// Removes the specified attribute from the specified filter.
/// </devdoc>
public void RemoveFilteredAttribute(string filter, string name) {
if (String.IsNullOrEmpty(name)) {
throw ExceptionUtil.ParameterNullOrEmpty("name");
}
if (filter == null) {
filter = String.Empty;
}
if (_allFiltersDictionary != null) {
_allFiltersDictionary.Remove(Util.CreateFilteredName(filter, name));
}
FilteredAttributeDictionary filteredAttributes = (FilteredAttributeDictionary)_filterTable[filter];
if (filteredAttributes != null) {
filteredAttributes.Data.Remove(name);
}
}
/// <devdoc>
/// Replaces the specified attribute's value from the specified filter.
/// </devdoc>
public void ReplaceFilteredAttribute(string filter, string name, string value) {
if (String.IsNullOrEmpty(name)) {
throw ExceptionUtil.ParameterNullOrEmpty("name");
}
if (filter == null) {
filter = String.Empty;
}
if (_allFiltersDictionary != null) {
_allFiltersDictionary[Util.CreateFilteredName(filter, name)] = value;
}
FilteredAttributeDictionary filteredAttributes = (FilteredAttributeDictionary)_filterTable[filter];
if (filteredAttributes == null) {
filteredAttributes = new FilteredAttributeDictionary(this, filter);
_filterTable[filter] = filteredAttributes;
}
filteredAttributes.Data[name] = value;
}
#region IDictionary implementation
/// <internalonly/>
bool IDictionary.IsFixedSize {
get {
return false;
}
}
/// <internalonly/>
bool IDictionary.IsReadOnly {
get {
return false;
}
}
/// <internalonly/>
object IDictionary.this[object key] {
get {
return AllFiltersDictionary[key];
}
set {
if (key == null) {
throw new ArgumentNullException("key");
}
string attrName;
string filter = Util.ParsePropertyDeviceFilter(key.ToString(), out attrName);
ReplaceFilteredAttribute(filter, attrName, value.ToString());
}
}
/// <internalonly/>
ICollection IDictionary.Keys {
get {
return AllFiltersDictionary.Keys;
}
}
/// <internalonly/>
ICollection IDictionary.Values {
get {
return AllFiltersDictionary.Values;
}
}
/// <internalonly/>
void IDictionary.Add(object key, object value) {
if (key == null) {
throw new ArgumentNullException("key");
}
if (value == null) {
value = String.Empty;
}
string attrName;
string filter = Util.ParsePropertyDeviceFilter(key.ToString(), out attrName);
AddFilteredAttribute(filter, attrName, value.ToString());
}
/// <internalonly/>
bool IDictionary.Contains(object key) {
return AllFiltersDictionary.Contains(key);
}
/// <internalonly/>
void IDictionary.Clear() {
AllFiltersDictionary.Clear();
_filterTable.Clear();
}
/// <internalonly/>
IDictionaryEnumerator IDictionary.GetEnumerator() {
return AllFiltersDictionary.GetEnumerator();
}
/// <internalonly/>
void IDictionary.Remove(object key) {
if (key == null) {
throw new ArgumentNullException("key");
}
string attrName;
string filter = Util.ParsePropertyDeviceFilter(key.ToString(), out attrName);
RemoveFilteredAttribute(filter, attrName);
}
#endregion IDictionary implementation
#region ICollection implementation
/// <internalonly/>
int ICollection.Count {
get {
return AllFiltersDictionary.Count;
}
}
/// <internalonly/>
bool ICollection.IsSynchronized {
get {
return ((ICollection)AllFiltersDictionary).IsSynchronized;
}
}
/// <internalonly/>
object ICollection.SyncRoot {
get {
return AllFiltersDictionary.SyncRoot;
}
}
/// <internalonly/>
void ICollection.CopyTo(Array array, int index) {
AllFiltersDictionary.CopyTo(array, index);
}
/// <internalonly/>
IEnumerator IEnumerable.GetEnumerator() {
return AllFiltersDictionary.GetEnumerator();
}
#endregion ICollection implementation
}
}
|