/// <summary>
/// Adds the supplied operator to the tree.
/// The operator is added according to precedence and associativity.
/// </summary>
/// <param name="topNode">The top node of the tree.</param>
/// <param name="next">The operator to add.</param>
private void AddToTree(ref ExpressionItem topNode, ExpressionItem next)
{
if (topNode is OperatorItem)
{
OperatorItem currentNode = (OperatorItem)topNode;
if (currentNode.Configuration.Precedence < ((OperatorItem)next).Configuration.Precedence ||
(currentNode.Configuration.Precedence == ((OperatorItem)next).Configuration.Precedence &&
((OperatorItem)next).Configuration.Associativity == Associativity.left))
{
//The top node has lower precedence, or the new operator has left associativity:
//add it as top node and add the current tree as left parameter.
((OperatorItem)next).AddParameter(currentNode);
topNode = next;
}
else if (((OperatorItem)next).Configuration.Associativity == Associativity.left)
{
//The new operator has associativity left.
//Find the first node with same precedence and add the new operator at that position
//with the found node as left parameter.
ExpressionItem child = currentNode.Parameters[currentNode.Parameters.Length - 1];
while (child is OperatorItem &&
((OperatorItem)child).Configuration.Precedence > ((OperatorItem)next).Configuration.Precedence)
{
currentNode = (OperatorItem)child;
child = currentNode.Parameters[currentNode.Parameters.Length - 1];
}
ExpressionItem[] currentParams = currentNode.Parameters;
currentNode.RemoveParameters();
((OperatorItem)next).AddParameter(currentParams[currentParams.Length - 1]);
currentParams[currentParams.Length - 1] = next;
currentNode.AddParameterRange(currentParams);
}
else if (((OperatorItem)next).Configuration.Associativity == Associativity.right)
{
//The new node has right associativity.
//find the first node with lower precedence and add the new operator at that position
//with the found node as left parameter.
ExpressionItem child = currentNode.Parameters[currentNode.Parameters.Length - 1];
while (child is OperatorItem &&
((OperatorItem)child).Configuration.Precedence >= ((OperatorItem)next).Configuration.Precedence)
{
currentNode = (OperatorItem)child;
child = currentNode.Parameters[currentNode.Parameters.Length - 1];
}
ExpressionItem[] currentParams = currentNode.Parameters;
currentNode.RemoveParameters();
((OperatorItem)next).AddParameter(currentParams[currentParams.Length - 1]);
currentParams[currentParams.Length - 1] = next;
currentNode.AddParameterRange(currentParams);
}
}
else
{
//The next item isn't an operator. This case will not be used.
((OperatorItem)next).AddParameter(topNode);
topNode = next;
}
//Fill the right hand side of the new operator.
FillParameters(next);
}
public Operator(string str)
{
if (string.IsNullOrWhiteSpace(str))
{
throw new Exception("It is not a Operator");
}
string operatorStr = str.Trim();
//string[] regex = { "^(=|=)$", "^(+|+)$", "^(-|—|－)$", "^(x|X|×)$", "^(/|÷)$", "^(\\(|（)$", "^(\\)|）)$" };
int index = -1;
for (int i = 0; i < operatorRegexes.Length; i++)
{
string rule = "^" + operatorRegexes[i] + "$";
Regex r = new Regex(rule, RegexOptions.IgnoreCase);
// Match the regular expression pattern against a text string.
Match m = r.Match(str);
if (m.Success)
{
index = i;
break;
}
}
if (index < 0)
{
throw new Exception(str + " is not a Operator");
}
this.item = (OperatorItem)(index);
}
public static OperatorItemDto ToDto(this OperatorItem obj)
{
return(new()
{
Name = obj.Name,
Rid = obj.Rid
});
}
public ReturnItem(AMemberItem parent, XElement element)
: base(parent, element)
{
Type = parent switch
{
MethodItem methodItem => methodItem.Method.ReturnType,
OperatorItem operatorItem => operatorItem.Method.ReturnType,
_ => throw new NotSupportedException()
};
}
public ParameterItem(AMemberItem parent, XElement element)
: base(parent, element)
{
Parameter = parent switch
{
MethodItem methodItem => methodItem.Method.Parameters.First(p => p.Name == Name),
OperatorItem operatorItem => operatorItem.Method.Parameters.First(p => p.Name == Name),
ConstructorItem constructorItem => constructorItem.Constructor.Parameters.First(p => p.Name == Name),
PropertyItem property => property.Property.Parameters.First(p => p.Name == Name),
_ => throw new NotSupportedException()
};
}
private void RefreshOperators()
{
if (!IsInitialized)
{
return;
}
if (cmbAttribute.SelectedItem is AttributeItem attributeItem && attributeItem.Metadata.AttributeType is AttributeTypeCode attributeType)
{
//cmbOperator.SelectedItem = null;
cmbOperator.Items.Clear();
cmbOperator.Items.AddRange(OperatorItem.GetConditionsByAttributeType(attributeType));
ReFillControl(cmbOperator);
}
}
private void buttonAdd_Click(object sender, EventArgs e)
{
if (comboBoxField.SelectedItem == null || comboBoxOperator.SelectedItem == null)
{
return;
}
FieldItem selectedField = (FieldItem)comboBoxField.SelectedItem;
OperatorItem selectedOperator = (OperatorItem)comboBoxOperator.SelectedItem;
string value = textBoxValue.Text;
Condition.Add(selectedField.Field, selectedOperator.Operator, value);
FillList();
}
private void cmbAttribute_SelectedIndexChanged(object sender, EventArgs e)
{
if (cmbAttribute.SelectedItem != null)
{
var attributeType = ((AttributeItem)cmbAttribute.SelectedItem).Metadata.AttributeType;
if (attributeType.HasValue)
{
var tmpColl = ControlUtils.GetAttributesCollection(this.Controls, false);
cmbOperator.SelectedItem = null;
cmbOperator.Items.Clear();
cmbOperator.Items.AddRange(OperatorItem.GetConditionsByAttributeType(attributeType.Value));
ControlUtils.FillControl(tmpColl, cmbOperator);
}
}
UpdateValueField();
}
private void operatorList_Tap(object sender, System.Windows.Input.GestureEventArgs e)
{
if (operatorList.SelectedItem != null)
{
clpb.Visibility = System.Windows.Visibility.Visible;
OperatorItem sItem = operatorList.SelectedItem as OperatorItem;
shablnUSSD = sItem.SHBLN;
shablnType = sItem.TYPE;
// Выбрать номер телефона
if (shablnType == "31")
{
if (Options.phonenumberhelp == true)
{
StartPhoneTask();
return;
}
ShowAddToClipboard(sItem.USSD);
}
// Ввести число
else if (shablnType == "32")
{
if (Options.phonenumberhelp == true)
{
StartUSSDEdit();
return;
}
ShowAddToClipboard(sItem.USSD);
}
// Ввести число и номер телефона
else if (shablnType == "33")
{
if (Options.phonenumberhelp == true)
{
StartPhoneTask();
return;
}
ShowAddToClipboard(sItem.USSD);
}
else
{
ShowAddToClipboard(sItem.USSD);
}
}
}
void AddButtonList(IEnumerable <ParseObject> rersult)
{
foreach (Transform child in contentRect.GetComponentsInChildren <Transform>())
{
if (child.gameObject.name.Equals("OperatorItem"))
{
Destroy(child.gameObject);
}
}
for (int i = 0; i < results.Count; i++)
{
ParseObject obj = results[i];
//Debug.Log(obj["stars"].GetType());
if (isAttack)
{
if (obj["team"].Equals("Attackers"))
{
GameObject newobj;
newobj = (GameObject)Instantiate(operatorPrefab);
newobj.transform.SetParent(contentRect);
newobj.transform.localScale = new Vector3(1f, 1f, 1f);
newobj.name = "OperatorItem";
OperatorItem map = newobj.GetComponent <OperatorItem>();
map.Setup(obj, this);
}
}
else
{
if (obj["team"].Equals("Defenders"))
{
GameObject newobj;
newobj = (GameObject)Instantiate(operatorPrefab);
newobj.transform.SetParent(contentRect);
newobj.transform.localScale = new Vector3(1f, 1f, 1f);
newobj.name = "OperatorItem";
OperatorItem map = newobj.GetComponent <OperatorItem>();
map.Setup(obj, this);
}
}
}
}
private int CalculateSection(int operand1, int operand2, OperatorItem oper)
{
switch (oper)
{
case OperatorItem.Plus:
return(operand1 + operand2);
case OperatorItem.Minus:
return(operand1 - operand2);
case OperatorItem.Times:
return(operand1 * operand2);
case OperatorItem.Divides:
return(operand1 / operand2);
default:
throw new Exception("Fail to calculate.");
}
}
private static Dictionary <string, AMemberItem> Parse(XDocument document)
{
Dictionary <string, AMemberItem> items = new Dictionary <string, AMemberItem>();
AMemberItem HandleTypeItem(XElement typeElement)
{
string parentNamespace = typeElement.GetNamespace();
if (!items.TryGetValue($"{TypeItem.Id}{parentNamespace}", out AMemberItem parent) &&
!items.TryGetValue($"{NamespaceItem.Id}{parentNamespace}", out parent))
{
parent = new NamespaceItem(parentNamespace);
items.Add($"{NamespaceItem.Id}{parent.Name}", parent);
}
TypeItem typeItem = new TypeItem(parent, typeElement);
items.Add(typeElement.GetFullName(), typeItem);
return(typeItem);
}
foreach (XElement element in document.GetMembers().Where(e => e.GetFullName().StartsWith(TypeItem.Id)))
{
HandleTypeItem(element);
}
foreach (XElement element in document.GetMembers().Where(e => !e.GetFullName().StartsWith(TypeItem.Id)))
{
string parentFullName = element.GetNamespace();
if (!items.TryGetValue($"{TypeItem.Id}{parentFullName}", out AMemberItem parent))
{
parent = HandleTypeItem(TypeItem.CreateEmptyXElement(parentFullName));
}
AMemberItem newItem;
string fullName = element.GetFullName();
if (fullName.StartsWith(FieldItem.Id))
{
newItem = new FieldItem(parent, element);
}
else if (fullName.StartsWith(PropertyItem.Id))
{
newItem =
fullName.EndsWith(")")
? new IndexItem(new MethodItem(parent, element))
: new PropertyItem(parent, element) as AMemberItem;
}
else if (fullName.StartsWith(MethodItem.Id))
{
newItem = new MethodItem(parent, element);
newItem =
newItem.Name.StartsWith("#")
? new ConstructorItem(newItem as MethodItem)
: OperatorItem.HandleOperator(newItem as MethodItem);
}
else if (fullName.StartsWith(EventItem.Id))
{
newItem = new EventItem(parent, element);
}
else
{
throw new Exception($"unhandled doc item {fullName}");
}
items.Add(fullName, newItem);
}
return(items);
}
// 0 -- the same priority
// -1 -- item < other
// 1 -- item > other
// 2 -- error
public int compare(Operator otherOps)
{
OperatorItem other = otherOps.GetOperator();
switch (item)
{
case OperatorItem.Plus:
switch (other)
{
case OperatorItem.Plus:
case OperatorItem.Minus:
return(1);
case OperatorItem.Times:
case OperatorItem.Divides:
case OperatorItem.LeftBrace:
return(-1);
case OperatorItem.RightBrace:
case OperatorItem.StackTop:
return(1);
}
break;
case OperatorItem.Minus:
switch (other)
{
case OperatorItem.Plus:
case OperatorItem.Minus:
return(1);
case OperatorItem.Times:
case OperatorItem.Divides:
case OperatorItem.LeftBrace:
return(-1);
case OperatorItem.RightBrace:
case OperatorItem.StackTop:
return(1);
}
break;
case OperatorItem.Times:
switch (other)
{
case OperatorItem.Plus:
case OperatorItem.Minus:
case OperatorItem.Times:
case OperatorItem.Divides:
return(1);
case OperatorItem.LeftBrace:
return(-1);
case OperatorItem.RightBrace:
case OperatorItem.StackTop:
return(1);
}
break;
case OperatorItem.Divides:
switch (other)
{
case OperatorItem.Plus:
case OperatorItem.Minus:
case OperatorItem.Times:
case OperatorItem.Divides:
return(1);
case OperatorItem.LeftBrace:
return(-1);
case OperatorItem.RightBrace:
case OperatorItem.StackTop:
return(1);
}
break;
case OperatorItem.LeftBrace:
switch (other)
{
case OperatorItem.Plus:
case OperatorItem.Minus:
case OperatorItem.Times:
case OperatorItem.Divides:
case OperatorItem.LeftBrace:
return(-1);
case OperatorItem.RightBrace:
return(0);
case OperatorItem.StackTop:
return(2);
}
break;
case OperatorItem.RightBrace:
switch (other)
{
case OperatorItem.Plus:
case OperatorItem.Minus:
case OperatorItem.Times:
case OperatorItem.Divides:
return(1);
case OperatorItem.LeftBrace:
return(2);
case OperatorItem.RightBrace:
case OperatorItem.StackTop:
return(1);
}
break;
case OperatorItem.StackTop:
switch (other)
{
case OperatorItem.Plus:
case OperatorItem.Minus:
case OperatorItem.Times:
case OperatorItem.Divides:
case OperatorItem.LeftBrace:
return(-1);
case OperatorItem.RightBrace:
return(2);
case OperatorItem.StackTop:
return(0);
}
break;
}
return(2);
}
public Operator()
{
this.item = OperatorItem.StackTop;
}
