mcs/class/referencesource/mscorlib/system/runtime/interopservices/windowsruntime/vectortocollectionadapter.cs

   1 // ==++==
   2 //
   3 //   Copyright (c) Microsoft Corporation.  All rights reserved.
   4 //
   5 // ==--==
   6 //
   7 // <OWNER>GPaperin</OWNER>
   8 // <OWNER>Microsoft</OWNER>
   9
  10 using System;
  11 using System.Security;
  12 using System.Collections;
  13 using System.Collections.Generic;
  14 using System.Diagnostics.Contracts;
  15 using System.Runtime.InteropServices;
  16 using System.Runtime.CompilerServices;
  17
  18 namespace System.Runtime.InteropServices.WindowsRuntime
  19 {
  20     // This is a set of stub methods implementing the support for the ICollection`1 interface on WinRT
  21     // objects that support IVector`1. Used by the interop mashaling infrastructure.
  22     //
  23     // The methods on this class must be written VERY carefully to avoid introducing security holes.
  24     // That's because they are invoked with special "this"! The "this" object
  25     // for all of these methods are not VectorToCollectionAdapter objects. Rather, they are of type
  26     // IVector<T>. No actual VectorToCollectionAdapter object is ever instantiated. Thus, you will see
  27     // a lot of expressions that cast "this" to "IVector<T>".
  28     internal sealed class VectorToCollectionAdapter
  29     {
  30         private VectorToCollectionAdapter()
  31         {
  32             Contract.Assert(false, "This class is never instantiated");
  33         }
  34
  35         // int Count { get }
  36         [Pure]
  37         [SecurityCritical]
  38         internal int Count<T>()
  39         {
  40             IVector<T> _this = JitHelpers.UnsafeCast<IVector<T>>(this);
  41             uint size = _this.Size;
  42             if (((uint)Int32.MaxValue) < size)
  43             {
  44                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CollectionBackingListTooLarge"));
  45             }
  46
  47             return (int)size;
  48         }
  49
  50         // bool IsReadOnly { get }
  51         [SecurityCritical]
  52         internal bool IsReadOnly<T>()
  53         {
  54             return false;
  55         }
  56
  57         // void Add(T item)
  58         [SecurityCritical]
  59         internal void Add<T>(T item)
  60         {
  61             IVector<T> _this = JitHelpers.UnsafeCast<IVector<T>>(this);
  62             _this.Append(item);
  63         }
  64
  65         // void Clear()
  66         [SecurityCritical]
  67         internal void Clear<T>()
  68         {
  69             IVector<T> _this = JitHelpers.UnsafeCast<IVector<T>>(this);
  70             _this.Clear();
  71         }
  72
  73         // bool Contains(T item)
  74         [SecurityCritical]
  75         internal bool Contains<T>(T item)
  76         {
  77             IVector<T> _this = JitHelpers.UnsafeCast<IVector<T>>(this);
  78
  79             uint index;
  80             return _this.IndexOf(item, out index);
  81         }
  82
  83         // void CopyTo(T[] array, int arrayIndex)
  84         [SecurityCritical]
  85         internal void CopyTo<T>(T[] array, int arrayIndex)
  86         {
  87             if (array == null)
  88                 throw new ArgumentNullException("array");
  89
  90             if (arrayIndex < 0)
  91                 throw new ArgumentOutOfRangeException("arrayIndex");
  92
  93             if (array.Length <= arrayIndex && Count<T>() > 0)
  94                 throw new ArgumentException(Environment.GetResourceString("Argument_IndexOutOfArrayBounds"));
  95
  96             if (array.Length - arrayIndex < Count<T>())
  97                 throw new ArgumentException(Environment.GetResourceString("Argument_InsufficientSpaceToCopyCollection"));
  98
  99             Contract.EndContractBlock();
 100
 101             IVector<T> _this = JitHelpers.UnsafeCast<IVector<T>>(this);
 102             int count = Count<T>();
 103             for (int i = 0; i < count; i++)
 104             {
 105                 array[i + arrayIndex] = VectorToListAdapter.GetAt<T>(_this, (uint)i);
 106             }
 107         }
 108
 109         // bool Remove(T item)
 110         [SecurityCritical]
 111         internal bool Remove<T>(T item)
 112         {
 113             IVector<T> _this = JitHelpers.UnsafeCast<IVector<T>>(this);
 114
 115             uint index;
 116             bool exists = _this.IndexOf(item, out index);
 117
 118             if (!exists)
 119                 return false;
 120
 121             if (((uint)Int32.MaxValue) < index)
 122             {
 123                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CollectionBackingListTooLarge"));
 124             }
 125
 126             VectorToListAdapter.RemoveAtHelper<T>(_this, index);
 127             return true;
 128         }
 129     }
 130 }