public Expression ParseHierarchy(Expression parentexpression, BaseModel.Hier <string> exprstringtree)
{
if (parentexpression == null)
{
//parentexpression = ParseExpressionString(exprstringtree.Item);
}
var expr = ParseExpressionString(exprstringtree.Item);
var ix = 0;
foreach (var item in exprstringtree.HChildren)
{
var subexpr = ParseHierarchy(parentexpression, item);
var exprplaceholder = expr.GetExpressionForPlaceHolder(ix);
if (exprplaceholder != null)
{
exprplaceholder.SubExpressions.Add(subexpr);
}
else
{
}
//expr.SubExpressions.Add(subexpr);
ix++;
}
//parentexpression.SubExpressions.Add(expr);
return(expr);
}
public void PutbackStrings(BaseModel.Hier <String> h, Dictionary <string, string> d)
{
foreach (var ditem in d)
{
h.Item = h.Item.Replace(ditem.Key, ditem.Value);
}
foreach (var ch in h.HChildren)
{
PutbackStrings(ch, d);
}
}
public virtual BaseModel.Hier <String> GetTreeString(string expression)
{
expression = Utilities.Strings.HtmlDecode(expression);
var thenelses = Utilities.Strings.TextsBetween(expression, Syntax.Then, Syntax.Else);
foreach (var thenelse in thenelses)
{
var part = thenelse.Trim();
if (!part.StartsWith(Syntax.ExpressionContainer_Left))
{
part = Syntax.ExpressionContainer_Left + part + Syntax.ExpressionContainer_Right;
expression = expression.Replace(Syntax.Then + thenelse + Syntax.Else, Syntax.Then + part + Syntax.Else);
}
}
var item = new BaseModel.Hier <String>();
var leftexprcontainercount = 0;
var rightexprcontainercount = 0;
var leftcontainerix = -1;
var subexpressions = new List <string>();
var strings = Utilities.Strings.TextsBetween(expression, Literals.Quote, Literals.Quote);
var stringdictionary = new Dictionary <string, string>();
var c = 0;
foreach (var str in strings)
{
var key = String.Format(Literals.PlaceholderFormat, c);
var value = Literals.Quote + str + Literals.Quote;
expression = expression.Replace(value, key);
stringdictionary.Add(key, value);
c++;
}
for (int i = 0; i < expression.Length; i++)
{
var character = expression[i].ToString();
if (character == Syntax.ExpressionContainer_Left)
{
leftexprcontainercount++;
if (leftcontainerix == -1)
{
leftcontainerix = i;
}
}
if (character == Syntax.ExpressionContainer_Right)
{
rightexprcontainercount++;
}
if (rightexprcontainercount > leftexprcontainercount)
{
throw new Exception("InvalidExpression");
}
if (leftexprcontainercount > 0 && leftexprcontainercount == rightexprcontainercount)
{
var ix1 = leftcontainerix + 1;
var ix2 = i - ix1;
var subexpression = expression.Substring(ix1, ix2);
if (!String.IsNullOrEmpty(subexpression.Trim()))
{
var parameter = Syntax.ExpressionPlaceholder + subexpressions.Count;
subexpressions.Add(subexpression);
expression = expression.Remove(ix1, ix2);
expression = expression.Insert(ix1, parameter);
i = leftcontainerix + parameter.Length + 1;
leftexprcontainercount = 0;
rightexprcontainercount = 0;
leftcontainerix = -1;
var subtree = GetTreeString(subexpression);
item.AddChildren(subtree);
}
//item.Children.Add(subtree);
}
}
//foreach (var ditem in stringdictionary)
//{
// foreach (var ch in item.HChildren)
// {
// ch.Item = ch.Item.Replace(ditem.Key, ditem.Value);
// }
//}
item.Item = expression;
PutbackStrings(item, stringdictionary);
return(item);
}
