/// <summary>
/// Fetch our own <see cref="PatternConverter"/> SerializingConverter.
/// </summary>
/// <param name="info">description of the PatternConverter</param>
/// <returns>pattern converter set up</returns>
/// <remarks>
/// <para>
/// Please note that properties are only supported with log4net 1.2.11 and above.
/// </para>
/// </remarks>
protected virtual PatternConverter CreateSerializingConverter(ConverterInfo info)
{
var conv = info.Type == null ? null : Activator.CreateInstance(info.Type) as PatternConverter;
if (conv == null)
{
conv = new JsonPatternConverter();
}
#if !LOG4NET_1_2_10_COMPATIBLE
conv.Properties = info.Properties;
#endif
return(conv);
}
/// <summary>
/// Create an instance from a <see cref="ConverterInfo"/>, instantiating it's <see cref="PatternConverter"/>.
/// </summary>
/// <remarks>
/// Properties["option"] (a <see cref="String"/>) can be used to set an option on the converter instance.
/// </remarks>
/// <remarks>
/// Properties are only supported in log4net 1.2.11 and later.
/// </remarks>
/// <param name="info"></param>
public RawCallLayout(ConverterInfo info)
{
Name = info.Name;
var conv = (PatternConverter)Activator.CreateInstance(info.Type);
#if !LOG4NET_1_2_10_COMPATIBLE
conv.Properties = info.Properties;
if (info.Properties.Contains("option"))
{
conv.Option = Convert.ToString(info.Properties["option"]);
}
#endif
if (conv is IOptionHandler)
{
((IOptionHandler)conv).ActivateOptions();
}
m_getter = (e) => Format(conv, e);
m_info = info;
}
/// <summary>
/// Activate the options that were previously set with calls to properties.
/// </summary>
/// <remarks>
/// <para>
/// This allows an object to defer activation of its options until all
/// options have been set. This is required for components which have
/// related options that remain ambiguous until all are set.
/// </para>
/// <para>
/// If a component implements this interface then this method must be called
/// after its properties have been set before the component can be used.
/// </para>
/// <para>
/// The strange constructor call to this method is suspended using
/// <see cref="m_constructed"/>.
/// </para>
/// </remarks>
public override void ActivateOptions()
{
if (!m_constructed)
{
return;
}
// pass control to parent in case we do not get a serializer :o[
base.ActivateOptions();
// just to get those converters
var parser = CreatePatternParser(String.Empty);
#if LOG4NET_1_2_10_COMPATIBLE
int convord = 0;
var converters = new ConverterInfo[parser.PatternConverters.Count];
foreach (DictionaryEntry entry in parser.PatternConverters)
{
converters[convord++] = new ConverterInfo()
{
Name = Convert.ToString(entry.Key),
Type = (Type)entry.Value
};
}
#else
// Extract discovered converters
var converters = Enumerable.ToArray(
Enumerable.Cast <ConverterInfo>(
parser.PatternConverters.Values
)
);
#endif
var arrangement = new MultipleArrangement();
if (m_arrangement.Arrangements.Count != 0)
{
arrangement.AddArrangement(m_arrangement);
}
var patternArrangement = ArrangementConverter.GetArrangement(ConversionPattern, converters);
if (patternArrangement != null)
{
arrangement.AddArrangement(patternArrangement);
}
if (arrangement.Arrangements.Count == 0)
{
// cater for bare defaults
arrangement.AddArrangement(new DefaultArrangement());
}
var serconv = SerializingConverter;
if (serconv == null)
{
var name = SerializerName ?? DefaultSerializerName;
var info = (parser.PatternConverters.ContainsKey(name)
? parser.PatternConverters[name] as ConverterInfo
: null
) ?? CreateSerializingConverterInfo(name, typeof(JsonPatternConverter));
SerializingConverter = serconv = CreateSerializingConverter(info);
}
if (serconv != null)
{
SetUpSerializingConverter(serconv, converters, arrangement, m_fetcher, m_renderer, m_decorators.ToArray());
}
}
