private static void SetRowSpanState(List <GridTableState.ColumnSlice> columns, StringSlice line, out bool isHeaderRow, out bool hasRowSpan)
{
var lineStart = line.Start;
isHeaderRow = line.PeekChar(1) == '=' || line.PeekChar(2) == '=';
hasRowSpan = false;
foreach (var columnSlice in columns)
{
if (columnSlice.CurrentCell != null)
{
line.Start = lineStart + columnSlice.Start + 1;
line.End = lineStart + columnSlice.End - 1;
line.Trim();
if (line.IsEmptyOrWhitespace() || !IsRowSeperator(line))
{
hasRowSpan = true;
columnSlice.CurrentCell.RowSpan++;
columnSlice.CurrentCell.AllowClose = false;
}
else
{
columnSlice.CurrentCell.AllowClose = true;
}
}
}
}
/// <summary>
/// Attempts to parse a modification.
/// </summary>
static public bool TryParse(StringSlice inData, out VariantModification outModification)
{
inData = inData.Trim();
VariantModifyOperator op = default(VariantModifyOperator);
int operatorIdx = -1;
int operatorLength = 0;
VariantUtils.TryFindOperator(inData, '=', VariantModifyOperator.Set, ref operatorIdx, ref op, ref operatorLength);
VariantUtils.TryFindOperator(inData, '+', VariantModifyOperator.Add, ref operatorIdx, ref op, ref operatorLength);
VariantUtils.TryFindOperator(inData, '-', VariantModifyOperator.Subtract, ref operatorIdx, ref op, ref operatorLength);
VariantUtils.TryFindOperator(inData, '*', VariantModifyOperator.Multiply, ref operatorIdx, ref op, ref operatorLength);
VariantUtils.TryFindOperator(inData, '/', VariantModifyOperator.Divide, ref operatorIdx, ref op, ref operatorLength);
if (operatorIdx < 0)
{
outModification = default(VariantModification);
return(false);
}
outModification.Operator = op;
StringSlice key = inData.Substring(0, operatorIdx);
StringSlice operand = inData.Substring(operatorIdx + 1);
if (!TableKeyPair.TryParse(key, out outModification.VariableKey))
{
outModification = default(VariantModification);
return(false);
}
return(VariantOperand.TryParse(operand, out outModification.Operand));
}
static public void CanTrimBoth()
{
StringSlice firstString = "\n \tTrim Me\t\n";
StringSlice trimmed = firstString.Trim();
Assert.AreEqual("Trim Me", trimmed.ToString());
}
/// <summary>
/// Returns if the given string is a valid identifier.
/// </summary>
static public bool IsValidIdentifier(StringSlice inSlice)
{
inSlice = inSlice.Trim();
if (inSlice.Length == 0)
{
return(false);
}
char c = inSlice[0];
if (char.IsDigit(c))
{
return(false);
}
for (int i = 0; i < inSlice.Length; ++i)
{
c = inSlice[i];
if (char.IsLetterOrDigit(c))
{
continue;
}
if (c == '_' || c == '.' || c == '-')
{
continue;
}
return(false);
}
return(true);
}
public void TestStringLineGroupWithModifiedStart()
{
var line1 = new StringSlice(" ABC");
line1.NextChar();
line1.NextChar();
var line2 = new StringSlice(" DEF ");
line2.Trim();
var text = new StringLineGroup(4) {line1, line2};
var result = ToString(text.ToCharIterator());
TextAssert.AreEqual("ABC\nDEF", result);
}
/// <summary>
/// Attempts to parse a StringSlice into a Variant Key.
/// Valid formats are:
/// <list type="bullet">
/// <item>variableId</item>
/// <item>tableId:variableId</item>
/// </list>
/// </summary>
static public bool TryParse(StringSlice inSource, out TableKeyPair outKey)
{
if (inSource.IsEmpty)
{
outKey = default(TableKeyPair);
return(false);
}
inSource = inSource.Trim();
int operatorIdx = inSource.IndexOf(TableOperator);
if (operatorIdx >= 0)
{
int variantIdx = operatorIdx + TableOperator.Length;
if (variantIdx >= inSource.Length)
{
outKey = default(TableKeyPair);
return(false);
}
StringSlice tableId = inSource.Substring(0, operatorIdx).TrimEnd();
StringSlice variantId = inSource.Substring(variantIdx).TrimStart();
if (!VariantUtils.IsValidIdentifier(tableId) || !VariantUtils.IsValidIdentifier(variantId))
{
outKey = default(TableKeyPair);
return(false);
}
outKey = new TableKeyPair(tableId, variantId);
return(true);
}
if (!VariantUtils.IsValidIdentifier(inSource))
{
outKey = default(TableKeyPair);
return(false);
}
outKey = new TableKeyPair(inSource);
return(true);
}
/// <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>
/// Attempts to parse a comparison.
/// </summary>
static public bool TryParse(StringSlice inData, out VariantComparison outComparison)
{
inData = inData.Trim();
VariantCompareOperator op = VariantCompareOperator.True;
int operatorIdx = -1;
int operatorLength = 0;
VariantUtils.TryFindOperator(inData, EqualsOperator, VariantCompareOperator.EqualTo, ref operatorIdx, ref op, ref operatorLength);
VariantUtils.TryFindOperator(inData, NotEqualOperator, VariantCompareOperator.NotEqualTo, ref operatorIdx, ref op, ref operatorLength);
VariantUtils.TryFindOperator(inData, GreaterThanOrEqualToOperator, VariantCompareOperator.GreaterThanOrEqualTo, ref operatorIdx, ref op, ref operatorLength);
VariantUtils.TryFindOperator(inData, LessThanOrEqualToOperator, VariantCompareOperator.LessThanOrEqualTo, ref operatorIdx, ref op, ref operatorLength);
VariantUtils.TryFindOperator(inData, GreaterThanOperator, VariantCompareOperator.GreaterThan, ref operatorIdx, ref op, ref operatorLength);
VariantUtils.TryFindOperator(inData, LessThanOperator, VariantCompareOperator.LessThan, ref operatorIdx, ref op, ref operatorLength);
VariantUtils.TryFindOperator(inData, NotOperator, VariantCompareOperator.False, ref operatorIdx, ref op, ref operatorLength);
VariantUtils.TryFindOperator(inData, ShortEqualsOperator, VariantCompareOperator.EqualTo, ref operatorIdx, ref op, ref operatorLength);
VariantUtils.TryFindOperator(inData, ExistsOperator, VariantCompareOperator.Exists, ref operatorIdx, ref op, ref operatorLength);
VariantUtils.TryFindOperator(inData, DoesNotExistOperator, VariantCompareOperator.DoesNotExist, ref operatorIdx, ref op, ref operatorLength);
if (operatorIdx < 0)
{
op = VariantCompareOperator.True;
}
outComparison.Operator = op;
StringSlice idSlice = StringSlice.Empty;
StringSlice operandSlice = StringSlice.Empty;
bool bRequiresOperand = true;
switch (op)
{
case VariantCompareOperator.False:
{
idSlice = inData.Substring(1).TrimStart();
bRequiresOperand = false;
break;
}
case VariantCompareOperator.True:
{
idSlice = inData;
bRequiresOperand = false;
break;
}
case VariantCompareOperator.Exists:
{
idSlice = inData.Substring(0, operatorIdx).TrimEnd();
bRequiresOperand = false;
break;
}
case VariantCompareOperator.DoesNotExist:
{
idSlice = inData.Substring(0, operatorIdx).TrimEnd();
bRequiresOperand = false;
break;
}
default:
{
idSlice = inData.Substring(0, operatorIdx).TrimEnd();
operandSlice = inData.Substring(operatorIdx + operatorLength).TrimStart();
break;
}
}
if (!VariantOperand.TryParse(idSlice, out outComparison.Left))
{
outComparison = default(VariantComparison);
return(false);
}
if (!bRequiresOperand)
{
outComparison.Right = default(VariantOperand);
return(true);
}
return(VariantOperand.TryParse(operandSlice, out outComparison.Right));
}
/// <summary>
/// Attempts to parse a string slice into a variant.
/// </summary>
static public bool TryParse(StringSlice inSlice, bool inbAllowImplicitHash, out Variant outValue)
{
inSlice = inSlice.Trim();
if (inSlice.Length <= 0 || inSlice.Equals("null", true))
{
outValue = Variant.Null;
return(true);
}
if (inSlice.StartsWith(StringHashing.CustomHashPrefix) || inSlice.StartsWith(StringHashing.StringPrefix) ||
(inSlice.Length >= 2 && inSlice.StartsWith('"') && inSlice.EndsWith('"')))
{
StringHash32 hash;
if (StringHash32.TryParse(inSlice, out hash))
{
outValue = hash;
return(true);
}
}
bool bBoolVal;
if (StringParser.TryParseBool(inSlice, out bBoolVal))
{
outValue = new Variant(bBoolVal);
return(true);
}
int intVal;
if (StringParser.TryParseInt(inSlice, out intVal))
{
outValue = new Variant(intVal);
return(true);
}
uint uintVal;
if (StringParser.TryParseUInt(inSlice, out uintVal))
{
outValue = new Variant(uintVal);
return(true);
}
float floatVal;
if (StringParser.TryParseFloat(inSlice, out floatVal))
{
outValue = new Variant(floatVal);
return(true);
}
if (inbAllowImplicitHash)
{
StringHash32 hash;
if (StringHash32.TryParse(inSlice, out hash))
{
outValue = hash;
return(true);
}
}
outValue = default(Variant);
return(false);
}
