[Sum] Extract method to inline struct implementation.

reegeek · reegeek · commit e0a3b0c689fb · 2020-02-24T10:48:21.000+01:00
diff --git a/src/StructLinq/Sum/SumStructEnumerable.cs b/src/StructLinq/Sum/SumStructEnumerable.cs
@@ -12,179 +12,239 @@ namespace StructLinq
 
     public static partial class StructEnumerable
     {
+        private static Int16 SumInt16<TEnumerator>(TEnumerator enumerator)
+            where TEnumerator : struct, IEnumerator<Int16>
+        {
+            Int16 result = 0;
+            while (enumerator.MoveNext())
+            {
+                result += enumerator.Current;
+            }
+            return result;
+        }
+        
         public static Int16 Sum<TEnumerator>(this IStructEnumerable<Int16, TEnumerator> enumerable)
             where TEnumerator : struct, IEnumerator<Int16>
         {
             using (var enumerator = enumerable.GetStructEnumerator())
             {
-				Int16 result = 0;
-				while (enumerator.MoveNext())
-				{
-					result += enumerator.Current;
-				}
-				return result;
+                return SumInt16(enumerator);
             }
         }
     }
 
 
     public static partial class StructEnumerable
     {
+        private static Int32 SumInt32<TEnumerator>(TEnumerator enumerator)
+            where TEnumerator : struct, IEnumerator<Int32>
+        {
+            Int32 result = 0;
+            while (enumerator.MoveNext())
+            {
+                result += enumerator.Current;
+            }
+            return result;
+        }
+        
         public static Int32 Sum<TEnumerator>(this IStructEnumerable<Int32, TEnumerator> enumerable)
             where TEnumerator : struct, IEnumerator<Int32>
         {
             using (var enumerator = enumerable.GetStructEnumerator())
             {
-				Int32 result = 0;
-				while (enumerator.MoveNext())
-				{
-					result += enumerator.Current;
-				}
-				return result;
+                return SumInt32(enumerator);
             }
         }
     }
 
 
     public static partial class StructEnumerable
     {
+        private static Int64 SumInt64<TEnumerator>(TEnumerator enumerator)
+            where TEnumerator : struct, IEnumerator<Int64>
+        {
+            Int64 result = 0;
+            while (enumerator.MoveNext())
+            {
+                result += enumerator.Current;
+            }
+            return result;
+        }
+        
         public static Int64 Sum<TEnumerator>(this IStructEnumerable<Int64, TEnumerator> enumerable)
             where TEnumerator : struct, IEnumerator<Int64>
         {
             using (var enumerator = enumerable.GetStructEnumerator())
             {
-				Int64 result = 0;
-				while (enumerator.MoveNext())
-				{
-					result += enumerator.Current;
-				}
-				return result;
+                return SumInt64(enumerator);
             }
         }
     }
 
 
     public static partial class StructEnumerable
     {
+        private static UInt16 SumUInt16<TEnumerator>(TEnumerator enumerator)
+            where TEnumerator : struct, IEnumerator<UInt16>
+        {
+            UInt16 result = 0;
+            while (enumerator.MoveNext())
+            {
+                result += enumerator.Current;
+            }
+            return result;
+        }
+        
         public static UInt16 Sum<TEnumerator>(this IStructEnumerable<UInt16, TEnumerator> enumerable)
             where TEnumerator : struct, IEnumerator<UInt16>
         {
             using (var enumerator = enumerable.GetStructEnumerator())
             {
-				UInt16 result = 0;
-				while (enumerator.MoveNext())
-				{
-					result += enumerator.Current;
-				}
-				return result;
+                return SumUInt16(enumerator);
             }
         }
     }
 
 
     public static partial class StructEnumerable
     {
+        private static UInt32 SumUInt32<TEnumerator>(TEnumerator enumerator)
+            where TEnumerator : struct, IEnumerator<UInt32>
+        {
+            UInt32 result = 0;
+            while (enumerator.MoveNext())
+            {
+                result += enumerator.Current;
+            }
+            return result;
+        }
+        
         public static UInt32 Sum<TEnumerator>(this IStructEnumerable<UInt32, TEnumerator> enumerable)
             where TEnumerator : struct, IEnumerator<UInt32>
         {
             using (var enumerator = enumerable.GetStructEnumerator())
             {
-				UInt32 result = 0;
-				while (enumerator.MoveNext())
-				{
-					result += enumerator.Current;
-				}
-				return result;
+                return SumUInt32(enumerator);
             }
         }
     }
 
 
     public static partial class StructEnumerable
     {
+        private static UInt64 SumUInt64<TEnumerator>(TEnumerator enumerator)
+            where TEnumerator : struct, IEnumerator<UInt64>
+        {
+            UInt64 result = 0;
+            while (enumerator.MoveNext())
+            {
+                result += enumerator.Current;
+            }
+            return result;
+        }
+        
         public static UInt64 Sum<TEnumerator>(this IStructEnumerable<UInt64, TEnumerator> enumerable)
             where TEnumerator : struct, IEnumerator<UInt64>
         {
             using (var enumerator = enumerable.GetStructEnumerator())
             {
-				UInt64 result = 0;
-				while (enumerator.MoveNext())
-				{
-					result += enumerator.Current;
-				}
-				return result;
+                return SumUInt64(enumerator);
             }
         }
     }
 
 
     public static partial class StructEnumerable
     {
+        private static Single SumSingle<TEnumerator>(TEnumerator enumerator)
+            where TEnumerator : struct, IEnumerator<Single>
+        {
+            Single result = 0;
+            while (enumerator.MoveNext())
+            {
+                result += enumerator.Current;
+            }
+            return result;
+        }
+        
         public static Single Sum<TEnumerator>(this IStructEnumerable<Single, TEnumerator> enumerable)
             where TEnumerator : struct, IEnumerator<Single>
         {
             using (var enumerator = enumerable.GetStructEnumerator())
             {
-				Single result = 0;
-				while (enumerator.MoveNext())
-				{
-					result += enumerator.Current;
-				}
-				return result;
+                return SumSingle(enumerator);
             }
         }
     }
 
 
     public static partial class StructEnumerable
     {
+        private static Double SumDouble<TEnumerator>(TEnumerator enumerator)
+            where TEnumerator : struct, IEnumerator<Double>
+        {
+            Double result = 0;
+            while (enumerator.MoveNext())
+            {
+                result += enumerator.Current;
+            }
+            return result;
+        }
+        
         public static Double Sum<TEnumerator>(this IStructEnumerable<Double, TEnumerator> enumerable)
             where TEnumerator : struct, IEnumerator<Double>
         {
             using (var enumerator = enumerable.GetStructEnumerator())
             {
-				Double result = 0;
-				while (enumerator.MoveNext())
-				{
-					result += enumerator.Current;
-				}
-				return result;
+                return SumDouble(enumerator);
             }
         }
     }
 
 
     public static partial class StructEnumerable
     {
+        private static Byte SumByte<TEnumerator>(TEnumerator enumerator)
+            where TEnumerator : struct, IEnumerator<Byte>
+        {
+            Byte result = 0;
+            while (enumerator.MoveNext())
+            {
+                result += enumerator.Current;
+            }
+            return result;
+        }
+        
         public static Byte Sum<TEnumerator>(this IStructEnumerable<Byte, TEnumerator> enumerable)
             where TEnumerator : struct, IEnumerator<Byte>
         {
             using (var enumerator = enumerable.GetStructEnumerator())
             {
-				Byte result = 0;
-				while (enumerator.MoveNext())
-				{
-					result += enumerator.Current;
-				}
-				return result;
+                return SumByte(enumerator);
             }
         }
     }
 
 
     public static partial class StructEnumerable
     {
+        private static SByte SumSByte<TEnumerator>(TEnumerator enumerator)
+            where TEnumerator : struct, IEnumerator<SByte>
+        {
+            SByte result = 0;
+            while (enumerator.MoveNext())
+            {
+                result += enumerator.Current;
+            }
+            return result;
+        }
+        
         public static SByte Sum<TEnumerator>(this IStructEnumerable<SByte, TEnumerator> enumerable)
             where TEnumerator : struct, IEnumerator<SByte>
         {
             using (var enumerator = enumerable.GetStructEnumerator())
             {
-				SByte result = 0;
-				while (enumerator.MoveNext())
-				{
-					result += enumerator.Current;
-				}
-				return result;
+                return SumSByte(enumerator);
             }
         }
     }
diff --git a/src/StructLinq/Sum/SumStructEnumerable.tt b/src/StructLinq/Sum/SumStructEnumerable.tt
@@ -34,17 +34,23 @@ namespace StructLinq
 
     public static partial class StructEnumerable
     {
+        private static <#= t.Name #> Sum<#= t.Name #><TEnumerator>(TEnumerator enumerator)
+            where TEnumerator : struct, IEnumerator<<#= t.Name #>>
+        {
+            <#= t.Name #> result = 0;
+            while (enumerator.MoveNext())
+            {
+                result += enumerator.Current;
+            }
+            return result;
+        }
+        
         public static <#= t.Name #> Sum<TEnumerator>(this IStructEnumerable<<#= t.Name #>, TEnumerator> enumerable)
             where TEnumerator : struct, IEnumerator<<#= t.Name #>>
         {
             using (var enumerator = enumerable.GetStructEnumerator())
             {
-				<#= t.Name #> result = 0;
-				while (enumerator.MoveNext())
-				{
-					result += enumerator.Current;
-				}
-				return result;
+                return Sum<#= t.Name #>(enumerator);
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -12,179 +12,239 @@ namespace StructLinq`
`12`	`12`
`13`	`13`	`public static partial class StructEnumerable`
`14`	`14`	`{`
	`15`	`+ private static Int16 SumInt16<TEnumerator>(TEnumerator enumerator)`
	`16`	`+ where TEnumerator : struct, IEnumerator<Int16>`
	`17`	`+ {`
	`18`	`+ Int16 result = 0;`
	`19`	`+ while (enumerator.MoveNext())`
	`20`	`+ {`
	`21`	`+ result += enumerator.Current;`
	`22`	`+ }`
	`23`	`+ return result;`
	`24`	`+ }`
	`25`	`+`
`15`	`26`	`public static Int16 Sum<TEnumerator>(this IStructEnumerable<Int16, TEnumerator> enumerable)`
`16`	`27`	`where TEnumerator : struct, IEnumerator<Int16>`
`17`	`28`	`{`
`18`	`29`	`using (var enumerator = enumerable.GetStructEnumerator())`
`19`	`30`	`{`
`20`		`- Int16 result = 0;`
`21`		`- while (enumerator.MoveNext())`
`22`		`- {`
`23`		`- result += enumerator.Current;`
`24`		`- }`
`25`		`- return result;`
	`31`	`+ return SumInt16(enumerator);`
`26`	`32`	`}`
`27`	`33`	`}`
`28`	`34`	`}`
`29`	`35`
`30`	`36`
`31`	`37`	`public static partial class StructEnumerable`
`32`	`38`	`{`
	`39`	`+ private static Int32 SumInt32<TEnumerator>(TEnumerator enumerator)`
	`40`	`+ where TEnumerator : struct, IEnumerator<Int32>`
	`41`	`+ {`
	`42`	`+ Int32 result = 0;`
	`43`	`+ while (enumerator.MoveNext())`
	`44`	`+ {`
	`45`	`+ result += enumerator.Current;`
	`46`	`+ }`
	`47`	`+ return result;`
	`48`	`+ }`
	`49`	`+`
`33`	`50`	`public static Int32 Sum<TEnumerator>(this IStructEnumerable<Int32, TEnumerator> enumerable)`
`34`	`51`	`where TEnumerator : struct, IEnumerator<Int32>`
`35`	`52`	`{`
`36`	`53`	`using (var enumerator = enumerable.GetStructEnumerator())`
`37`	`54`	`{`
`38`		`- Int32 result = 0;`
`39`		`- while (enumerator.MoveNext())`
`40`		`- {`
`41`		`- result += enumerator.Current;`
`42`		`- }`
`43`		`- return result;`
	`55`	`+ return SumInt32(enumerator);`
`44`	`56`	`}`
`45`	`57`	`}`
`46`	`58`	`}`
`47`	`59`
`48`	`60`
`49`	`61`	`public static partial class StructEnumerable`
`50`	`62`	`{`
	`63`	`+ private static Int64 SumInt64<TEnumerator>(TEnumerator enumerator)`
	`64`	`+ where TEnumerator : struct, IEnumerator<Int64>`
	`65`	`+ {`
	`66`	`+ Int64 result = 0;`
	`67`	`+ while (enumerator.MoveNext())`
	`68`	`+ {`
	`69`	`+ result += enumerator.Current;`
	`70`	`+ }`
	`71`	`+ return result;`
	`72`	`+ }`
	`73`	`+`
`51`	`74`	`public static Int64 Sum<TEnumerator>(this IStructEnumerable<Int64, TEnumerator> enumerable)`
`52`	`75`	`where TEnumerator : struct, IEnumerator<Int64>`
`53`	`76`	`{`
`54`	`77`	`using (var enumerator = enumerable.GetStructEnumerator())`
`55`	`78`	`{`
`56`		`- Int64 result = 0;`
`57`		`- while (enumerator.MoveNext())`
`58`		`- {`
`59`		`- result += enumerator.Current;`
`60`		`- }`
`61`		`- return result;`
	`79`	`+ return SumInt64(enumerator);`
`62`	`80`	`}`
`63`	`81`	`}`
`64`	`82`	`}`
`65`	`83`
`66`	`84`
`67`	`85`	`public static partial class StructEnumerable`
`68`	`86`	`{`
	`87`	`+ private static UInt16 SumUInt16<TEnumerator>(TEnumerator enumerator)`
	`88`	`+ where TEnumerator : struct, IEnumerator<UInt16>`
	`89`	`+ {`
	`90`	`+ UInt16 result = 0;`
	`91`	`+ while (enumerator.MoveNext())`
	`92`	`+ {`
	`93`	`+ result += enumerator.Current;`
	`94`	`+ }`
	`95`	`+ return result;`
	`96`	`+ }`
	`97`	`+`
`69`	`98`	`public static UInt16 Sum<TEnumerator>(this IStructEnumerable<UInt16, TEnumerator> enumerable)`
`70`	`99`	`where TEnumerator : struct, IEnumerator<UInt16>`
`71`	`100`	`{`
`72`	`101`	`using (var enumerator = enumerable.GetStructEnumerator())`
`73`	`102`	`{`
`74`		`- UInt16 result = 0;`
`75`		`- while (enumerator.MoveNext())`
`76`		`- {`
`77`		`- result += enumerator.Current;`
`78`		`- }`
`79`		`- return result;`
	`103`	`+ return SumUInt16(enumerator);`
`80`	`104`	`}`
`81`	`105`	`}`
`82`	`106`	`}`
`83`	`107`
`84`	`108`
`85`	`109`	`public static partial class StructEnumerable`
`86`	`110`	`{`
	`111`	`+ private static UInt32 SumUInt32<TEnumerator>(TEnumerator enumerator)`
	`112`	`+ where TEnumerator : struct, IEnumerator<UInt32>`
	`113`	`+ {`
	`114`	`+ UInt32 result = 0;`
	`115`	`+ while (enumerator.MoveNext())`
	`116`	`+ {`
	`117`	`+ result += enumerator.Current;`
	`118`	`+ }`
	`119`	`+ return result;`
	`120`	`+ }`
	`121`	`+`
`87`	`122`	`public static UInt32 Sum<TEnumerator>(this IStructEnumerable<UInt32, TEnumerator> enumerable)`
`88`	`123`	`where TEnumerator : struct, IEnumerator<UInt32>`
`89`	`124`	`{`
`90`	`125`	`using (var enumerator = enumerable.GetStructEnumerator())`
`91`	`126`	`{`
`92`		`- UInt32 result = 0;`
`93`		`- while (enumerator.MoveNext())`
`94`		`- {`
`95`		`- result += enumerator.Current;`
`96`		`- }`
`97`		`- return result;`
	`127`	`+ return SumUInt32(enumerator);`
`98`	`128`	`}`
`99`	`129`	`}`
`100`	`130`	`}`
`101`	`131`
`102`	`132`
`103`	`133`	`public static partial class StructEnumerable`
`104`	`134`	`{`
	`135`	`+ private static UInt64 SumUInt64<TEnumerator>(TEnumerator enumerator)`
	`136`	`+ where TEnumerator : struct, IEnumerator<UInt64>`
	`137`	`+ {`
	`138`	`+ UInt64 result = 0;`
	`139`	`+ while (enumerator.MoveNext())`
	`140`	`+ {`
	`141`	`+ result += enumerator.Current;`
	`142`	`+ }`
	`143`	`+ return result;`
	`144`	`+ }`
	`145`	`+`
`105`	`146`	`public static UInt64 Sum<TEnumerator>(this IStructEnumerable<UInt64, TEnumerator> enumerable)`
`106`	`147`	`where TEnumerator : struct, IEnumerator<UInt64>`
`107`	`148`	`{`
`108`	`149`	`using (var enumerator = enumerable.GetStructEnumerator())`
`109`	`150`	`{`
`110`		`- UInt64 result = 0;`
`111`		`- while (enumerator.MoveNext())`
`112`		`- {`
`113`		`- result += enumerator.Current;`
`114`		`- }`
`115`		`- return result;`
	`151`	`+ return SumUInt64(enumerator);`
`116`	`152`	`}`
`117`	`153`	`}`
`118`	`154`	`}`
`119`	`155`
`120`	`156`
`121`	`157`	`public static partial class StructEnumerable`
`122`	`158`	`{`
	`159`	`+ private static Single SumSingle<TEnumerator>(TEnumerator enumerator)`
	`160`	`+ where TEnumerator : struct, IEnumerator<Single>`
	`161`	`+ {`
	`162`	`+ Single result = 0;`
	`163`	`+ while (enumerator.MoveNext())`
	`164`	`+ {`
	`165`	`+ result += enumerator.Current;`
	`166`	`+ }`
	`167`	`+ return result;`
	`168`	`+ }`
	`169`	`+`
`123`	`170`	`public static Single Sum<TEnumerator>(this IStructEnumerable<Single, TEnumerator> enumerable)`
`124`	`171`	`where TEnumerator : struct, IEnumerator<Single>`
`125`	`172`	`{`
`126`	`173`	`using (var enumerator = enumerable.GetStructEnumerator())`
`127`	`174`	`{`
`128`		`- Single result = 0;`
`129`		`- while (enumerator.MoveNext())`
`130`		`- {`
`131`		`- result += enumerator.Current;`
`132`		`- }`
`133`		`- return result;`
	`175`	`+ return SumSingle(enumerator);`
`134`	`176`	`}`
`135`	`177`	`}`
`136`	`178`	`}`
`137`	`179`
`138`	`180`
`139`	`181`	`public static partial class StructEnumerable`
`140`	`182`	`{`
	`183`	`+ private static Double SumDouble<TEnumerator>(TEnumerator enumerator)`
	`184`	`+ where TEnumerator : struct, IEnumerator<Double>`
	`185`	`+ {`
	`186`	`+ Double result = 0;`
	`187`	`+ while (enumerator.MoveNext())`
	`188`	`+ {`
	`189`	`+ result += enumerator.Current;`
	`190`	`+ }`
	`191`	`+ return result;`
	`192`	`+ }`
	`193`	`+`
`141`	`194`	`public static Double Sum<TEnumerator>(this IStructEnumerable<Double, TEnumerator> enumerable)`
`142`	`195`	`where TEnumerator : struct, IEnumerator<Double>`
`143`	`196`	`{`
`144`	`197`	`using (var enumerator = enumerable.GetStructEnumerator())`
`145`	`198`	`{`
`146`		`- Double result = 0;`
`147`		`- while (enumerator.MoveNext())`
`148`		`- {`
`149`		`- result += enumerator.Current;`
`150`		`- }`
`151`		`- return result;`
	`199`	`+ return SumDouble(enumerator);`
`152`	`200`	`}`
`153`	`201`	`}`
`154`	`202`	`}`
`155`	`203`
`156`	`204`
`157`	`205`	`public static partial class StructEnumerable`
`158`	`206`	`{`
	`207`	`+ private static Byte SumByte<TEnumerator>(TEnumerator enumerator)`
	`208`	`+ where TEnumerator : struct, IEnumerator<Byte>`
	`209`	`+ {`
	`210`	`+ Byte result = 0;`
	`211`	`+ while (enumerator.MoveNext())`
	`212`	`+ {`
	`213`	`+ result += enumerator.Current;`
	`214`	`+ }`
	`215`	`+ return result;`
	`216`	`+ }`
	`217`	`+`
`159`	`218`	`public static Byte Sum<TEnumerator>(this IStructEnumerable<Byte, TEnumerator> enumerable)`
`160`	`219`	`where TEnumerator : struct, IEnumerator<Byte>`
`161`	`220`	`{`
`162`	`221`	`using (var enumerator = enumerable.GetStructEnumerator())`
`163`	`222`	`{`
`164`		`- Byte result = 0;`
`165`		`- while (enumerator.MoveNext())`
`166`		`- {`
`167`		`- result += enumerator.Current;`
`168`		`- }`
`169`		`- return result;`
	`223`	`+ return SumByte(enumerator);`
`170`	`224`	`}`
`171`	`225`	`}`
`172`	`226`	`}`
`173`	`227`
`174`	`228`
`175`	`229`	`public static partial class StructEnumerable`
`176`	`230`	`{`
	`231`	`+ private static SByte SumSByte<TEnumerator>(TEnumerator enumerator)`
	`232`	`+ where TEnumerator : struct, IEnumerator<SByte>`
	`233`	`+ {`
	`234`	`+ SByte result = 0;`
	`235`	`+ while (enumerator.MoveNext())`
	`236`	`+ {`
	`237`	`+ result += enumerator.Current;`
	`238`	`+ }`
	`239`	`+ return result;`
	`240`	`+ }`
	`241`	`+`
`177`	`242`	`public static SByte Sum<TEnumerator>(this IStructEnumerable<SByte, TEnumerator> enumerable)`
`178`	`243`	`where TEnumerator : struct, IEnumerator<SByte>`
`179`	`244`	`{`
`180`	`245`	`using (var enumerator = enumerable.GetStructEnumerator())`
`181`	`246`	`{`
`182`		`- SByte result = 0;`
`183`		`- while (enumerator.MoveNext())`
`184`		`- {`
`185`		`- result += enumerator.Current;`
`186`		`- }`
`187`		`- return result;`
	`247`	`+ return SumSByte(enumerator);`
`188`	`248`	`}`
`189`	`249`	`}`
`190`	`250`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,17 +34,23 @@ namespace StructLinq`
`34`	`34`
`35`	`35`	`public static partial class StructEnumerable`
`36`	`36`	`{`
	`37`	`+ private static <#= t.Name #> Sum<#= t.Name #><TEnumerator>(TEnumerator enumerator)`
	`38`	`+ where TEnumerator : struct, IEnumerator<<#= t.Name #>>`
	`39`	`+ {`
	`40`	`+ <#= t.Name #> result = 0;`
	`41`	`+ while (enumerator.MoveNext())`
	`42`	`+ {`
	`43`	`+ result += enumerator.Current;`
	`44`	`+ }`
	`45`	`+ return result;`
	`46`	`+ }`
	`47`	`+`
`37`	`48`	`public static <#= t.Name #> Sum<TEnumerator>(this IStructEnumerable<<#= t.Name #>, TEnumerator> enumerable)`
`38`	`49`	`where TEnumerator : struct, IEnumerator<<#= t.Name #>>`
`39`	`50`	`{`
`40`	`51`	`using (var enumerator = enumerable.GetStructEnumerator())`
`41`	`52`	`{`
`42`		`- <#= t.Name #> result = 0;`
`43`		`- while (enumerator.MoveNext())`
`44`		`- {`
`45`		`- result += enumerator.Current;`
`46`		`- }`
`47`		`- return result;`
	`53`	`+ return Sum<#= t.Name #>(enumerator);`
`48`	`54`	`}`
`49`	`55`	`}`
`50`	`56`	`}`