logging-log4net-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Christian Grobmeier <grobme...@gmail.com>
Subject Re: [PATCH 1 of 5] Step 1: refactoring
Date Tue, 22 Jan 2013 20:47:36 GMT
On Tue, Jan 22, 2013 at 2:46 PM, Dominik Psenner <dpsenner@gmail.com> wrote:
> Quite a large patch, but looks sensible.

Do you expect any response from other devs?

In case you do, we practice CTR (Commit then review). If you are happy
with the patches, then just apply them to the code. If you are not
happy / in doubt, get to the ML. No need to wait for a second
confirmation :-)

Cheers
Christian


>
>>-----Original Message-----
>>From: Dominik Psenner [mailto:dpsenner@gmail.com]
>>Sent: Tuesday, January 22, 2013 2:41 PM
>>To: log4net-dev@logging.apache.org
>>Subject: [PATCH 1 of 5] Step 1: refactoring
>>
>>Trivial changes to tabs and spaces, formatting etc.
>>
>>diff -r b430bc3cc0f4 -r dc18d71a5304 src/Appender/RollingFileAppender.cs
>>--- a/src/Appender/RollingFileAppender.cs      Tue Jan 22 14:27:20 2013
> +0100
>>+++ b/src/Appender/RollingFileAppender.cs      Tue Jan 22 14:31:05 2013
> +0100
>>@@ -1,10 +1,10 @@
>> #region Apache License
>> //
>>-// Licensed to the Apache Software Foundation (ASF) under one or more
>>+// Licensed to the Apache Software Foundation (ASF) under one or more
>> // contributor license agreements. See the NOTICE file distributed with
>>-// this work for additional information regarding copyright ownership.
>>+// this work for additional information regarding copyright ownership.
>> // The ASF licenses this file to you under the Apache License, Version 2.0
>>-// (the "License"); you may not use this file except in compliance with
>>+// (the "License"); you may not use this file except in compliance with
>> // the License. You may obtain a copy of the License at
>> //
>> // http://www.apache.org/licenses/LICENSE-2.0
>>@@ -31,12 +31,12 @@
>>       // The following sounds good, and I though it was the case, but
> after
>>       // further testing on Windows I have not been able to confirm it.
>>
>>-      /// On the Windows platform if another process has a write lock on
>>the file
>>+      /// On the Windows platform if another process has a write lock on
>>the file
>>       /// that is to be deleted, but allows shared read access to the file
>>then the
>>-      /// file can be moved, but cannot be deleted. If the other process
>>also allows
>>-      /// shared delete access to the file then the file will be deleted
>>once that
>>+      /// file can be moved, but cannot be deleted. If the other process
>>also allows
>>+      /// shared delete access to the file then the file will be deleted
>>once that
>>       /// process closes the file. If it is necessary to open the log file
>>or any
>>-      /// of the backup files outside of this appender for either read or
>>+      /// of the backup files outside of this appender for either read or
>>       /// write access please ensure that read and delete share modes are
>>enabled.
>> #endif
>>
>>@@ -68,34 +68,34 @@
>>       /// <item>Infinite number of backups by file size <see
>>cref="MaxSizeRollBackups"/></item>
>>       /// </list>
>>       /// </para>
>>-      ///
>>+      ///
>>       /// <note>
>>       /// <para>
>>-      /// For large or infinite numbers of backup files a <see
>>cref="CountDirection"/>
>>+      /// For large or infinite numbers of backup files a <see
>>cref="CountDirection"/>
>>       /// greater than zero is highly recommended, otherwise all the
> backup
>>files need
>>       /// to be renamed each time a new backup is created.
>>       /// </para>
>>       /// <para>
>>-      /// When Date/Time based rolling is used setting <see
>>cref="StaticLogFileName"/>
>>+      /// When Date/Time based rolling is used setting <see
>>cref="StaticLogFileName"/>
>>       /// to <see langword="true"/> will reduce the number of file
>>renamings to few or none.
>>       /// </para>
>>       /// </note>
>>-      ///
>>+      ///
>>       /// <note type="caution">
>>       /// <para>
>>       /// Changing <see cref="StaticLogFileName"/> or <see
>>cref="CountDirection"/> without clearing
>>-      /// the log file directory of backup files will cause unexpected and
>>unwanted side effects.
>>+      /// the log file directory of backup files will cause unexpected and
>>unwanted side effects.
>>       /// </para>
>>       /// </note>
>>-      ///
>>+      ///
>>       /// <para>
>>       /// If Date/Time based rolling is enabled this appender will attempt
>>to roll existing files
>>       /// in the directory without a Date/Time tag based on the last write
>>date of the base log file.
>>-      /// The appender only rolls the log file when a message is logged.
> If
>>Date/Time based rolling
>>+      /// The appender only rolls the log file when a message is logged.
> If
>>Date/Time based rolling
>>       /// is enabled then the appender will not roll the log file at the
>>Date/Time boundary but
>>       /// at the point when the next message is logged after the boundary
>>has been crossed.
>>       /// </para>
>>-      ///
>>+      ///
>>       /// <para>
>>       /// The <see cref="RollingFileAppender"/> extends the <see
>>cref="FileAppender"/> and
>>       /// has the same behavior when opening the log file.
>>@@ -110,7 +110,7 @@
>>       /// When rolling a backup file necessitates deleting an older backup
>>file the
>>       /// file to be deleted is moved to a temporary name before being
>>deleted.
>>       /// </para>
>>-      ///
>>+      ///
>>       /// <note type="caution">
>>       /// <para>
>>       /// A maximum number of backup files when rolling on date/time
>>boundaries is not supported.
>>@@ -123,10 +123,10 @@
>>       /// <author>Douglas de la Torre</author>
>>       /// <author>Edward Smit</author>
>>       public class RollingFileAppender : FileAppender
>>-    {
>>-        #region Public Enums
>>+      {
>>+              #region Public Enums
>>
>>-        /// <summary>
>>+              /// <summary>
>>               /// Style of rolling to use
>>               /// </summary>
>>               /// <remarks>
>>@@ -231,7 +231,7 @@
>>               /// Default constructor.
>>               /// </para>
>>               /// </remarks>
>>-              public RollingFileAppender()
>>+              public RollingFileAppender()
>>               {
>>               }
>>
>>@@ -240,9 +240,9 @@
>>               #region Public Instance Properties
>>
>> #if !NET_1_0 && !CLI_1_0 && !NETCF
>>-        /// <summary>
>>+              /// <summary>
>>               /// Gets or sets the strategy for determining the current
> date
>>and time. The default
>>-              /// implementation is to use LocalDateTime which internally
>>calls through to DateTime.Now.
>>+              /// implementation is to use LocalDateTime which internally
>>calls through to DateTime.Now.
>>               /// DateTime.UtcNow may be used on frameworks newer than
> .NET
>>1.0 by specifying
>>               /// <see cref="RollingFileAppender.UniversalDateTime"/>.
>>               /// </summary>
>>@@ -253,19 +253,19 @@
>>               /// <para>
>>               /// Gets or sets the <see
>>cref="RollingFileAppender.IDateTime"/> used to return the current date and
>>time.
>>               /// </para>
>>-        /// <para>
>>-        /// There are two built strategies for determining the current
>>date and time,
>>+              /// <para>
>>+              /// There are two built strategies for determining the
> current
>>date and time,
>>               /// <see cref="RollingFileAppender.LocalDateTime"/>
>>-        /// and <see cref="RollingFileAppender.UniversalDateTime"/>.
>>-        /// </para>
>>-        /// <para>
>>+              /// and <see cref="RollingFileAppender.UniversalDateTime"/>.
>>+              /// </para>
>>+              /// <para>
>>               /// The default strategy is <see
>>cref="RollingFileAppender.LocalDateTime"/>.
>>               /// </para>
>>               /// </remarks>
>> #else
>>-        /// <summary>
>>+              /// <summary>
>>               /// Gets or sets the strategy for determining the current
> date
>>and time. The default
>>-              /// implementation is to use LocalDateTime which internally
>>calls through to DateTime.Now.
>>+              /// implementation is to use LocalDateTime which internally
>>calls through to DateTime.Now.
>>               /// </summary>
>>               /// <value>
>>               /// An implementation of the <see
>>cref="RollingFileAppender.IDateTime"/> interface which returns the current
>>date and time.
>>@@ -274,12 +274,12 @@
>>               /// <para>
>>               /// Gets or sets the <see
>>cref="RollingFileAppender.IDateTime"/> used to return the current date and
>>time.
>>               /// </para>
>>-        /// <para>
>>+              /// <para>
>>               /// The default strategy is <see
>>cref="RollingFileAppender.LocalDateTime"/>.
>>               /// </para>
>>               /// </remarks>
>> #endif
>>-        public IDateTime DateTimeStrategy
>>+              public IDateTime DateTimeStrategy
>>               {
>>                       get { return m_dateTime; }
>>                       set { m_dateTime = value; }
>>@@ -290,12 +290,12 @@
>>               /// when rolling over on date.
>>               /// </summary>
>>               /// <value>
>>-              /// The date pattern to be used for generating file names
> when
>>rolling
>>+              /// The date pattern to be used for generating file names
> when
>>rolling
>>               /// over on date.
>>               /// </value>
>>               /// <remarks>
>>               /// <para>
>>-              /// Takes a string in the same format as expected by
>>+              /// Takes a string in the same format as expected by
>>               /// <see cref="log4net.DateFormatter.SimpleDateFormatter"
> />.
>>               /// </para>
>>               /// <para>
>>@@ -308,7 +308,7 @@
>>                       get { return m_datePattern; }
>>                       set { m_datePattern = value; }
>>               }
>>-
>>+
>>               /// <summary>
>>               /// Gets or sets the maximum number of backup files that are
>>kept before
>>               /// the oldest is erased.
>>@@ -319,16 +319,16 @@
>>               /// </value>
>>               /// <remarks>
>>               /// <para>
>>-              /// If set to zero, then there will be no backup files and
> the
>>log file
>>-              /// will be truncated when it reaches <see
>>cref="MaxFileSize"/>.
>>+              /// If set to zero, then there will be no backup files and
> the
>>log file
>>+              /// will be truncated when it reaches <see
>>cref="MaxFileSize"/>.
>>               /// </para>
>>               /// <para>
>>-              /// If a negative number is supplied then no deletions will
> be
>>made.  Note
>>-              /// that this could result in very slow performance as a
> large
>>number of
>>+              /// If a negative number is supplied then no deletions will
> be
>>made.  Note
>>+              /// that this could result in very slow performance as a
> large
>>number of
>>               /// files are rolled over unless <see
> cref="CountDirection"/>
>>is used.
>>               /// </para>
>>               /// <para>
>>-              /// The maximum applies to <b>each</b> time based group of
>>files and
>>+              /// The maximum applies to <b>each</b> time based group of
>>files and
>>               /// <b>not</b> the total.
>>               /// </para>
>>               /// </remarks>
>>@@ -337,20 +337,20 @@
>>                       get { return m_maxSizeRollBackups; }
>>                       set { m_maxSizeRollBackups = value; }
>>               }
>>-
>>+
>>               /// <summary>
>>               /// Gets or sets the maximum size that the output file is
>>allowed to reach
>>               /// before being rolled over to backup files.
>>               /// </summary>
>>               /// <value>
>>-              /// The maximum size in bytes that the output file is
> allowed
>>to reach before being
>>+              /// The maximum size in bytes that the output file is
> allowed
>>to reach before being
>>               /// rolled over to backup files.
>>               /// </value>
>>               /// <remarks>
>>               /// <para>
>>               /// This property is equivalent to <see
>>cref="MaximumFileSize"/> except
>>               /// that it is required for differentiating the setter
> taking a
>>-              /// <see cref="long"/> argument from the setter taking a
> <see
>>cref="string"/>
>>+              /// <see cref="long"/> argument from the setter taking a
> <see
>>cref="string"/>
>>               /// argument.
>>               /// </para>
>>               /// <para>
>>@@ -362,20 +362,20 @@
>>                       get { return m_maxFileSize; }
>>                       set { m_maxFileSize = value; }
>>               }
>>-
>>+
>>               /// <summary>
>>               /// Gets or sets the maximum size that the output file is
>>allowed to reach
>>               /// before being rolled over to backup files.
>>               /// </summary>
>>               /// <value>
>>-              /// The maximum size that the output file is allowed to
> reach
>>before being
>>+              /// The maximum size that the output file is allowed to
> reach
>>before being
>>               /// rolled over to backup files.
>>               /// </value>
>>               /// <remarks>
>>               /// <para>
>>               /// This property allows you to specify the maximum size
> with
>>the
>>-              /// suffixes "KB", "MB" or "GB" so that the size is
> interpreted
>>being
>>-              /// expressed respectively in kilobytes, megabytes or
>>gigabytes.
>>+              /// suffixes "KB", "MB" or "GB" so that the size is
> interpreted
>>being
>>+              /// expressed respectively in kilobytes, megabytes or
>>gigabytes.
>>               /// </para>
>>               /// <para>
>>               /// For example, the value "10KB" will be interpreted as
> 10240
>>bytes.
>>@@ -396,7 +396,7 @@
>>               }
>>
>>               /// <summary>
>>-              /// Gets or sets the rolling file count direction.
>>+              /// Gets or sets the rolling file count direction.
>>               /// </summary>
>>               /// <value>
>>               /// The rolling file count direction.
>>@@ -413,7 +413,7 @@
>>               /// <para>
>>               /// <see cref="CountDirection" /> &gt;= 0 does the opposite
>>i.e.
>>               /// log.1 is the first backup made, log.5 is the 5th backup
>>made, etc.
>>-              /// For infinite backups use <see cref="CountDirection" />
>>&gt;= 0 to reduce
>>+              /// For infinite backups use <see cref="CountDirection" />
>>&gt;= 0 to reduce
>>               /// rollover costs.
>>               /// </para>
>>               /// <para>The default file count direction is -1.</para>
>>@@ -423,7 +423,7 @@
>>                       get { return m_countDirection; }
>>                       set { m_countDirection = value; }
>>               }
>>-
>>+
>>               /// <summary>
>>               /// Gets or sets the rolling style.
>>               /// </summary>
>>@@ -445,7 +445,7 @@
>>                       set
>>                       {
>>                               m_rollingStyle = value;
>>-                              switch (m_rollingStyle)
>>+                              switch (m_rollingStyle)
>>                               {
>>                                       case RollingMode.Once:
>>                                               m_rollDate = false;
>>@@ -467,30 +467,30 @@
>>                                       case RollingMode.Composite:
>>                                               m_rollDate = true;
>>                                               m_rollSize = true;
>>-                                              break;
>>+                                              break;
>>                               }
>>                       }
>>               }
>>
>>-        /// <summary>
>>-        /// Gets or sets a value indicating whether to preserve the file
>>name extension when rolling.
>>-        /// </summary>
>>-        /// <value>
>>-        /// <c>true</c> if the file name extension should be preserved.
>>-        /// </value>
>>-        /// <remarks>
>>-        /// <para>
>>-        /// By default file.log is rolled to file.log.yyyy-MM-dd or
>>file.log.curSizeRollBackup.
>>-        /// However, under Windows the new file name will loose any
>>program associations as the
>>-        /// extension is changed. Optionally file.log can be renamed to
>>file.yyyy-MM-dd.log or
>>-        /// file.curSizeRollBackup.log to maintain any program
>>associations.
>>-        /// </para>
>>-        /// </remarks>
>>-        public bool PreserveLogFileNameExtension
>>-        {
>>-            get { return m_preserveLogFileNameExtension; }
>>-            set { m_preserveLogFileNameExtension = value; }
>>-        }
>>+              /// <summary>
>>+              /// Gets or sets a value indicating whether to preserve the
>>file name extension when rolling.
>>+              /// </summary>
>>+              /// <value>
>>+              /// <c>true</c> if the file name extension should be
> preserved.
>>+              /// </value>
>>+              /// <remarks>
>>+              /// <para>
>>+              /// By default file.log is rolled to file.log.yyyy-MM-dd or
>>file.log.curSizeRollBackup.
>>+              /// However, under Windows the new file name will loose any
>>program associations as the
>>+              /// extension is changed. Optionally file.log can be renamed
> to
>>file.yyyy-MM-dd.log or
>>+              /// file.curSizeRollBackup.log to maintain any program
>>associations.
>>+              /// </para>
>>+              /// </remarks>
>>+              public bool PreserveLogFileNameExtension
>>+              {
>>+                      get { return m_preserveLogFileNameExtension; }
>>+                      set { m_preserveLogFileNameExtension = value; }
>>+              }
>>
>>               /// <summary>
>>               /// Gets or sets a value indicating whether to always log to
>>@@ -507,7 +507,7 @@
>>               /// file.log.yyyy-mm-dd.curSizeRollBackup).
>>               /// </para>
>>               /// <para>
>>-              /// This will make time based rollovers with a large number
> of
>>backups
>>+              /// This will make time based rollovers with a large number
> of
>>backups
>>               /// much faster as the appender it won't have to rename all
> the
>>backups!
>>               /// </para>
>>               /// </remarks>
>>@@ -519,21 +519,21 @@
>>
>>               #endregion Public Instance Properties
>>
>>-          #region Private Static Fields
>>+              #region Private Static Fields
>>
>>-          /// <summary>
>>-          /// The fully qualified type of the RollingFileAppender class.
>>-          /// </summary>
>>-          /// <remarks>
>>-          /// Used by the internal logger to record the Type of the
>>-          /// log message.
>>-          /// </remarks>
>>-          private readonly static Type declaringType =
>>typeof(RollingFileAppender);
>>+              /// <summary>
>>+              /// The fully qualified type of the RollingFileAppender
> class.
>>+              /// </summary>
>>+              /// <remarks>
>>+              /// Used by the internal logger to record the Type of the
>>+              /// log message.
>>+              /// </remarks>
>>+              private readonly static Type declaringType =
>>typeof(RollingFileAppender);
>>
>>-          #endregion Private Static Fields
>>+              #endregion Private Static Fields
>>
>>-              #region Override implementation of FileAppender
>>-
>>+              #region Override implementation of FileAppender
>>+
>>               /// <summary>
>>               /// Sets the quiet writer being used.
>>               /// </summary>
>>@@ -541,7 +541,7 @@
>>               /// This method can be overridden by sub classes.
>>               /// </remarks>
>>               /// <param name="writer">the writer to set</param>
>>-              override protected void SetQWForFiles(TextWriter writer)
>>+              override protected void SetQWForFiles(TextWriter writer)
>>               {
>>                       QuietWriter = new CountingQuietTextWriter(writer,
>>ErrorHandler);
>>               }
>>@@ -557,12 +557,12 @@
>>               /// is need and then appends to the file last.
>>               /// </para>
>>               /// </remarks>
>>-              override protected void Append(LoggingEvent loggingEvent)
>>+              override protected void Append(LoggingEvent loggingEvent)
>>               {
>>                       AdjustFileBeforeAppend();
>>                       base.Append(loggingEvent);
>>               }
>>-
>>+
>>               /// <summary>
>>               /// Write out an array of logging events.
>>               /// </summary>
>>@@ -574,7 +574,7 @@
>>               /// is need and then appends to the file last.
>>               /// </para>
>>               /// </remarks>
>>-              override protected void Append(LoggingEvent[] loggingEvents)
>>+              override protected void Append(LoggingEvent[] loggingEvents)
>>               {
>>                       AdjustFileBeforeAppend();
>>                       base.Append(loggingEvents);
>>@@ -592,21 +592,21 @@
>>               /// </remarks>
>>               virtual protected void AdjustFileBeforeAppend()
>>               {
>>-                      if (m_rollDate)
>>+                      if (m_rollDate)
>>                       {
>>                               DateTime n = m_dateTime.Now;
>>-                              if (n >= m_nextCheck)
>>+                              if (n >= m_nextCheck)
>>                               {
>>                                       m_now = n;
>>                                       m_nextCheck = NextCheckDate(m_now,
>>m_rollPoint);
>>-
>>+
>>                                       RollOverTime(true);
>>                               }
>>                       }
>>-
>>-                      if (m_rollSize)
>>+
>>+                      if (m_rollSize)
>>                       {
>>-                              if ((File != null) &&
>>((CountingQuietTextWriter)QuietWriter).Count >= m_maxFileSize)
>>+                              if ((File != null) &&
>>((CountingQuietTextWriter)QuietWriter).Count >= m_maxFileSize)
>>                               {
>>                                       RollOverSize();
>>                               }
>>@@ -631,7 +631,7 @@
>>
>>                               // Calculate the current size of the file
>>                               long currentCount = 0;
>>-                              if (append)
>>+                              if (append)
>>                               {
>>
> using(SecurityContext.Impersonate(this))
>>                                       {
>>@@ -656,7 +656,7 @@
>>                                       }
>>                               }
>>
>>-                              if (!m_staticLogFileName)
>>+                              if (!m_staticLogFileName)
>>                               {
>>                                       m_scheduledFilename = fileName;
>>                               }
>>@@ -676,25 +676,25 @@
>>               /// <returns>the output file name</returns>
>>               /// <remarks>
>>               /// The output file name is based on the base fileName
>>specified.
>>-              /// If <see cref="StaticLogFileName"/> is set then the
> output
>>+              /// If <see cref="StaticLogFileName"/> is set then the
> output
>>               /// file name is the same as the base file passed in.
> Otherwise
>>               /// the output file depends on the date pattern, on the
> count
>>               /// direction or both.
>>               /// </remarks>
>>               protected string GetNextOutputFileName(string fileName)
>>               {
>>-                      if (!m_staticLogFileName)
>>+                      if (!m_staticLogFileName)
>>                       {
>>                               fileName = fileName.Trim();
>>
>>                               if (m_rollDate)
>>                               {
>>-                    fileName = CombinePath(fileName,
>>m_now.ToString(m_datePattern,
>>System.Globalization.DateTimeFormatInfo.InvariantInfo));
>>+                                      fileName = CombinePath(fileName,
>>m_now.ToString(m_datePattern,
>>System.Globalization.DateTimeFormatInfo.InvariantInfo));
>>                               }
>>
>>-                              if (m_countDirection >= 0)
>>+                              if (m_countDirection >= 0)
>>                               {
>>-                    fileName = CombinePath(fileName, "." +
>>m_curSizeRollBackups);
>>+                                      fileName = CombinePath(fileName, "."
> +
>>m_curSizeRollBackups);
>>                               }
>>                       }
>>
>>@@ -711,7 +711,7 @@
>>               private void DetermineCurSizeRollBackups()
>>               {
>>                       m_curSizeRollBackups = 0;
>>-
>>+
>>                       string fullPath = null;
>>                       string fileName = null;
>>
>>@@ -735,14 +735,14 @@
>>               /// <returns></returns>
>>               private string GetWildcardPatternForFile(string
> baseFileName)
>>               {
>>-            if (m_preserveLogFileNameExtension)
>>-            {
>>-                return Path.GetFileNameWithoutExtension(baseFileName) +
>>".*" + Path.GetExtension(baseFileName);
>>-            }
>>-            else
>>-            {
>>-                return baseFileName + '*';
>>-            }
>>+                      if (m_preserveLogFileNameExtension)
>>+                      {
>>+                              return
>>Path.GetFileNameWithoutExtension(baseFileName) + ".*" +
>>Path.GetExtension(baseFileName);
>>+                      }
>>+                      else
>>+                      {
>>+                              return baseFileName + '*';
>>+                      }
>>               }
>>
>>               /// <summary>
>>@@ -767,10 +767,10 @@
>>                                       string baseFileName =
>>Path.GetFileName(fullPath);
>>
>>                                       string[] files =
>>Directory.GetFiles(directory, GetWildcardPatternForFile(baseFileName));
>>-
>>+
>>                                       if (files != null)
>>                                       {
>>-                                              for (int i = 0; i <
> files.Length; i++)
>>+                                              for (int i = 0; i <
> files.Length; i++)
>>                                               {
>>                                                       string curFileName =
>>Path.GetFileName(files[i]);
>>                                                       if
>>(curFileName.StartsWith(Path.GetFileNameWithoutExtension(baseFileName)))
>>@@ -790,14 +790,15 @@
>>               /// </summary>
>>               private void RollOverIfDateBoundaryCrossing()
>>               {
>>-                      if (m_staticLogFileName && m_rollDate)
>>+                      if (m_staticLogFileName && m_rollDate)
>>                       {
>>-                              if (FileExists(m_baseFileName))
>>+                              if (FileExists(m_baseFileName))
>>                               {
>>                                       DateTime last;
>>-
> using(SecurityContext.Impersonate(this)) {
>>+
> using(SecurityContext.Impersonate(this))
>>+                                      {
>> #if !NET_1_0 && !CLI_1_0 && !NETCF
>>-                        if (DateTimeStrategy is UniversalDateTime)
>>+                                              if (DateTimeStrategy is
>>UniversalDateTime)
>>                                               {
>>                                                       last =
>>System.IO.File.GetLastWriteTimeUtc(m_baseFileName);
>>                                               }
>>@@ -806,12 +807,12 @@
>> #endif
>>                                                       last =
>>System.IO.File.GetLastWriteTime(m_baseFileName);
>> #if !NET_1_0 && !CLI_1_0 && !NETCF
>>-                        }
>>+                                              }
>> #endif
>>-                    }
>>+                                      }
>>                                       LogLog.Debug(declaringType,
>>"["+last.ToString(m_datePattern,System.Globalization.DateTimeFormatInfo.Inv
>>ariantInfo)+"] vs.
>>["+m_now.ToString(m_datePattern,System.Globalization.DateTimeFormatInfo.Inv
>>ariantInfo)+"]");
>>
>>-                                      if
>>(!(last.ToString(m_datePattern,System.Globalization.DateTimeFormatInfo.Inva
>>riantInfo).Equals(m_now.ToString(m_datePattern,
>>System.Globalization.DateTimeFormatInfo.InvariantInfo))))
>>+                                      if
>>(!(last.ToString(m_datePattern,System.Globalization.DateTimeFormatInfo.Inva
>>riantInfo).Equals(m_now.ToString(m_datePattern,
>>System.Globalization.DateTimeFormatInfo.InvariantInfo))))
>>                                       {
>>                                               m_scheduledFilename =
> m_baseFileName +
>>last.ToString(m_datePattern,
>>System.Globalization.DateTimeFormatInfo.InvariantInfo);
>>                                               LogLog.Debug(declaringType,
> "Initial
>>roll over to ["+m_scheduledFilename+"]");
>>@@ -835,7 +836,7 @@
>>               ///     </list>
>>               ///     </para>
>>               /// </remarks>
>>-              protected void ExistingInit()
>>+              protected void ExistingInit()
>>               {
>>                       DetermineCurSizeRollBackups();
>>                       RollOverIfDateBoundaryCrossing();
>>@@ -878,29 +879,29 @@
>>               /// <param name="curFileName"></param>
>>               private void InitializeFromOneFile(string baseFile, string
>>curFileName)
>>               {
>>-            if
>>(curFileName.StartsWith(Path.GetFileNameWithoutExtension(baseFile)) ==
>>false)
>>+                      if (!
>>curFileName.StartsWith(Path.GetFileNameWithoutExtension(baseFile)))
>>                       {
>>                               // This is not a log file, so ignore
>>                               return;
>>                       }
>>-                      if (curFileName.Equals(baseFile))
>>+                      if (curFileName.Equals(baseFile))
>>                       {
>>                               // Base log file is not an incremented
> logfile (.1
>>or .2, etc)
>>                               return;
>>                       }
>>-
>>-            /*
>>-                      if (m_staticLogFileName)
>>+
>>+                      /*
>>+                      if (m_staticLogFileName)
>>                       {
>>                               int endLength = curFileName.Length - index;
>>-                              if (baseFile.Length + endLength !=
>>curFileName.Length)
>>+                              if (baseFile.Length + endLength !=
>>curFileName.Length)
>>                               {
>>                                       // file is probably
> scheduledFilename + .x so
>>I don't care
>>                                       return;
>>                               }
>>                       }
>>-            */
>>-
>>+                      */
>>+
>>                       // Only look for files in the current roll point
>>                       if (m_rollDate && !m_staticLogFileName)
>>                       {
>>@@ -910,48 +911,48 @@
>>                                       return;
>>                               }
>>                       }
>>-
>>-                      try
>>+
>>+                      try
>>                       {
>>                               // Bump the counter up to the highest count
> seen so
>>far
>>-                int backup = GetBackUpIndex(curFileName);
>>-
>>-                // caution: we might get a false positive when certain
>>-                // date patterns such as yyyyMMdd are used...those are
>>-                // valid number but aren't the kind of back up index
>>-                // we're looking for
>>-                if (backup > m_curSizeRollBackups)
>>-                {
>>-                    if (0 == m_maxSizeRollBackups)
>>-                    {
>>-                        // Stay at zero when zero backups are desired
>>-                    }
>>-                    else if (-1 == m_maxSizeRollBackups)
>>-                    {
>>-                        // Infinite backups, so go as high as the highest
>>value
>>-                        m_curSizeRollBackups = backup;
>>-                    }
>>-                    else
>>-                    {
>>-                        // Backups limited to a finite number
>>-                        if (m_countDirection >= 0)
>>-                        {
>>-                            // Go with the highest file when counting up
>>-                            m_curSizeRollBackups = backup;
>>-                        }
>>-                        else
>>-                        {
>>-                            // Clip to the limit when counting down
>>-                            if (backup <= m_maxSizeRollBackups)
>>-                            {
>>-                                m_curSizeRollBackups = backup;
>>-                            }
>>-                        }
>>-                    }
>>-                    LogLog.Debug(declaringType, "File name [" +
>>curFileName + "] moves current count to [" + m_curSizeRollBackups + "]");
>>-                }
>>-                      }
>>-                      catch(FormatException)
>>+                              int backup = GetBackUpIndex(curFileName);
>>+
>>+                              // caution: we might get a false positive
> when
>>certain
>>+                              // date patterns such as yyyyMMdd are
> used...those
>>are
>>+                              // valid number but aren't the kind of back
> up
>>index
>>+                              // we're looking for
>>+                              if (backup > m_curSizeRollBackups)
>>+                              {
>>+                                      if (0 == m_maxSizeRollBackups)
>>+                                      {
>>+                                              // Stay at zero when zero
> backups are
>>desired
>>+                                      }
>>+                                      else if (-1 == m_maxSizeRollBackups)
>>+                                      {
>>+                                              // Infinite backups, so go
> as high as
>>the highest value
>>+                                              m_curSizeRollBackups =
> backup;
>>+                                      }
>>+                                      else
>>+                                      {
>>+                                              // Backups limited to a
> finite number
>>+                                              if (m_countDirection >= 0)
>>+                                              {
>>+                                                      // Go with the
> highest file when
>>counting up
>>+                                                      m_curSizeRollBackups
> = backup;
>>+                                              }
>>+                                              else
>>+                                              {
>>+                                                      // Clip to the limit
> when
>>counting down
>>+                                                      if (backup <=
>>m_maxSizeRollBackups)
>>+                                                      {
>>+
> m_curSizeRollBackups =
>>backup;
>>+                                                      }
>>+                                              }
>>+                                      }
>>+                                      LogLog.Debug(declaringType, "File
> name [" +
>>curFileName + "] moves current count to [" + m_curSizeRollBackups + "]");
>>+                              }
>>+                      }
>>+                      catch(FormatException)
>>                       {
>>                               //this happens when file.log ->
> file.log.yyyy-MM-dd
>>which is normal
>>                               //when staticLogFileName == false
>>@@ -959,38 +960,38 @@
>>                       }
>>               }
>>
>>-        /// <summary>
>>-        /// Attempts to extract a number from the end of the file name
>>that indicates
>>-        /// the number of the times the file has been rolled over.
>>-        /// </summary>
>>-        /// <remarks>
>>-        /// Certain date pattern extensions like yyyyMMdd will be parsed
>>as valid backup indexes.
>>-        /// </remarks>
>>-        /// <param name="curFileName"></param>
>>-        /// <returns></returns>
>>-          private int GetBackUpIndex(string curFileName)
>>-          {
>>-            int backUpIndex = -1;
>>-            string fileName = curFileName;
>>+              /// <summary>
>>+              /// Attempts to extract a number from the end of the file
> name
>>that indicates
>>+              /// the number of the times the file has been rolled over.
>>+              /// </summary>
>>+              /// <remarks>
>>+              /// Certain date pattern extensions like yyyyMMdd will be
>>parsed as valid backup indexes.
>>+              /// </remarks>
>>+              /// <param name="curFileName"></param>
>>+              /// <returns></returns>
>>+              private int GetBackUpIndex(string curFileName)
>>+              {
>>+                      int backUpIndex = -1;
>>+                      string fileName = curFileName;
>>
>>-            if (m_preserveLogFileNameExtension)
>>-            {
>>-                fileName = Path.GetFileNameWithoutExtension(fileName);
>>-            }
>>-
>>-            int index = fileName.LastIndexOf(".");
>>-            if (index > 0)
>>-            {
>>-                // if the "yyyy-MM-dd" component of file.log.yyyy-MM-dd is
>>passed to TryParse
>>-                // it will gracefully fail and return backUpIndex will be
>>0
>>-                SystemInfo.TryParse(fileName.Substring(index + 1), out
>>backUpIndex);
>>-            }
>>+                      if (m_preserveLogFileNameExtension)
>>+                      {
>>+                              fileName =
>>Path.GetFileNameWithoutExtension(fileName);
>>+                      }
>>
>>-            return backUpIndex;
>>-          }
>>+                      int index = fileName.LastIndexOf(".");
>>+                      if (index > 0)
>>+                      {
>>+                              // if the "yyyy-MM-dd" component of
> file.log.yyyy-
>>MM-dd is passed to TryParse
>>+                              // it will gracefully fail and return
> backUpIndex
>>will be 0
>>+                              SystemInfo.TryParse(fileName.Substring(index
> + 1),
>>out backUpIndex);
>>+                      }
>>
>>-          /// <summary>
>>-              /// Takes a list of files and a base file name, and looks
> for
>>+                      return backUpIndex;
>>+              }
>>+
>>+              /// <summary>
>>+              /// Takes a list of files and a base file name, and looks
> for
>>               /// 'incremented' versions of the base file.  Bumps the max
>>               /// count up to the highest count seen.
>>               /// </summary>
>>@@ -1018,13 +1019,13 @@
>>               /// Essentially the date pattern is examined to determine
> what
>>the
>>               /// most suitable roll point is. The roll point chosen is
> the
>>roll point
>>               /// with the smallest period that can be detected using the
>>date pattern
>>-              /// supplied. i.e. if the date pattern only outputs the
> year,
>>month, day
>>+              /// supplied. i.e. if the date pattern only outputs the
> year,
>>month, day
>>               /// and hour then the smallest roll point that can be
> detected
>>would be
>>               /// and hourly roll point as minutes could not be detected.
>>               /// </remarks>
>>-              private RollPoint ComputeCheckPeriod(string datePattern)
>>+              private RollPoint ComputeCheckPeriod(string datePattern)
>>               {
>>-                      // s_date1970 is 1970-01-01 00:00:00 this is
>>UniversalSortableDateTimePattern
>>+                      // s_date1970 is 1970-01-01 00:00:00 this is
>>UniversalSortableDateTimePattern
>>                       // (based on ISO 8601) using universal time. This
> date is
>>used for reference
>>                       // purposes to calculate the resolution of the date
>>pattern.
>>
>>@@ -1032,7 +1033,7 @@
>>                       string r0 = s_date1970.ToString(datePattern,
>>System.Globalization.DateTimeFormatInfo.InvariantInfo);
>>
>>                       // Check each type of rolling mode starting with the
>>smallest increment.
>>-                      for(int i = (int)RollPoint.TopOfMinute; i <=
>>(int)RollPoint.TopOfMonth; i++)
>>+                      for(int i = (int)RollPoint.TopOfMinute; i <=
>>(int)RollPoint.TopOfMonth; i++)
>>                       {
>>                               // Get string representation of next pattern
>>                               string r1 = NextCheckDate(s_date1970,
>>(RollPoint)i).ToString(datePattern,
>>System.Globalization.DateTimeFormatInfo.InvariantInfo);
>>@@ -1040,7 +1041,7 @@
>>                               LogLog.Debug(declaringType, "Type = ["+i+"],
> r0 =
>>["+r0+"], r1 = ["+r1+"]");
>>
>>                               // Check if the string representations are
>>different
>>-                              if (r0 != null && r1 != null &&
> !r0.Equals(r1))
>>+                              if (r0 != null && r1 != null &&
> !r0.Equals(r1))
>>                               {
>>                                       // Found highest precision roll
> point
>>                                       return (RollPoint)i;
>>@@ -1056,13 +1057,13 @@
>>               /// <remarks>
>>               /// <para>
>>               /// This is part of the <see cref="IOptionHandler"/> delayed
>>object
>>-              /// activation scheme. The <see cref="ActivateOptions"/>
> method
>>must
>>+              /// activation scheme. The <see cref="ActivateOptions"/>
> method
>>must
>>               /// be called on this object after the configuration
> properties
>>have
>>               /// been set. Until <see cref="ActivateOptions"/> is called
>>this
>>-              /// object is in an undefined state and must not be used.
>>+              /// object is in an undefined state and must not be used.
>>               /// </para>
>>               /// <para>
>>-              /// If any of the configuration properties are modified then
>>+              /// If any of the configuration properties are modified then
>>               /// <see cref="ActivateOptions"/> must be called again.
>>               /// </para>
>>               /// <para>
>>@@ -1071,14 +1072,14 @@
>>               /// the current number of backups.
>>               /// </para>
>>               /// </remarks>
>>-              override public void ActivateOptions()
>>+              override public void ActivateOptions()
>>               {
>>                       if (m_dateTime == null)
>>                       {
>>                               m_dateTime = new LocalDateTime();
>>                       }
>>
>>-                      if (m_rollDate && m_datePattern != null)
>>+                      if (m_rollDate && m_datePattern != null)
>>                       {
>>                               m_now = m_dateTime.Now;
>>                               m_rollPoint =
> ComputeCheckPeriod(m_datePattern);
>>@@ -1090,8 +1091,8 @@
>>
>>                               // next line added as this removes the name
> check
>>in rollOver
>>                               m_nextCheck = NextCheckDate(m_now,
> m_rollPoint);
>>-                      }
>>-                      else
>>+                      }
>>+                      else
>>                       {
>>                               if (m_rollDate)
>>                               {
>>@@ -1117,36 +1118,36 @@
>>
>>                       if (m_rollDate && File != null &&
> m_scheduledFilename ==
>>null)
>>                       {
>>-                m_scheduledFilename = CombinePath(File,
>>m_now.ToString(m_datePattern,
>>System.Globalization.DateTimeFormatInfo.InvariantInfo));
>>+                              m_scheduledFilename = CombinePath(File,
>>m_now.ToString(m_datePattern,
>>System.Globalization.DateTimeFormatInfo.InvariantInfo));
>>                       }
>>
>>                       ExistingInit();
>>-
>>+
>>                       base.ActivateOptions();
>>               }
>>
>>               #endregion
>>-
>>+
>>               #region Roll File
>>
>>-        /// <summary>
>>-        ///
>>-        /// </summary>
>>-        /// <param name="path1"></param>
>>-        /// <param name="path2">.1, .2, .3, etc.</param>
>>-        /// <returns></returns>
>>-        private string CombinePath(string path1, string path2)
>>-        {
>>-            string extension = Path.GetExtension(path1);
>>-            if (m_preserveLogFileNameExtension && extension.Length > 0)
>>-            {
>>-                return Path.Combine(Path.GetDirectoryName(path1),
>>Path.GetFileNameWithoutExtension(path1) + path2 + extension);
>>-            }
>>-            else
>>-            {
>>-                return path1 + path2;
>>-            }
>>-        }
>>+              /// <summary>
>>+              ///
>>+              /// </summary>
>>+              /// <param name="path1"></param>
>>+              /// <param name="path2">.1, .2, .3, etc.</param>
>>+              /// <returns></returns>
>>+              private string CombinePath(string path1, string path2)
>>+              {
>>+                      string extension = Path.GetExtension(path1);
>>+                      if (m_preserveLogFileNameExtension &&
> extension.Length >
>>0)
>>+                      {
>>+                              return
> Path.Combine(Path.GetDirectoryName(path1),
>>Path.GetFileNameWithoutExtension(path1) + path2 + extension);
>>+                      }
>>+                      else
>>+                      {
>>+                              return path1 + path2;
>>+                      }
>>+              }
>>
>>               /// <summary>
>>               /// Rollover the file(s) to date/time tagged file(s).
>>@@ -1155,53 +1156,53 @@
>>               /// <remarks>
>>               /// <para>
>>               /// Rollover the file(s) to date/time tagged file(s).
>>-              /// Resets curSizeRollBackups.
>>+              /// Resets curSizeRollBackups.
>>               /// If fileIsOpen is set then the new file is opened
> (through
>>SafeOpenFile).
>>               /// </para>
>>               /// </remarks>
>>-              protected void RollOverTime(bool fileIsOpen)
>>+              protected void RollOverTime(bool fileIsOpen)
>>               {
>>-                      if (m_staticLogFileName)
>>+                      if (m_staticLogFileName)
>>                       {
>>                               // Compute filename, but only if datePattern
> is
>>specified
>>-                              if (m_datePattern == null)
>>+                              if (m_datePattern == null)
>>                               {
>>                                       ErrorHandler.Error("Missing
> DatePattern
>>option in rollOver().");
>>                                       return;
>>                               }
>>-
>>+
>>                               //is the new file name equivalent to the
> 'current'
>>one
>>                               //something has gone wrong if we hit this --
> we
>>should only
>>                               //roll over if the new file will be
> different from
>>the old
>>                               string dateFormat =
> m_now.ToString(m_datePattern,
>>System.Globalization.DateTimeFormatInfo.InvariantInfo);
>>-                if (m_scheduledFilename.Equals(CombinePath(File,
>>dateFormat)))
>>+                              if
> (m_scheduledFilename.Equals(CombinePath(File,
>>dateFormat)))
>>                               {
>>-                    ErrorHandler.Error("Compare " + m_scheduledFilename +
>>" : " + CombinePath(File, dateFormat));
>>+                                      ErrorHandler.Error("Compare " +
>>m_scheduledFilename + " : " + CombinePath(File, dateFormat));
>>                                       return;
>>                               }
>>-
>>+
>>                               if (fileIsOpen)
>>                               {
>>                                       // close current file, and rename it
> to
>>datedFilename
>>                                       this.CloseFile();
>>                               }
>>-
>>+
>>                               //we may have to roll over a large number of
>>backups here
>>-                              for (int i = 1; i <= m_curSizeRollBackups;
> i++)
>>+                              for (int i = 1; i <= m_curSizeRollBackups;
> i++)
>>                               {
>>-                    string from = CombinePath(File, "." + i);
>>-                    string to = CombinePath(m_scheduledFilename, "." + i);
>>+                                      string from = CombinePath(File, "."
> + i);
>>+                                      string to =
> CombinePath(m_scheduledFilename,
>>"." + i);
>>                                       RollFile(from, to);
>>                               }
>>-
>>+
>>                               RollFile(File, m_scheduledFilename);
>>                       }
>>-
>>+
>>                       //We've cleared out the old date and are ready for
> the
>>new
>>-                      m_curSizeRollBackups = 0;
>>-
>>+                      m_curSizeRollBackups = 0;
>>+
>>                       //new scheduled name
>>-            m_scheduledFilename = CombinePath(File,
>>m_now.ToString(m_datePattern,
>>System.Globalization.DateTimeFormatInfo.InvariantInfo));
>>+                      m_scheduledFilename = CombinePath(File,
>>m_now.ToString(m_datePattern,
>>System.Globalization.DateTimeFormatInfo.InvariantInfo));
>>
>>                       if (fileIsOpen)
>>                       {
>>@@ -1209,7 +1210,7 @@
>>                               SafeOpenFile(m_baseFileName, false);
>>                       }
>>               }
>>-
>>+
>>               /// <summary>
>>               /// Renames file <paramref name="fromFile"/> to file
> <paramref
>>name="toFile"/>.
>>               /// </summary>
>>@@ -1221,7 +1222,7 @@
>>               /// also checks for existence of target file and deletes if
> it
>>does.
>>               /// </para>
>>               /// </remarks>
>>-              protected void RollFile(string fromFile, string toFile)
>>+              protected void RollFile(string fromFile, string toFile)
>>               {
>>                       if (FileExists(fromFile))
>>                       {
>>@@ -1265,7 +1266,7 @@
>>                               return System.IO.File.Exists(path);
>>                       }
>>               }
>>-
>>+
>>               /// <summary>
>>               /// Deletes the specified file if it exists.
>>               /// </summary>
>>@@ -1278,9 +1279,9 @@
>>               /// be deleted, but it still can be moved.
>>               /// </para>
>>               /// </remarks>
>>-              protected void DeleteFile(string fileName)
>>+              protected void DeleteFile(string fileName)
>>               {
>>-                      if (FileExists(fileName))
>>+                      if (FileExists(fileName))
>>                       {
>>                               // We may not have permission to delete the
> file,
>>or the file may be locked
>>
>>@@ -1327,7 +1328,7 @@
>>                               }
>>                       }
>>               }
>>-
>>+
>>               /// <summary>
>>               /// Implements file roll base on file size.
>>               /// </summary>
>>@@ -1354,18 +1355,18 @@
>>               /// renamed if needed and no files are deleted.
>>               /// </para>
>>               /// </remarks>
>>-              protected void RollOverSize()
>>+              protected void RollOverSize()
>>               {
>>                       this.CloseFile(); // keep windows happy.
>>-
>>+
>>                       LogLog.Debug(declaringType, "rolling over count
>>["+((CountingQuietTextWriter)QuietWriter).Count+"]");
>>                       LogLog.Debug(declaringType, "maxSizeRollBackups
>>["+m_maxSizeRollBackups+"]");
>>                       LogLog.Debug(declaringType, "curSizeRollBackups
>>["+m_curSizeRollBackups+"]");
>>                       LogLog.Debug(declaringType, "countDirection
>>["+m_countDirection+"]");
>>
>>                       RollOverRenameFiles(File);
>>-
>>-                      if (!m_staticLogFileName && m_countDirection >= 0)
>>+
>>+                      if (!m_staticLogFileName && m_countDirection >= 0)
>>                       {
>>                               m_curSizeRollBackups++;
>>                       }
>>@@ -1386,7 +1387,7 @@
>>               /// If <c>countDirection</c> &lt; 0, then files
>>               /// {<c>File.1</c>, ..., <c>File.curSizeRollBackups -1</c>}
>>               /// are renamed to {<c>File.2</c>, ...,
>>-              /// <c>File.curSizeRollBackups</c>}.
>>+              /// <c>File.curSizeRollBackups</c>}.
>>               /// </para>
>>               /// <para>
>>               /// If <c>maxSizeRollBackups</c> is equal to zero, then the
>>@@ -1400,35 +1401,35 @@
>>               /// This is called by <see cref="RollOverSize"/> to rename
> the
>>files.
>>               /// </para>
>>               /// </remarks>
>>-              protected void RollOverRenameFiles(string baseFileName)
>>+              protected void RollOverRenameFiles(string baseFileName)
>>               {
>>                       // If maxBackups <= 0, then there is no file
> renaming to
>>be done.
>>-                      if (m_maxSizeRollBackups != 0)
>>+                      if (m_maxSizeRollBackups != 0)
>>                       {
>>-                              if (m_countDirection < 0)
>>+                              if (m_countDirection < 0)
>>                               {
>>                                       // Delete the oldest file, to keep
> Windows
>>happy.
>>-                                      if (m_curSizeRollBackups ==
>>m_maxSizeRollBackups)
>>+                                      if (m_curSizeRollBackups ==
>>m_maxSizeRollBackups)
>>                                       {
>>-                        DeleteFile(CombinePath(baseFileName, "." +
>>m_maxSizeRollBackups));
>>+
> DeleteFile(CombinePath(baseFileName,
>>"." + m_maxSizeRollBackups));
>>                                               m_curSizeRollBackups--;
>>                                       }
>>-
>>+
>>                                       // Map {(maxBackupIndex - 1), ...,
> 2, 1} to
>>{maxBackupIndex, ..., 3, 2}
>>-                                      for (int i = m_curSizeRollBackups; i
>>= 1; i-
>>-)
>>+                                      for (int i = m_curSizeRollBackups; i
>>= 1; i-
>>-)
>>                                       {
>>-                        RollFile((CombinePath(baseFileName, "." + i)),
>>(CombinePath(baseFileName, "." + (i + 1))));
>>+
> RollFile((CombinePath(baseFileName, "."
>>+ i)), (CombinePath(baseFileName, "." + (i + 1))));
>>                                       }
>>-
>>+
>>                                       m_curSizeRollBackups++;
>>
>>                                       // Rename fileName to fileName.1
>>-                    RollFile(baseFileName, CombinePath(baseFileName,
>>".1"));
>>-                              }
>>-                              else
>>+                                      RollFile(baseFileName,
>>CombinePath(baseFileName, ".1"));
>>+                              }
>>+                              else
>>                               {
>>                                       //countDirection >= 0
>>-                                      if (m_curSizeRollBackups >=
>>m_maxSizeRollBackups && m_maxSizeRollBackups > 0)
>>+                                      if (m_curSizeRollBackups >=
>>m_maxSizeRollBackups && m_maxSizeRollBackups > 0)
>>                                       {
>>                                               //delete the first and keep
> counting
>>up.
>>                                               int oldestFileIndex =
>>m_curSizeRollBackups - m_maxSizeRollBackups;
>>@@ -1446,20 +1447,20 @@
>>                                               if (!m_staticLogFileName)
>>                                               {
>>                                                       int lastDotIndex =
>>archiveFileBaseName.LastIndexOf(".");
>>-                                                      if (lastDotIndex >=
> 0)
>>+                                                      if (lastDotIndex >=
> 0)
>>                                                       {
>>
> archiveFileBaseName =
>>archiveFileBaseName.Substring(0, lastDotIndex);
>>                                                       }
>>                                               }
>>
>>                                               // Delete the archive file
>>-                        DeleteFile(CombinePath(archiveFileBaseName, "." +
>>oldestFileIndex));
>>+
>>       DeleteFile(CombinePath(archiveFileBaseName, "." + oldestFileIndex));
>>                                       }
>>-
>>-                                      if (m_staticLogFileName)
>>+
>>+                                      if (m_staticLogFileName)
>>                                       {
>>                                               m_curSizeRollBackups++;
>>-                        RollFile(baseFileName, CombinePath(baseFileName,
>>"." + m_curSizeRollBackups));
>>+                                              RollFile(baseFileName,
>>CombinePath(baseFileName, "." + m_curSizeRollBackups));
>>                                       }
>>                               }
>>                       }
>>@@ -1486,13 +1487,13 @@
>>               /// worth of time and get the start time of the next window
> for
>>the rollpoint.
>>               /// </para>
>>               /// </remarks>
>>-              protected DateTime NextCheckDate(DateTime currentDateTime,
>>RollPoint rollPoint)
>>+              protected DateTime NextCheckDate(DateTime currentDateTime,
>>RollPoint rollPoint)
>>               {
>>                       // Local variable to work on (this does not look
> very
>>efficient)
>>                       DateTime current = currentDateTime;
>>
>>                       // Do slightly different things depending on what
> the
>>type of roll point we want.
>>-                      switch(rollPoint)
>>+                      switch(rollPoint)
>>                       {
>>                               case RollPoint.TopOfMinute:
>>                                       current = current.AddMilliseconds(-
>>current.Millisecond);
>>@@ -1512,11 +1513,11 @@
>>                                       current = current.AddSeconds(-
>>current.Second);
>>                                       current = current.AddMinutes(-
>>current.Minute);
>>
>>-                                      if (current.Hour < 12)
>>+                                      if (current.Hour < 12)
>>                                       {
>>                                               current =
> current.AddHours(12 -
>>current.Hour);
>>-                                      }
>>-                                      else
>>+                                      }
>>+                                      else
>>                                       {
>>                                               current = current.AddHours(-
>>current.Hour);
>>                                               current =
> current.AddDays(1);
>>@@ -1547,7 +1548,7 @@
>>                                       current = current.AddDays(1 -
> current.Day);
>>/* first day of month is 1 not 0 */
>>                                       current = current.AddMonths(1);
>>                                       break;
>>-                      }
>>+                      }
>>                       return current;
>>               }
>>
>>@@ -1563,38 +1564,38 @@
>>               private IDateTime m_dateTime = null;
>>
>>               /// <summary>
>>-              /// The date pattern. By default, the pattern is set to
>><c>".yyyy-MM-dd"</c>
>>+              /// The date pattern. By default, the pattern is set to
>><c>".yyyy-MM-dd"</c>
>>               /// meaning daily rollover.
>>               /// </summary>
>>               private string m_datePattern = ".yyyy-MM-dd";
>>-
>>+
>>               /// <summary>
>>               /// The actual formatted filename that is currently being
>>written to
>>               /// or will be the file transferred to on roll over
>>               /// (based on staticLogFileName).
>>               /// </summary>
>>               private string m_scheduledFilename = null;
>>-
>>+
>>               /// <summary>
>>               /// The timestamp when we shall next recompute the filename.
>>               /// </summary>
>>               private DateTime m_nextCheck = DateTime.MaxValue;
>>-
>>+
>>               /// <summary>
>>               /// Holds date of last roll over
>>               /// </summary>
>>               private DateTime m_now;
>>-
>>+
>>               /// <summary>
>>               /// The type of rolling done
>>               /// </summary>
>>               private RollPoint m_rollPoint;
>>-
>>+
>>               /// <summary>
>>               /// The default maximum file size is 10MB
>>               /// </summary>
>>               private long m_maxFileSize = 10*1024*1024;
>>-
>>+
>>               /// <summary>
>>               /// There is zero backup files by default
>>               /// </summary>
>>@@ -1604,12 +1605,12 @@
>>               /// How many sized based backups have been made so far
>>               /// </summary>
>>               private int m_curSizeRollBackups = 0;
>>-
>>+
>>               /// <summary>
>>-              /// The rolling file count direction.
>>+              /// The rolling file count direction.
>>               /// </summary>
>>               private int m_countDirection = -1;
>>-
>>+
>>               /// <summary>
>>               /// The rolling mode used in this appender.
>>               /// </summary>
>>@@ -1624,13 +1625,13 @@
>>               /// Cache flag set if we are rolling by size.
>>               /// </summary>
>>               private bool m_rollSize = true;
>>-
>>+
>>               /// <summary>
>>               /// Value indicating whether to always log to the same file.
>>               /// </summary>
>>               private bool m_staticLogFileName = true;
>>-
>>-              /// <summary>
>>+
>>+              /// <summary>
>>               /// Value indicating whether to preserve the file name
>>extension when rolling.
>>               /// </summary>
>>               private bool m_preserveLogFileNameExtension = false;
>>@@ -1640,7 +1641,7 @@
>>               /// FileName provided in configuration.  Used for rolling
>>properly
>>               /// </summary>
>>               private string m_baseFileName;
>>-
>>+
>>               #endregion Private Instance Fields
>>
>>               #region Static Members
>>@@ -1697,7 +1698,7 @@
>>               }
>>
>> #if !NET_1_0 && !CLI_1_0 && !NETCF
>>-        /// <summary>
>>+              /// <summary>
>>               /// Implementation of <see cref="IDateTime"/> that returns
> the
>>current time as the coordinated universal time (UTC).
>>               /// </summary>
>>               private class UniversalDateTime : IDateTime
>>@@ -1718,6 +1719,6 @@
>>               }
>> #endif
>>
>>-        #endregion DateTime
>>+              #endregion DateTime
>>       }
>> }
>



--
http://www.grobmeier.de
https://www.timeandbill.de

Mime
View raw message