fix all stelycop warnings except documentation (#40)

* fix all warnings except documentation

* fix few more naming issues

Author: SergeyKanzhelev

src/OpenCensus/Api/Stats/IMeasure.cs

@@ -21,15 +21,15 @@ namespace OpenCensus.Stats
 
     public interface IMeasure
     {
-        T Match<T>(
-            Func<IMeasureDouble, T> p0,
-            Func<IMeasureLong, T> p1,
-            Func<IMeasure, T> defaultFunction);
-
         string Name { get; }
 
         string Description { get; }
 
         string Unit { get; }
+
+        T Match<T>(
+            Func<IMeasureDouble, T> p0,
+            Func<IMeasureLong, T> p1,
+            Func<IMeasure, T> defaultFunction);
     }
 }

src/OpenCensus/Api/Stats/MeasureUnit.cs

@@ -28,7 +28,7 @@ public static class MeasureUnit
 
         public static string Tarabyte { get; } = "terabytes";
 
-        private static string Minutes { get; } = "minutes";
+        public static string Minutes { get; } = "minutes";
 
         public static string Seconds { get; } = "seconds";
 

src/OpenCensus/Api/Tags/ITagger.cs

@@ -26,10 +26,10 @@ public interface ITagger
 
         ITagContextBuilder EmptyBuilder { get; }
 
-        ITagContextBuilder ToBuilder(ITagContext tags);
-
         ITagContextBuilder CurrentBuilder { get; }
 
         IScope WithTagContext(ITagContext tags);
+
+        ITagContextBuilder ToBuilder(ITagContext tags);
     }
 }

src/OpenCensus/Api/Trace/Export/ISampledSpanStore.cs

@@ -22,6 +22,8 @@ public interface ISampledSpanStore
     {
         ISampledSpanStoreSummary Summary { get; }
 
+        ISet<string> RegisteredSpanNamesForCollection { get; }
+
         IList<ISpanData> GetLatencySampledSpans(ISampledSpanStoreLatencyFilter filter);
 
         IList<ISpanData> GetErrorSampledSpans(ISampledSpanStoreErrorFilter filter);
@@ -30,8 +32,6 @@ public interface ISampledSpanStore
 
         void UnregisterSpanNamesForCollection(IList<string> spanNames);
 
-        ISet<string> RegisteredSpanNamesForCollection { get; }
-
         void ConsiderForSampling(ISpan span);
     }
 }

src/OpenCensus/Api/Trace/Propagation/ISetter.cs

@@ -16,8 +16,8 @@
 
 namespace OpenCensus.Trace.Propagation
 {
-    public interface ISetter<C>
+    public interface ISetter<T>
     {
-        void Put(C carrier, string key, string value);
+        void Put(T carrier, string key, string value);
     }
 }

src/OpenCensus/Api/Trace/Propagation/ITextFormat.cs

@@ -22,8 +22,8 @@ public interface ITextFormat
     {
         IList<string> Fields { get; }
 
-        void Inject<C>(ISpanContext spanContext, C carrier, ISetter<C> setter);
+        void Inject<T>(ISpanContext spanContext, T carrier, ISetter<T> setter);
 
-        ISpanContext Extract<C>(C carrier, IGetter<C> getter);
+        ISpanContext Extract<T>(T carrier, IGetter<T> getter);
     }
 }

src/OpenCensus/Impl/Common/Duration.cs

@@ -18,9 +18,9 @@ namespace OpenCensus.Common
 {
     public class Duration : IDuration
     {
-        private const long MAX_SECONDS = 315576000000L;
-        private const int MAX_NANOS = 999999999;
-        private static readonly IDuration ZERO = new Duration(0, 0);
+        private const long MaxSeconds = 315576000000L;
+        private const int MaxNanos = 999999999;
+        private static readonly IDuration Zero = new Duration(0, 0);
 
         public Duration(long seconds, int nanos)
         {
@@ -34,19 +34,19 @@ public Duration(long seconds, int nanos)
 
         public static IDuration Create(long seconds, int nanos)
         {
-            if (seconds < -MAX_SECONDS || seconds > MAX_SECONDS)
+            if (seconds < -MaxSeconds || seconds > MaxSeconds)
             {
-                return ZERO;
+                return Zero;
             }
 
-            if (nanos < -MAX_NANOS || nanos > MAX_NANOS)
+            if (nanos < -MaxNanos || nanos > MaxNanos)
             {
-                return ZERO;
+                return Zero;
             }
 
             if ((seconds < 0 && nanos > 0) || (seconds > 0 && nanos < 0))
             {
-                return ZERO;
+                return Zero;
             }
 
             return new Duration(seconds, nanos);
@@ -63,6 +63,7 @@ public int CompareTo(IDuration other)
             return (this.Nanos < other.Nanos) ? -1 : ((this.Nanos > other.Nanos) ? 1 : 0);
         }
 
+        /// <inheritdoc/>
         public override string ToString()
         {
             return "Duration{"
@@ -71,6 +72,7 @@ public override string ToString()
                 + "}";
         }
 
+    /// <inheritdoc/>
         public override bool Equals(object o)
         {
             if (o == this)
@@ -87,6 +89,7 @@ public override bool Equals(object o)
             return false;
         }
 
+    /// <inheritdoc/>
         public override int GetHashCode()
         {
             long h = 1;

src/OpenCensus/Impl/Common/Timestamp.cs

@@ -20,11 +20,11 @@ namespace OpenCensus.Common
 
     public class Timestamp : ITimestamp
     {
-        private const long MAX_SECONDS = 315576000000L;
-        private const int MAX_NANOS = 999999999;
-        private const long MILLIS_PER_SECOND = 1000L;
-        private const long NANOS_PER_MILLI = 1000 * 1000;
-        private const long NANOS_PER_SECOND = NANOS_PER_MILLI * MILLIS_PER_SECOND;
+        private const long MaxSeconds = 315576000000L;
+        private const int MaxNanos = 999999999;
+        private const long MillisPerSecond = 1000L;
+        private const long NanosPerMilli = 1000 * 1000;
+        private const long NanosPerSecond = NanosPerMilli * MillisPerSecond;
 
         internal Timestamp(long seconds, int nanos)
         {
@@ -39,12 +39,12 @@ internal Timestamp(long seconds, int nanos)
         public static ITimestamp Create(long seconds, int nanos)
         {
             // TODO:
-            if (seconds < -MAX_SECONDS || seconds > MAX_SECONDS)
+            if (seconds < -MaxSeconds || seconds > MaxSeconds)
             {
                 return new Timestamp(0, 0);
             }
 
-            if (nanos < 0 || nanos > MAX_NANOS)
+            if (nanos < 0 || nanos > MaxNanos)
             {
                 return new Timestamp(0, 0);
             }
@@ -55,7 +55,7 @@ public static ITimestamp Create(long seconds, int nanos)
         public static ITimestamp FromMillis(long millis)
         {
             Timestamp zero = new Timestamp(0, 0);
-            long nanos = millis * NANOS_PER_MILLI;
+            long nanos = millis * NanosPerMilli;
             return zero.Plus(0, nanos);
         }
 
@@ -76,12 +76,12 @@ public IDuration SubtractTimestamp(ITimestamp timestamp)
             if (durationSeconds < 0 && durationNanos > 0)
             {
                 durationSeconds += 1;
-                durationNanos = (int)(durationNanos - NANOS_PER_SECOND);
+                durationNanos = (int)(durationNanos - NanosPerSecond);
             }
             else if (durationSeconds > 0 && durationNanos < 0)
             {
                 durationSeconds -= 1;
-                durationNanos = (int)(durationNanos + NANOS_PER_SECOND);
+                durationNanos = (int)(durationNanos + NanosPerSecond);
             }
 
             return Duration.Create(durationSeconds, durationNanos);
@@ -98,6 +98,7 @@ public int CompareTo(ITimestamp other)
             return (this.Nanos < other.Nanos) ? -1 : ((this.Nanos > other.Nanos) ? 1 : 0);
         }
 
+        /// <inheritdoc/>
         public override string ToString()
         {
             return "Timestamp{"
@@ -106,6 +107,7 @@ public override string ToString()
                 + "}";
         }
 
+        /// <inheritdoc/>
         public override bool Equals(object o)
         {
             if (o == this)
@@ -122,6 +124,7 @@ public override bool Equals(object o)
             return false;
         }
 
+        /// <inheritdoc/>
         public override int GetHashCode()
         {
             long h = 1;
@@ -134,9 +137,9 @@ public override int GetHashCode()
 
         private static ITimestamp OfSecond(long seconds, long nanoAdjustment)
         {
-            long floor = (long)Math.Floor((double)nanoAdjustment / NANOS_PER_SECOND);
+            long floor = (long)Math.Floor((double)nanoAdjustment / NanosPerSecond);
             long secs = seconds + floor;
-            long nos = nanoAdjustment - (floor * NANOS_PER_SECOND);
+            long nos = nanoAdjustment - (floor * NanosPerSecond);
             return Create(secs, (int)nos);
         }
 
@@ -148,7 +151,7 @@ private ITimestamp Plus(long secondsToAdd, long nanosToAdd)
             }
 
             long sec = this.Seconds + secondsToAdd;
-            long nanoSeconds = Math.DivRem(nanosToAdd, NANOS_PER_SECOND, out long nanosSpill);
+            long nanoSeconds = Math.DivRem(nanosToAdd, NanosPerSecond, out long nanosSpill);
             sec = sec + nanoSeconds;
             long nanoAdjustment = this.Nanos + nanosSpill;
             return OfSecond(sec, nanoAdjustment);

src/OpenCensus/Impl/Internal/VarInt.cs

@@ -22,10 +22,10 @@ namespace OpenCensus.Internal
     public static class VarInt
     {
         /** Maximum encoded size of 32-bit positive integers (in bytes) */
-        public const int MAX_VARINT_SIZE = 5;
+        public const int MaxVarintSize = 5;
 
         /** maximum encoded size of 64-bit longs, and negative 32-bit ints (in bytes) */
-        public const int MAX_VARLONG_SIZE = 10;
+        public const int MaxVarlongSize = 10;
 
         public static int VarIntSize(int i)
         {

src/OpenCensus/Impl/Stats/Aggregation.cs

@@ -21,6 +21,6 @@ namespace OpenCensus.Stats
 
     public abstract class Aggregation : IAggregation
     {
-        public abstract M Match<M>(Func<ISum, M> p0, Func<ICount, M> p1, Func<IMean, M> p2, Func<IDistribution, M> p3, Func<ILastValue, M> p4, Func<IAggregation, M> p5);
+        public abstract T Match<T>(Func<ISum, T> p0, Func<ICount, T> p1, Func<IMean, T> p2, Func<IDistribution, T> p3, Func<ILastValue, T> p4, Func<IAggregation, T> p5);
     }
 }