Dictionaries are implemented now. Everything tests out against python.

The next step is the packet stream interface.

1 files changed, 149 insertions, 0 deletions

diff --git a/cs-dotnet/src/gatsdictionary.cs b/cs-dotnet/src/gatsdictionary.cs
new file mode 100644
index 0000000..0122c3a
--- /dev/null
+++ b/cs-dotnet/src/gatsdictionary.cs
@@ -0,0 +1,149 @@
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Com.Xagasoft.Gats
+{
+    public class GatsDictionary : GatsObject, IDictionary<string, GatsObject>
+//          ICollection<KeyValuePair<string, GatsObject>>,
+//      IEnumerable<KeyValuePair<string, GatsObject>>
+    {
+        private Dictionary<string, GatsObject> Value =
+            new Dictionary<string, GatsObject>();
+
+        public GatsDictionary()
+        {
+        }
+
+        public override string ToString()
+        {
+            StringBuilder bld = new StringBuilder();
+            bld.Append("{");
+            bool begin = true;
+            foreach( KeyValuePair<string, GatsObject> j in Value )
+            {
+                if( begin )
+                    begin = false;
+                else
+                    bld.Append(", ");
+                bld.Append( j.Key );
+                bld.Append(" = ");
+                bld.Append( j.Value );
+            }
+            bld.Append("}");
+            return bld.ToString();
+        }
+
+        public override void Read( Stream s, char type )
+        {
+            for(;;)
+            {
+                GatsObject key = GatsObject.Read( s );
+                if( key == null )
+                    break;
+                if( key.GetType() != typeof(GatsString) )
+                    throw new GatsException( GatsException.Type.InvalidFormat );
+                Value.Add( key.ToString(), GatsObject.Read( s ) );
+            }
+        }
+
+        public override void Write( Stream s )
+        {
+            s.WriteByte( (int)'d' );
+            foreach( KeyValuePair<string, GatsObject> j in Value )
+            {
+                new GatsString( j.Key ).Write( s );
+                j.Value.Write( s );
+            }
+            s.WriteByte( (int)'e' );
+        }
+
+        //
+        // List interface overrides under here.
+        //
+        public void Add( string key, GatsObject obj )
+        {
+            Value.Add( key, obj );
+        }
+
+        public bool Remove( string key )
+        {
+            return Value.Remove( key );
+        }
+
+        public bool ContainsKey( string key )
+        {
+            return Value.ContainsKey( key );
+        }
+
+        public bool TryGetValue( string key, out GatsObject obj )
+        {
+            return Value.TryGetValue( key, out obj );
+        }
+
+        public GatsObject this[string key]
+        {
+            get { return this.Value[key]; }
+            set { this.Value[key] = value; }
+        }
+        
+        public ICollection<string> Keys
+        {
+            get { return this.Value.Keys; }
+        }
+
+        public ICollection<GatsObject> Values
+        {
+            get { return this.Value.Values; }
+        }
+
+        public int Count
+        {
+            get { return this.Value.Count; }
+        }
+
+        public bool IsReadOnly
+        {
+            get { return false; } // return this.Value.IsReadOnly; }
+        }
+
+        public void Add( KeyValuePair<string,GatsObject> pair )
+        {
+            ((IDictionary<string,GatsObject>)Value).Add( pair );
+        }
+
+        public void Clear()
+        {
+            Value.Clear();
+        }
+
+        public bool Contains( KeyValuePair<string,GatsObject> pair )
+        {
+            return ((IDictionary<string,GatsObject>)Value).Contains( pair );
+        }
+
+        public void CopyTo( KeyValuePair<string,GatsObject>[] result,
+                int count )
+        {
+            ((IDictionary<string,GatsObject>)Value).CopyTo( result, count );
+        }
+        
+        public bool Remove( KeyValuePair<string,GatsObject> pair )
+        {
+            return ((IDictionary<string,GatsObject>)Value).Remove( pair );
+        }
+
+        IEnumerator<KeyValuePair<string,GatsObject> > IEnumerable<KeyValuePair<string,GatsObject> >.GetEnumerator()
+        {
+            return Value.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return Value.GetEnumerator();
+        }
+    }
+}
+