* GetChannelSinkProperties.cs: Implemented GetChannelSinkProperties().

	* ServerDispatchSink.cs: Removed some TODOs.
	* AggregateDictionary.cs: Added.

svn path=/trunk/mcs/; revision=20134

diff --git a/mcs/class/corlib/System.Runtime.Remoting.Channels/AggregateDictionary.cs b/mcs/class/corlib/System.Runtime.Remoting.Channels/AggregateDictionary.cs
new file mode 100644 (file)
index 0000000..0a72180
--- /dev/null
+++ b/mcs/class/corlib/System.Runtime.Remoting.Channels/AggregateDictionary.cs
@@ -0,0 +1,189 @@
+//
+// System.Runtime.Remoting.Channels.AggregateDictionary.cs
+//
+// Author: Lluis Sanchez Gual (lluis@ximian.com)
+//
+// 2002 (C) Copyright, Novell, Inc.
+//
+
+using System.Collections;
+
+namespace System.Runtime.Remoting
+{
+       internal class AggregateDictionary: IDictionary
+       {
+               IDictionary[] dictionaries;
+               ArrayList _values;
+               ArrayList _keys;
+               
+               public AggregateDictionary (IDictionary[] dics)
+               {
+                       dictionaries = dics;
+               }
+               
+               public bool IsFixedSize 
+               { 
+                       get { return true; }
+               }               
+               
+               public bool IsReadOnly 
+               { 
+                       get { return true; }
+               } 
+               
+               public object this [object key]
+               { 
+                       get 
+                       {
+                               foreach (IDictionary dic in dictionaries)
+                                       if (dic.Contains (key)) return dic [key];
+                               return null;
+                       }
+                       
+                       set
+                       {
+                               throw new NotSupportedException ();
+                       }
+               }
+               
+               public ICollection Keys 
+               { 
+                       get
+                       {
+                               if (_keys != null) return _keys;
+                               
+                               _keys = new ArrayList ();
+                               foreach (IDictionary dic in dictionaries)
+                                       _keys.AddRange (dic.Keys);
+                               return _keys;
+                       }
+               } 
+               
+               public ICollection Values 
+               { 
+                       get
+                       {
+                               if (_values != null) return _values;
+                               
+                               _values = new ArrayList ();
+                               foreach (IDictionary dic in dictionaries)
+                                       _values.AddRange (dic.Values);
+                               return _values;
+                       }
+               }
+               
+               public void Add (object key, object value)
+               {
+                       throw new NotSupportedException ();
+               }
+               
+               public void Clear ()
+               {
+                       throw new NotSupportedException ();
+               }
+               
+               public bool Contains (object ob)
+               {
+                       foreach (IDictionary dic in dictionaries)
+                               if (dic.Contains (ob)) return true;
+                       return false;
+               }
+               
+               public IDictionaryEnumerator GetEnumerator ()
+               {
+                       return new AggregateEnumerator (dictionaries);
+               }
+               
+               IEnumerator IEnumerable.GetEnumerator ()
+               {
+                       return new AggregateEnumerator (dictionaries);
+               }
+               
+               public void Remove (object ob)
+               {
+                       throw new NotSupportedException ();
+               }
+               
+               public void CopyTo (Array array, int index)
+               {
+                       foreach (object ob in this)
+                               array.SetValue (ob, index++);
+               }
+               
+               public int Count 
+               { 
+                       get
+                       {
+                               int c = 0;
+                               foreach (IDictionary dic in dictionaries)
+                                       c += dic.Count;
+                               return c;
+                       }
+               }
+               
+               public bool IsSynchronized 
+               { 
+                       get { return false; }
+               }
+               
+               public object SyncRoot 
+               { 
+                       get { return this; }
+               } 
+       }
+       
+       internal class AggregateEnumerator: IDictionaryEnumerator
+       {
+               IDictionary[] dictionaries;
+               int pos = 0;
+               IDictionaryEnumerator currente;
+               
+               public AggregateEnumerator (IDictionary[] dics)
+               {
+                       dictionaries = dics;
+                       Reset ();
+               }
+               
+               public DictionaryEntry Entry 
+               { 
+                       get { return currente.Entry; }
+               }
+               
+               public object Key 
+               {
+                       get { return currente.Key; }
+               }
+               
+               public object Value 
+               { 
+                       get { return currente.Value; }
+               }
+               
+               public object Current 
+               { 
+                       get { return currente.Current; }
+               }
+               
+               public bool MoveNext ()
+               {
+                       if (pos >= dictionaries.Length) return false;
+
+                       if (!currente.MoveNext()) 
+                       {
+                               pos++;
+                               if (pos >= dictionaries.Length) return false;
+                               currente = dictionaries [pos].GetEnumerator ();
+                               return MoveNext ();
+                       }
+                       
+                       return true;
+               }
+               
+               public void Reset ()
+               {
+                       pos = 0;
+                       if (dictionaries.Length > 0)
+                               currente = dictionaries [0].GetEnumerator ();
+               }
+       }
+}

diff --git a/mcs/class/corlib/System.Runtime.Remoting.Channels/ChangeLog b/mcs/class/corlib/System.Runtime.Remoting.Channels/ChangeLog
index 91405f0e92fd93e525ebd62a67e7416298de6be4..c929235c4bd16fd625dc79f9f745a986d66284fd 100644 (file)
--- a/mcs/class/corlib/System.Runtime.Remoting.Channels/ChangeLog
+++ b/mcs/class/corlib/System.Runtime.Remoting.Channels/ChangeLog
@@ -1,3 +1,9 @@
+2003-11-17  Lluis Sanchez Gual <lluis@ximian.com>
+
+       * GetChannelSinkProperties.cs: Implemented GetChannelSinkProperties().
+       * ServerDispatchSink.cs: Removed some TODOs.
+       * AggregateDictionary.cs: Added.
+
 2003-11-16  Lluis Sanchez Gual <lluis@ximian.com>
 
        * ChannelServices.cs: Removed some TODOs. Implemented AsyncDispatchMessage.

diff --git a/mcs/class/corlib/System.Runtime.Remoting.Channels/ChannelServices.cs b/mcs/class/corlib/System.Runtime.Remoting.Channels/ChannelServices.cs
index dcd5a4b9c7991b5c5d93207074796d2e74b7892b..59923319861f8ffa295f500f9e26bdcd80bf8cec 100644 (file)
--- a/mcs/class/corlib/System.Runtime.Remoting.Channels/ChannelServices.cs
+++ b/mcs/class/corlib/System.Runtime.Remoting.Channels/ChannelServices.cs
@@ -170,10 +170,30 @@ namespace System.Runtime.Remoting.Channels
                        }
                }
 
-               [MonoTODO]
                public static IDictionary GetChannelSinkProperties (object obj)
                {
-                       throw new NotImplementedException ();
+                       if (!RemotingServices.IsTransparentProxy (obj))
+                               throw new ArgumentException ("obj must be a proxy","obj");
+                               
+                       ClientIdentity ident = (ClientIdentity) RemotingServices.GetRealProxy (obj).ObjectIdentity;
+                       IMessageSink sink = ident.ChannelSink;
+                       ArrayList dics = new ArrayList ();
+                       
+                       while (sink != null && !(sink is IClientChannelSink))
+                               sink = sink.NextSink;
+
+                       if (sink == null)
+                               return new Hashtable ();
+
+                       IClientChannelSink csink = sink as IClientChannelSink;
+                       while (csink != null)
+                       {
+                               dics.Add (csink.Properties);
+                               csink = csink.NextChannelSink;
+                       }
+
+                       IDictionary[] adics = (IDictionary[]) dics.ToArray (typeof(IDictionary[]));
+                       return new AggregateDictionary (adics);
                }
 
                public static string[] GetUrlsForObject (MarshalByRefObject obj)

diff --git a/mcs/class/corlib/System.Runtime.Remoting.Channels/ServerDispatchSink.cs b/mcs/class/corlib/System.Runtime.Remoting.Channels/ServerDispatchSink.cs
index 26be25514748cde50ab76fa62d7dafb36808ac10..fd83a6f1e5a40aa008f09b1c880147f84f655369 100644 (file)
--- a/mcs/class/corlib/System.Runtime.Remoting.Channels/ServerDispatchSink.cs
+++ b/mcs/class/corlib/System.Runtime.Remoting.Channels/ServerDispatchSink.cs
@@ -30,18 +30,17 @@ namespace System.Runtime.Remoting.Channels {
                        }
                }
 
-               [MonoTODO]
                public void AsyncProcessResponse (IServerResponseChannelSinkStack sinkStack, object state,
                                                  IMessage msg, ITransportHeaders headers, Stream stream)
                {
-                       throw new NotImplementedException ();
+                       // Never called (this sink does not push itself into the sink stack)
+                       throw new NotSupportedException ();
                }
 
-               [MonoTODO]
                public Stream GetResponseStream (IServerResponseChannelSinkStack sinkStack, object state,
                                                 IMessage msg, ITransportHeaders headers)
                {
-                       throw new NotImplementedException ();
+                       return null;
                }
                
                public ServerProcessing ProcessMessage (IServerChannelSinkStack sinkStack,