The Labs \ Source Viewer \ SSCLI \ System.Net \ Stamp

  1. //------------------------------------------------------------------------------
  2. // <copyright file="cookiecollection.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. namespace System.Net
  16. {
  17.     using System.Collections;
  18.     using System.Globalization;
  19.     using System.Runtime.Serialization;
  20.    
  21.     //
  22.     // CookieCollection
  23.     //
  24.     // A list of cookies maintained in Sorted order. Only one cookie with matching Name/Domain/Path
  25.     //
  26.    
  27.     /// <devdoc>
  28.     /// <para>[To be supplied.]</para>
  29.     /// </devdoc>
  30.     [Serializable()]
  31.     public class CookieCollection : ICollection
  32.     {
  33.        
  34.         // fields
  35.         internal enum Stamp
  36.         {
  37.             Check = 0,
  38.             Set = 1,
  39.             SetToUnused = 2,
  40.             SetToMaxUsed = 3
  41.         }
  42.        
  43.         internal int m_version;
  44.         ArrayList m_list = new ArrayList();
  45.        
  46.         DateTime m_TimeStamp = DateTime.MinValue;
  47.         bool m_has_other_versions;
  48.        
  49.         [OptionalField()]
  50.         bool m_IsReadOnly;
  51.        
  52.         // constructors
  53.        
  54.         /// <devdoc>
  55.         /// <para>[To be supplied.]</para>
  56.         /// </devdoc>
  57.         public CookieCollection()
  58.         {
  59.             m_IsReadOnly = true;
  60.         }
  61.        
  62.        
  63.         internal CookieCollection(bool IsReadOnly)
  64.         {
  65.             m_IsReadOnly = IsReadOnly;
  66.         }
  67.        
  68.         // properties
  69.        
  70.         /// <devdoc>
  71.         /// <para>[To be supplied.]</para>
  72.         /// </devdoc>
  73.         public bool IsReadOnly {
  74.             get { return m_IsReadOnly; }
  75.         }
  76.        
  77.         /// <devdoc>
  78.         /// <para>[To be supplied.]</para>
  79.         /// </devdoc>
  80.         public Cookie this[int index]
  81.         {
  82.             get {
  83.                 if (index < 0 || index >= m_list.Count) {
  84.                     throw new ArgumentOutOfRangeException("index");
  85.                 }
  86.                 return (Cookie)(m_list[index]);
  87.             }
  88.         }
  89.        
  90.         /// <devdoc>
  91.         /// <para>[To be supplied.]</para>
  92.         /// </devdoc>
  93.         public Cookie this[string name]
  94.         {
  95.             get {
  96.                 foreach (Cookie c in m_list) {
  97.                     if (string.Compare(c.Name, name, StringComparison.OrdinalIgnoreCase) == 0) {
  98.                         return c;
  99.                     }
  100.                 }
  101.                 return null;
  102.             }
  103.         }
  104.        
  105.         // methods
  106.        
  107.         /// <devdoc>
  108.         /// <para>[To be supplied.]</para>
  109.         /// </devdoc>
  110.         public void Add(Cookie cookie)
  111.         {
  112.             if (cookie == null) {
  113.                 throw new ArgumentNullException("cookie");
  114.             }
  115.             ++m_version;
  116.             int idx = IndexOf(cookie);
  117.             if (idx == -1) {
  118.                 m_list.Add(cookie);
  119.             }
  120.             else {
  121.                 m_list[idx] = cookie;
  122.             }
  123.         }
  124.        
  125.         /// <devdoc>
  126.         /// <para>[To be supplied.]</para>
  127.         /// </devdoc>
  128.         public void Add(CookieCollection cookies)
  129.         {
  130.             if (cookies == null) {
  131.                 throw new ArgumentNullException("cookies");
  132.             }
  133.             //if (cookies == this) {
  134.             // cookies = new CookieCollection(cookies);
  135.             //}
  136.             foreach (Cookie cookie in cookies) {
  137.                 Add(cookie);
  138.             }
  139.         }
  140.        
  141.         // ICollection interface
  142.        
  143.         /// <devdoc>
  144.         /// <para>[To be supplied.]</para>
  145.         /// </devdoc>
  146.         public int Count {
  147.             get { return m_list.Count; }
  148.         }
  149.        
  150.         /// <devdoc>
  151.         /// <para>[To be supplied.]</para>
  152.         /// </devdoc>
  153.         public bool IsSynchronized {
  154.             get { return false; }
  155.         }
  156.        
  157.         /// <devdoc>
  158.         /// <para>[To be supplied.]</para>
  159.         /// </devdoc>
  160.         public object SyncRoot {
  161.             get { return this; }
  162.         }
  163.        
  164.         /// <devdoc>
  165.         /// <para>[To be supplied.]</para>
  166.         /// </devdoc>
  167.         public void CopyTo(Array array, int index)
  168.         {
  169.             m_list.CopyTo(array, index);
  170.         }
  171.        
  172.         /// <devdoc>
  173.         /// <para>[To be supplied.]</para>
  174.         /// </devdoc>
  175.         public void CopyTo(Cookie[] array, int index)
  176.         {
  177.             m_list.CopyTo(array, index);
  178.         }
  179.        
  180.        
  181.         internal DateTime TimeStamp(Stamp how)
  182.         {
  183.             switch (how) {
  184.                 case Stamp.Set:
  185.                     m_TimeStamp = DateTime.Now;
  186.                     break;
  187.                 case Stamp.SetToMaxUsed:
  188.                     m_TimeStamp = DateTime.MaxValue;
  189.                     break;
  190.                 case Stamp.SetToUnused:
  191.                     m_TimeStamp = DateTime.MinValue;
  192.                     break;
  193.                 case Stamp.Check:
  194.                 default:
  195.                     break;
  196.             }
  197.             return m_TimeStamp;
  198.         }
  199.        
  200.        
  201.         // This is for internal cookie container usage
  202.         // For others not that m_has_other_versions gets changed ONLY in InternalAdd
  203.         internal bool IsOtherVersionSeen {
  204.             get { return m_has_other_versions; }
  205.         }
  206.        
  207.         // If isStrict == false, assumes that incoming cookie is unique
  208.         // If isStrict == true, replace the cookie if found same with newest Variant
  209.         // returns 1 if added, 0 if replaced or rejected
  210.         internal int InternalAdd(Cookie cookie, bool isStrict)
  211.         {
  212.             int ret = 1;
  213.             if (isStrict) {
  214.                 IComparer comp = Cookie.GetComparer();
  215.                 int idx = 0;
  216.                 foreach (Cookie c in m_list) {
  217.                     if (comp.Compare(cookie, c) == 0) {
  218.                         ret = 0;
  219.                         //will replace or reject
  220.                         //Cookie2 spec requires that new Variant cookie overwrite the old one
  221.                         if (c.Variant <= cookie.Variant) {
  222.                             m_list[idx] = cookie;
  223.                         }
  224.                         break;
  225.                     }
  226.                     ++idx;
  227.                 }
  228.                 if (idx == m_list.Count) {
  229.                     m_list.Add(cookie);
  230.                 }
  231.             }
  232.             else {
  233.                 m_list.Add(cookie);
  234.             }
  235.             if (cookie.Version != Cookie.MaxSupportedVersion) {
  236.                 m_has_other_versions = true;
  237.             }
  238.             return ret;
  239.         }
  240.        
  241.        
  242.         internal int IndexOf(Cookie cookie)
  243.         {
  244.             IComparer comp = Cookie.GetComparer();
  245.             int idx = 0;
  246.             foreach (Cookie c in m_list) {
  247.                 if (comp.Compare(cookie, c) == 0) {
  248.                     return idx;
  249.                 }
  250.                 ++idx;
  251.             }
  252.             return -1;
  253.         }
  254.        
  255.         internal void RemoveAt(int idx)
  256.         {
  257.             m_list.RemoveAt(idx);
  258.         }
  259.        
  260.        
  261.         // IEnumerable interface
  262.        
  263.         /// <devdoc>
  264.         /// <para>[To be supplied.]</para>
  265.         /// </devdoc>
  266.         public IEnumerator GetEnumerator()
  267.         {
  268.             return new CookieCollectionEnumerator(this);
  269.         }
  270.        
  271.         #if DEBUG
  272.         /// <devdoc>
  273.         /// <para>[To be supplied.]</para>
  274.         /// </devdoc>
  275.         internal void Dump()
  276.         {
  277.             GlobalLog.Print("CookieCollection:");
  278.             foreach (Cookie cookie in this) {
  279.                 cookie.Dump();
  280.             }
  281.         }
  282.         #endif
  283.        
  284.         //Not used anymore delete ?
  285.         private class CookieCollectionEnumerator : IEnumerator
  286.         {
  287.            
  288.             CookieCollection m_cookies;
  289.             int m_count;
  290.             int m_index = -1;
  291.             int m_version;
  292.            
  293.             internal CookieCollectionEnumerator(CookieCollection cookies)
  294.             {
  295.                 m_cookies = cookies;
  296.                 m_count = cookies.Count;
  297.                 m_version = cookies.m_version;
  298.             }
  299.            
  300.             // IEnumerator interface
  301.            
  302.             object IEnumerator.Current {
  303.                 get {
  304.                     if (m_index < 0 || m_index >= m_count) {
  305.                         throw new InvalidOperationException(SR.GetString(SR.InvalidOperation_EnumOpCantHappen));
  306.                     }
  307.                     if (m_version != m_cookies.m_version) {
  308.                         throw new InvalidOperationException(SR.GetString(SR.InvalidOperation_EnumFailedVersion));
  309.                     }
  310.                     return m_cookies[m_index];
  311.                 }
  312.             }
  313.            
  314.             bool IEnumerator.MoveNext()
  315.             {
  316.                 if (m_version != m_cookies.m_version) {
  317.                     throw new InvalidOperationException(SR.GetString(SR.InvalidOperation_EnumFailedVersion));
  318.                 }
  319.                 if (++m_index < m_count) {
  320.                     return true;
  321.                 }
  322.                 m_index = m_count;
  323.                 return false;
  324.             }
  325.            
  326.             void IEnumerator.Reset()
  327.             {
  328.                 m_index = -1;
  329.             }
  330.         }
  331.     }
  332. }

Developer Fusion