/// <summary>
/// Parses a tag's contents into data.
/// </summary>
static public TagData Parse(StringSlice inSlice, IDelimiterRules inDelimiters)
{
TagData data;
Parse(inSlice, inDelimiters, out data);
return(data);
}
public virtual void Dispose()
{
if (m_RichBuilder != null)
{
m_RichBuilder.Length = 0;
m_RichBuilder = null;
}
m_Delimiters = null;
}
static protected bool HasSameDelims(IDelimiterRules inA, IDelimiterRules inB)
{
if (inA == inB)
{
return(true);
}
return(inA.TagStartDelimiter == inB.TagStartDelimiter &&
inA.TagEndDelimiter == inB.TagEndDelimiter &&
inA.RegionCloseDelimiter == inB.RegionCloseDelimiter &&
ArrayUtils.ContentEquals(inA.TagDataDelimiters, inB.TagDataDelimiters));
}
static protected bool RecognizeRichText(TagData inData, IDelimiterRules inDelimiters)
{
// recognize hex colors
if (inData.Id.StartsWith('#'))
{
StringSlice colorCheck = inData.Id.Substring(1);
if (colorCheck.Length == 6 || colorCheck.Length == 8)
{
bool bIsColor = true;
for (int i = 0; i < colorCheck.Length; ++i)
{
char c = char.ToLowerInvariant(colorCheck[i]);
bool bIsHex = char.IsNumber(c) || (c >= 'a' && c <= 'f');
if (!bIsHex)
{
bIsColor = false;
break;
}
}
if (bIsColor)
{
return(true);
}
}
}
foreach (var tag in StringUtils.RichText.RecognizedRichTags)
{
if (inData.Id.Equals(tag, true))
{
return(true);
}
}
if (inDelimiters.AdditionalRichTextTags != null)
{
foreach (var tag in inDelimiters.AdditionalRichTextTags)
{
if (inData.Id.Equals(tag, true))
{
return(true);
}
}
}
return(false);
}
static protected bool ContainsPotentialTags(StringSlice inSlice, IDelimiterRules inDelimiters)
{
if (inDelimiters.RichText)
{
bool bIdenticalDelims = inDelimiters.TagStartDelimiter == "<" && inDelimiters.TagEndDelimiter == ">";
if (inSlice.Contains("<") || inSlice.Contains(">"))
{
return(true);
}
if (bIdenticalDelims)
{
return(false);
}
}
return(inSlice.Contains(inDelimiters.TagStartDelimiter) && inSlice.Contains(inDelimiters.TagEndDelimiter));
}
public void Dispose()
{
if (Builder != null)
{
BlockParser.ReturnStringBuilder(Builder);
Builder = null;
}
if (ContentBuilder != null)
{
BlockParser.ReturnStringBuilder(ContentBuilder);
ContentBuilder = null;
}
PrefixPriorities = null;
Rules = null;
Generator = null;
TagDelimiters = null;
Cache = null;
Package = null;
CurrentBlock = null;
}
/// <summary>
/// Parses a tag's contents into data.
/// </summary>
static public void Parse(StringSlice inSlice, IDelimiterRules inDelimiters, out TagData outTagData)
{
if (inDelimiters == null)
{
throw new ArgumentNullException("inDelimiters");
}
StringSlice tag = inSlice;
tag = tag.Trim(MinimalWhitespaceChars);
bool bRemovedTagBoundaries = false;
if (tag.StartsWith(inDelimiters.TagStartDelimiter))
{
tag = tag.Substring(inDelimiters.TagStartDelimiter.Length);
bRemovedTagBoundaries = true;
}
if (tag.EndsWith(inDelimiters.TagEndDelimiter))
{
tag = tag.Substring(0, tag.Length - inDelimiters.TagEndDelimiter.Length);
bRemovedTagBoundaries = true;
}
if (bRemovedTagBoundaries)
{
tag = tag.Trim(MinimalWhitespaceChars);
}
if (inSlice.Length == 0)
{
outTagData = default(TagData);
return;
}
ClosingTagState closeState = 0;
char endDelim = inDelimiters.RegionCloseDelimiter;
if (endDelim != 0)
{
if (tag.StartsWith(endDelim))
{
closeState |= ClosingTagState.Start;
tag = tag.Substring(1);
}
if (tag.EndsWith(endDelim))
{
closeState |= ClosingTagState.End;
tag = tag.Substring(0, tag.Length - 1);
}
}
if (closeState != 0)
{
tag = tag.Trim(MinimalWhitespaceChars);
}
char[] dataDelims = inDelimiters.TagDataDelimiters;
int dataDelimIdx = tag.Length;
foreach (var delim in dataDelims)
{
int idx = tag.IndexOf(delim);
if (idx >= 0 && idx < dataDelimIdx)
{
dataDelimIdx = idx;
if (idx <= 0)
{
break;
}
}
}
if (dataDelimIdx >= tag.Length)
{
outTagData.Id = tag;
outTagData.Data = StringSlice.Empty;
}
else
{
outTagData.Id = tag.Substring(0, dataDelimIdx).TrimEnd(MinimalWhitespaceChars);
outTagData.Data = tag.Substring(dataDelimIdx).TrimStart(dataDelims).TrimStart(MinimalWhitespaceChars);
}
outTagData.m_CloseState = closeState;
}
/// <summary>
/// Returns if the given string contains any text or rich text tags.
/// </summary>
static public bool ContainsText(StringSlice inString, IDelimiterRules inDelimiters, IEnumerable <string> inTextTags = null)
{
bool bTrackRichText = inDelimiters.RichText;
bool bTrackTags = !bTrackRichText || !HasSameDelims(inDelimiters, RichTextDelimiters);
int length = inString.Length;
int charIdx = 0;
int richStart = -1;
int tagStart = -1;
int copyStart = 0;
while (charIdx < length)
{
if (bTrackRichText)
{
if (inString.AttemptMatch(charIdx, "<"))
{
richStart = charIdx;
}
else if (inString.AttemptMatch(charIdx, ">"))
{
return(true);
}
}
if (bTrackTags)
{
if (inString.AttemptMatch(charIdx, inDelimiters.TagStartDelimiter))
{
tagStart = charIdx;
}
else if (inString.AttemptMatch(charIdx, inDelimiters.TagEndDelimiter))
{
StringSlice check = inString.Substring(copyStart, tagStart - copyStart);
if (!check.IsWhitespace)
{
return(true);
}
if (inTextTags != null)
{
TagData data = TagData.Parse(inString.Substring(tagStart, charIdx - tagStart + 1), inDelimiters);
foreach (var tag in inTextTags)
{
if (data.Id == tag)
{
return(true);
}
}
}
copyStart = charIdx + 1;
tagStart = -1;
richStart = -1;
}
}
++charIdx;
}
StringSlice finalCheck = inString.Substring(copyStart, length - copyStart);
return(!finalCheck.IsWhitespace);
}
