The Labs \ Source Viewer \ SSCLI \ System.Diagnostics \ LogSwitch

  1. // ==++==
  2. //
  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. //
  14. // ==--==
  15. namespace System.Diagnostics
  16. {
  17.     using System;
  18.     using System.IO;
  19.     using System.Collections;
  20.    
  21.     [Serializable()]
  22.     internal class LogSwitch
  23.     {
  24.         // ! WARNING !
  25.         // If any fields are added/deleted/modified, perform the
  26.         // same in the EE code (debugdebugger.cpp)
  27.         internal string strName;
  28.         internal string strDescription;
  29.         private LogSwitch ParentSwitch;
  30.         private LogSwitch[] ChildSwitch;
  31.         internal LoggingLevels iLevel;
  32.         internal LoggingLevels iOldLevel;
  33.         private int iNumChildren;
  34.         private int iChildArraySize;
  35.        
  36.         // ! END WARNING !
  37.        
  38.        
  39.         private LogSwitch()
  40.         {
  41.         }
  42.        
  43.         // Constructs a LogSwitch. A LogSwitch is used to categorize log messages.
  44.         //
  45.         // All switches (except for the global LogSwitch) have a parent LogSwitch.
  46.         //
  47.         public LogSwitch(string name, string description, LogSwitch parent)
  48.         {
  49.             if ((name != null) && (parent != null)) {
  50.                 if (name.Length == 0)
  51.                     throw new ArgumentOutOfRangeException("Name", Environment.GetResourceString("Argument_StringZeroLength"));
  52.                
  53.                 strName = name;
  54.                 strDescription = description;
  55.                 iLevel = LoggingLevels.ErrorLevel;
  56.                 iOldLevel = iLevel;
  57.                
  58.                 // update the parent switch to reflect this child switch
  59.                 parent.AddChildSwitch(this);
  60.                
  61.                 ParentSwitch = parent;
  62.                
  63.                 ChildSwitch = null;
  64.                 iNumChildren = 0;
  65.                 iChildArraySize = 0;
  66.                
  67.                 Log.m_Hashtable.Add(strName, this);
  68.                
  69.                 // Call into the EE to let it know about the creation of
  70.                 // this switch
  71.                 Log.AddLogSwitch(this);
  72.                
  73.                 // update switch count
  74.                 Log.iNumOfSwitches++;
  75.             }
  76.             else
  77.                 throw new ArgumentNullException((name == null ? "name" : "parent"));
  78.         }
  79.        
  80.         internal LogSwitch(string name, string description)
  81.         {
  82.             strName = name;
  83.             strDescription = description;
  84.             iLevel = LoggingLevels.ErrorLevel;
  85.             iOldLevel = iLevel;
  86.             ParentSwitch = null;
  87.             ChildSwitch = null;
  88.             iNumChildren = 0;
  89.             iChildArraySize = 0;
  90.            
  91.             Log.m_Hashtable.Add(strName, this);
  92.            
  93.             // Call into the EE to let it know about the creation of
  94.             // this switch
  95.             Log.AddLogSwitch(this);
  96.            
  97.             // update switch count
  98.             Log.iNumOfSwitches++;
  99.         }
  100.        
  101.        
  102.         // Get property returns the name of the switch
  103.         public virtual string Name {
  104.             get { return strName; }
  105.         }
  106.        
  107.         // Get property returns the description of the switch
  108.         public virtual string Description {
  109.             get { return strDescription; }
  110.         }
  111.        
  112.        
  113.         // Get property returns the parent of the switch
  114.         public virtual LogSwitch Parent {
  115.             get { return ParentSwitch; }
  116.         }
  117.        
  118.        
  119.         // Property to Get/Set the level of log messages which are "on" for the switch.
  120.         //
  121.         public virtual LoggingLevels MinimumLevel {
  122.             get { return iLevel; }
  123.             set {
  124.                 iLevel = value;
  125.                 iOldLevel = value;
  126.                 string strParentName = ParentSwitch != null ? ParentSwitch.Name : "";
  127.                 if (Debugger.IsAttached)
  128.                     Log.ModifyLogSwitch((int)iLevel, strName, strParentName);
  129.                
  130.                 Log.InvokeLogSwitchLevelHandlers(this, iLevel);
  131.             }
  132.         }
  133.        
  134.        
  135.         // Checks if the given level is "on" for this switch or one of its parents.
  136.         //
  137.         public virtual bool CheckLevel(LoggingLevels level)
  138.         {
  139.             if (iLevel > level) {
  140.                 // recurse through the list till parent is hit.
  141.                 if (this.ParentSwitch == null)
  142.                     return false;
  143.                 else
  144.                     return this.ParentSwitch.CheckLevel(level);
  145.             }
  146.             else
  147.                 return true;
  148.         }
  149.        
  150.        
  151.         // Returns a switch with the particular name, if any. Returns null if no
  152.         // such switch exists.
  153.         public static LogSwitch GetSwitch(string name)
  154.         {
  155.             return (LogSwitch)Log.m_Hashtable[name];
  156.         }
  157.        
  158.         private void AddChildSwitch(LogSwitch child)
  159.         {
  160.             if (iChildArraySize <= iNumChildren) {
  161.                 int iIncreasedSize;
  162.                
  163.                 if (iChildArraySize == 0)
  164.                     iIncreasedSize = 10;
  165.                 else
  166.                     iIncreasedSize = (iChildArraySize * 3) / 2;
  167.                
  168.                 // increase child array size in chunks of 4
  169.                 LogSwitch[] newChildSwitchArray = new LogSwitch[iIncreasedSize];
  170.                
  171.                 // copy the old array objects into the new one.
  172.                 if (iNumChildren > 0)
  173.                     Array.Copy(ChildSwitch, newChildSwitchArray, iNumChildren);
  174.                
  175.                 iChildArraySize = iIncreasedSize;
  176.                
  177.                 ChildSwitch = newChildSwitchArray;
  178.             }
  179.            
  180.             ChildSwitch[iNumChildren++] = child;
  181.         }
  182.        
  183.        
  184.     }
  185. }

Developer Fusion