The Labs \ Source Viewer \ SSCLI \ System.Xml.Xsl.Runtime \ Int32Aggregator

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlAggregates.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. using System;
  16. using System.Xml;
  17. using System.Diagnostics;
  18. using System.ComponentModel;
  19. namespace System.Xml.Xsl.Runtime
  20. {
  21.    
  22.     /// <summary>
  23.     /// Computes aggregates over a sequence of Int32 values.
  24.     /// </summary>
  25.     [EditorBrowsable(EditorBrowsableState.Never)]
  26.     public struct Int32Aggregator
  27.     {
  28.         private int result;
  29.         private int cnt;
  30.        
  31.         public void Create()
  32.         {
  33.             this.cnt = 0;
  34.         }
  35.        
  36.         public void Sum(int value)
  37.         {
  38.             if (this.cnt == 0) {
  39.                 this.result = value;
  40.                 this.cnt = 1;
  41.             }
  42.             else {
  43.                 this.result += value;
  44.             }
  45.         }
  46.        
  47.         public void Average(int value)
  48.         {
  49.             if (this.cnt == 0)
  50.                 this.result = value;
  51.             else
  52.                 this.result += value;
  53.            
  54.             this.cnt++;
  55.         }
  56.        
  57.         public void Minimum(int value)
  58.         {
  59.             if (this.cnt == 0 || value < this.result)
  60.                 this.result = value;
  61.            
  62.             this.cnt = 1;
  63.         }
  64.        
  65.         public void Maximum(int value)
  66.         {
  67.             if (this.cnt == 0 || value > this.result)
  68.                 this.result = value;
  69.            
  70.             this.cnt = 1;
  71.         }
  72.        
  73.         public int SumResult {
  74.             get { return this.result; }
  75.         }
  76.         public int AverageResult {
  77.             get { return this.result / this.cnt; }
  78.         }
  79.         public int MinimumResult {
  80.             get { return this.result; }
  81.         }
  82.         public int MaximumResult {
  83.             get { return this.result; }
  84.         }
  85.        
  86.         public bool IsEmpty {
  87.             get { return this.cnt == 0; }
  88.         }
  89.     }
  90.    
  91.    
  92.     /// <summary>
  93.     /// Computes aggregates over a sequence of Int64 values.
  94.     /// </summary>
  95.     [EditorBrowsable(EditorBrowsableState.Never)]
  96.     public struct Int64Aggregator
  97.     {
  98.         private long result;
  99.         private int cnt;
  100.        
  101.         public void Create()
  102.         {
  103.             this.cnt = 0;
  104.         }
  105.        
  106.         public void Sum(long value)
  107.         {
  108.             if (this.cnt == 0) {
  109.                 this.result = value;
  110.                 this.cnt = 1;
  111.             }
  112.             else {
  113.                 this.result += value;
  114.             }
  115.         }
  116.        
  117.         public void Average(long value)
  118.         {
  119.             if (this.cnt == 0)
  120.                 this.result = value;
  121.             else
  122.                 this.result += value;
  123.            
  124.             this.cnt++;
  125.         }
  126.        
  127.         public void Minimum(long value)
  128.         {
  129.             if (this.cnt == 0 || value < this.result)
  130.                 this.result = value;
  131.            
  132.             this.cnt = 1;
  133.         }
  134.        
  135.         public void Maximum(long value)
  136.         {
  137.             if (this.cnt == 0 || value > this.result)
  138.                 this.result = value;
  139.            
  140.             this.cnt = 1;
  141.         }
  142.        
  143.         public long SumResult {
  144.             get { return this.result; }
  145.         }
  146.         public long AverageResult {
  147.             get { return this.result / (long)this.cnt; }
  148.         }
  149.         public long MinimumResult {
  150.             get { return this.result; }
  151.         }
  152.         public long MaximumResult {
  153.             get { return this.result; }
  154.         }
  155.        
  156.         public bool IsEmpty {
  157.             get { return this.cnt == 0; }
  158.         }
  159.     }
  160.    
  161.    
  162.     /// <summary>
  163.     /// Computes aggregates over a sequence of Decimal values.
  164.     /// </summary>
  165.     [EditorBrowsable(EditorBrowsableState.Never)]
  166.     public struct DecimalAggregator
  167.     {
  168.         private decimal result;
  169.         private int cnt;
  170.        
  171.         public void Create()
  172.         {
  173.             this.cnt = 0;
  174.         }
  175.        
  176.         public void Sum(decimal value)
  177.         {
  178.             if (this.cnt == 0) {
  179.                 this.result = value;
  180.                 this.cnt = 1;
  181.             }
  182.             else {
  183.                 this.result += value;
  184.             }
  185.         }
  186.        
  187.         public void Average(decimal value)
  188.         {
  189.             if (this.cnt == 0)
  190.                 this.result = value;
  191.             else
  192.                 this.result += value;
  193.            
  194.             this.cnt++;
  195.         }
  196.        
  197.         public void Minimum(decimal value)
  198.         {
  199.             if (this.cnt == 0 || value < this.result)
  200.                 this.result = value;
  201.            
  202.             this.cnt = 1;
  203.         }
  204.        
  205.         public void Maximum(decimal value)
  206.         {
  207.             if (this.cnt == 0 || value > this.result)
  208.                 this.result = value;
  209.            
  210.             this.cnt = 1;
  211.         }
  212.        
  213.         public decimal SumResult {
  214.             get { return this.result; }
  215.         }
  216.         public decimal AverageResult {
  217.             get { return this.result / (decimal)this.cnt; }
  218.         }
  219.         public decimal MinimumResult {
  220.             get { return this.result; }
  221.         }
  222.         public decimal MaximumResult {
  223.             get { return this.result; }
  224.         }
  225.        
  226.         public bool IsEmpty {
  227.             get { return this.cnt == 0; }
  228.         }
  229.     }
  230.    
  231.    
  232.     /// <summary>
  233.     /// Computes aggregates over a sequence of Double values.
  234.     /// </summary>
  235.     [EditorBrowsable(EditorBrowsableState.Never)]
  236.     public struct DoubleAggregator
  237.     {
  238.         private double result;
  239.         private int cnt;
  240.        
  241.         public void Create()
  242.         {
  243.             this.cnt = 0;
  244.         }
  245.        
  246.         public void Sum(double value)
  247.         {
  248.             if (this.cnt == 0) {
  249.                 this.result = value;
  250.                 this.cnt = 1;
  251.             }
  252.             else {
  253.                 this.result += value;
  254.             }
  255.         }
  256.        
  257.         public void Average(double value)
  258.         {
  259.             if (this.cnt == 0)
  260.                 this.result = value;
  261.             else
  262.                 this.result += value;
  263.            
  264.             this.cnt++;
  265.         }
  266.        
  267.         public void Minimum(double value)
  268.         {
  269.             if (this.cnt == 0 || value < this.result || double.IsNaN(value))
  270.                 this.result = value;
  271.            
  272.             this.cnt = 1;
  273.         }
  274.        
  275.         public void Maximum(double value)
  276.         {
  277.             if (this.cnt == 0 || value > this.result || double.IsNaN(value))
  278.                 this.result = value;
  279.            
  280.             this.cnt = 1;
  281.         }
  282.        
  283.         public double SumResult {
  284.             get { return this.result; }
  285.         }
  286.         public double AverageResult {
  287.             get { return this.result / (double)this.cnt; }
  288.         }
  289.         public double MinimumResult {
  290.             get { return this.result; }
  291.         }
  292.         public double MaximumResult {
  293.             get { return this.result; }
  294.         }
  295.        
  296.         public bool IsEmpty {
  297.             get { return this.cnt == 0; }
  298.         }
  299.     }
  300. }

Developer Fusion