/[xmltv_parser]/trunk/libxmltv/Core/PropertyDictionary.cs
ViewVC logotype

Diff of /trunk/libxmltv/Core/PropertyDictionary.cs

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

--- trunk/libxmltv/Core/PropertyDictionary.cs	2013/03/09 17:42:34	90
+++ trunk/libxmltv/Core/PropertyDictionary.cs	2013/03/10 17:41:52	118
@@ -4,17 +4,33 @@
 using System.Text;
 using libxmltv.Interfaces;
 using System.Runtime.Serialization;
+using System.Collections;
+using System.Runtime.InteropServices;
+using System.Reflection;
 
 namespace libxmltv.Core
 {
-
-    public class PropertyCollection<T> : IPropertyCollection<T>
+    [Serializable]
+    internal class PropertyCollection<T> : IPropertyCollection<T>
     {
         private List<T> items = new List<T>();
         public PropertyCollection() : this(new List<T>()) { }
         public PropertyCollection(ICollection<T> collection) { foreach (var t in collection) { items.Add(t); } }
         public int PropertyCount { get { return items.Count; } }
-        public bool IsReadOnly { get { return (items as ICollection<T>).IsReadOnly; } }
+
+        public bool IsReadOnly
+        {
+            get
+            {
+                ICollection<T> collection = (items as ICollection<T>);
+                if (collection == null)
+                {
+                    throw new InvalidCastException(string.Format("Unable to cast: '{0}' to '{1}'", items.GetType().Name, typeof(ICollection<T>).Name));
+                }
+                return collection.IsReadOnly;
+            }
+        }
+
         public void AddProperty(T item) { items.Add(item); }
         public void ClearProperties() { items.Clear(); }
         public bool ContainsProperty(T item) { return items.Contains(item); }
@@ -22,20 +38,75 @@
         public bool RemoveProperty(T item) { return items.Remove(item); }
         public IEnumerator<T> GetEnumerator() { return items.GetEnumerator(); }
         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return items.GetEnumerator(); }
-    }
 
-    public class PropertyDictionary<TKey, TValue> : IPropertyDictionary<TKey, TValue>
+        public override string ToString()
+        {
+            return string.Format("Property Count: {0}", PropertyCount);
+        }
+    }
+    [Serializable]
+    internal class PropertyDictionary : PropertyDictionary<string, object>, IPropertyDictionary
     {
+        public PropertyDictionary() : base() { }
+        public PropertyDictionary(IPropertyDictionary dictionary) : base(dictionary) { }
+        public PropertyDictionary(IEqualityComparer<string> comparer) : base(comparer) { }
+        public PropertyDictionary(int capacity) :base(capacity) { }
+        public PropertyDictionary(IPropertyDictionary dictionary, IEqualityComparer<string> comparer) : base(dictionary, comparer) { }
+        public PropertyDictionary(int capacity, IEqualityComparer<string> comparer) : base(capacity, comparer) { }
+        protected PropertyDictionary(SerializationInfo info, StreamingContext context) : base(info, context) { }
+    }
+    [Serializable]
+    internal class PropertyDictionary<TKey, TValue> : IPropertyDictionary<TKey, TValue>
+    {
+        [StructLayout(LayoutKind.Sequential)]
+        private struct Entry
+        {
+            public int hashCode;
+            public int next;
+            public TKey name;
+            public TValue value;
+            public override string ToString()
+            {
+                return new PropertyValuePair<TKey, TValue>(name, value).ToString();
+            }
+        }
+        private Entry[] entries
+        {
+           get{
+               List<Entry> list = new List<Entry>();
+               int index = 0;
+               foreach (var t in properties)
+               {
+                   Entry entry = new Entry();
+                   entry.hashCode = this.properties.Comparer.GetHashCode(t.Key) & 0x7fffffff;
+                   entry.next = index + 1;
+                   entry.name = t.Key;
+                   entry.value = t.Value;
+                   list.Add(entry);
+                   index++;
+               }
+               return list.ToArray();
+           }
+        }
+
+        private int version
+        {
+            get
+            {
+                Type t = typeof(Dictionary<TKey, TValue>);
+                var field = t.GetField("version", BindingFlags.NonPublic | BindingFlags.Instance);
+                var v = Convert.ToInt32(field.GetValue(properties));
+                return v;
+            }
+        }
         private Dictionary<TKey, TValue> properties;
         public PropertyDictionary() { properties = new Dictionary<TKey, TValue>(); }
-        public PropertyDictionary(IPropertyDictionary<TKey, TValue> dictionary) { properties = new Dictionary<TKey, TValue>(); foreach (var d in dictionary) { properties.Add(d.Key, d.Value); } }
+        public PropertyDictionary(IPropertyDictionary<TKey, TValue> dictionary) :this() { foreach (var d in dictionary) { properties.Add(d.Name, d.Value); } }
         public PropertyDictionary(IEqualityComparer<TKey> comparer) { properties = new Dictionary<TKey, TValue>(comparer); }
         public PropertyDictionary(int capacity) { properties = new Dictionary<TKey, TValue>(capacity); }
-        public PropertyDictionary(IPropertyDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey> comparer) : this(comparer) { foreach (var d in dictionary) { properties.Add(d.Key, d.Value); } }
+        public PropertyDictionary(IPropertyDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey> comparer) : this(comparer) { foreach (var d in dictionary) { properties.Add(d.Name, d.Value); } }
         public PropertyDictionary(int capacity, IEqualityComparer<TKey> comparer) { properties = new Dictionary<TKey, TValue>(capacity, comparer); }
-        protected PropertyDictionary(SerializationInfo info, StreamingContext context)
-        {
-        }
+        protected PropertyDictionary(SerializationInfo info, StreamingContext context) { }
         public IPropertyCollection<TKey> PropertyKeys { get { return new PropertyCollection<TKey>(properties.Keys); } }
         public IPropertyCollection<TValue> PropertyValues { get { return new PropertyCollection<TValue>(properties.Values); } }
         public TValue this[TKey key]
@@ -69,18 +140,110 @@
         public bool RemoveProperty(TKey key) { return properties.Remove(key); }
         public bool TryGetPropertyValue(TKey key, out TValue value) { return properties.TryGetValue(key, out value); }
         public int PropertyCount { get { return properties.Count; } }
-        public bool IsReadOnly { get { return (properties as ICollection<TKey>).IsReadOnly; } }
-        public void AddProperty(KeyValuePair<TKey, TValue> item) { AddProperty(item.Key, item.Value); }
+        public bool IsReadOnly
+        {
+            get
+            {
+                IDictionary<TKey, TValue> collection = (properties as IDictionary<TKey, TValue>);
+                if (collection == null)
+                {
+                    throw new InvalidCastException(string.Format("Unable to cast: '{0}' to '{1}'", properties.GetType().Name, typeof(IDictionary<TKey, TValue>).Name));
+                }
+                return collection.IsReadOnly;
+            }
+        }
+        public void AddProperty(IPropertyValuePair<TKey, TValue> item) { AddProperty(item.Name, item.Value); }
         public void ClearProperties() { properties.Clear(); }
-        public bool ContainsProperty(KeyValuePair<TKey, TValue> item) { return ContainsProperty(item.Key); }
-        public void CopyPropertiesTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex) { var list = properties.ToList(); list.CopyTo(array, arrayIndex); }
-        public bool RemoveProperty(KeyValuePair<TKey, TValue> item) { return RemoveProperty(item.Key); }
-        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() { return properties.GetEnumerator(); }
+        public bool ContainsProperty(IPropertyValuePair<TKey, TValue> item) { return ContainsProperty(item.Name); }
+        public void CopyPropertiesTo(IPropertyValuePair<TKey, TValue>[] array, int arrayIndex) 
+        {
+            var list = properties.ToList().Cast<IPropertyValuePair<TKey, TValue>>().ToList();
+            list.CopyTo(array, arrayIndex); 
+        }
+        public bool RemoveProperty(IPropertyValuePair<TKey, TValue> item) { return RemoveProperty(item.Name); }
+        IEnumerator<IPropertyValuePair<TKey, TValue>> IEnumerable<IPropertyValuePair<TKey, TValue>>.GetEnumerator() { return new PropertyDictionaryEnumerator(this, 2); }
         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return properties.GetEnumerator(); }
-       
-    }
 
-    public class PropertyDictionary : PropertyDictionary<string, object>
-    {
+        public override string ToString()
+        {
+            return string.Format("Property Count: {0}", PropertyCount);
+        }
+        #region enumerator support
+        public class PropertyDictionaryEnumerator : IEnumerator<IPropertyValuePair<TKey, TValue>>, IDisposable
+        {
+            private PropertyDictionary<TKey, TValue> dictionary;
+            private int index;
+            private IPropertyValuePair<TKey, TValue> current;
+            private int getEnumeratorRetType;
+            internal const int DictEntry = 1;
+            internal const int KeyValuePair = 2;
+            private int version;
+            public PropertyDictionaryEnumerator(PropertyDictionary<TKey, TValue> dictionary, int getEnumeratorRetType) 
+            {
+                this.dictionary = dictionary;
+                this.version = dictionary.version;
+                this.index = 0;
+                this.getEnumeratorRetType = getEnumeratorRetType;
+                this.current = new PropertyValuePair<TKey, TValue>();
+            }
+
+            public IPropertyValuePair<TKey, TValue> Current
+            {
+                get { return this.current; }
+            }
+
+            public void Dispose()
+            {
+            }
+
+            object IEnumerator.Current
+            {
+                get
+                {
+                    if ((this.index == 0) || (this.index == (this.dictionary.Count() + 1)))
+                    {
+                        throw new InvalidOperationException("Operation can't happen");
+                    }
+                    if (this.getEnumeratorRetType == 1)
+                    {
+                        return new DictionaryEntry(this.current.Name, this.current.Value);
+                    }
+                    return new PropertyValuePair<TKey, TValue>(this.current.Name, this.current.Value);
+                }
+            }
+
+            public bool MoveNext()
+            {
+                if (this.version != this.dictionary.version)
+                {
+                    ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumFailedVersion);
+                }
+                while (this.index < this.dictionary.Count())
+                {
+                    if (this.dictionary.entries[this.index].hashCode >= 0)
+                    {
+                        this.current =(IPropertyValuePair<TKey,TValue>)(PropertyValuePair<TKey,TValue>)new KeyValuePair<TKey, TValue>(this.dictionary.entries[this.index].name, this.dictionary.entries[this.index].value);
+                        this.index++;
+                        return true;
+                    }
+                    this.index++;
+                }
+                this.index = this.dictionary.Count() + 1;
+                this.current = new PropertyValuePair<TKey, TValue>();
+                return false;
+            }
+            public void Reset()
+            {
+                if (this.version != this.dictionary.version)
+                {
+                    ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumFailedVersion);
+                }
+                this.index = 0;
+                this.current = (IPropertyValuePair<TKey, TValue>)(PropertyValuePair<TKey, TValue>)new KeyValuePair<TKey, TValue>();
+            }
+        }
+        #endregion   
     }
+
+   
 }

 

  ViewVC Help
Powered by ViewVC 1.1.22