mono/InternetAddressList.custom

   1 #region Native Methods
   2                 [DllImport("gmime")]
   3                 static extern int internet_address_list_length (IntPtr list);
   4
   5                 [DllImport("gmime")]
   6                 static extern void internet_address_list_clear (IntPtr list);
   7
   8                 [DllImport("gmime")]
   9                 static extern int internet_address_list_add (IntPtr list, IntPtr ia);
  10
  11                 //[DllImport("gmime")]
  12                 //static extern void internet_address_list_concat (IntPtr list, IntPtr concat);
  13
  14                 [DllImport("gmime")]
  15                 static extern void internet_address_list_insert (IntPtr list, int index, IntPtr ia);
  16
  17                 [DllImport("gmime")]
  18                 static extern bool internet_address_list_remove (IntPtr list, IntPtr ia);
  19
  20                 [DllImport("gmime")]
  21                 static extern bool internet_address_list_remove_at (IntPtr list, int index);
  22
  23                 [DllImport("gmime")]
  24                 static extern bool internet_address_list_contains (IntPtr list, IntPtr ia);
  25
  26                 [DllImport("gmime")]
  27                 static extern int internet_address_list_index_of (IntPtr list, IntPtr ia);
  28
  29                 [DllImport("gmime")]
  30                 static extern IntPtr internet_address_list_get_address (IntPtr list, int index);
  31
  32                 [DllImport("gmime")]
  33                 static extern void internet_address_list_set_address (IntPtr list, int index, IntPtr ia);
  34
  35                 [DllImport("gmime")]
  36                 static extern IntPtr internet_address_list_to_string (IntPtr list, bool encode);
  37
  38                 [DllImport("gmime")]
  39                 static extern IntPtr internet_address_list_parse_string (IntPtr str);
  40 #endregion
  41
  42                 Exception CannotAdd (object value)
  43                 {
  44                         if (value == null)
  45                                 return new ArgumentNullException ("value");
  46
  47                         string message = String.Format ("Cannot add objects of type '{0}' to an InternetAddressList.",
  48                                                         value.GetType ().ToString ());
  49
  50                         return new InvalidOperationException (message);
  51                 }
  52
  53                 Exception CannotInsert (object value)
  54                 {
  55                         if (value == null)
  56                                 return new ArgumentNullException ("value");
  57
  58                         string message = String.Format ("Cannot insert objects of type '{0}' into an InternetAddressList.",
  59                                                         value.GetType ().ToString ());
  60
  61                         return new InvalidOperationException (message);
  62                 }
  63
  64                 Exception CannotRemove (object value)
  65                 {
  66                         if (value == null)
  67                                 return new ArgumentNullException ("value");
  68
  69                         string  message = String.Format ("Cannot remove objects of type '{0}' from an InternetAddressList.",
  70                                                          value.GetType ().ToString ());
  71
  72                         return new InvalidOperationException (message);
  73                 }
  74
  75                 Exception CannotSet (object value)
  76                 {
  77                         if (value == null)
  78                                 return new ArgumentNullException ("value");
  79
  80                         string message = String.Format ("Cannot set objects of type '{0}' on an InternetAddressList.",
  81                                                         value.GetType ().ToString ());
  82
  83                         return new InvalidOperationException (message);
  84                 }
  85
  86                 public int Count {
  87                         get { return internet_address_list_length (Handle); }
  88                 }
  89
  90                 public bool IsFixedSize {
  91                         get { return false; }
  92                 }
  93
  94                 public bool IsReadOnly {
  95                         get { return false; }
  96                 }
  97
  98                 public bool IsSynchronized {
  99                         get { return false; }
 100                 }
 101
 102                 public object SyncRoot {
 103                         get { return this; }
 104                 }
 105
 106                 public int Add (InternetAddress addr)
 107                 {
 108                         if (addr == null)
 109                                 throw CannotAdd (addr);
 110
 111                         return internet_address_list_add (Handle, addr.Handle);
 112                 }
 113
 114                 int IList.Add (object value)
 115                 {
 116                         InternetAddress addr = value as InternetAddress;
 117
 118                         if (addr == null)
 119                                 throw CannotAdd (value);
 120
 121                         return Add (addr);
 122                 }
 123
 124                 public void Clear ()
 125                 {
 126                         internet_address_list_clear (Handle);
 127                 }
 128
 129                 public bool Contains (InternetAddress addr)
 130                 {
 131                         if (addr == null)
 132                                 return false;
 133
 134                         return internet_address_list_contains (Handle, addr.Handle);
 135                 }
 136
 137                 bool IList.Contains (object value)
 138                 {
 139                         return Contains (value as InternetAddress);
 140                 }
 141
 142                 public void CopyTo (Array array, int index)
 143                 {
 144                         if (array == null)
 145                                 throw new ArgumentNullException ("array");
 146
 147                         if (index < 0)
 148                                 throw new ArgumentOutOfRangeException ("index");
 149
 150                         int n = Count;
 151
 152                         for (int i = 0; i < n; i++)
 153                                 array.SetValue (((IList) this)[i], index + i);
 154                 }
 155
 156                 public IEnumerator GetEnumerator ()
 157                 {
 158                         int n = Count;
 159
 160                         for (int i = 0; i < n; i++)
 161                                 yield return this[i];
 162
 163                         yield break;
 164                 }
 165
 166                 public int IndexOf (InternetAddress addr)
 167                 {
 168                         if (addr == null)
 169                                 return -1;
 170
 171                         return internet_address_list_index_of (Handle, addr.Handle);
 172                 }
 173
 174                 int IList.IndexOf (object value)
 175                 {
 176                         return IndexOf (value as InternetAddress);
 177                 }
 178
 179                 public void Insert (int index, InternetAddress addr)
 180                 {
 181                         if (addr == null)
 182                                 throw CannotInsert (addr);
 183
 184                         if (index < 0)
 185                                 throw new ArgumentOutOfRangeException ("index");
 186
 187                         internet_address_list_insert (Handle, index, addr.Handle);
 188                 }
 189
 190                 void IList.Insert (int index, object value)
 191                 {
 192                         InternetAddress addr = value as InternetAddress;
 193
 194                         if (addr == null)
 195                                 throw CannotInsert (value);
 196
 197                         Insert (index, addr);
 198                 }
 199
 200                 public void Remove (InternetAddress addr)
 201                 {
 202                         if (addr == null)
 203                                 throw CannotRemove (addr);
 204
 205                         internet_address_list_remove (Handle, addr.Handle);
 206                 }
 207
 208                 void IList.Remove (object value)
 209                 {
 210                         InternetAddress addr = value as InternetAddress;
 211
 212                         if (addr == null)
 213                                 throw CannotRemove (value);
 214
 215                         Remove (addr);
 216                 }
 217
 218                 public void RemoveAt (int index)
 219                 {
 220                         if (index < 0 || index >= Count)
 221                                 throw new ArgumentOutOfRangeException ("index");
 222
 223                         internet_address_list_remove_at (Handle, index);
 224                 }
 225
 226                 public InternetAddress this[int index] {
 227                         get {
 228                                 IntPtr raw = internet_address_list_get_address (Handle, index);
 229
 230                                 if (raw == IntPtr.Zero)
 231                                         return null;
 232
 233                                 return GLib.Object.GetObject (raw) as InternetAddress;
 234                         }
 235
 236                         set {
 237                                 if (value == null)
 238                                         throw CannotSet (value);
 239
 240                                 internet_address_list_set_address (Handle, index, value.Handle);
 241                         }
 242                 }
 243
 244                 object IList.this[int index] {
 245                         get {
 246                                 return this[index];
 247                         }
 248
 249                         set {
 250                                 this[index] = value as InternetAddress;
 251                         }
 252                 }
 253
 254                 public static InternetAddressList Parse (string str)
 255                 {
 256                         IntPtr native_str = GLib.Marshaller.StringToPtrGStrdup (str);
 257                         IntPtr raw = internet_address_list_parse_string (native_str);
 258                         InternetAddressList list = null;
 259
 260                         if (raw != IntPtr.Zero)
 261                                 list = new InternetAddressList (raw);
 262
 263                         GLib.Marshaller.Free (native_str);
 264
 265                         return list;
 266                 }
 267
 268                 public string ToString (bool encode)
 269                 {
 270                         IntPtr raw = internet_address_list_to_string (Handle, encode);
 271
 272                         if (raw == IntPtr.Zero)
 273                                 return String.Empty;
 274
 275                         return GLib.Marshaller.PtrToStringGFree (raw);
 276                 }
 277
 278                 public override string ToString ()
 279                 {
 280                         return ToString (false);
 281                 }