mcs/class/corlib/System.Security.Policy/Evidence.cs

   1 // System.Security.Policy.Evidence
   2 //
   3 // Authors:
   4 //  Sean MacIsaac (macisaac@ximian.com)
   5 //  Nick Drochak (ndrochak@gol.com)
   6 //  Jackson Harper (Jackson@LatitudeGeo.com)
   7 //
   8 // (C) 2001 Ximian, Inc.
   9
  10 using System;
  11 using System.Collections;
  12
  13 namespace System.Security.Policy {
  14
  15         [MonoTODO]
  16         [Serializable]
  17         public sealed class Evidence : ICollection, IEnumerable {
  18
  19                 private ArrayList hostEvidenceList = new ArrayList ();
  20                 private ArrayList assemblyEvidenceList = new ArrayList ();
  21
  22                 public Evidence ()
  23                 {
  24                 }
  25
  26                 public Evidence (Evidence evidence)
  27                 {
  28                         if (evidence != null)
  29                                 Merge (evidence);
  30                 }
  31
  32                 public Evidence (object[] hostEvidence, object[] assemblyEvidence )
  33                 {
  34                         if (null != hostEvidence)
  35                                 hostEvidenceList.AddRange (hostEvidence);
  36                         if (null != assemblyEvidence)
  37                                 assemblyEvidenceList.AddRange (assemblyEvidence);
  38                 }
  39
  40                 //
  41                 // Public Properties
  42                 //
  43
  44                 public int Count {
  45                         get {
  46                                 return (hostEvidenceList.Count + assemblyEvidenceList.Count);
  47                         }
  48                 }
  49
  50                 public bool IsReadOnly {
  51                         get{ return false; }
  52                 }
  53
  54                 public bool IsSynchronized {
  55                         get { return false; }
  56                 }
  57
  58                 [MonoTODO]
  59                 public bool Locked {
  60                         get {
  61                                 throw new NotImplementedException ();
  62                         }
  63                         set {
  64                                 throw new NotImplementedException ();
  65                         }
  66                 }
  67
  68                 public object SyncRoot {
  69                         get { return this; }
  70                 }
  71
  72                 //
  73                 // Public Methods
  74                 //
  75
  76                 public void AddAssembly (object id)
  77                 {
  78                         assemblyEvidenceList.Add (id);
  79                 }
  80
  81                 [MonoTODO("If Locked is true and the code that calls this method does not have SecurityPermissionFlag.ControlEvidence a SecurityException should be thrown")]
  82                 public void AddHost (object id)
  83                 {
  84                         hostEvidenceList.Add (id);
  85                 }
  86
  87                 public void CopyTo (Array array, int index)
  88                 {
  89                         if (hostEvidenceList.Count > 0)
  90                                 hostEvidenceList.CopyTo (array,index);
  91                         if (assemblyEvidenceList.Count > 0)
  92                                 assemblyEvidenceList.CopyTo (array,index + hostEvidenceList.Count);
  93                 }
  94
  95                 public IEnumerator GetEnumerator ()
  96                 {
  97                         return new EvidenceEnumerator (hostEvidenceList.GetEnumerator (),
  98                                 assemblyEvidenceList.GetEnumerator ());
  99                 }
 100
 101                 public IEnumerator GetAssemblyEnumerator ()
 102                 {
 103                         return assemblyEvidenceList.GetEnumerator ();
 104                 }
 105
 106                 public IEnumerator GetHostEnumerator ()
 107                 {
 108                         return hostEvidenceList.GetEnumerator ();
 109                 }
 110
 111                 public void Merge (Evidence evidence)
 112                 {
 113                         IEnumerator hostenum, assemblyenum;
 114
 115                         hostenum = evidence.GetHostEnumerator ();
 116                         while( hostenum.MoveNext () ) {
 117                                 AddHost (hostenum.Current);
 118                         }
 119
 120                         assemblyenum = evidence.GetAssemblyEnumerator ();
 121                         while( assemblyenum.MoveNext () ) {
 122                                 AddAssembly (assemblyenum.Current);
 123                         }
 124                 }
 125
 126                 private class EvidenceEnumerator : IEnumerator {
 127
 128                         private IEnumerator currentEnum, hostEnum, assemblyEnum;
 129
 130                         public EvidenceEnumerator (IEnumerator hostenum, IEnumerator assemblyenum)
 131                         {
 132                                 this.hostEnum = hostenum;
 133                                 this.assemblyEnum = assemblyenum;
 134                                 currentEnum = hostEnum;
 135                         }
 136
 137                         public bool MoveNext ()
 138                         {
 139                                 bool ret = currentEnum.MoveNext ();
 140
 141                                 if ( !ret && hostEnum == currentEnum ) {
 142                                         currentEnum = assemblyEnum;
 143                                         ret = assemblyEnum.MoveNext ();
 144                                 }
 145
 146                                 return ret;
 147                         }
 148
 149                         public void Reset ()
 150                         {
 151                                 hostEnum.Reset ();
 152                                 assemblyEnum.Reset ();
 153                                 currentEnum = hostEnum;
 154                         }
 155
 156                         public object Current {
 157                                 get {
 158                                         return currentEnum.Current;
 159                                 }
 160                         }
 161                 }
 162         }
 163 }
 164