wasSharp – Diff between revs 17 and 27

Subversion Repositories:

?pathlinks?

Rev 17 – Details – Blame – Last modification – View Log

 ï»¿// The MIT License (MIT)
 //
 // Copyright (c) 2015 Dave Transom
 //
 // Permission is hereby granted, free of charge, to any person obtaining a
 // copy of this software and associated documentation files (the
 // "Software"), to deal in the Software without restriction, including
 // without limitation the rights to use, copy, modify, merge, publish,
 // distribute, sublicense, and/or sell copies of the Software, and to
 // permit persons to whom the Software is furnished to do so, subject to
 // the following conditions:
 //
 // The above copyright notice and this permission notice shall be included
 // in all copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
     ///     Accept-Language: en-us,en;q=0.5
     /// </example>
     [DebuggerDisplay("QValue[{Name}, {Weight}]")]
     public struct QValue : IComparable<QValue>
+    {
-        private static readonly char[] delimiters = {';', '='};
+        private static readonly char[] delimiters = { ';', '=' };
         private const float defaultWeight = 1;
         #region Fields
         private float _weight;
         private int _ordinal;
-        #endregion
+        #endregion Fields
             _ordinal = ordinal;
             ParseInternal(ref this, value);
         }
-        #endregion
+        #endregion Constructors
         /// <summary>
         ///     Whether the value is empty (i.e. has no name)
         /// </summary>
         public bool IsEmpty => string.IsNullOrEmpty(Name);
-        #endregion
+        #endregion Properties
         #region Methods
                 float.TryParse(parts[2], NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture.NumberFormat,
                     out target._weight);
+            }
+        }
-        #endregion
+        #endregion Methods
         #region IComparable<QValue> Members
                 value = ord.CompareTo(-other._ordinal);
+            }
             return value;
+        }
-        #endregion
+        #endregion IComparable<QValue> Members
         #region CompareByWeight
         public static int CompareByWeightDesc(QValue x, QValue y)
+        {
             return -x.CompareTo(y);
+        }
-        #endregion
+        #endregion CompareByWeight
+    }
     /// <summary>
     ///     http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
     /// </remarks>
     [DebuggerDisplay("QValue[{Count}, {AcceptWildcard}]")]
     public sealed class QValueList : List<QValue>
+    {
-        private static readonly char[] delimiters = {','};
+        private static readonly char[] delimiters = { ',' };
         #region Add
             base.Add(item);
             applyAutoSort();
         }
-        #endregion
+        #endregion Add
             AutoSort = state;
             applyAutoSort();
         }
-        #endregion
+        #endregion AddRange
             Predicate<QValue> criteria =
                 item => item.Name.Equals(name, StringComparison.OrdinalIgnoreCase);
             return Find(criteria);
+        }
-        #endregion
+        #endregion Find
         #region FindHighestWeight
+        {
             Predicate<QValue> criteria = item => isCandidate(item.Name, candidates);
             return Find(criteria);
+        }
-        #endregion
+        #endregion FindHighestWeight
         #region FindPreferred
             Predicate<QValue> criteria =
                 item => isCandidate(item.Name, candidates) && item.CanAccept;
             return Find(criteria);
+        }
-        #endregion
+        #endregion FindPreferred
         #region DefaultSort
         public void DefaultSort()
+        {
             Sort(QValue.CompareByWeightDesc);
+        }
-        #endregion
+        #endregion DefaultSort
         #region applyAutoSort
+        {
             if (AutoSort)
                 DefaultSort();
+        }
-        #endregion
+        #endregion applyAutoSort
         #region isCandidate
                     return true;
+            }
             return false;
+        }
-        #endregion
-        #region Fields
-        #endregion
+        #endregion isCandidate
         #region Constructors
             /// methods like FindPreferred to work correctly
             DefaultSort();
             AutoSort = true;
+        }
-        #endregion
+        #endregion Constructors
         #region Properties
         /// </summary>
         /// <param name="candidates">The preferred order in which to return an encoding</param>
         /// <returns>An QValue based on weight, or null</returns>
         public QValue this[params string[] candidates] => FindPreferred(candidates);
-        #endregion
+        #endregion Properties
-    }
+    }
+}