private static IMarkdownToken GroupTextTokens(IMarkdownParser parser, IMarkdownRule rule, bool wrapParagraph, StringBuffer textContent, SourceInfo si)
{
if (textContent.EndsWith('\n'))
{
textContent = textContent.Substring(0, textContent.GetLength() - 1);
}
var rawMarkdown = textContent.ToString();
return CreateTwoPhaseToken(parser, rule, wrapParagraph, si.Copy(rawMarkdown));
}
public StringBuffer Concat(StringBuffer another)
{
if (another == Empty || another == null)
{
return this;
}
if (this == Empty)
{
return another;
}
if (another._index > ShrinkArrayLength)
{
var result = EnsureCapacity(1);
result._buffer[result._index++] = another.ToString();
return result;
}
else
{
var result = EnsureCapacity(another._index);
Array.Copy(another._buffer, 0, result._buffer, result._index, another._index);
result._index += another._index;
return result;
}
}
/// <summary>
/// Concat another string buffer. (Create new instance if self is <see cref="Empty"/>, otherwise, modify self).
/// </summary>
/// <param name="another">The string buffer.</param>
/// <returns>The string buffer.</returns>
public StringBuffer Concat(StringBuffer another)
{
if (another == Empty || another == null)
{
return(this);
}
if (this == Empty)
{
return(another);
}
if (another._index > ShrinkArrayLength)
{
var result = EnsureCapacity(1);
result._buffer[result._index++] = another.ToString();
return(result);
}
else
{
var result = EnsureCapacity(another._index);
Array.Copy(another._buffer, 0, result._buffer, result._index, another._index);
result._index += another._index;
return(result);
}
}
public StringBuffer Clone()
{
if (this == Empty)
{
return this;
}
var result = new StringBuffer(_index + MinArrayLength);
Array.Copy(_buffer, result._buffer, _index);
result._index = _index;
return result;
}
public StringBuffer Substring(int startIndex, int maxCount)
{
if (startIndex < 0)
{
throw new ArgumentOutOfRangeException(nameof(startIndex));
}
if (maxCount < 0)
{
throw new ArgumentOutOfRangeException(nameof(maxCount));
}
if (maxCount == 0)
{
return Empty;
}
var result = new StringBuffer(_buffer.Length);
int skipCount = startIndex;
int copyCount = maxCount;
for (int i = 0; i < _index; i++)
{
if (skipCount > 0)
{
if (skipCount < _buffer[i].Length)
{
result._index = 1;
if (_buffer[i].Length - skipCount > copyCount)
{
result._buffer[0] = _buffer[i].Substring(skipCount, copyCount);
return result;
}
else
{
result._buffer[0] = _buffer[i].Substring(skipCount);
copyCount -= result._buffer[0].Length;
}
}
skipCount -= _buffer[i].Length;
}
else
{
if (copyCount > _buffer[i].Length)
{
result._buffer[result._index++] = _buffer[i];
copyCount -= _buffer[i].Length;
}
else
{
result._buffer[result._index++] = copyCount == _buffer[i].Length ? _buffer[i] : _buffer[i].Remove(copyCount);
return result;
}
}
}
if (skipCount > 0)
{
throw new ArgumentOutOfRangeException(nameof(startIndex));
}
return result;
}
private static IMarkdownToken GroupTextTokens(IMarkdownParser parser, IMarkdownRule rule, bool wrapParagraph, StringBuffer textContent, SourceInfo si)
{
if (textContent.EndsWith('\n'))
{
textContent = textContent.Substring(0, textContent.GetLength() - 1);
}
var rawMarkdown = textContent.ToString();
return(CreateTwoPhaseToken(parser, rule, wrapParagraph, si.Copy(rawMarkdown)));
}
protected virtual StringBuffer ApplyInline(IMarkdownRenderer engine, StringBuffer content, MarkdownBlockContext context)
{
if (content == StringBuffer.Empty)
{
return StringBuffer.Empty;
}
var result = engine.Engine.Mark(content.ToString(), context.GetInlineContext());
return result;
}
private StringBuffer RenderTextInTokens(IMarkdownRenderer renderer, MarkdownBlockContext context, bool wrapParagraph, IMarkdownRule rule, StringBuffer textContent, string rawMarkdown)
{
if (wrapParagraph)
{
var parser = renderer.Engine.Parser;
var c = parser.SwitchContext(context);
var inlineContent = parser.TokenizeInline(textContent);
parser.SwitchContext(c);
return Render(renderer, new MarkdownParagraphBlockToken(rule, context, inlineContent, rawMarkdown), context);
}
else
{
return ApplyInline(renderer, textContent, context);
}
}
private static StringBuffer AppendSourceInfoCore(StringBuffer result, IMarkdownToken token)
{
return(result + " sourceFile=\"" + StringHelper.HtmlEncode(token.SourceInfo.File) + "\" sourceStartLineNumber=\"" + token.SourceInfo.LineNumber.ToString() + "\" sourceEndLineNumber=\"" + (token.SourceInfo.LineNumber + token.SourceInfo.ValidLineCount - 1).ToString() + "\"");
}
protected StringBuffer Insert(int startLineNumber, int endLineNumber, StringBuffer name, StringBuffer tokenContent = null)
{
StringBuffer result = $"{{\"name\":\"{startLineNumber}>{endLineNumber}>{name}\"";
if (tokenContent != null)
{
// If tokenContent is not empty ,should remove the last character(',')
if (tokenContent.EndsWith(','))
{
// TODO: add a method 'remove' of StringBuffer
string contentTemp = tokenContent;
tokenContent = contentTemp.Remove(contentTemp.Length - 1);
}
result += $",\"children\":[{tokenContent}]";
}
result += "},";
return(result);
}
private StringBuffer RenderTextInTokens(IMarkdownRenderer renderer, MarkdownBlockContext context, bool wrapParagraph, IMarkdownRule rule, StringBuffer textContent, string rawMarkdown)
{
if (wrapParagraph)
{
var parser = renderer.Engine.Parser;
var c = parser.SwitchContext(context);
var inlineContent = parser.TokenizeInline(textContent);
parser.SwitchContext(c);
return(Render(renderer, new MarkdownParagraphBlockToken(rule, context, inlineContent, rawMarkdown), context));
}
else
{
return(ApplyInline(renderer, textContent, context));
}
}
protected virtual StringBuffer ApplyInline(MarkdownEngine engine, StringBuffer content, MarkdownBlockContext context)
{
if (content == StringBuffer.Empty)
{
return StringBuffer.Empty;
}
var c = engine.SwitchContext(context.InlineContext);
var result = engine.Mark(content.ToString());
engine.SwitchContext(c);
return result;
}
private StringBuffer RenderTextInTokens(MarkdownEngine engine, MarkdownBlockContext context, bool wrapParagraph, IMarkdownRule rule, StringBuffer textContent)
{
if (wrapParagraph)
{
return Render(engine, new MarkdownParagraphBlockToken(rule, textContent), context);
}
else
{
return ApplyInline(engine, textContent, context);
}
}
private StringBuffer RenderTextInTokens(IMarkdownRenderer engine, MarkdownBlockContext context, bool wrapParagraph, IMarkdownRule rule, StringBuffer textContent, string rawMarkdown)
{
if (wrapParagraph)
{
return(Render(engine, new MarkdownParagraphBlockToken(rule, context, engine.Engine.Parser.TokenizeInline(textContent), rawMarkdown), context));
}
else
{
return(ApplyInline(engine, textContent, context));
}
}
private StringBuffer RenderTextInTokens(MarkdownEngine engine, MarkdownBlockContext context, bool wrapParagraph, IMarkdownRule rule, StringBuffer textContent)
{
if (wrapParagraph)
{
return(Render(engine, new MarkdownParagraphBlockToken(rule, textContent), context));
}
else
{
return(ApplyInline(engine, textContent, context));
}
}
private static StringBuffer AppendAttribute(StringBuffer buffer, string attributeName, string value)
{
if (string.IsNullOrEmpty(value)) return buffer;
buffer += " ";
buffer += attributeName;
buffer += "=\"";
buffer += StringHelper.HtmlEncode(value);
buffer += "\"";
return buffer;
}
