/// <summary>
/// Process a parsed converter pattern
/// </summary>
/// <param name="converterName">the name of the converter</param>
/// <param name="option">the optional option for the converter</param>
/// <param name="formattingInfo">the formatting info for the converter</param>
private void ProcessConverter(string converterName, string option, FormattingInfo formattingInfo)
{
LogLog.Debug(declaringType, "Converter [" + converterName + "] Option [" + option + "] Format [min=" + formattingInfo.Min + ",max=" + formattingInfo.Max + ",leftAlign=" + formattingInfo.LeftAlign.ToString() + "]");
ConverterInfo converterInfo = (ConverterInfo)m_patternConverters[converterName];
if (converterInfo == null)
{
LogLog.Error(declaringType, "Unknown converter name [" + converterName + "] in conversion pattern.");
return;
}
PatternConverter patternConverter = null;
try
{
patternConverter = (PatternConverter)Activator.CreateInstance(converterInfo.Type);
}
catch (Exception ex)
{
LogLog.Error(declaringType, "Failed to create instance of Type [" + converterInfo.Type.FullName + "] using default constructor. Exception: " + ex.ToString());
}
patternConverter.FormattingInfo = formattingInfo;
patternConverter.Option = option;
patternConverter.Properties = converterInfo.Properties;
(patternConverter as IOptionHandler)?.ActivateOptions();
AddConverter(patternConverter);
}
private void ProcessConverter(string converterName, string option, FormattingInfo formattingInfo)
{
object[] objArray1 = new object[11];
objArray1[0] = "Converter [";
objArray1[1] = converterName;
objArray1[2] = "] Option [";
objArray1[3] = option;
objArray1[4] = "] Format [min=";
objArray1[5] = formattingInfo.Min;
objArray1[6] = ",max=";
objArray1[7] = formattingInfo.Max;
objArray1[8] = ",leftAlign=";
objArray1[9] = formattingInfo.LeftAlign;
objArray1[10] = "]";
LogLog.Debug(declaringType, string.Concat(objArray1));
ConverterInfo info = (ConverterInfo)this.m_patternConverters[converterName];
if (info == null)
{
LogLog.Error(declaringType, "Unknown converter name [" + converterName + "] in conversion pattern.");
}
else
{
PatternConverter pc = null;
try
{
pc = (PatternConverter)Activator.CreateInstance(info.Type);
}
catch (Exception exception)
{
LogLog.Error(declaringType, "Failed to create instance of Type [" + info.Type.FullName + "] using default constructor. Exception: " + exception.ToString());
}
pc.FormattingInfo = formattingInfo;
pc.Option = option;
pc.Properties = info.Properties;
IOptionHandler handler = pc as IOptionHandler;
if (handler != null)
{
handler.ActivateOptions();
}
this.AddConverter(pc);
}
}
/// <summary>
/// Process a parsed converter pattern
/// 处理已解析的转换器模式
/// </summary>
/// <param name="converterName">the name of the converter</param>
/// <param name="option">the optional option for the converter</param>
/// <param name="formattingInfo">the formatting info for the converter</param>
private void ProcessConverter(string converterName, string option, FormattingInfo formattingInfo)
{
LogLog.Debug(declaringType, "Converter [" + converterName + "] Option [" + option + "] Format [min=" + formattingInfo.Min + ",max=" + formattingInfo.Max + ",leftAlign=" + formattingInfo.LeftAlign + "]");
// Lookup the converter type
ConverterInfo converterInfo = (ConverterInfo)m_patternConverters[converterName];
if (converterInfo == null)
{
//未知的转换器
LogLog.Error(declaringType, "Unknown converter name [" + converterName + "] in conversion pattern.");
}
else
{
// Create the pattern converter
// 创建模式转换器
PatternConverter pc = null;
try
{
pc = (PatternConverter)Activator.CreateInstance(converterInfo.Type);
}
catch (Exception createInstanceEx)
{
LogLog.Error(declaringType, "Failed to create instance of Type [" + converterInfo.Type.FullName + "] using default constructor. Exception: " + createInstanceEx.ToString());
}
// formattingInfo variable is an instance variable, occasionally reset and used over and over again
// formattingInfo变量是一个实例变量，偶尔会重新设置并反复使用
pc.FormattingInfo = formattingInfo;
pc.Option = option;
pc.Properties = converterInfo.Properties;
IOptionHandler optionHandler = pc as IOptionHandler;
if (optionHandler != null)
{
optionHandler.ActivateOptions();
}
AddConverter(pc);
}
}
/// <summary>
/// Process a parsed converter pattern
/// </summary>
/// <param name="converterName">the name of the converter</param>
/// <param name="option">the optional option for the converter</param>
/// <param name="formattingInfo">the formatting info for the converter</param>
void ProcessConverter(string converterName, string option, FormattingInfo formattingInfo)
{
LogLog.Debug("PatternParser: Converter [" + converterName + "] Option [" + option + "] Format [min=" +
formattingInfo.Min + ",max=" + formattingInfo.Max + ",leftAlign=" + formattingInfo.LeftAlign + "]");
// Lookup the converter type
var converterType = (Type)m_patternConverters[converterName];
if (converterType == null)
{
LogLog.Error("PatternParser: Unknown converter name [" + converterName + "] in conversion pattern.");
}
else
{
// Create the pattern converter
PatternConverter pc = null;
try
{
pc = (PatternConverter)Activator.CreateInstance(converterType);
}
catch (Exception createInstanceEx)
{
LogLog.Error("PatternParser: Failed to create instance of Type [" + converterType.FullName +
"] using default constructor. Exception: " + createInstanceEx);
}
// formattingInfo variable is an instance variable, occasionally reset
// and used over and over again
pc.FormattingInfo = formattingInfo;
pc.Option = option;
var optionHandler = pc as IOptionHandler;
if (optionHandler != null)
{
optionHandler.ActivateOptions();
}
AddConverter(pc);
}
}
/// <summary>
/// Internal method to parse the specified pattern to find specified matches
/// </summary>
/// <param name="pattern">the pattern to parse</param>
/// <param name="matches">the converter names to match in the pattern</param>
/// <remarks>
/// <para>
/// The matches param must be sorted such that longer strings come before shorter ones.
/// </para>
/// </remarks>
private void ParseInternal(string pattern, string[] matches)
{
int offset = 0;
while (offset < pattern.Length)
{
int i = pattern.IndexOf('%', offset);
if (i < 0 || i == pattern.Length - 1)
{
ProcessLiteral(pattern.Substring(offset));
offset = pattern.Length;
}
else
{
if (pattern[i + 1] == '%')
{
// Escaped
ProcessLiteral(pattern.Substring(offset, i - offset + 1));
offset = i + 2;
}
else
{
ProcessLiteral(pattern.Substring(offset, i - offset));
offset = i + 1;
FormattingInfo formattingInfo = new FormattingInfo();
// Process formatting options
// Look for the align flag
if (offset < pattern.Length)
{
if (pattern[offset] == '-')
{
// Seen align flag
formattingInfo.LeftAlign = true;
offset++;
}
}
// Look for the minimum length
while (offset < pattern.Length && char.IsDigit(pattern[offset]))
{
// Seen digit
if (formattingInfo.Min < 0)
{
formattingInfo.Min = 0;
}
formattingInfo.Min = (formattingInfo.Min * 10) + int.Parse(pattern[offset].ToString(), NumberFormatInfo.InvariantInfo);
offset++;
}
// Look for the separator between min and max
if (offset < pattern.Length)
{
if (pattern[offset] == '.')
{
// Seen separator
offset++;
}
}
// Look for the maximum length
while (offset < pattern.Length && char.IsDigit(pattern[offset]))
{
// Seen digit
if (formattingInfo.Max == int.MaxValue)
{
formattingInfo.Max = 0;
}
formattingInfo.Max = (formattingInfo.Max * 10) + int.Parse(pattern[offset].ToString(), NumberFormatInfo.InvariantInfo);
offset++;
}
int remainingStringLength = pattern.Length - offset;
// Look for pattern
for (int m = 0; m < matches.Length; m++)
{
string key = matches[m];
if (key.Length <= remainingStringLength)
{
if (string.Compare(pattern, offset, key, 0, key.Length) == 0)
{
// Found match
offset = offset + matches[m].Length;
string option = null;
// Look for option
if (offset < pattern.Length)
{
if (pattern[offset] == '{')
{
// Seen option start
offset++;
int optEnd = pattern.IndexOf('}', offset);
if (optEnd < 0)
{
// error
}
else
{
option = pattern.Substring(offset, optEnd - offset);
offset = optEnd + 1;
}
}
}
ProcessConverter(matches[m], option, formattingInfo);
break;
}
}
}
}
}
}
}
/// <summary>
/// Process a parsed converter pattern
/// </summary>
/// <param name="converterName">the name of the converter</param>
/// <param name="option">the optional option for the converter</param>
/// <param name="formattingInfo">the formatting info for the converter</param>
private void ProcessConverter(string converterName, string option, FormattingInfo formattingInfo)
{
LogLog.Debug("PatternParser: Converter ["+converterName+"] Option ["+option+"] Format [min="+formattingInfo.Min+",max="+formattingInfo.Max+",leftAlign="+formattingInfo.LeftAlign+"]");
// Lookup the converter type
Type converterType = (Type)m_patternConverters[converterName];
if (converterType == null)
{
LogLog.Error("PatternParser: Unknown converter name ["+converterName+"] in conversion pattern.");
}
else
{
// Create the pattern converter
PatternConverter pc = null;
try
{
pc = (PatternConverter)Activator.CreateInstance(converterType);
}
catch(Exception createInstanceEx)
{
LogLog.Error("PatternParser: Failed to create instance of Type ["+converterType.FullName+"] using default constructor. Exception: "+createInstanceEx.ToString());
}
// formattingInfo variable is an instance variable, occasionally reset
// and used over and over again
pc.FormattingInfo = formattingInfo;
pc.Option = option;
IOptionHandler optionHandler = pc as IOptionHandler;
if (optionHandler != null)
{
optionHandler.ActivateOptions();
}
AddConverter(pc);
}
}
/// <summary>
/// Internal method to parse the specified pattern to find specified matches
/// </summary>
/// <param name="pattern">the pattern to parse</param>
/// <param name="matches">the converter names to match in the pattern</param>
/// <remarks>
/// <para>
/// The matches param must be sorted such that longer strings come before shorter ones.
/// </para>
/// </remarks>
private void ParseInternal(string pattern, string[] matches)
{
int offset = 0;
while(offset < pattern.Length)
{
int i = pattern.IndexOf('%', offset);
if (i < 0 || i == pattern.Length - 1)
{
ProcessLiteral(pattern.Substring(offset));
offset = pattern.Length;
}
else
{
if (pattern[i+1] == '%')
{
// Escaped
ProcessLiteral(pattern.Substring(offset, i - offset + 1));
offset = i + 2;
}
else
{
ProcessLiteral(pattern.Substring(offset, i - offset));
offset = i + 1;
FormattingInfo formattingInfo = new FormattingInfo();
// Process formatting options
// Look for the align flag
if (offset < pattern.Length)
{
if (pattern[offset] == '-')
{
// Seen align flag
formattingInfo.LeftAlign = true;
offset++;
}
}
// Look for the minimum length
while (offset < pattern.Length && char.IsDigit(pattern[offset]))
{
// Seen digit
if (formattingInfo.Min < 0)
{
formattingInfo.Min = 0;
}
formattingInfo.Min = (formattingInfo.Min * 10) + int.Parse(pattern[offset].ToString(CultureInfo.InvariantCulture), System.Globalization.NumberFormatInfo.InvariantInfo);
offset++;
}
// Look for the separator between min and max
if (offset < pattern.Length)
{
if (pattern[offset] == '.')
{
// Seen separator
offset++;
}
}
// Look for the maximum length
while (offset < pattern.Length && char.IsDigit(pattern[offset]))
{
// Seen digit
if (formattingInfo.Max == int.MaxValue)
{
formattingInfo.Max = 0;
}
formattingInfo.Max = (formattingInfo.Max * 10) + int.Parse(pattern[offset].ToString(CultureInfo.InvariantCulture), System.Globalization.NumberFormatInfo.InvariantInfo);
offset++;
}
int remainingStringLength = pattern.Length - offset;
// Look for pattern
for(int m=0; m<matches.Length; m++)
{
if (matches[m].Length <= remainingStringLength)
{
if (String.Compare(pattern, offset, matches[m], 0, matches[m].Length, false, System.Globalization.CultureInfo.InvariantCulture) == 0)
{
// Found match
offset = offset + matches[m].Length;
string option = null;
// Look for option
if (offset < pattern.Length)
{
if (pattern[offset] == '{')
{
// Seen option start
offset++;
int optEnd = pattern.IndexOf('}', offset);
if (optEnd < 0)
{
// error
}
else
{
option = pattern.Substring(offset, optEnd - offset);
offset = optEnd + 1;
}
}
}
ProcessConverter(matches[m], option, formattingInfo);
break;
}
}
}
}
}
}
}
private void ParseInternal(string pattern, string[] matches)
{
int startIndex = 0;
while (startIndex < pattern.Length)
{
int index = pattern.IndexOf('%', startIndex);
if ((index < 0) || (index == (pattern.Length - 1)))
{
this.ProcessLiteral(pattern.Substring(startIndex));
startIndex = pattern.Length;
continue;
}
if (pattern[index + 1] == '%')
{
this.ProcessLiteral(pattern.Substring(startIndex, (index - startIndex) + 1));
startIndex = index + 2;
continue;
}
this.ProcessLiteral(pattern.Substring(startIndex, index - startIndex));
startIndex = index + 1;
FormattingInfo formattingInfo = new FormattingInfo();
if ((startIndex < pattern.Length) && (pattern[startIndex] == '-'))
{
formattingInfo.LeftAlign = true;
startIndex++;
}
while (true)
{
if ((startIndex >= pattern.Length) || !char.IsDigit(pattern[startIndex]))
{
if ((startIndex < pattern.Length) && (pattern[startIndex] == '.'))
{
startIndex++;
}
while (true)
{
if ((startIndex >= pattern.Length) || !char.IsDigit(pattern[startIndex]))
{
int num3 = pattern.Length - startIndex;
for (int i = 0; i < matches.Length; i++)
{
if ((matches[i].Length <= num3) && (string.Compare(pattern, startIndex, matches[i], 0, matches[i].Length, false, CultureInfo.InvariantCulture) == 0))
{
startIndex += matches[i].Length;
string option = null;
if ((startIndex < pattern.Length) && (pattern[startIndex] == '{'))
{
startIndex++;
int num5 = pattern.IndexOf('}', startIndex);
if (num5 >= 0)
{
option = pattern.Substring(startIndex, num5 - startIndex);
startIndex = num5 + 1;
}
}
this.ProcessConverter(matches[i], option, formattingInfo);
break;
}
}
break;
}
if (formattingInfo.Max == 0x7fffffff)
{
formattingInfo.Max = 0;
}
formattingInfo.Max = (formattingInfo.Max * 10) + int.Parse(pattern[startIndex].ToString(CultureInfo.InvariantCulture), NumberFormatInfo.InvariantInfo);
startIndex++;
}
break;
}
if (formattingInfo.Min < 0)
{
formattingInfo.Min = 0;
}
formattingInfo.Min = (formattingInfo.Min * 10) + int.Parse(pattern[startIndex].ToString(CultureInfo.InvariantCulture), NumberFormatInfo.InvariantInfo);
startIndex++;
}
}
}
/// <summary>
/// Internal method to parse the specified pattern to find specified matches
/// </summary>
/// <param name="pattern">the pattern to parse</param>
/// <param name="matches">the converter names to match in the pattern</param>
/// <remarks>
/// <para>
/// The matches param must be sorted such that longer strings come before shorter ones.
/// </para>
/// </remarks>
private void ParseInternal(string pattern, string[] matches)
{
int i = 0;
while (i < pattern.Length)
{
int num = pattern.IndexOf('%', i);
if (num < 0 || num == pattern.Length - 1)
{
ProcessLiteral(pattern.Substring(i));
i = pattern.Length;
continue;
}
if (pattern[num + 1] == '%')
{
ProcessLiteral(pattern.Substring(i, num - i + 1));
i = num + 2;
continue;
}
ProcessLiteral(pattern.Substring(i, num - i));
i = num + 1;
FormattingInfo formattingInfo = new FormattingInfo();
if (i < pattern.Length && pattern[i] == '-')
{
formattingInfo.LeftAlign = true;
i++;
}
for (; i < pattern.Length && char.IsDigit(pattern[i]); i++)
{
if (formattingInfo.Min < 0)
{
formattingInfo.Min = 0;
}
formattingInfo.Min = formattingInfo.Min * 10 + int.Parse(pattern[i].ToString(), NumberFormatInfo.InvariantInfo);
}
if (i < pattern.Length && pattern[i] == '.')
{
i++;
}
for (; i < pattern.Length && char.IsDigit(pattern[i]); i++)
{
if (formattingInfo.Max == int.MaxValue)
{
formattingInfo.Max = 0;
}
formattingInfo.Max = formattingInfo.Max * 10 + int.Parse(pattern[i].ToString(), NumberFormatInfo.InvariantInfo);
}
int num2 = pattern.Length - i;
for (int j = 0; j < matches.Length; j++)
{
string text = matches[j];
if (text.Length > num2 || string.Compare(pattern, i, text, 0, text.Length) != 0)
{
continue;
}
i += matches[j].Length;
string option = null;
if (i < pattern.Length && pattern[i] == '{')
{
i++;
int num3 = pattern.IndexOf('}', i);
if (num3 >= 0)
{
option = pattern.Substring(i, num3 - i);
i = num3 + 1;
}
}
ProcessConverter(matches[j], option, formattingInfo);
break;
}
}
}
