#region License Information
/* HeuristicLab
* Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
*
* This file is part of HeuristicLab.
*
* HeuristicLab is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* HeuristicLab is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with HeuristicLab. If not, see .
*/
#endregion
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
namespace HeuristicLab.Collections {
[StorableClass]
[Serializable]
public class ReadOnlyObservableDictionary : IObservableDictionary {
[Storable]
protected IObservableDictionary dict;
#region Properties
public ICollection Keys {
get { return dict.Keys; }
}
public ICollection Values {
get { return dict.Values; }
}
public int Count {
get { return dict.Count; }
}
bool ICollection>.IsReadOnly {
get { return true; }
}
public TValue this[TKey key] {
get { return dict[key]; }
}
TValue IDictionary.this[TKey key] {
get { return dict[key]; }
set { throw new NotSupportedException(); }
}
#endregion
#region Constructors
protected ReadOnlyObservableDictionary() { }
public ReadOnlyObservableDictionary(IObservableDictionary dictionary) {
if (dictionary == null) throw new ArgumentNullException();
dict = dictionary;
RegisterEvents();
}
[StorableConstructor]
protected ReadOnlyObservableDictionary(bool deserializing) { }
[StorableHook(HookType.AfterDeserialization)]
private void AfterDeserialization() {
RegisterEvents();
}
#endregion
#region Access
public bool ContainsKey(TKey key) {
return dict.ContainsKey(key);
}
bool ICollection>.Contains(KeyValuePair item) {
return dict.Contains(item);
}
public bool TryGetValue(TKey key, out TValue value) {
return dict.TryGetValue(key, out value);
}
#endregion
#region Manipulation
void IDictionary.Add(TKey key, TValue value) {
throw new NotSupportedException();
}
void ICollection>.Add(KeyValuePair item) {
throw new NotSupportedException();
}
bool IDictionary.Remove(TKey key) {
throw new NotSupportedException();
}
bool ICollection>.Remove(KeyValuePair item) {
throw new NotSupportedException();
}
void ICollection>.Clear() {
throw new NotSupportedException();
}
#endregion
#region Conversion
void ICollection>.CopyTo(KeyValuePair[] array, int arrayIndex) {
((ICollection>)dict).CopyTo(array, arrayIndex);
}
#endregion
#region Enumeration
public IEnumerator> GetEnumerator() {
return dict.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator() {
return ((IEnumerable)dict).GetEnumerator();
}
#endregion
#region Events
protected void RegisterEvents() {
dict.ItemsAdded += new CollectionItemsChangedEventHandler>(dict_ItemsAdded);
dict.ItemsRemoved += new CollectionItemsChangedEventHandler>(dict_ItemsRemoved);
dict.ItemsReplaced += new CollectionItemsChangedEventHandler>(dict_ItemsReplaced);
dict.CollectionReset += new CollectionItemsChangedEventHandler>(dict_CollectionReset);
dict.PropertyChanged += new PropertyChangedEventHandler(dict_PropertyChanged);
}
[field: NonSerialized]
public event CollectionItemsChangedEventHandler> ItemsAdded;
protected virtual void OnItemsAdded(IEnumerable> items) {
CollectionItemsChangedEventHandler> handler = ItemsAdded;
if (handler != null) handler(this, new CollectionItemsChangedEventArgs>(items));
}
[field: NonSerialized]
public event CollectionItemsChangedEventHandler> ItemsRemoved;
protected virtual void OnItemsRemoved(IEnumerable> items) {
CollectionItemsChangedEventHandler> handler = ItemsRemoved;
if (handler != null) handler(this, new CollectionItemsChangedEventArgs>(items));
}
[field: NonSerialized]
public event CollectionItemsChangedEventHandler> ItemsReplaced;
protected virtual void OnItemsReplaced(IEnumerable> items, IEnumerable> oldItems) {
CollectionItemsChangedEventHandler> handler = ItemsReplaced;
if (handler != null) handler(this, new CollectionItemsChangedEventArgs>(items, oldItems));
}
[field: NonSerialized]
public event CollectionItemsChangedEventHandler> CollectionReset;
protected virtual void OnCollectionReset(IEnumerable> items, IEnumerable> oldItems) {
CollectionItemsChangedEventHandler> handler = CollectionReset;
if (handler != null) handler(this, new CollectionItemsChangedEventArgs>(items, oldItems));
}
[field: NonSerialized]
public event PropertyChangedEventHandler PropertyChanged;
protected virtual void OnPropertyChanged(string propertyName) {
PropertyChangedEventHandler handler = PropertyChanged;
if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
}
private void dict_ItemsAdded(object sender, CollectionItemsChangedEventArgs> e) {
OnItemsAdded(e.Items);
}
private void dict_ItemsRemoved(object sender, CollectionItemsChangedEventArgs> e) {
OnItemsRemoved(e.Items);
}
private void dict_ItemsReplaced(object sender, CollectionItemsChangedEventArgs> e) {
OnItemsReplaced(e.Items, e.OldItems);
}
private void dict_CollectionReset(object sender, CollectionItemsChangedEventArgs> e) {
OnCollectionReset(e.Items, e.OldItems);
}
private void dict_PropertyChanged(object sender, PropertyChangedEventArgs e) {
if (e.PropertyName.Equals("Item[]") || e.PropertyName.Equals("Keys") || e.PropertyName.Equals("Values") || e.PropertyName.Equals("Count"))
OnPropertyChanged(e.PropertyName);
}
#endregion
}
}