e79aa3c0ed
Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4
416 lines
11 KiB
C#
416 lines
11 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="SiteMapNodeCollection.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
/*
|
|
* Copyright (c) 2002 Microsoft Corporation
|
|
*/
|
|
|
|
namespace System.Web {
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Diagnostics;
|
|
using System.Security.Permissions;
|
|
using System.Web.UI;
|
|
using System.Web.UI.WebControls;
|
|
|
|
public class SiteMapNodeCollection : IHierarchicalEnumerable, IList {
|
|
|
|
internal static SiteMapNodeCollection Empty = new ReadOnlySiteMapNodeCollection(new SiteMapNodeCollection());
|
|
private int _initialSize = 10;
|
|
private ArrayList _innerList;
|
|
|
|
|
|
public SiteMapNodeCollection() {
|
|
}
|
|
|
|
// Create the collection with initial capacity.
|
|
public SiteMapNodeCollection(int capacity) {
|
|
_initialSize = capacity;
|
|
}
|
|
|
|
public SiteMapNodeCollection(SiteMapNode value) {
|
|
if (value == null) {
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
|
|
_initialSize = 1;
|
|
List.Add(value);
|
|
}
|
|
|
|
|
|
public SiteMapNodeCollection(SiteMapNode[] value) {
|
|
if (value == null) {
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
|
|
_initialSize = value.Length;
|
|
AddRangeInternal(value);
|
|
}
|
|
|
|
|
|
public SiteMapNodeCollection(SiteMapNodeCollection value) {
|
|
if (value == null) {
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
|
|
_initialSize = value.Count;
|
|
AddRangeInternal(value);
|
|
}
|
|
|
|
public virtual int Count {
|
|
get {
|
|
return List.Count;
|
|
}
|
|
}
|
|
|
|
public virtual bool IsSynchronized {
|
|
get {
|
|
return List.IsSynchronized;
|
|
}
|
|
}
|
|
|
|
public virtual object SyncRoot {
|
|
get {
|
|
return List.SyncRoot;
|
|
}
|
|
}
|
|
|
|
private ArrayList List {
|
|
get {
|
|
Debug.Assert(!(this is ReadOnlySiteMapNodeCollection), "List should not be called on ReadOnlySiteMapNodeCollection.");
|
|
|
|
if (_innerList == null) {
|
|
_innerList = new ArrayList(_initialSize);
|
|
}
|
|
|
|
return _innerList;
|
|
}
|
|
}
|
|
|
|
|
|
public virtual bool IsFixedSize {
|
|
get { return false; }
|
|
}
|
|
|
|
|
|
public virtual bool IsReadOnly {
|
|
get { return false; }
|
|
}
|
|
|
|
|
|
public virtual SiteMapNode this[int index] {
|
|
get {
|
|
return (SiteMapNode)List[index];
|
|
}
|
|
set {
|
|
if (value == null) {
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
List[index] = value;
|
|
}
|
|
}
|
|
|
|
|
|
public virtual int Add(SiteMapNode value) {
|
|
if (value == null) {
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
return List.Add(value);
|
|
}
|
|
|
|
|
|
public virtual void AddRange(SiteMapNode[] value) {
|
|
AddRangeInternal(value);
|
|
}
|
|
|
|
|
|
public virtual void AddRange(SiteMapNodeCollection value) {
|
|
AddRangeInternal(value);
|
|
}
|
|
|
|
private void AddRangeInternal(IList value) {
|
|
if (value == null) {
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
|
|
List.AddRange(value);
|
|
}
|
|
|
|
public virtual void Clear() {
|
|
List.Clear();
|
|
}
|
|
|
|
public virtual bool Contains(SiteMapNode value) {
|
|
return List.Contains(value);
|
|
}
|
|
|
|
|
|
public virtual void CopyTo(SiteMapNode[] array, int index) {
|
|
CopyToInternal(array, index);
|
|
}
|
|
|
|
internal virtual void CopyToInternal(Array array, int index) {
|
|
List.CopyTo(array, index);
|
|
}
|
|
|
|
public SiteMapDataSourceView GetDataSourceView(SiteMapDataSource owner, string viewName) {
|
|
return new SiteMapDataSourceView(owner, viewName, this);
|
|
}
|
|
|
|
public virtual IEnumerator GetEnumerator() {
|
|
return List.GetEnumerator();
|
|
}
|
|
|
|
|
|
public SiteMapHierarchicalDataSourceView GetHierarchicalDataSourceView() {
|
|
return new SiteMapHierarchicalDataSourceView(this);
|
|
}
|
|
|
|
|
|
public virtual IHierarchyData GetHierarchyData(object enumeratedItem) {
|
|
return enumeratedItem as IHierarchyData;
|
|
}
|
|
|
|
|
|
public virtual int IndexOf(SiteMapNode value) {
|
|
return List.IndexOf(value);
|
|
}
|
|
|
|
|
|
public virtual void Insert(int index, SiteMapNode value) {
|
|
if (value == null) {
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
|
|
List.Insert(index, value);
|
|
}
|
|
|
|
|
|
protected virtual void OnValidate(object value) {
|
|
if (value == null) {
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
|
|
if (!(value is SiteMapNode)) {
|
|
throw new ArgumentException(
|
|
SR.GetString(SR.SiteMapNodeCollection_Invalid_Type, value.GetType().ToString()));
|
|
}
|
|
}
|
|
|
|
|
|
public static SiteMapNodeCollection ReadOnly(SiteMapNodeCollection collection) {
|
|
if (collection == null) {
|
|
throw new ArgumentNullException("collection");
|
|
}
|
|
|
|
return new ReadOnlySiteMapNodeCollection(collection);
|
|
}
|
|
|
|
|
|
public virtual void Remove(SiteMapNode value) {
|
|
if (value == null) {
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
|
|
List.Remove(value);
|
|
}
|
|
|
|
public virtual void RemoveAt(int index) {
|
|
List.RemoveAt(index);
|
|
}
|
|
|
|
#region ICollection implementation
|
|
int ICollection.Count {
|
|
get {
|
|
return Count;
|
|
}
|
|
}
|
|
|
|
bool ICollection.IsSynchronized {
|
|
get {
|
|
return IsSynchronized;
|
|
}
|
|
}
|
|
|
|
object ICollection.SyncRoot {
|
|
get {
|
|
return SyncRoot;
|
|
}
|
|
}
|
|
|
|
void ICollection.CopyTo(Array array, int index) {
|
|
CopyToInternal(array, index);
|
|
}
|
|
#endregion
|
|
|
|
#region IEnumerable implementation
|
|
IEnumerator IEnumerable.GetEnumerator() {
|
|
return GetEnumerator();
|
|
}
|
|
#endregion
|
|
|
|
#region IHierarchicalEnumerable implementation
|
|
|
|
/// <internalonly/>
|
|
IHierarchyData IHierarchicalEnumerable.GetHierarchyData(object enumeratedItem) {
|
|
return GetHierarchyData(enumeratedItem);
|
|
}
|
|
#endregion
|
|
|
|
#region IList implementation
|
|
/// <internalonly/>
|
|
bool IList.IsFixedSize {
|
|
get { return IsFixedSize; }
|
|
}
|
|
|
|
/// <internalonly/>
|
|
bool IList.IsReadOnly {
|
|
get { return IsReadOnly; }
|
|
}
|
|
|
|
|
|
/// <internalonly/>
|
|
object IList.this[int index] {
|
|
get {
|
|
return this[index];
|
|
}
|
|
set {
|
|
OnValidate(value);
|
|
this[index] = (SiteMapNode)value;
|
|
}
|
|
}
|
|
|
|
int IList.Add(object value) {
|
|
OnValidate(value);
|
|
return Add((SiteMapNode)value);
|
|
}
|
|
|
|
void IList.Clear() {
|
|
Clear();
|
|
}
|
|
|
|
bool IList.Contains(object value) {
|
|
OnValidate(value);
|
|
return Contains((SiteMapNode)value);
|
|
}
|
|
|
|
int IList.IndexOf(object value) {
|
|
OnValidate(value);
|
|
return IndexOf((SiteMapNode)value);
|
|
}
|
|
|
|
void IList.Insert(int index, object value) {
|
|
OnValidate(value);
|
|
Insert(index, (SiteMapNode)value);
|
|
}
|
|
|
|
void IList.Remove(object value) {
|
|
OnValidate(value);
|
|
Remove((SiteMapNode)value);
|
|
}
|
|
|
|
void IList.RemoveAt(int index) {
|
|
RemoveAt(index);
|
|
}
|
|
#endregion
|
|
|
|
private sealed class ReadOnlySiteMapNodeCollection : SiteMapNodeCollection {
|
|
private SiteMapNodeCollection _internalCollection;
|
|
|
|
internal ReadOnlySiteMapNodeCollection(SiteMapNodeCollection collection) {
|
|
if (collection == null) {
|
|
throw new ArgumentNullException("collection");
|
|
}
|
|
|
|
_internalCollection = collection;
|
|
}
|
|
|
|
public override int Count {
|
|
get {
|
|
return _internalCollection.Count;
|
|
}
|
|
}
|
|
|
|
public override bool IsFixedSize {
|
|
get { return true; }
|
|
}
|
|
|
|
public override bool IsReadOnly {
|
|
get { return true; }
|
|
}
|
|
|
|
public override bool IsSynchronized {
|
|
get {
|
|
return _internalCollection.IsSynchronized;
|
|
}
|
|
}
|
|
|
|
public override object SyncRoot {
|
|
get {
|
|
return _internalCollection.SyncRoot;
|
|
}
|
|
}
|
|
|
|
|
|
public override int Add(SiteMapNode value) {
|
|
throw new NotSupportedException(SR.GetString(SR.Collection_readonly));
|
|
}
|
|
|
|
|
|
public override void AddRange(SiteMapNode[] value) {
|
|
throw new NotSupportedException(SR.GetString(SR.Collection_readonly));
|
|
}
|
|
|
|
|
|
public override void AddRange(SiteMapNodeCollection value) {
|
|
throw new NotSupportedException(SR.GetString(SR.Collection_readonly));
|
|
}
|
|
|
|
public override void Clear() {
|
|
throw new NotSupportedException(SR.GetString(SR.Collection_readonly));
|
|
}
|
|
|
|
public override bool Contains(SiteMapNode node) {
|
|
return _internalCollection.Contains(node);
|
|
}
|
|
|
|
internal override void CopyToInternal(Array array, int index) {
|
|
_internalCollection.List.CopyTo(array, index);
|
|
}
|
|
|
|
public override SiteMapNode this[int index] {
|
|
get {
|
|
return _internalCollection[index];
|
|
}
|
|
set {
|
|
throw new NotSupportedException(SR.GetString(SR.Collection_readonly));
|
|
}
|
|
}
|
|
|
|
public override IEnumerator GetEnumerator() {
|
|
return _internalCollection.GetEnumerator();
|
|
}
|
|
|
|
public override int IndexOf(SiteMapNode value) {
|
|
return _internalCollection.IndexOf(value);
|
|
}
|
|
|
|
public override void Insert(int index, SiteMapNode value) {
|
|
throw new NotSupportedException(SR.GetString(SR.Collection_readonly));
|
|
}
|
|
|
|
public override void Remove(SiteMapNode value) {
|
|
throw new NotSupportedException(SR.GetString(SR.Collection_readonly));
|
|
}
|
|
|
|
public override void RemoveAt(int index) {
|
|
throw new NotSupportedException(SR.GetString(SR.Collection_readonly));
|
|
}
|
|
}
|
|
}
|
|
}
|