/// <summary>
/// Inserts the specified inline after this instance.
/// </summary>
/// <param name="next">The inline to insert after this instance.</param>
/// <exception cref="System.ArgumentNullException"></exception>
/// <exception cref="System.ArgumentException">Inline has already a parent</exception>
public void InsertAfter(Inline next)
{
if (next == null)
{
ThrowHelper.ArgumentNullException(nameof(next));
}
if (next.Parent != null)
{
ThrowHelper.ArgumentException("Inline has already a parent", nameof(next));
}
var previousNext = NextSibling;
if (previousNext != null)
{
previousNext.PreviousSibling = next;
}
next.PreviousSibling = this;
next.NextSibling = previousNext;
NextSibling = next;
if (Parent != null)
{
Parent.OnChildInsert(next);
next.Parent = Parent;
}
}
public static IntPtr ImportMethod(IntPtr moduleHandle, string methodName)
{
if (moduleHandle == IntPtr.Zero)
{
throw ThrowHelper.ArgumentOutOfRangeException(nameof(moduleHandle));
}
if (methodName == null)
{
throw ThrowHelper.ArgumentNullException(nameof(methodName));
}
if (methodName.Length == 0)
{
throw ThrowHelper.ArgumentOutOfRangeException(nameof(methodName));
}
IntPtr procAddress = GetProcAddress(moduleHandle, methodName);
if (procAddress == IntPtr.Zero)
{
throw new DynamicImportException($"DynamicImport failed to find method \"{ methodName }\" in module \"0x{ moduleHandle.ToString("X") }\"!");
}
else
{
return(procAddress);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MarkdownParser" /> class.
/// </summary>
/// <param name="text">The reader.</param>
/// <param name="pipeline">The pipeline.</param>
/// <param name="context">A parser context used for the parsing.</param>
/// <exception cref="System.ArgumentNullException">
/// </exception>
private MarkdownParser(string text, MarkdownPipeline pipeline, MarkdownParserContext context)
{
if (text == null)
{
ThrowHelper.ArgumentNullException_text();
}
if (pipeline == null)
{
ThrowHelper.ArgumentNullException(nameof(pipeline));
}
roughLineCountEstimate = text.Length / 40;
text = FixupZero(text);
lineReader = new LineReader(text);
preciseSourceLocation = pipeline.PreciseSourceLocation;
// Initialize the pipeline
document = new MarkdownDocument();
// Initialize the block parsers
blockProcessor = new BlockProcessor(document, pipeline.BlockParsers, context);
// Initialize the inline parsers
inlineProcessor = new InlineProcessor(document, pipeline.InlineParsers, pipeline.PreciseSourceLocation, context)
{
DebugLog = pipeline.DebugLog
};
documentProcessed = pipeline.DocumentProcessed;
}
/// <summary>
/// Creates a pipeline automatically configured from an input markdown based on the presence of the configuration tag.
/// </summary>
/// <param name="inputText">The input text.</param>
/// <returns>The pipeline configured from the input</returns>
/// <exception cref="ArgumentNullException"></exception>
public MarkdownPipeline CreatePipelineFromInput(string inputText)
{
if (inputText == null)
{
ThrowHelper.ArgumentNullException(nameof(inputText));
}
var builder = new MarkdownPipelineBuilder();
string defaultConfig = DefaultExtensions;
var indexOfSelfPipeline = inputText.IndexOf(SelfPipelineHintTagStart, StringComparison.OrdinalIgnoreCase);
if (indexOfSelfPipeline >= 0)
{
var optionStart = indexOfSelfPipeline + SelfPipelineHintTagStart.Length;
var endOfTag = inputText.IndexOf("-->", optionStart, StringComparison.OrdinalIgnoreCase);
if (endOfTag >= 0)
{
defaultConfig = inputText.Substring(optionStart, endOfTag - optionStart).Trim();
}
}
if (!string.IsNullOrEmpty(defaultConfig))
{
builder.Configure(defaultConfig);
}
return(builder.Build());
}
/// <summary>
/// Inserts the specified inline before this instance.
/// </summary>
/// <param name="previous">The inline previous to insert before this instance.</param>
/// <exception cref="System.ArgumentNullException"></exception>
/// <exception cref="System.ArgumentException">Inline has already a parent</exception>
public void InsertBefore(Inline previous)
{
if (previous == null)
{
ThrowHelper.ArgumentNullException(nameof(previous));
}
if (previous.Parent != null)
{
ThrowHelper.ArgumentException("Inline has already a parent", nameof(previous));
}
var previousSibling = PreviousSibling;
if (previousSibling != null)
{
previousSibling.NextSibling = previous;
}
PreviousSibling = previous;
previous.NextSibling = this;
if (Parent != null)
{
Parent.OnChildInsert(previous);
previous.Parent = Parent;
}
}
public static IntPtr ImportLibrary(string libraryName)
{
if (libraryName == null)
{
throw ThrowHelper.ArgumentNullException(nameof(libraryName));
}
if (libraryName.Length == 0)
{
throw ThrowHelper.ArgumentOutOfRangeException(nameof(libraryName));
}
IntPtr hModule = GetModuleHandle(libraryName);
if (hModule == IntPtr.Zero)
{
hModule = LoadLibrary(libraryName);
}
if (hModule == IntPtr.Zero)
{
throw new DynamicImportException($"DynamicImport failed to import library \"{ libraryName }\"!");
}
else
{
return(hModule);
}
}
public void Sort(Comparison <Block> comparison)
{
if (comparison == null)
{
ThrowHelper.ArgumentNullException(nameof(comparison));
}
Array.Sort(children, 0, Count, new BlockComparer(comparison));
}
public void Sort(IComparer <Block> comparer)
{
if (comparer == null)
{
ThrowHelper.ArgumentNullException(nameof(comparer));
}
Array.Sort(children, 0, Count, comparer);
}
public void Sort(IComparer <Block> comparer)
{
if (comparer is null)
{
ThrowHelper.ArgumentNullException(nameof(comparer));
}
Array.Sort(_children, 0, Count, new BlockComparerWrapper(comparer));
}
protected DelimiterInline(InlineParser parser)
{
if (parser == null)
{
ThrowHelper.ArgumentNullException(nameof(parser));
}
Parser = parser;
IsActive = true;
}
public Enumerator(ContainerInline container) : this()
{
if (container == null)
{
ThrowHelper.ArgumentNullException(nameof(container));
}
this.container = container;
currentChild = nextChild = container.FirstChild;
}
/// <summary>
/// Sets all pins to low level.
/// </summary>
/// <param name="expander">Object of type IGpioExpander.</param>
/// <exception cref="ArgumentNullException">Object of type IGpioExpander is null.</exception>
public static void DigitalPortLowLevel(this GpioExpander expander)
{
if (expander is null)
{
throw ThrowHelper.ArgumentNullException(nameof(expander));
}
expander.DigitalWritePort(0);
}
/// <summary>
/// Fixes click of the TroykaButton.
/// </summary>
/// <param name="expander">Object of type IGpioExpander.</param>
/// <param name="pin">Pin number.</param>
/// <returns>True - click, False - not click.</returns>
/// <exception cref="ArgumentNullException">Object of type IGpioExpander is null.</exception>
public static bool TroykaButtonClick(this GpioExpander expander, int pin)
{
if (expander is null)
{
throw ThrowHelper.ArgumentNullException(nameof(expander));
}
return(!expander.DigitalRead(pin));
}
/// <summary>
/// Initializes a new instance of the <see cref="EmphasisDelimiterInline" /> class.
/// </summary>
/// <param name="parser">The parser.</param>
/// <param name="descriptor">The descriptor.</param>
/// <exception cref="ArgumentNullException"></exception>
public EmphasisDelimiterInline(InlineParser parser, EmphasisDescriptor descriptor) : base(parser)
{
if (descriptor is null)
{
ThrowHelper.ArgumentNullException(nameof(descriptor));
}
Descriptor = descriptor;
DelimiterChar = descriptor.Character;
}
/// <summary>
/// Allows to setup a <see cref="IMarkdownRenderer"/>.
/// </summary>
/// <param name="renderer">The markdown renderer to setup</param>
public void Setup(IMarkdownRenderer renderer)
{
if (renderer is null)
{
ThrowHelper.ArgumentNullException(nameof(renderer));
}
foreach (var extension in Extensions)
{
extension.Setup(this, renderer);
}
}
/// <summary>
/// Opens the specified block.
/// </summary>
/// <param name="block">The block.</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException">The block must be opened</exception>
public void Open(Block block)
{
if (block == null)
{
ThrowHelper.ArgumentNullException(nameof(block));
}
if (!block.IsOpen)
{
ThrowHelper.ArgumentException("The block must be opened", nameof(block));
}
OpenedBlocks.Add(block);
}
/// <summary>
/// Create a <see cref="IHostProvider"/> with delegate handler.
/// </summary>
/// <param name="hostPrefix">Prefix of host that can be handled.</param>
/// <param name="handler">Handler that generate iframe url, if uri cannot be handled, it can return <see langword="null"/>.</param>
/// <param name="allowFullScreen">Should the generated iframe has allowfullscreen attribute.</param>
/// <param name="iframeClass">"class" attribute of generated iframe.</param>
/// <returns>A <see cref="IHostProvider"/> with delegate handler.</returns>
public static IHostProvider Create(string hostPrefix, Func <Uri, string?> handler, bool allowFullScreen = true, string?iframeClass = null)
{
if (string.IsNullOrEmpty(hostPrefix))
{
ThrowHelper.ArgumentException("hostPrefix is null or empty.", nameof(hostPrefix));
}
if (handler is null)
{
ThrowHelper.ArgumentNullException(nameof(handler));
}
return(new DelegateProvider(hostPrefix, handler, allowFullScreen, iframeClass));
}
public static GpioExpander GetGpioExpander(this I2cBus bus, int address = GpioExpander.DefaultAddress)
{
if (bus is null)
{
throw ThrowHelper.ArgumentNullException(nameof(bus));
}
if (address is < 0 or > 127)
{
throw ThrowHelper.ArgumentOutOfRangeException(nameof(address), address);
}
return(new RaspberryPiExpander(bus.CreateDevice(address)));
}
public void Set(string label, LinkReferenceDefinition link)
{
if (link == null)
{
ThrowHelper.ArgumentNullException(nameof(link));
}
if (!Contains(link))
{
Add(link);
if (!Links.ContainsKey(label))
{
Links[label] = link;
}
}
}
// This class is immutable
/// <summary>
/// Initializes a new instance of the <see cref="MarkdownPipeline" /> class.
/// </summary>
internal MarkdownPipeline(OrderedList <IMarkdownExtension> extensions, BlockParserList blockParsers, InlineParserList inlineParsers, TextWriter debugLog, ProcessDocumentDelegate documentProcessed)
{
if (blockParsers == null)
{
ThrowHelper.ArgumentNullException(nameof(blockParsers));
}
if (inlineParsers == null)
{
ThrowHelper.ArgumentNullException(nameof(inlineParsers));
}
// Add all default parsers
Extensions = extensions;
BlockParsers = blockParsers;
InlineParsers = inlineParsers;
DebugLog = debugLog;
DocumentProcessed = documentProcessed;
}
/// <summary>
/// Converts a Markdown document to HTML.
/// </summary>
/// <param name="document">A Markdown document.</param>
/// <param name="pipeline">The pipeline used for the conversion.</param>
/// <returns>The result of the conversion</returns>
/// <exception cref="ArgumentNullException">if markdown document variable is null</exception>
public static string ToHtml(this MarkdownDocument document, MarkdownPipeline?pipeline = null)
{
if (document is null)
{
ThrowHelper.ArgumentNullException(nameof(document));
}
pipeline ??= DefaultPipeline;
using var rentedRenderer = pipeline.RentHtmlRenderer();
HtmlRenderer renderer = rentedRenderer.Instance;
renderer.Render(document);
renderer.Writer.Flush();
return(renderer.Writer.ToString() ?? string.Empty);
}
/// <summary>
/// Initializes a new instance of the <see cref="InlineProcessor" /> class.
/// </summary>
/// <param name="document">The document.</param>
/// <param name="parsers">The parsers.</param>
/// <param name="preciseSourcelocation">A value indicating whether to provide precise source location.</param>
/// <param name="context">A parser context used for the parsing.</param>
/// <exception cref="ArgumentNullException">
/// </exception>
public InlineProcessor(MarkdownDocument document, InlineParserList parsers, bool preciseSourcelocation, MarkdownParserContext context)
{
if (document == null)
{
ThrowHelper.ArgumentNullException(nameof(document));
}
if (parsers == null)
{
ThrowHelper.ArgumentNullException(nameof(parsers));
}
Document = document;
Parsers = parsers;
Context = context;
PreciseSourceLocation = preciseSourcelocation;
lineOffsets = new List <StringLineGroup.LineOffset>();
ParserStates = new object[Parsers.Count];
LiteralInlineParser = new LiteralInlineParser();
}
/// <summary>
/// Converts a Markdown string using a custom <see cref="IMarkdownRenderer"/>.
/// </summary>
/// <param name="markdown">A Markdown text.</param>
/// <param name="renderer">The renderer to convert Markdown to.</param>
/// <param name="pipeline">The pipeline used for the conversion.</param>
/// <param name="context">A parser context used for the parsing.</param>
/// <exception cref="ArgumentNullException">if markdown or writer variable are null</exception>
public static object Convert(string markdown, IMarkdownRenderer renderer, MarkdownPipeline?pipeline = null, MarkdownParserContext?context = null)
{
if (markdown is null)
{
ThrowHelper.ArgumentNullException_markdown();
}
if (renderer is null)
{
ThrowHelper.ArgumentNullException(nameof(renderer));
}
pipeline = GetPipeline(pipeline, markdown);
var document = MarkdownParser.Parse(markdown, pipeline, context);
pipeline.Setup(renderer);
return(renderer.Render(document));
}
/// <summary>
/// Embraces this instance by the specified container.
/// </summary>
/// <param name="container">The container to use to embrace this instance.</param>
/// <exception cref="ArgumentNullException">If the container is null</exception>
public void EmbraceChildrenBy(ContainerInline container)
{
if (container == null)
{
ThrowHelper.ArgumentNullException(nameof(container));
}
var child = FirstChild;
while (child != null)
{
var next = child.NextSibling;
// TODO: optimize this
child.Remove();
container.AppendChild(child);
child = next;
}
AppendChild(container);
}
/// <summary>
/// Converts a Markdown string using a custom <see cref="IMarkdownRenderer"/>.
/// </summary>
/// <param name="markdown">A Markdown text.</param>
/// <param name="renderer">The renderer to convert Markdown to.</param>
/// <param name="pipeline">The pipeline used for the conversion.</param>
/// <param name="context">A parser context used for the parsing.</param>
/// <exception cref="System.ArgumentNullException">if markdown or writer variable are null</exception>
public static object Convert(string markdown, IMarkdownRenderer renderer, MarkdownPipeline pipeline = null, MarkdownParserContext context = null)
{
if (markdown == null)
{
ThrowHelper.ArgumentNullException_markdown();
}
if (renderer == null)
{
ThrowHelper.ArgumentNullException(nameof(renderer));
}
pipeline ??= new MarkdownPipelineBuilder().Build();
pipeline = CheckForSelfPipeline(pipeline, markdown);
var document = Parse(markdown, pipeline, context);
pipeline.Setup(renderer);
return(renderer.Render(document));
}
/// <summary>
/// Converts a Markdown document to HTML.
/// </summary>
/// <param name="document">A Markdown document.</param>
/// <param name="writer">The destination <see cref="TextWriter"/> that will receive the result of the conversion.</param>
/// <param name="pipeline">The pipeline used for the conversion.</param>
/// <returns>The result of the conversion</returns>
/// <exception cref="ArgumentNullException">if markdown document variable is null</exception>
public static void ToHtml(this MarkdownDocument document, TextWriter writer, MarkdownPipeline?pipeline = null)
{
if (document is null)
{
ThrowHelper.ArgumentNullException(nameof(document));
}
if (writer is null)
{
ThrowHelper.ArgumentNullException_writer();
}
pipeline ??= DefaultPipeline;
using var rentedRenderer = pipeline.RentHtmlRenderer(writer);
HtmlRenderer renderer = rentedRenderer.Instance;
renderer.Render(document);
renderer.Writer.Flush();
}
/// <summary>
/// Moves all the children of this container after the specified inline.
/// </summary>
/// <param name="parent">The parent.</param>
public void MoveChildrenAfter(Inline parent)
{
if (parent == null)
{
ThrowHelper.ArgumentNullException(nameof(parent));
}
var child = FirstChild;
var nextSibling = parent;
while (child != null)
{
var next = child.NextSibling;
// TODO: optimize this
child.Remove();
nextSibling.InsertAfter(child);
nextSibling = child;
child = next;
}
}
/// <summary>
/// Converts the string representation of a KeyStates enum value to a KeyStates enum value.
/// </summary>
/// <param name="value">The string representation of a KeyStates enum value.</param>
/// <returns>A KeyStates enum value.</returns>
public static KeyStates FromString(string value)
{
if (value == null)
{
throw ThrowHelper.ArgumentNullException(nameof(value));
}
if (value.Length == 0)
{
throw ThrowHelper.ArgumentOutOfRangeException(nameof(value));
}
if (Enum.TryParse <KeyStates>(value, true, out var result))
{
return(result);
}
else
{
throw ThrowHelper.EnumParseException <KeyStates>(value);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BlockProcessor" /> class.
/// </summary>
/// <param name="document">The document to build blocks into.</param>
/// <param name="parsers">The list of parsers.</param>
/// <param name="context">A parser context used for the parsing.</param>
/// <exception cref="ArgumentNullException">
/// </exception>
public BlockProcessor(MarkdownDocument document, BlockParserList parsers, MarkdownParserContext context)
{
if (document == null)
{
ThrowHelper.ArgumentNullException(nameof(document));
}
if (parsers == null)
{
ThrowHelper.ArgumentNullException(nameof(parsers));
}
parserStateCache = new BlockParserStateCache(this);
Document = document;
document.IsOpen = true;
Parsers = parsers;
Context = context;
OpenedBlocks = new List <Block>();
NewBlocks = new Stack <Block>();
root = this;
Open(document);
}
/// <summary>
/// Copies/merge the values from this instance to the specified <see cref="HtmlAttributes"/> instance.
/// </summary>
/// <param name="htmlAttributes">The HTML attributes.</param>
/// <param name="mergeIdAndProperties">If set to <c>true</c> it will merge properties to the target htmlAttributes. Default is <c>false</c></param>
/// <param name="shared">If set to <c>true</c> it will try to share Classes and Properties if destination don't have them, otherwise it will make a copy. Default is <c>true</c></param>
/// <exception cref="ArgumentNullException"></exception>
public void CopyTo(HtmlAttributes htmlAttributes, bool mergeIdAndProperties = false, bool shared = true)
{
if (htmlAttributes == null)
{
ThrowHelper.ArgumentNullException(nameof(htmlAttributes));
}
// Add html htmlAttributes to the object
if (!mergeIdAndProperties || Id != null)
{
htmlAttributes.Id = Id;
}
if (htmlAttributes.Classes == null)
{
htmlAttributes.Classes = shared ? Classes : Classes != null ? new List <string>(Classes) : null;
}
else if (Classes != null)
{
htmlAttributes.Classes.AddRange(Classes);
}
if (htmlAttributes.Properties == null)
{
htmlAttributes.Properties = shared ? Properties : Properties != null ? new List <KeyValuePair <string, string> >(Properties) : null;
}
else if (Properties != null)
{
if (mergeIdAndProperties)
{
foreach (var prop in Properties)
{
htmlAttributes.AddPropertyIfNotExist(prop.Key, prop.Value);
}
}
else
{
htmlAttributes.Properties.AddRange(Properties);
}
}
}