// ReSharper disable once CodeAnnotationAnalyzer
internal void AppendChunk([NotNull] FormatChunk chunk)
{
if (ChildrenInternal == null)
{
ChildrenInternal = new List <FormatChunk>();
}
ChildrenInternal.Add(chunk);
}
/// <summary>
/// Resolves the specified tag.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="chunk">The chunk.</param>
/// <returns>A <see cref="Resolution" />.</returns>
public override object Resolve(FormatWriteContext context, FormatChunk chunk)
{
// ReSharper disable once PossibleNullReferenceException
switch (chunk.Tag.ToLowerInvariant())
{
case "verbose":
return VerboseFormat;
case "reversed":
return ReversedFormat;
case "key":
return Key;
case "value":
return Value;
case "position":
return new Resolution(context.Position, true);
case "!fill":
int length = Math.Min(
120,
context.Layout.Width.Value - context.Layout.FirstLineIndentSize.Value);
char c = !string.IsNullOrEmpty(chunk.Format) ? chunk.Format[0] : '-';
StringBuilder fill = new StringBuilder(length + context.Position < 1 ? 2 : 4);
if (context.Position > 0) fill.AppendLine();
fill.AppendLine(new string(c, length));
// Note we have to replace control chunk with value chunk to write it out.
return new Resolution(new FormatChunk(fill.ToString()), true);
case "nest":
string k;
string v;
if (string.IsNullOrWhiteSpace(chunk.Format))
{
k = "UnspecKey";
v = "UnspecValue";
}
else
{
string[] split = chunk.Format.Split(new[] { ',' }, 2, StringSplitOptions.RemoveEmptyEntries);
if (split.Length < 1)
{
k = "UnspecKey";
v = "UnspecValue";
}
else if (split.Length < 2)
{
k = split[0];
v = "UnspecValue";
}
else
{
k = split[0];
v = split[1];
}
}
return new RWTest(k, v);
default:
return Resolution.Unknown;
}
}
/// <summary>
/// Resolves the specified tag.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="chunk">The chunk.</param>
/// <returns>A <see cref="Resolution" />.</returns>
// ReSharper disable once CodeAnnotationAnalyzer
public override object Resolve(FormatWriteContext context, FormatChunk chunk)
{
TValue value;
// ReSharper disable once AssignNullToNotNullAttribute
return(_values.TryGetValue(chunk.Tag, out value)
? value
: Resolution.Unknown);
}
/// <summary>
/// Resolves the specified tag.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="chunk">The chunk.</param>
/// <returns>A <see cref="Resolution" />.</returns>
// ReSharper disable once CodeAnnotationAnalyzer
public override object Resolve(FormatWriteContext context, FormatChunk chunk)
{
int index;
return(int.TryParse(chunk.Tag, out index) &&
index >= 0 &&
index < _values.Count
? _values[index]
: Resolution.Unknown);
}
/// <summary>
/// Performs a deep copy of the child chunks from <paramref name="source"/> to <paramref name="destination"/>.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="destination">The destination.</param>
internal static void DeepCopyChunks([NotNull] FormatChunk source, [NotNull] FormatChunk destination)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (destination == null)
{
throw new ArgumentNullException("destination");
}
if (source.ChildrenInternal != null &&
source.ChildrenInternal.Count > 0)
{
Stack <FormatChunk, IEnumerable <FormatChunk> > stack = new Stack <FormatChunk, IEnumerable <FormatChunk> >();
stack.Push(destination, source.ChildrenInternal.ToArray());
while (stack.Count > 0)
{
FormatChunk currParent;
IEnumerable <FormatChunk> chunks;
stack.Pop(out currParent, out chunks);
Debug.Assert(currParent != null);
Debug.Assert(chunks != null);
// ReSharper disable once PossibleNullReferenceException
currParent.ChildrenInternal = new List <FormatChunk>();
// Adds each chunk to the current parent
// ReSharper disable once PossibleNullReferenceException
foreach (FormatChunk child in chunks)
{
Debug.Assert(child != null);
FormatChunk newChunk = new FormatChunk(
child.Resolver,
child.Tag,
child.Alignment,
child.Format,
child.IsResolved,
child.Value,
child.IsControl);
currParent.ChildrenInternal.Add(newChunk);
// If the chunk has any children they need to be added to the new chunk
if (child.ChildrenInternal != null &&
child.ChildrenInternal.Count >= 1)
{
stack.Push(newChunk, child.ChildrenInternal);
}
}
}
}
}
public static IEnumerable <FormatChunk> Parse([NotNull] string value, [CanBeNull] IResolvable resolver = null)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
FormatChunk fc = new FormatChunk();
fc.Append(
value,
resolver);
return(fc.Children);
}
/// <summary>
/// Resolves the specified tag.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="chunk">The chunk.</param>
/// <returns>A <see cref="Resolution" />.</returns>
// ReSharper disable once CodeAnnotationAnalyzer
public override object Resolve(FormatWriteContext context, FormatChunk chunk)
{
Resolution resolution;
// ReSharper disable once PossibleNullReferenceException
string tag = chunk.Tag;
Debug.Assert(tag != null);
if (ResolveControls || !chunk.IsControl)
{
if ((_values == null || !_values.TryGetValue(tag, out resolution)))
{
// Get the resolution using the resolver.
object result = _resolver(context, chunk);
resolution = result as Resolution? ?? new Resolution(result);
if (!resolution.NoCache)
{
// Cache the resolution.
if (_values == null)
{
_values =
new Dictionary <string, Resolution>(
IsCaseSensitive
? StringComparer.CurrentCulture
: StringComparer.CurrentCultureIgnoreCase);
}
// ReSharper disable once AssignNullToNotNullAttribute
_values[tag] = resolution;
}
}
}
else
{
resolution = (Resolution)Resolution.Unknown;
}
// If we don't have a resolution, ask the parent.
if (!resolution.IsResolved &&
ResolveOuterTags &&
Parent != null)
{
// ReSharper disable once PossibleNullReferenceException
resolution = (Resolution)Parent.Resolve(context, chunk);
}
return(resolution);
}
/// <summary>
/// Creates a clone of the <see cref="FormatChunk" />, changing the resolved value.
/// </summary>
/// <param name="chunk">The chunk.</param>
/// <param name="value">The value.</param>
public FormatChunk([NotNull] FormatChunk chunk, Optional <object> value)
{
if (chunk == null)
{
throw new ArgumentNullException("chunk");
}
Resolver = chunk.Resolver;
Tag = chunk.Tag;
IsControl = chunk.IsControl;
Alignment = chunk.Alignment;
Format = chunk.Format;
DeepCopyChunks(chunk, this);
if (!value.IsAssigned)
{
return;
}
IsResolved = true;
Value = value.Value;
}
/// <summary>
/// Resolves the specified tag.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="chunk">The chunk.</param>
/// <returns>An object that will be cached unless it is a <see cref="T:WebApplications.Utilities.Formatting.Resolution" />.</returns>
// ReSharper disable once CodeAnnotationAnalyzer
public override object Resolve(FormatWriteContext context, FormatChunk chunk)
{
// ReSharper disable once PossibleNullReferenceException
switch (chunk.Tag.ToLowerInvariant())
{
case "name":
return Name;
case "value":
return Value;
default:
return Resolution.Unknown;
}
}
/// <summary>
/// Resolves the specified tag.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="chunk">The chunk.</param>
/// <returns>An object that will be cached unless it is a <see cref="T:WebApplications.Utilities.Formatting.Resolution" />.</returns>
// ReSharper disable once CodeAnnotationAnalyzer
public override object Resolve(FormatWriteContext context, FormatChunk chunk)
{
if (chunk.Tag == null) throw new ArgumentException();
switch (chunk.Tag.ToLowerInvariant())
{
case "isvalid":
return IsValid ? Resolution.Empty : Resolution.Null;
case "guid":
return Guid;
case "host":
return Host;
case "name":
return Name;
case "fullname":
return FullName;
case "pipe":
return Pipe;
default:
return Resolution.Unknown;
}
}
/// <summary>
/// Resolves the specified tag.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="chunk">The chunk.</param>
/// <returns>
/// An object that will be cached unless it is a <see cref="T:WebApplications.Utilities.Formatting.Resolution" />.
/// </returns>
public override object Resolve(FormatWriteContext context, FormatChunk chunk)
{
Debug.Assert(chunk.Tag != null);
switch (chunk.Tag.ToLowerInvariant())
{
case "name":
return Name;
case "altnames":
return _names.Length > 1
? _names.Skip(1)
: Resolution.Null;
case "description":
return Description;
case "parameters":
object[] parameters = ArgumentParameters.Select(ResolveParameter).ToArray();
return parameters.Length > 0 ? parameters : Resolution.Null;
default:
return Resolution.Unknown;
}
}
/// <summary>
/// Resolves the specified tag.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="chunk">The chunk.</param>
/// <returns>An object that will be cached unless it is a <see cref="T:WebApplications.Utilities.Formatting.Resolution" />.</returns>
// ReSharper disable once CodeAnnotationAnalyzer
public override object Resolve(FormatWriteContext context, FormatChunk chunk)
{
CultureInfo culture = context.FormatProvider as CultureInfo ?? Translation.DefaultCulture;
// ReSharper disable once PossibleNullReferenceException
switch (chunk.Tag.ToLowerInvariant())
{
/*
* Standard named formats.
*/
case "default":
case "verbose":
return VerboseFormat;
case "short":
return ShortFormat;
case "all":
return AllFormat;
case "json":
return JSONFormat;
case "xml":
return XMLFormat;
/*
* Control Tags.
*/
case FormatBuilder.ForegroundColorTag:
case FormatBuilder.BackgroundColorTag:
// Replace the LogLevel colour with this colour.
return string.Equals(
chunk.Format,
LogLevelColorName,
StringComparison.InvariantCultureIgnoreCase)
// Don't cache the response as it is format dependant.
? new Resolution(_level.ToColor(), true)
: Resolution.UnknownYet;
/*
* Log element completion.
*/
case FormatTagHeader:
// Create a header based on the format pattern.
// Get the width of the writer, for creating headers.
int width = Math.Min(256, context.Layout.Width.Value - context.Layout.FirstLineIndentSize.Value);
string pattern = chunk.Format;
if (string.IsNullOrEmpty(pattern))
pattern = "=";
bool startNewLine = context.Position > 0;
char[] header = new char[width + (startNewLine ? 2 : 1)];
int c = 0;
if (startNewLine)
header[c++] = '\r'; // Formatter normalizes '\r' to newline automatically.
for (int p = 0; p < width; p++)
header[c++] = pattern[p % pattern.Length];
header[c] = '\r';
// We have to replace the original chunk with a non-control chunk for it to to be output.
// Set NoCache to true to support format changes.
return new Resolution(new FormatChunk(new string(header)), true);
case FormatTagMessage:
return new LogElement(
() => Resources.LogKeys_Message,
GetMessage(culture));
case FormatTagResource:
return string.IsNullOrWhiteSpace(_resourceProperty)
? Resolution.Null
: new LogElement(
() => Resources.LogKeys_Resource,
_resourceProperty);
case FormatTagCulture:
return new LogElement(
() => Resources.LogKeys_Culture,
culture);
case FormatTagTimeStamp:
return new LogElement(
() => Resources.LogKeys_TimeStamp,
((CombGuid)_guid).Created);
case FormatTagLevel:
return new LogElement(
() => Resources.LogKeys_Level,
_level);
case FormatTagGuid:
return new LogElement(
() => Resources.LogKeys_Guid,
_guid);
case FormatTagException:
return string.IsNullOrWhiteSpace(_exceptionType)
? Resolution.Null
: new LogElement(
() => Resources.LogKeys_Exception,
_exceptionType);
case FormatTagThreadID:
return _threadID < 0
? Resolution.Null
: new LogElement(
() => Resources.LogKeys_ThreadID,
_threadID);
case FormatTagThreadName:
return string.IsNullOrWhiteSpace(_threadName)
? Resolution.Null
: new LogElement(
() => Resources.LogKeys_ThreadName,
_threadName);
case FormatTagApplicationName:
return string.IsNullOrWhiteSpace(ApplicationName)
? Resolution.Null
: new LogElement(
() => Resources.LogKeys_ApplicationName,
ApplicationName);
case FormatTagApplicationGuid:
return new LogElement(
() => Resources.LogKeys_ApplicationGuid,
ApplicationGuid);
case FormatTagInnerException:
if ((_innerExceptionGuids == null) ||
(_innerExceptionGuids.Length < 1)) return Resolution.Null;
return new LogEnumerableElement(
() => Resources.LogKeys_InnerException,
_innerExceptionGuids.Cast<object>());
case FormatTagStoredProcedure:
// TODO This can be a specialized LogElement!
return string.IsNullOrWhiteSpace(_storedProcedure)
? Resolution.Null
: new LogElement(
() => Resources.LogKeys_StoredProcedure,
_storedProcedure + " at line " + _storedProcedureLine.ToString("D"));
case FormatTagContext:
return (_context == null) ||
(_context.Count < 1)
? Resolution.Null
: _context;
case FormatTagStackTrace:
return string.IsNullOrWhiteSpace(_stackTrace)
? Resolution.Null
: new LogElement(
() => Resources.LogKeys_StackTrace,
_stackTrace);
default:
return Resolution.Unknown;
}
}
/// <summary> /// Resolves the specified tag. /// </summary> /// <param name="context">The context.</param> /// <param name="chunk">The chunk.</param> /// <returns>An object that will be cached unless it is a <see cref="Resolution" />.</returns> public abstract object Resolve(FormatWriteContext context, FormatChunk chunk);
/// <summary>
/// Resolves the specified tag.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="chunk">The chunk.</param>
/// <returns>An object that will be cached unless it is a <see cref="T:WebApplications.Utilities.Formatting.Resolution" />.</returns>
public override object Resolve(FormatWriteContext context, FormatChunk chunk)
{
string key;
// ReSharper disable once PossibleNullReferenceException
switch (chunk.Tag.ToLowerInvariant())
{
case "default":
case "verbose":
return EnumerableElementVerboseFormat;
case "xml":
return EnumerableElementXMLFormat;
case "json":
return EnumerableElementJSONFormat;
case "noline":
return EnumerableElementNoLineFormat;
case "key":
key = Translation.GetResource(
Resource,
context.FormatProvider as CultureInfo ?? Translation.DefaultCulture);
return string.IsNullOrEmpty(key)
? Resolution.Null
: key;
case "keyxml":
key = Translation.GetResource(
Resource,
context.FormatProvider as CultureInfo ?? Translation.DefaultCulture);
return string.IsNullOrEmpty(key)
? Resolution.Null
: key.XmlEscape();
case "keyxmltag":
key = Translation.GetResource(
Resource,
context.FormatProvider as CultureInfo ?? Translation.DefaultCulture);
return string.IsNullOrEmpty(key)
? Resolution.Null
: key.Replace(' ', '_');
case "value":
return Values;
case "valuexml":
return Values.Select(v => v != null ? v.XmlEscape() : null);
default:
return Resolution.Unknown;
}
}
/// <summary> /// Resolves the specified tag. /// </summary> /// <param name="context">The context.</param> /// <param name="chunk">The chunk.</param> /// <returns>An object that will be cached unless it is a <see cref="Resolution" />.</returns> public abstract object Resolve(FormatWriteContext context, FormatChunk chunk);
/// <summary>
/// Resolves the specified tag.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="chunk">The chunk.</param>
/// <returns>A <see cref="Resolution" />.</returns>
// ReSharper disable once CodeAnnotationAnalyzer
public override object Resolve(FormatWriteContext context, FormatChunk chunk)
{
Resolution resolution;
// ReSharper disable once PossibleNullReferenceException
string tag = chunk.Tag;
Debug.Assert(tag != null);
if (ResolveControls || !chunk.IsControl)
{
if ((_values == null || !_values.TryGetValue(tag, out resolution)))
{
// Get the resolution using the resolver.
object result = _resolver(context, chunk);
resolution = result as Resolution? ?? new Resolution(result);
if (!resolution.NoCache)
{
// Cache the resolution.
if (_values == null)
_values =
new Dictionary<string, Resolution>(
IsCaseSensitive
? StringComparer.CurrentCulture
: StringComparer.CurrentCultureIgnoreCase);
// ReSharper disable once AssignNullToNotNullAttribute
_values[tag] = resolution;
}
}
}
else
resolution = (Resolution)Resolution.Unknown;
// If we don't have a resolution, ask the parent.
if (!resolution.IsResolved &&
ResolveOuterTags &&
Parent != null)
// ReSharper disable once PossibleNullReferenceException
resolution = (Resolution)Parent.Resolve(context, chunk);
return resolution;
}
internal FormatChunk Append([NotNull] string value, [CanBeNull] IResolvable resolver = null)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
string tag = null;
string alignment = null;
string format = null;
Stack <FormatChunk> chunks = new Stack <FormatChunk>();
FormatChunk chunk = this;
StringBuilder builder = new StringBuilder(value.Length);
ParserState state = ParserState.Value;
int i = 0;
while (i < value.Length)
{
char c = value[i++];
// Un-escape
if (c == '\\' &&
(i < value.Length))
{
builder.Append(value[i++]);
continue;
}
bool gotFillPoint = false;
switch (state)
{
case ParserState.Tag:
switch (c)
{
case FormatBuilder.AlignmentChar:
state = ParserState.Alignment;
break;
case FormatBuilder.FormatChar:
state = ParserState.Format;
break;
case FormatBuilder.CloseChar:
state = ParserState.Value;
gotFillPoint = true;
break;
default:
builder.Append(c);
break;
}
if (state != ParserState.Tag)
{
// We've got a tag
tag = builder.ToString();
builder.Clear();
}
break;
case ParserState.Alignment:
switch (c)
{
case FormatBuilder.FormatChar:
state = ParserState.Format;
break;
case FormatBuilder.CloseChar:
state = ParserState.Value;
gotFillPoint = true;
break;
default:
builder.Append(c);
break;
}
if (state != ParserState.Alignment)
{
// We've got an alignment
alignment = builder.ToString();
builder.Clear();
}
break;
case ParserState.Format:
switch (c)
{
case FormatBuilder.OpenChar:
if (i >= value.Length || value[i] == FormatBuilder.OpenChar)
{
builder.Append(FormatBuilder.OpenChar);
i++;
break;
}
// We have a nested format!
Debug.Assert(tag != null);
FormatChunk newChunk = new FormatChunk(
chunks.Count < 1 ? resolver : null,
tag,
alignment,
null);
tag = null;
alignment = null;
if (builder.Length > 0)
{
Debug.Assert(newChunk.ChildrenInternal == null);
newChunk.AppendChunk(new FormatChunk(builder.ToString()));
builder.Clear();
}
chunk.AppendChunk(newChunk);
chunks.Push(chunk);
chunk = newChunk;
state = ParserState.Tag;
break;
case FormatBuilder.CloseChar:
state = ParserState.Value;
gotFillPoint = true;
format = builder.ToString();
builder.Clear();
break;
default:
builder.Append(c);
break;
}
break;
default:
switch (c)
{
case FormatBuilder.OpenChar:
if (i >= value.Length || value[i] == FormatBuilder.OpenChar)
{
builder.Append(FormatBuilder.OpenChar);
i++;
break;
}
state = ParserState.Tag;
// We've got a value
if (builder.Length > 0)
{
chunk.AppendChunk(new FormatChunk(builder.ToString()));
builder.Clear();
}
break;
case FormatBuilder.CloseChar:
state = ParserState.Value;
if (chunks.Count > 0)
{
// Closing a nest fill point.
if (builder.Length > 0)
{
chunk.AppendChunk(new FormatChunk(builder.ToString()));
builder.Clear();
}
chunk = chunks.Pop();
Debug.Assert(chunk != null);
}
else
{
builder.Append(c);
}
break;
default:
builder.Append(c);
break;
}
break;
}
if (gotFillPoint)
{
Debug.Assert(tag != null);
FormatChunk newChunk = new FormatChunk(
chunks.Count < 1 ? resolver : null,
tag,
alignment,
format);
chunk.AppendChunk(newChunk);
tag = null;
alignment = null;
format = null;
}
}
if (builder.Length <= 0)
{
return(this);
}
// We have some left overs
string v = builder.ToString();
builder.Clear();
if (tag != null)
{
builder.Append(FormatBuilder.OpenChar).Append(tag);
}
if (alignment != null)
{
builder.Append(FormatBuilder.AlignmentChar).Append(alignment);
}
if (builder.Length < 1)
{
chunk.AppendChunk(new FormatChunk(v));
}
else
{
builder.Append(FormatBuilder.FormatChar).Append(v);
chunk.AppendChunk(new FormatChunk(builder.ToString()));
}
return(this);
}
/// <summary> /// Resolves the specified tag. /// </summary> /// <param name="context">The context.</param> /// <param name="chunk">The chunk.</param> /// <returns>A <see cref="Resolution" />.</returns> // ReSharper disable once CodeAnnotationAnalyzer public override object Resolve(FormatWriteContext context, FormatChunk chunk) => _resolver(context, chunk);
/// <summary> /// Resolves the specified tag. /// </summary> /// <param name="context">The context.</param> /// <param name="chunk">The chunk.</param> /// <returns>A <see cref="Resolution" />.</returns> // ReSharper disable once CodeAnnotationAnalyzer public override object Resolve(FormatWriteContext context, FormatChunk chunk) => _resolver(context, chunk);
internal FormatChunk Append([NotNull] string value, [CanBeNull] IResolvable resolver = null)
{
if (value == null) throw new ArgumentNullException("value");
string tag = null;
string alignment = null;
string format = null;
Stack<FormatChunk> chunks = new Stack<FormatChunk>();
FormatChunk chunk = this;
StringBuilder builder = new StringBuilder(value.Length);
ParserState state = ParserState.Value;
int i = 0;
while (i < value.Length)
{
char c = value[i++];
// Un-escape
if (c == '\\' &&
(i < value.Length))
{
builder.Append(value[i++]);
continue;
}
bool gotFillPoint = false;
switch (state)
{
case ParserState.Tag:
switch (c)
{
case FormatBuilder.AlignmentChar:
state = ParserState.Alignment;
break;
case FormatBuilder.FormatChar:
state = ParserState.Format;
break;
case FormatBuilder.CloseChar:
state = ParserState.Value;
gotFillPoint = true;
break;
default:
builder.Append(c);
break;
}
if (state != ParserState.Tag)
{
// We've got a tag
tag = builder.ToString();
builder.Clear();
}
break;
case ParserState.Alignment:
switch (c)
{
case FormatBuilder.FormatChar:
state = ParserState.Format;
break;
case FormatBuilder.CloseChar:
state = ParserState.Value;
gotFillPoint = true;
break;
default:
builder.Append(c);
break;
}
if (state != ParserState.Alignment)
{
// We've got an alignment
alignment = builder.ToString();
builder.Clear();
}
break;
case ParserState.Format:
switch (c)
{
case FormatBuilder.OpenChar:
// We have a nested format!
Debug.Assert(tag != null);
FormatChunk newChunk = new FormatChunk(
chunks.Count < 1 ? resolver : null,
tag,
alignment,
null);
tag = null;
alignment = null;
if (builder.Length > 0)
{
Debug.Assert(newChunk.ChildrenInternal == null);
newChunk.AppendChunk(new FormatChunk(builder.ToString()));
builder.Clear();
}
chunk.AppendChunk(newChunk);
chunks.Push(chunk);
chunk = newChunk;
state = ParserState.Tag;
break;
case FormatBuilder.CloseChar:
state = ParserState.Value;
gotFillPoint = true;
format = builder.ToString();
builder.Clear();
break;
default:
builder.Append(c);
break;
}
break;
default:
switch (c)
{
case FormatBuilder.OpenChar:
state = ParserState.Tag;
// We've got a value
if (builder.Length > 0)
{
chunk.AppendChunk(new FormatChunk(builder.ToString()));
builder.Clear();
}
break;
case FormatBuilder.CloseChar:
state = ParserState.Value;
if (chunks.Count > 0)
{
// Closing a nest fill point.
if (builder.Length > 0)
{
chunk.AppendChunk(new FormatChunk(builder.ToString()));
builder.Clear();
}
chunk = chunks.Pop();
Debug.Assert(chunk != null);
}
else
builder.Append(c);
break;
default:
builder.Append(c);
break;
}
break;
}
if (gotFillPoint)
{
Debug.Assert(tag != null);
FormatChunk newChunk = new FormatChunk(
chunks.Count < 1 ? resolver : null,
tag,
alignment,
format);
chunk.AppendChunk(newChunk);
tag = null;
alignment = null;
format = null;
}
}
if (builder.Length <= 0) return this;
// We have some left overs
string v = builder.ToString();
builder.Clear();
if (tag != null)
builder.Append(FormatBuilder.OpenChar).Append(tag);
if (alignment != null)
builder.Append(FormatBuilder.AlignmentChar).Append(alignment);
if (builder.Length < 1)
chunk.AppendChunk(new FormatChunk(v));
else
{
builder.Append(FormatBuilder.FormatChar).Append(v);
chunk.AppendChunk(new FormatChunk(builder.ToString()));
}
return this;
}
public static IEnumerable<FormatChunk> Parse([NotNull] string value, [CanBeNull] IResolvable resolver = null)
{
if (value == null) throw new ArgumentNullException("value");
FormatChunk fc = new FormatChunk();
fc.Append(
value,
resolver);
return fc.Children;
}
/// <summary>
/// Performs a deep copy of the child chunks from <paramref name="source"/> to <paramref name="destination"/>.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="destination">The destination.</param>
internal static void DeepCopyChunks([NotNull] FormatChunk source, [NotNull] FormatChunk destination)
{
if (source == null) throw new ArgumentNullException("source");
if (destination == null) throw new ArgumentNullException("destination");
if (source.ChildrenInternal != null &&
source.ChildrenInternal.Count > 0)
{
Stack<FormatChunk, IEnumerable<FormatChunk>> stack = new Stack<FormatChunk, IEnumerable<FormatChunk>>();
stack.Push(destination, source.ChildrenInternal.ToArray());
while (stack.Count > 0)
{
FormatChunk currParent;
IEnumerable<FormatChunk> chunks;
stack.Pop(out currParent, out chunks);
Debug.Assert(currParent != null);
Debug.Assert(chunks != null);
// ReSharper disable once PossibleNullReferenceException
currParent.ChildrenInternal = new List<FormatChunk>();
// Adds each chunk to the current parent
// ReSharper disable once PossibleNullReferenceException
foreach (FormatChunk child in chunks)
{
Debug.Assert(child != null);
FormatChunk newChunk = new FormatChunk(
child.Resolver,
child.Tag,
child.Alignment,
child.Format,
child.IsResolved,
child.Value,
child.IsControl);
currParent.ChildrenInternal.Add(newChunk);
// If the chunk has any children they need to be added to the new chunk
if (child.ChildrenInternal != null &&
child.ChildrenInternal.Count >= 1)
stack.Push(newChunk, child.ChildrenInternal);
}
}
}
}
/// <summary>
/// Resolves the specified tag.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="chunk">The chunk.</param>
/// <returns>An object that will be cached unless it is a <see cref="T:WebApplications.Utilities.Formatting.Resolution" />.</returns>
// ReSharper disable once CodeAnnotationAnalyzer
public override object Resolve(FormatWriteContext context, FormatChunk chunk)
{
// ReSharper disable once PossibleNullReferenceException
switch (chunk.Tag.ToLowerInvariant())
{
case "default":
case "verbose":
return ElementVerboseFormat;
case "xml":
return ElementXMLFormat;
case "json":
return ElementJSONFormat;
case "noline":
return ElementNoLineFormat;
case "key":
return Key;
case "keyxml":
return Key.XmlEscape();
case "keyxmltag":
return Key.Replace(' ', '_');
case "value":
return Value;
case "valuexml":
return Value.XmlEscape();
case "valuejson":
return Value == null ? "null" : Value.ToJSON();
default:
return Resolution.Unknown;
}
}
/// <summary>
/// Resolves the specified tag.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="chunk">The chunk.</param>
/// <returns>An object that will be cached unless it is a <see cref="T:WebApplications.Utilities.Formatting.Resolution" />.</returns>
// ReSharper disable once CodeAnnotationAnalyzer
public override object Resolve(FormatWriteContext context, FormatChunk chunk)
{
// ReSharper disable once PossibleNullReferenceException
switch (chunk.Tag.ToLowerInvariant())
{
case "default":
case "verbose":
return ElementVerboseFormat;
case "xml":
return ElementXMLFormat;
case "json":
return ElementJSONFormat;
case "jsonfirst":
return ElementJSONFirstFormat;
case "noline":
return ElementNoLineFormat;
case "key":
string key = Translation.GetResource(
Resource,
context.FormatProvider as CultureInfo ?? Translation.DefaultCulture);
return string.IsNullOrEmpty(key)
? Resolution.Null
: key;
case "keyxml":
string keyXml = Translation.GetResource(
Resource,
context.FormatProvider as CultureInfo ?? Translation.DefaultCulture);
return string.IsNullOrEmpty(keyXml)
? Resolution.Null
: keyXml.XmlEscape();
case "keyxmltag":
string keyXmlTag = Translation.GetResource(
Resource,
context.FormatProvider as CultureInfo ?? Translation.DefaultCulture);
return string.IsNullOrEmpty(keyXmlTag)
? Resolution.Null
: keyXmlTag.Replace(' ', '_');
case "value":
return Value;
case "valuexml":
return Value == null ? Resolution.Null : Value.XmlEscape();
case "valuejson":
return Value == null ? "null" : Value.ToString().ToJSON();
default:
return Resolution.Unknown;
}
}
