private IResultAndExitString <ElementToken> TokenizeElement(ref StringWalker enumerator)
{
var elementsParts = new List <IToken>();
while (true)
{
if (NextPart(ref enumerator, out var part))
{
if (IsExit(part))
{
if (elementsParts.Any())
{
return(new ResultAndExitString <ElementToken>(part, new ElementToken(elementsParts.ToArray())));
}
else
{
return(new ResultAndExitString <ElementToken>(part));
}
}
if (TryEnter(part, ref enumerator, out var token))
{
elementsParts.Add(token);
}
else
{
elementsParts.Add(new AtomicToken(part));
}
}
public void can_walk_2_by_time_in_6_length_string()
{
var str = new StringWalker("abcdef");
str.Read(2).Should().Be("ab");
str.Read(2).Should().Be("cd");
str.Read(2).Should().Be("ef");
}
public static ILispNode Neq(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object [] args)
{
#region DateTime
try
{
var merger = new AtomMerger(new LispMissing());
var walker = new DateTimeWalker("!=");
var result = functor.WalkAsBoolean(arguments, callStack, 2, merger, walker);
return((merger.MissingSymbols.Count() > 0)
? merger.MissingSymbols
: result);
}
catch {}
#endregion
try
{
var merger = new AtomMerger(new LispMissing());
var walker = new NumberWalker("!=");
var result = functor.WalkAsBoolean(arguments, callStack, 2, merger, walker);
return((merger.MissingSymbols.Count() > 0)
? merger.MissingSymbols
: result);
}
catch {}
try
{
var merger = new AtomMerger(new LispMissing());
var walker = new BooleanWalker("!=");
var result = functor.WalkAsBoolean(arguments, callStack, 2, merger, walker);
return((merger.MissingSymbols.Count() > 0)
? merger.MissingSymbols
: result);
}
catch {}
try
{
var merger = new AtomMerger(new LispMissing());
var walker = new StringWalker("!=");
var result = functor.WalkAsBoolean(arguments, callStack, 2, merger, walker);
return((merger.MissingSymbols.Count() > 0)
? merger.MissingSymbols
: result);
}
catch {}
throw new Exception("!= requires all arguments to be dates, numbers, booleans or strings");
}
public object Read(StringWalker str)
{
var value = str.Read(FormatString.Length);
if (value == new string('0', FormatString.Length)) return null;
return DateTime.ParseExact(value, FormatString, CultureInfo.InvariantCulture);
}
public void peek_doesn_t_change_position()
{
var str = new StringWalker("abcd");
str.Read(2).Should().Be("ab");
str.Position.Should().Be(2);
str.Peek(2).Should().Be("cd");
str.Position.Should().Be(2);
}
public void field_of_constant_datetime_format_culture()
{
var field = new Field("teste", "constant(2009-11-25, date)", "string(dd/MM/yyyy)");
var bag = new ValueBag();
var str = new StringWalker("12345678");
field.Read(str, bag);
bag["teste"].Value.Should().Be(new DateTime(2009, 11, 25));
bag["teste"].Format().Should().Be("25/11/2009");
}
private ResultAndExitString <T> OuterTokenzie <T>(
ref StringWalker enumerator,
Inner inner,
IReadOnlyList <string> exits,
Func <IToken[], T> makeToken,
bool alwaysMake,
bool addExitString)
where T : class, IToken
{
var elements = new List <IToken>();
while (true)
{
var res = inner(ref enumerator);
if (res.HasToken())
{
elements.Add(res.GetTokenOrThrow());
}
if (res.TryGetExitString(out var exitString))
{
if (exits.Contains(exitString))
{
if (alwaysMake || elements.Any())
{
return(new ResultAndExitString <T>(exitString, makeToken(elements.ToArray())));
}
else
{
return(new ResultAndExitString <T>(exitString));
}
}
else
{
if (addExitString)
{
elements.Add(new AtomicToken(exitString));
}
}
}
else
{
if (alwaysMake || elements.Any())
{
return(new ResultAndExitString <T>(makeToken(elements.ToArray())));
}
else
{
return(new ResultAndExitString <T>());
}
}
}
}
public int? FindNextIndex(char value)
{
var stringWalker = new StringWalker();
var startingSource = source.Substring(startIndex);
foreach (var position in stringWalker.Iterate(startingSource))
{
if (position.Character == value && !stringWalker.StateIs(StringWalkerState.InsideString))
return position.Index + startIndex;
}
return null;
}
private IResultAndExitString <LineToken> TokenzieLine(ref StringWalker enumerator)
{
var elementsParts = new List <IToken>();
while (true)
{
if (NextPart(ref enumerator, out var part))
{
if (IsExit(part !))
{
if (elementsParts.Any())
{
return(new ResultAndExitString <LineToken>(part !, new LineToken(elementsParts.ToArray())));
}
else
{
return(new ResultAndExitString <LineToken>(part !));
}
}
if (TryEnter(part !, ref enumerator, out var token))
{
elementsParts.Add(token !);
}
public void can_set_position()
{
var str = new StringWalker("abcd");
str.Position = 2;
str.Read(2).Should().Be("cd");
}
public JsonFormatter(string json)
{
_walker = new StringWalker(json);
ResetLine();
}
public void can_read_implicit_integral_type_from_string()
{
var str = new StringWalker("12345");
var number = new NumberType("4");
number.Read(str).Should().Be.OfType<int>().And.Be(1234);
}
public void can_read_implicit_decimal_type_from_string()
{
var str = new StringWalker("123456789");
var number = new NumberType("4,3");
number.Read(str).Should().Be.OfType<decimal>().And.Be(1234.567m);
}
public object Read(StringWalker str)
{
throw new NotImplementedException();
}
public object Read(StringWalker str)
{
var value = str.Read(Length);
if (Trim) value = value.Trim();
return value;
}
public object Read(StringWalker str)
{
return value;
}
public static ILispNode Unique(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object [] args)
{
var Values = arguments.Select(x => x.Eval(callStack, true)).ToList();
try
{
Values.Sort((x, y) => (x as LispAtom).ValueAsDateTime.CompareTo((y as LispAtom).ValueAsDateTime));
var merger = new AtomMerger(new LispMissing());
var walker = new DateTimeWalker((r, prev, curr) => { return(((bool)r) && (LispAtom.CastToDateTime(prev) != LispAtom.CastToDateTime(curr))); });
var result = functor.WalkAsBoolean(Values, callStack, 2, merger, walker);
return((merger.MissingSymbols.Count() > 0)
? merger.MissingSymbols
: result);
}
catch {}
try
{
Values.Sort(
(x, y) => ((x as LispAtom).ValueAsNumber < (y as LispAtom).ValueAsNumber)
? -1
: +1);
var merger = new AtomMerger(new LispMissing());
var walker = new NumberWalker((r, prev, curr) => { return(((bool)r) && (LispAtom.CastToNumber(prev) != LispAtom.CastToNumber(curr))); });
var result = functor.WalkAsBoolean(Values, callStack, 2, merger, walker);
return((merger.MissingSymbols.Count() > 0)
? merger.MissingSymbols
: result);
}
catch {}
try
{
Values.Sort((x, y) => (String.Compare((x as LispAtom).ValueAsBoolean.ToString(), (y as LispAtom).ValueAsBoolean.ToString(), true)));
var merger = new AtomMerger(new LispMissing());
var walker = new BooleanWalker((r, prev, curr) => { return((bool)r && (LispAtom.CastToBoolean(prev) != LispAtom.CastToBoolean(curr))); });
var result = functor.WalkAsBoolean(Values, callStack, 2, merger, walker);
return((merger.MissingSymbols.Count() > 0)
? merger.MissingSymbols
: result);
}
catch {}
try
{
Values.Sort((x, y) => String.Compare((x as LispAtom).ValueAsString, (y as LispAtom).ValueAsString, true));
var merger = new AtomMerger(new LispMissing());
var walker = new StringWalker((r, prev, curr) => { return(((bool)r) && (LispAtom.CastToString(prev) != LispAtom.CastToString(curr))); });
var result = functor.WalkAsBoolean(Values, callStack, 2, merger, walker);
return((merger.MissingSymbols.Count() > 0)
? merger.MissingSymbols
: result);
}
catch {}
return(new LispAtom(true));
//throw new Exception("UNIQUE requires all arguments to be dates, numbers or strings");
}
