public static ITimeable BuildTimeTernary(List <Token> tokens)
{
IBoolable condition = BoolableBuilder.Build(GetTernaryCondition(tokens));
if (condition.IsNull())
{
return(null);
}
ITimeable confirmationCase = TimeableBuilder.Build(GetTernaryConfirmation(tokens));
if (confirmationCase.IsNull())
{
return(null);
}
ITimeable negationCase = TimeableBuilder.Build(GetTernaryNegation(tokens));
if (negationCase.IsNull())
{
return(null);
}
return(new TimeTernary(condition, confirmationCase, negationCase));
}
private static ITimeable BuildFromDateAndClock(List <Token> tokens)
{
List <Token> beforeComma = new List <Token>();
List <Token> afterComma = new List <Token>();
int level = 0;
bool pastComma = false;
foreach (Token tok in tokens)
{
if (tok.GetTokenType().Equals(TokenType.BracketOn))
{
level++;
}
if (tok.GetTokenType().Equals(TokenType.BracketOff))
{
level--;
}
if (tok.GetTokenType().Equals(TokenType.Comma) && level == 0)
{
pastComma = true;
}
else
{
if (pastComma)
{
afterComma.Add(tok);
}
else
{
beforeComma.Add(tok);
}
}
}
ITimeable itim = TimeableBuilder.Build(beforeComma);
if (itim.IsNull())
{
return(null);
}
IClock clock = BuildClock(afterComma);
if (clock.IsNull())
{
return(null);
}
if (itim is Time)
{
(itim as Time).SetNewClock(clock);
return(itim);
}
else
{
return(new TimeableWithClock(itim, clock));
}
}
private static IBoolable BuildBetweenTimes(ITimeable tim, List <Token> left, List <Token> right)
{
ITimeable timLeft = TimeableBuilder.Build(left);
ITimeable timRight = TimeableBuilder.Build(right);
if (timLeft.IsNull() || timRight.IsNull())
{
return(null);
}
else
{
return(new BetweenTimes(tim, timLeft, timRight));
}
}
private static IBoolable BuildBetween(List <Token> tokens)
{
int betweenIndex = TokenGroups.IndexOfTokenOutsideBrackets(tokens, TokenType.Between);
int andIndex = TokenGroups.IndexOfTokenOutsideBrackets(tokens, TokenType.And);
if (andIndex < betweenIndex)
{
return(null);
}
if (betweenIndex == andIndex - 1)
{
throw new SyntaxErrorException("ERROR! Expression 'between' do not contain definition of value of left boundary.");
}
if (betweenIndex == 0)
{
throw new SyntaxErrorException("ERROR! Expression 'between' starts with keyword 'between' and thus do not contain comparing value.");
}
if (andIndex == tokens.Count - 1)
{
throw new SyntaxErrorException("ERROR! Expression 'between' ends with keyword 'and' and thus do not contain definition of value of right boundary.");
}
List <Token> valueTokens = tokens.Take(betweenIndex).ToList();
List <Token> leftTokens = tokens.GetRange(betweenIndex + 1, andIndex - betweenIndex - 1);
List <Token> rightTokens = tokens.Skip(andIndex + 1).ToList();
INumerable inum = NumerableBuilder.Build(valueTokens);
if (!inum.IsNull())
{
return(BuildBetweenNumbers(inum, leftTokens, rightTokens));
}
ITimeable itim = TimeableBuilder.Build(valueTokens);
if (!itim.IsNull())
{
return(BuildBetweenTimes(itim, leftTokens, rightTokens));
}
return(null);
}
private static IBoolable BuildTimeComparison(List <Token> tokens)
{
int index = tokens.TakeWhile(x => !TokenGroups.IsTimeComparingSign(x.GetTokenType())).Count();
if (index == 0 || index == tokens.Count - 1)
{
return(null);
}
ComparisonType type = tokens[index].GetTokenType().Equals(TokenType.IsAfter) ? ComparisonType.Bigger : ComparisonType.Smaller;
List <Token> leftTokens = tokens.GetRange(0, index);
List <Token> rightTokens = tokens.GetRange(index + 1, tokens.Count - index - 1);
ITimeable leftL = TimeableBuilder.Build(leftTokens);
ITimeable rightL = TimeableBuilder.Build(rightTokens);
if (leftL.IsNull() || rightL.IsNull())
{
return(null);
}
return(new TimeComparison(leftL, rightL, type));
}
public static ITimeable BuildRelativeTime(List <Token> tokens)
{
List <RelativeTimeStruct> relativeTimes = new List <RelativeTimeStruct>();
List <Token> currentTokens = new List <Token>();
foreach (Token tok in tokens)
{
currentTokens.Add(tok);
if (IsTimeDirection(tok))
{
List <RelativeTimeStruct> rtss = BuildRelativeTimeStructs(currentTokens.Take(currentTokens.Count - 1).ToList(), currentTokens.Last());
if (rtss.IsNull())
{
return(null);
}
else
{
relativeTimes.AddRange(rtss);
}
currentTokens.Clear();
}
}
if (currentTokens.Count == 0)
{
throw new SyntaxErrorException("ERROR! Relative time expression do not have definition for reference time.");
}
ITimeable itim = TimeableBuilder.Build(currentTokens);
if (itim.IsNull())
{
return(null);
}
return(new RelativeTimeExpression(relativeTimes, itim));
}
public static IStringable Build(List <Token> tokens)
{
// try to build Numerable
INumerable inu = NumerableBuilder.Build(tokens);
if (!inu.IsNull())
{
return(inu as IStringable);
}
// try to build Timeable
ITimeable itim = TimeableBuilder.Build(tokens);
if (!itim.IsNull())
{
return(itim as IStringable);
}
// remove first and last bracket if it is there
while (tokens[0].GetTokenType().Equals(TokenType.BracketOn) && tokens[tokens.Count - 1].GetTokenType().Equals(TokenType.BracketOff) &&
!Brackets.ContainsIndependentBracketsPairs(tokens, BracketsType.Normal))
{
List <Token> tokensCopy = tokens.Select(t => t.Clone()).ToList();
tokensCopy.RemoveAt(tokens.Count - 1);
tokensCopy.RemoveAt(0);
tokens = tokensCopy;
}
// try to build simple one-token Stringable
if (tokens.Count == 1)
{
if (tokens[0].GetTokenType().Equals(TokenType.Variable))
{
string str = tokens[0].GetContent();
if (InterVariables.GetInstance().Contains(str, InterVarType.String))
{
return(new StringVariableRefer(str));
}
else
{
// try to build reference to date or clock time
IStringable istr = BuildTimeVariableRefer(tokens[0]);
if (!istr.IsNull())
{
return(istr);
}
}
}
if (tokens[0].GetTokenType().Equals(TokenType.StringConstant))
{
return(new StringConstant(tokens[0].GetContent()));
}
}
//try to build string function
if (Functions.IsPossibleFunction(tokens))
{
IStringable istr = StringFunction.Build(tokens);
if (!istr.IsNull())
{
return(istr);
}
}
// try to build string ternary
if (TernaryBuilder.IsPossibleTernary(tokens))
{
IStringable istr = TernaryBuilder.BuildStringTernary(tokens);
if (!istr.IsNull())
{
return(istr);
}
}
// try to build reference to n-th element of list of strings
if (tokens.Count > 3 && tokens[0].GetTokenType().Equals(TokenType.Variable) && tokens[1].GetTokenType().Equals(TokenType.SquareBracketOn) &&
tokens[tokens.Count - 1].GetTokenType().Equals(TokenType.SquareBracketOff))
{
IStringable istr = BuildListElement(tokens);
if (!istr.IsNull())
{
return(istr);
}
}
// try to build concatenated string -> text merged by +
if (TokenGroups.ContainsTokenOutsideBrackets(tokens, TokenType.Plus) && !TokenGroups.ContainsTokenOutsideBrackets(tokens, TokenType.Comma))
{
return(BuildConcatenated(tokens));
}
else
{
return(null);
}
}
