Refactor: removed trailing whitespace from RollingFileAppender.cs
Project: http://git-wip-us.apache.org/repos/asf/logging-log4net/repo Commit: http://git-wip-us.apache.org/repos/asf/logging-log4net/commit/c8e5130c Tree: http://git-wip-us.apache.org/repos/asf/logging-log4net/tree/c8e5130c Diff: http://git-wip-us.apache.org/repos/asf/logging-log4net/diff/c8e5130c Branch: refs/heads/develop Commit: c8e5130cde5ab416a2c7878ee8979329942d4ed0 Parents: 3c6ec8b Author: Dominik Psenner <dpsen...@apache.org> Authored: Thu Jul 27 17:36:10 2017 +0200 Committer: Dominik Psenner <dpsen...@apache.org> Committed: Thu Jul 27 17:36:10 2017 +0200 ---------------------------------------------------------------------- src/Appender/RollingFileAppender.cs | 282 +++++++++++++++---------------- 1 file changed, 141 insertions(+), 141 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/logging-log4net/blob/c8e5130c/src/Appender/RollingFileAppender.cs ---------------------------------------------------------------------- diff --git a/src/Appender/RollingFileAppender.cs b/src/Appender/RollingFileAppender.cs index 7554bf4..a56766b 100644 --- a/src/Appender/RollingFileAppender.cs +++ b/src/Appender/RollingFileAppender.cs @@ -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 @@ -32,12 +32,12 @@ namespace log4net.Appender // 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 @@ -69,34 +69,34 @@ namespace log4net.Appender /// <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. @@ -111,7 +111,7 @@ namespace log4net.Appender /// 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. @@ -232,7 +232,7 @@ namespace log4net.Appender /// Default constructor. /// </para> /// </remarks> - public RollingFileAppender() + public RollingFileAppender() { } @@ -261,7 +261,7 @@ namespace log4net.Appender #if !NET_1_0 && !CLI_1_0 && !NETCF /// <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> @@ -273,7 +273,7 @@ namespace log4net.Appender /// 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, + /// There are two built strategies for determining the current date and time, /// <see cref="RollingFileAppender.LocalDateTime"/> /// and <see cref="RollingFileAppender.UniversalDateTime"/>. /// </para> @@ -284,7 +284,7 @@ namespace log4net.Appender #else /// <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. @@ -309,12 +309,12 @@ namespace log4net.Appender /// 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> @@ -327,7 +327,7 @@ namespace log4net.Appender 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. @@ -338,16 +338,16 @@ namespace log4net.Appender /// </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> @@ -356,20 +356,20 @@ namespace log4net.Appender 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> @@ -381,20 +381,20 @@ namespace log4net.Appender 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. @@ -415,7 +415,7 @@ namespace log4net.Appender } /// <summary> - /// Gets or sets the rolling file count direction. + /// Gets or sets the rolling file count direction. /// </summary> /// <value> /// The rolling file count direction. @@ -432,7 +432,7 @@ namespace log4net.Appender /// <para> /// <see cref="CountDirection" /> >= 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" /> >= 0 to reduce + /// For infinite backups use <see cref="CountDirection" /> >= 0 to reduce /// rollover costs. /// </para> /// <para>The default file count direction is -1.</para> @@ -442,7 +442,7 @@ namespace log4net.Appender get { return m_countDirection; } set { m_countDirection = value; } } - + /// <summary> /// Gets or sets the rolling style. /// </summary> @@ -464,7 +464,7 @@ namespace log4net.Appender set { m_rollingStyle = value; - switch (m_rollingStyle) + switch (m_rollingStyle) { case RollingMode.Once: m_rollDate = false; @@ -486,7 +486,7 @@ namespace log4net.Appender case RollingMode.Composite: m_rollDate = true; m_rollSize = true; - break; + break; } } } @@ -526,7 +526,7 @@ namespace log4net.Appender /// 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> @@ -551,8 +551,8 @@ namespace log4net.Appender #endregion Private Static Fields - #region Override implementation of FileAppender - + #region Override implementation of FileAppender + /// <summary> /// Sets the quiet writer being used. /// </summary> @@ -560,7 +560,7 @@ namespace log4net.Appender /// 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); } @@ -576,12 +576,12 @@ namespace log4net.Appender /// 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> @@ -593,7 +593,7 @@ namespace log4net.Appender /// 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); @@ -671,7 +671,7 @@ namespace log4net.Appender // Calculate the current size of the file long currentCount = 0; - if (append) + if (append) { using(SecurityContext.Impersonate(this)) { @@ -696,7 +696,7 @@ namespace log4net.Appender } } - if (!m_staticLogFileName) + if (!m_staticLogFileName) { m_scheduledFilename = fileName; } @@ -716,14 +716,14 @@ namespace log4net.Appender /// <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(); @@ -732,7 +732,7 @@ namespace log4net.Appender 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); } @@ -751,7 +751,7 @@ namespace log4net.Appender private void DetermineCurSizeRollBackups() { m_curSizeRollBackups = 0; - + string fullPath = null; string fileName = null; @@ -807,10 +807,10 @@ namespace log4net.Appender 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))) @@ -830,9 +830,9 @@ namespace log4net.Appender /// </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)) { @@ -851,7 +851,7 @@ namespace log4net.Appender } LogLog.Debug(declaringType, "["+last.ToString(m_datePattern,System.Globalization.DateTimeFormatInfo.InvariantInfo)+"] vs. ["+m_now.ToString(m_datePattern,System.Globalization.DateTimeFormatInfo.InvariantInfo)+"]"); - if (!(last.ToString(m_datePattern,System.Globalization.DateTimeFormatInfo.InvariantInfo).Equals(m_now.ToString(m_datePattern, System.Globalization.DateTimeFormatInfo.InvariantInfo)))) + if (!(last.ToString(m_datePattern,System.Globalization.DateTimeFormatInfo.InvariantInfo).Equals(m_now.ToString(m_datePattern, System.Globalization.DateTimeFormatInfo.InvariantInfo)))) { m_scheduledFilename = CombinePath(m_baseFileName, last.ToString(m_datePattern, System.Globalization.DateTimeFormatInfo.InvariantInfo)); LogLog.Debug(declaringType, "Initial roll over to ["+m_scheduledFilename+"]"); @@ -875,7 +875,7 @@ namespace log4net.Appender /// </list> /// </para> /// </remarks> - protected void ExistingInit() + protected void ExistingInit() { DetermineCurSizeRollBackups(); RollOverIfDateBoundaryCrossing(); @@ -923,24 +923,24 @@ namespace log4net.Appender // 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) { @@ -953,12 +953,12 @@ namespace log4net.Appender 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 @@ -993,8 +993,8 @@ namespace log4net.Appender } LogLog.Debug(declaringType, "File name [" + curFileName + "] moves current count to [" + m_curSizeRollBackups + "]"); } - } - catch(FormatException) + } + catch(FormatException) { //this happens when file.log -> file.log.yyyy-MM-dd which is normal //when staticLogFileName == false @@ -1020,7 +1020,7 @@ namespace log4net.Appender { fileName = Path.GetFileNameWithoutExtension(fileName); } - + int index = fileName.LastIndexOf("."); if (index > 0) { @@ -1033,7 +1033,7 @@ namespace log4net.Appender } /// <summary> - /// Takes a list of files and a base file name, and looks for + /// 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> @@ -1061,13 +1061,13 @@ namespace log4net.Appender /// 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. @@ -1075,7 +1075,7 @@ namespace log4net.Appender 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); @@ -1083,7 +1083,7 @@ namespace log4net.Appender 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; @@ -1099,13 +1099,13 @@ namespace log4net.Appender /// <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> @@ -1114,14 +1114,14 @@ namespace log4net.Appender /// 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); @@ -1133,8 +1133,8 @@ namespace log4net.Appender // next line added as this removes the name check in rollOver m_nextCheck = NextCheckDate(m_now, m_rollPoint); - } - else + } + else { if (m_rollDate) { @@ -1169,16 +1169,16 @@ namespace log4net.Appender } ExistingInit(); - + base.ActivateOptions(); } #endregion - + #region Roll File /// <summary> - /// + /// /// </summary> /// <param name="path1"></param> /// <param name="path2">.1, .2, .3, etc.</param> @@ -1203,51 +1203,51 @@ namespace log4net.Appender /// <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)); 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); 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)); @@ -1257,7 +1257,7 @@ namespace log4net.Appender SafeOpenFile(m_baseFileName, false); } } - + /// <summary> /// Renames file <paramref name="fromFile"/> to file <paramref name="toFile"/>. /// </summary> @@ -1269,7 +1269,7 @@ namespace log4net.Appender /// 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)) { @@ -1313,7 +1313,7 @@ namespace log4net.Appender return System.IO.File.Exists(path); } } - + /// <summary> /// Deletes the specified file if it exists. /// </summary> @@ -1326,9 +1326,9 @@ namespace log4net.Appender /// 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 @@ -1375,7 +1375,7 @@ namespace log4net.Appender } } } - + /// <summary> /// Implements file roll base on file size. /// </summary> @@ -1402,18 +1402,18 @@ namespace log4net.Appender /// 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++; } @@ -1434,7 +1434,7 @@ namespace log4net.Appender /// If <c>countDirection</c> < 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 @@ -1448,35 +1448,35 @@ namespace log4net.Appender /// 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)); 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)))); } - + m_curSizeRollBackups++; // Rename fileName to fileName.1 RollFile(baseFileName, CombinePath(baseFileName, ".1")); - } - else + } + 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; @@ -1506,7 +1506,7 @@ namespace log4net.Appender else { int lastDotIndex = archiveFileBaseName.LastIndexOf("."); - if (lastDotIndex >= 0) + if (lastDotIndex >= 0) { archiveFileBaseName = archiveFileBaseName.Substring(0, lastDotIndex); } @@ -1516,8 +1516,8 @@ namespace log4net.Appender // Delete the archive file DeleteFile(CombinePath(archiveFileBaseName, "." + oldestFileIndex)); } - - if (m_staticLogFileName) + + if (m_staticLogFileName) { m_curSizeRollBackups++; RollFile(baseFileName, CombinePath(baseFileName, "." + m_curSizeRollBackups)); @@ -1547,13 +1547,13 @@ namespace log4net.Appender /// 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); @@ -1573,11 +1573,11 @@ namespace log4net.Appender 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); @@ -1608,7 +1608,7 @@ namespace log4net.Appender current = current.AddDays(1 - current.Day); /* first day of month is 1 not 0 */ current = current.AddMonths(1); break; - } + } return current; } @@ -1624,38 +1624,38 @@ namespace log4net.Appender 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> @@ -1665,12 +1665,12 @@ namespace log4net.Appender /// 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> @@ -1685,12 +1685,12 @@ namespace log4net.Appender /// 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> /// Value indicating whether to preserve the file name extension when rolling. /// </summary>
