public void Init(ParsingContext context, ParseTreeNode parseNode)
{
#region get Type
_TypeName = ((AstNode)parseNode.ChildNodes[1].AstNode).AsString;
#endregion
#region get myAttributes
if (HasChildNodes(parseNode.ChildNodes[3]))
{
var AttrUpdateOrAssign = (AttributeUpdateOrAssignListNode)parseNode.ChildNodes[3].AstNode;
_listOfUpdates = AttrUpdateOrAssign.ListOfUpdate;
}
#endregion
#region whereClauseOpt
if (parseNode.ChildNodes[4].ChildNodes != null && parseNode.ChildNodes[4].ChildNodes.Count != 0)
{
var tempWhereNode = (WhereExpressionNode)parseNode.ChildNodes[4].AstNode;
_WhereExpression = tempWhereNode.BinaryExpressionDefinition;
}
#endregion
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
if (HasChildNodes(parseNode))
{
//get type
if (parseNode.ChildNodes[1] != null && parseNode.ChildNodes[1].AstNode != null)
{
_type = ((AstNode)(parseNode.ChildNodes[1].AstNode)).AsString;
}
else
{
throw new NotImplementedQLException("");
}
if (parseNode.ChildNodes[3] != null && HasChildNodes(parseNode.ChildNodes[3]))
{
_attributeAssignList = (parseNode.ChildNodes[3].AstNode as AttributeAssignListNode).AttributeAssigns;
}
if (parseNode.ChildNodes[4] != null && ((WhereExpressionNode)parseNode.ChildNodes[4].AstNode).BinaryExpressionDefinition != null)
{
_whereExpression = ((WhereExpressionNode)parseNode.ChildNodes[4].AstNode).BinaryExpressionDefinition;
}
}
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
if (HasChildNodes(parseNode))
{
//get type
if (parseNode.ChildNodes[1] != null && parseNode.ChildNodes[1].AstNode != null)
{
_Type = ((AstNode)(parseNode.ChildNodes[1].AstNode)).AsString;
}
else
{
throw new NotImplementedQLException("");
}
if (parseNode.ChildNodes[3] != null && HasChildNodes(parseNode.ChildNodes[3]))
{
_AttributeAssignList = new List <AAttributeAssignOrUpdate>((parseNode.ChildNodes[3].AstNode as AttributeUpdateOrAssignListNode).ListOfUpdate.Select(e => e as AAttributeAssignOrUpdate));
}
if (parseNode.ChildNodes[4] != null && ((WhereExpressionNode)parseNode.ChildNodes[4].AstNode).BinaryExpressionDefinition != null)
{
_WhereExpression = ((WhereExpressionNode)parseNode.ChildNodes[4].AstNode).BinaryExpressionDefinition;
}
}
}
private static IEnumerable <IVertex> ProcessBinaryExpression(
BinaryExpressionDefinition binExpression,
GQLPluginManager myPluginManager,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
Int64 myTransactionToken,
IVertexType vertexType)
{
//validate
binExpression.Validate(myPluginManager,
myGraphDB,
mySecurityToken,
myTransactionToken,
vertexType);
//calculate
var expressionGraph =
binExpression.Calculon(myPluginManager,
myGraphDB,
mySecurityToken,
myTransactionToken,
new CommonUsageGraph(myGraphDB,
mySecurityToken,
myTransactionToken),
false);
//extract
return
(expressionGraph.Select(
new LevelKey(vertexType.ID,
myGraphDB,
mySecurityToken,
myTransactionToken),
null, true));
}
/// <summary>
/// Creates all readouts of all types in the <paramref name="myTypeList"/>
/// </summary>
private List <IEnumerable <IVertexView> > CreateVertices(SecurityToken mySecurityToken,
Int64 myTransactionToken,
Dictionary <String, IVertexType> myTypeList,
SelectResultManager mySelectResultManager,
BinaryExpressionDefinition myWhereExpressionDefinition,
Int64 myResolutionDepth,
OrderByDefinition myOrderByDefinition,
UInt64?myLimit,
UInt64?myOffset)
{
var _ListOfListOfVertices = new List <IEnumerable <IVertexView> >();
// Create vertices for type
foreach (var typeRef in myTypeList)
{
var _Vertices = CreateVerticesForType(mySecurityToken,
myTransactionToken,
typeRef,
mySelectResultManager,
myWhereExpressionDefinition,
myResolutionDepth,
myOrderByDefinition,
myLimit,
myOffset);
// If this type did not returned any result, we wont add it to the result
if (_Vertices != null)
{
_ListOfListOfVertices.Add(_Vertices);
}
}
return(_ListOfListOfVertices);
}
public InvalidBinaryExpressionIndexException(BinaryExpressionDefinition myBinaryExpression)
{
_msg = String.Format("The index {0} for the BinaryExpression {1} {2} {3} is not valid",
myBinaryExpression.ExpressionIndex,
myBinaryExpression.Left.ToString(),
myBinaryExpression.Operator,
myBinaryExpression.Right.ToString());
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
if (HasChildNodes(parseNode))
{
if (parseNode.ChildNodes[1].AstNode is TupleNode && (parseNode.ChildNodes[1].AstNode as TupleNode).TupleDefinition.TupleElements.Count == 1)
{
var tuple = (parseNode.ChildNodes[1].AstNode as TupleNode).TupleDefinition.Simplyfy();
BinaryExpressionDefinition = (tuple.TupleElements[0].Value as BinaryExpressionDefinition);
}
else if (parseNode.ChildNodes[1].AstNode is BinaryExpressionNode)
{
BinaryExpressionDefinition = ((BinaryExpressionNode)parseNode.ChildNodes[1].AstNode).BinaryExpressionDefinition;
}
}
}
private BinaryExpressionDefinition GetConditionNode(String myOperator, BinaryExpressionDefinition myPrevNode, TupleDefinition myNodeList)
{
var binElem = myNodeList.FirstOrDefault();
if (binElem == null)
{
return(myPrevNode);
}
myNodeList.Remove(binElem);
var binNode = new BinaryExpressionDefinition(myOperator, myPrevNode, binElem.Value);
return(GetConditionNode(myOperator, binNode, myNodeList));
}
/// <summary>
/// Checks the where expression, optimize it and create an IExpressionGraph
/// </summary>
private IExpressionGraph GetExpressionGraphFromWhere(BinaryExpressionDefinition myWhereExpressionDefinition, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
#region interesting where
#region exec expr
myWhereExpressionDefinition.Validate(_pluginManager, _graphdb, mySecurityToken, myTransactionToken);
var calculonResult = myWhereExpressionDefinition.Calculon(_pluginManager, _graphdb, mySecurityToken, myTransactionToken, new CommonUsageGraph(_graphdb, mySecurityToken, myTransactionToken), false);
#endregion
#endregion
return(calculonResult);
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
if (HasChildNodes(parseNode))
{
_TypeName = ((AstNode)(parseNode.ChildNodes[1].AstNode)).AsString;
if (parseNode.ChildNodes[3] != null && HasChildNodes(parseNode.ChildNodes[3]))
{
_AttributeAssignList = (parseNode.ChildNodes[3].AstNode as AttributeAssignListNode).AttributeAssigns;
}
_whereExpression = ((BinaryExpressionNode)parseNode.ChildNodes[5].AstNode).BinaryExpressionDefinition;
System.Diagnostics.Debug.Assert(_whereExpression != null);
}
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
#region set type of binary expression
_OperatorSymbol = parseNode.ChildNodes[1].FirstChild.Token.ValueString;
_left = GetExpressionDefinition(parseNode.ChildNodes[0]);
_right = GetExpressionDefinition(parseNode.ChildNodes[2]);
if (parseNode.ChildNodes.Count > 3)
{
_expressionIndex = ((AstNode)parseNode.ChildNodes[4].AstNode).AsString;
}
#endregion
BinaryExpressionDefinition = new BinaryExpressionDefinition(_OperatorSymbol,
_left,
_right,
_expressionIndex);
OriginalString += _left.ToString() + " ";
OriginalString += _OperatorSymbol + " ";
OriginalString += _right.ToString();
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
_toBeDeletedAttributes = new List <String>();
_typeName = parseNode.ChildNodes[1].Token.ValueString;
if (HasChildNodes(parseNode.ChildNodes[3]))
{
foreach (var _ParseTreeNode in parseNode.ChildNodes[3].ChildNodes[0].ChildNodes)
{
_toBeDeletedAttributes.Add(_ParseTreeNode.ChildNodes[0].Token.ValueString);
}
}
#region whereClauseOpt
if (parseNode.ChildNodes[4].ChildNodes != null && parseNode.ChildNodes[4].ChildNodes.Count != 0)
{
WhereExpressionNode tempWhereNode = (WhereExpressionNode)parseNode.ChildNodes[4].AstNode;
_WhereExpression = tempWhereNode.BinaryExpressionDefinition;
}
#endregion
}
/// <summary>
/// Checks whether the <paramref name="myReference"/> is interesting for the <paramref name="myWhereExpressionDefinition"/>
/// </summary>
/// <param name="myReference">The reference defined in the FROM</param>
/// <param name="myWhereExpressionDefinition"></param>
/// <returns></returns>
private Boolean IsInterestingWhereForReference(String myReference, BinaryExpressionDefinition myWhereExpressionDefinition)
{
#region check left
var leftIDNode = myWhereExpressionDefinition.Left as IDChainDefinition;
if (leftIDNode != null)
{
if (leftIDNode.Reference != null)
{
if (leftIDNode.Reference.Item1.Equals(myReference))
{
return(true);
}
}
}
else if (myWhereExpressionDefinition.Left is BinaryExpressionDefinition)
{
return(IsInterestingWhereForReference(myReference, (BinaryExpressionDefinition)myWhereExpressionDefinition.Left));
}
// even atom value operation needs to be evaluate. Somthing like this:
// where 12 = 12 or where true
// should have a valid result!
else if (myWhereExpressionDefinition.Left is AOperationDefinition || myWhereExpressionDefinition.Left is AggregateDefinition)
{
return(true);
}
#endregion
#region check right
var rightIDNode = myWhereExpressionDefinition.Right as IDChainDefinition;
if (rightIDNode != null)
{
if (rightIDNode.Reference != null)
{
if (rightIDNode.Reference.Item1.Equals(myReference) || myWhereExpressionDefinition.Left is TupleDefinition)
{
return(true);
}
}
}
else if (myWhereExpressionDefinition.Right is BinaryExpressionDefinition)
{
return(IsInterestingWhereForReference(myReference, (BinaryExpressionDefinition)myWhereExpressionDefinition.Right));
}
// even atom value operation needs to be evaluate. Somthing like this:
// where 12 = 12 or where true
// should have a valid result!
else if (myWhereExpressionDefinition.Right is AOperationDefinition || myWhereExpressionDefinition.Right is AggregateDefinition)
{
return(true);
}
#endregion
return(false);
}
/// <summary>
/// Creates the lazy readouts for the given <paramref name="myTypeReference"/>
/// </summary>
private IEnumerable <IVertexView> CreateVerticesForType(SecurityToken mySecurityToken,
Int64 myTransactionToken,
KeyValuePair <String, IVertexType> myTypeReference,
SelectResultManager mySelectResultManager,
BinaryExpressionDefinition myWhereExpressionDefinition,
Int64 myResolutionDepth,
OrderByDefinition myOrderByDefinition,
UInt64?myLimit,
UInt64?myOffset)
{
IEnumerable <IVertexView> _Vertices = new List <IVertexView>();
#region Check groupings & aggregates
mySelectResultManager.ValidateGroupingAndAggregate(myTypeReference.Key, myTypeReference.Value);
#endregion
#region Check, whether the type was affected by the where expressions. This will use either the Graph or the GUID index of the type
Boolean isInterestingWhere = (myWhereExpressionDefinition != null && IsInterestingWhereForReference(myTypeReference.Key, myWhereExpressionDefinition));
#endregion
#region Create an IEnumerable of Readouts for this typeNode
var result = mySelectResultManager.Examine(myResolutionDepth, myTypeReference.Key, myTypeReference.Value, isInterestingWhere, ref _Vertices, mySecurityToken, myTransactionToken);
#endregion
#region If this type did not returned any result, we wont add it to the result
if (!result)
{
return(new List <IVertexView>());
}
#endregion
#region If there was a result for this typeNode we will add a new SelectionListElementResult
// _Vertices = mySelectResultManager.GetResult(_Vertices);
#region OrderBy
if (myOrderByDefinition != null)
{
OrderVertices(mySecurityToken, myTransactionToken, myOrderByDefinition, ref _Vertices);
}
#endregion
#region Limit
if (myLimit != null || myOffset != null)
{
ApplyLimitAndOffset(myLimit, myOffset, ref _Vertices);
}
#endregion
#endregion
return(_Vertices);
}
public AttributeAssignOrUpdateExpression(IDChainDefinition myIDChainDefinition, BinaryExpressionDefinition binaryExpressionDefinition)
: base(myIDChainDefinition)
{
BinaryExpressionDefinition = binaryExpressionDefinition;
}
/// <summary>
/// Initializes a new instance of the BinaryExpressionDefinition class.
/// </summary>
/// <param name="myBinaryExpression"></param>
/// <param name="innerException">The exception that is the cause of the current exception, this parameter can be NULL.</param>
public InvalidBinaryExpressionException(BinaryExpressionDefinition myBinaryExpression, Exception innerException = null) : base(innerException)
{
_msg = String.Format("The BinaryExpression is not valid: {0} {1} {2}", myBinaryExpression.Left.ToString(), myBinaryExpression.Operator, myBinaryExpression.Right.ToString());
}
public void Init(ParsingContext context, ParseTreeNode myParseTreeNode)
{
var _GraphQLGrammar = (SonesGQLGrammar)context.Language.Grammar;
_Targets = new HashSet <AAttributeAssignOrUpdateOrRemove>();
#region FROM Sources
_SourceType = ((ATypeNode)myParseTreeNode.ChildNodes[1].AstNode).ReferenceAndType.TypeName;
var typeNode = _SourceType;
_Sources = (myParseTreeNode.ChildNodes[2].AstNode as TupleNode).TupleDefinition;
if (_Sources.Count() > 1)
{
var firstElement = (BinaryExpressionDefinition)_Sources.First().Value;
_Sources.Remove(_Sources.First());
_Condition = GetConditionNode("OR", firstElement, _Sources);
}
else
{
_Condition = (BinaryExpressionDefinition)_Sources.First().Value;
}
#endregion
#region Find statement "VIA Edge"
IDNode _EdgeAttr = null;
// Semantic Web Yoda-style...
if (myParseTreeNode.ChildNodes[3].Token.KeyTerm == _GraphQLGrammar.S_VIA)
{
_EdgeAttr = (myParseTreeNode.ChildNodes[4].AstNode as IDNode);
}
else // Human language style...
{
if (myParseTreeNode.ChildNodes[5].Token.KeyTerm == _GraphQLGrammar.S_VIA)
{
_EdgeAttr = (myParseTreeNode.ChildNodes[6].AstNode as IDNode);
}
}
#endregion
#region Find statement "TO Targets"
TupleDefinition tupleDef = null;
// Semantic Web Yoda-style...
if (myParseTreeNode.ChildNodes[5].Token.KeyTerm == _GraphQLGrammar.S_TO)
{
typeNode = ((ATypeNode)myParseTreeNode.ChildNodes[6].ChildNodes[0].AstNode).ReferenceAndType.TypeName;
tupleDef = (myParseTreeNode.ChildNodes[6].ChildNodes[1].AstNode as TupleNode).TupleDefinition;
}
else // Human language style...
{
if (myParseTreeNode.ChildNodes[3].Token.KeyTerm == _GraphQLGrammar.S_TO)
{
typeNode = ((ATypeNode)myParseTreeNode.ChildNodes[4].ChildNodes[0].AstNode).ReferenceAndType.TypeName;
tupleDef = (myParseTreeNode.ChildNodes[4].ChildNodes[1].AstNode as TupleNode).TupleDefinition;
}
}
#endregion
#region Processing...
var tupleDefTargetType = new TupleDefinition(tupleDef.KindOfTuple);
foreach (var item in tupleDef.TupleElements)
{
var attrName = typeNode + SonesGQLConstants.EdgeTraversalDelimiterSymbol + ((IDChainDefinition)((BinaryExpressionDefinition)item.Value).Left).ContentString;
var leftNode = new IDChainDefinition(attrName, new List <TypeReferenceDefinition>()
{
new TypeReferenceDefinition(typeNode, typeNode)
});
leftNode.AddPart(new ChainPartTypeOrAttributeDefinition(((IDChainDefinition)((BinaryExpressionDefinition)item.Value).Left).ContentString));
var rightNode = ((BinaryExpressionDefinition)item.Value).Right;
var binExpression = new BinaryExpressionDefinition(((BinaryExpressionDefinition)item.Value).OperatorSymbol, leftNode, rightNode);
tupleDefTargetType.AddElement(new TupleElement(binExpression));
}
_Targets.Add(new AttributeAssignOrUpdateList(new CollectionDefinition(CollectionType.Set, tupleDefTargetType), _EdgeAttr.IDChainDefinition, false));
#endregion
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
_Sources = new HashSet <AAttributeAssignOrUpdateOrRemove>();
#region VIA edge
IDNode _EdgeAttr = null;
if (parseNode.ChildNodes[4].AstNode is IDNode) //Semantic Web Yoda style
{
_EdgeAttr = (parseNode.ChildNodes[4].AstNode as IDNode);
}
else //Human language style
{
_EdgeAttr = (parseNode.ChildNodes[6].AstNode as IDNode);
}
#endregion
#region sources
var typeNode = ((ATypeNode)parseNode.ChildNodes[1].AstNode).ReferenceAndType.TypeName;
var tupleDef = (parseNode.ChildNodes[2].AstNode as TupleNode).TupleDefinition;
var tupleDefSourceType = new TupleDefinition(tupleDef.KindOfTuple);
_TargetType = typeNode;
foreach (var item in tupleDef.TupleElements)
{
var attrName = typeNode + SonesGQLConstants.EdgeTraversalDelimiterSymbol + ((IDChainDefinition)((BinaryExpressionDefinition)item.Value).Left).ContentString;
var leftNode = new IDChainDefinition(attrName, new List <TypeReferenceDefinition>()
{
new TypeReferenceDefinition(typeNode, typeNode)
});
leftNode.AddPart(new ChainPartTypeOrAttributeDefinition(((IDChainDefinition)((BinaryExpressionDefinition)item.Value).Left).ContentString));
var rightNode = ((BinaryExpressionDefinition)item.Value).Right;
var binExpression = new BinaryExpressionDefinition(((BinaryExpressionDefinition)item.Value).OperatorSymbol, leftNode, rightNode);
tupleDefSourceType.AddElement(new TupleElement(binExpression));
}
_Sources.Add(new AttributeRemoveList(_EdgeAttr.IDChainDefinition, _EdgeAttr.IDChainDefinition.ContentString, tupleDefSourceType));
#endregion
#region sources FROM
if (parseNode.ChildNodes[6].ChildNodes[0].AstNode is ATypeNode) //Semantic Web Yoda style
{
typeNode = ((ATypeNode)parseNode.ChildNodes[6].ChildNodes[0].AstNode).ReferenceAndType.TypeName;
_Targets = (parseNode.ChildNodes[6].ChildNodes[1].AstNode as TupleNode).TupleDefinition;
}
else //Human language style
{
typeNode = ((ATypeNode)parseNode.ChildNodes[4].ChildNodes[0].AstNode).ReferenceAndType.TypeName;
_Targets = (parseNode.ChildNodes[4].ChildNodes[1].AstNode as TupleNode).TupleDefinition;
}
_SourceType = typeNode;
if (_Targets.Count() > 1)
{
var firstElement = (BinaryExpressionDefinition)_Targets.First().Value;
_Targets.Remove(_Targets.First());
_Condition = GetConditionNode("OR", firstElement, _Targets);
}
else
{
_Condition = (BinaryExpressionDefinition)_Targets.First().Value;
}
#endregion
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
#region Data
TypeList = new List <TypeReferenceDefinition>();
GroupByIDs = new List <IDChainDefinition>();
SelectedElements = new List <Tuple <AExpressionDefinition, string, SelectValueAssignment> >();
Limit = null;
Offset = null;
WhereExpressionDefinition = null;
ResolutionDepth = -1;
#endregion
#region TypeList
foreach (ParseTreeNode aNode in parseNode.ChildNodes[1].ChildNodes)
{
ATypeNode aType = (ATypeNode)aNode.AstNode;
// use the overrides equals to check duplicated references
if (!TypeList.Contains(aType.ReferenceAndType))
{
TypeList.Add(aType.ReferenceAndType);
}
else
{
throw new DuplicateReferenceOccurrenceException(aType.ReferenceAndType.TypeName);
}
}
#endregion
#region selList
foreach (ParseTreeNode aNode in parseNode.ChildNodes[3].ChildNodes)
{
SelectionListElementNode aColumnItemNode = (SelectionListElementNode)aNode.AstNode;
String typeName = null;
if (aColumnItemNode.SelType != TypesOfSelect.None)
{
foreach (var reference in GetTypeReferenceDefinitions(context))
{
//SelectedElements.Add(new IDChainDefinition(new ChainPartTypeOrAttributeDefinition(reference.TypeName), aColumnItemNode.SelType, typeName), null);
SelectedElements.Add(new Tuple <AExpressionDefinition, string, SelectValueAssignment>(
new IDChainDefinition(
new ChainPartTypeOrAttributeDefinition(reference.TypeName),
aColumnItemNode.SelType, typeName),
null, aColumnItemNode.ValueAssignment));
}
continue;
}
SelectedElements.Add(new Tuple <AExpressionDefinition, string, SelectValueAssignment>(
aColumnItemNode.ColumnSourceValue, aColumnItemNode.AliasId, aColumnItemNode.ValueAssignment));
}
#endregion
#region whereClauseOpt
if (parseNode.ChildNodes[4].ChildNodes != null && parseNode.ChildNodes[4].ChildNodes.Count > 0)
{
WhereExpressionNode tempWhereNode = (WhereExpressionNode)parseNode.ChildNodes[4].AstNode;
if (tempWhereNode.BinaryExpressionDefinition != null)
{
WhereExpressionDefinition = tempWhereNode.BinaryExpressionDefinition;
}
}
#endregion
#region groupClauseOpt
if (HasChildNodes(parseNode.ChildNodes[5]) && HasChildNodes(parseNode.ChildNodes[5].ChildNodes[2]))
{
foreach (ParseTreeNode node in parseNode.ChildNodes[5].ChildNodes[2].ChildNodes)
{
GroupByIDs.Add(((IDNode)node.AstNode).IDChainDefinition);
}
}
#endregion
#region havingClauseOpt
if (HasChildNodes(parseNode.ChildNodes[6]))
{
Having = ((BinaryExpressionNode)parseNode.ChildNodes[6].ChildNodes[1].AstNode).BinaryExpressionDefinition;
}
#endregion
#region orderClauseOpt
if (HasChildNodes(parseNode.ChildNodes[7]))
{
OrderByDefinition = ((OrderByNode)parseNode.ChildNodes[7].AstNode).OrderByDefinition;
}
#endregion
#region Offset
if (HasChildNodes(parseNode.ChildNodes[8]))
{
Offset = ((OffsetNode)parseNode.ChildNodes[8].AstNode).Count;
}
#endregion
#region Limit
if (HasChildNodes(parseNode.ChildNodes[9]))
{
Limit = ((LimitNode)parseNode.ChildNodes[9].AstNode).Count;
}
#endregion
#region Depth
if (HasChildNodes(parseNode.ChildNodes[10]))
{
ResolutionDepth = Convert.ToUInt16(parseNode.ChildNodes[10].ChildNodes[1].Token.Value);
}
#endregion
#region Select Output
if (HasChildNodes(parseNode.ChildNodes[11]))
{
_SelectOutputType = (parseNode.ChildNodes[11].AstNode as SelectOutputOptNode).SelectOutputType;
}
#endregion
}
/// <summary>
/// fast check if a given binary expression node is suitable for list integration
/// </summary>
/// <param name="aUniqueExpr">A BinaryExpressionNode.</param>
/// <param name="myAttributes"></param>
/// <returns></returns>
private bool IsValidBinaryExpressionNode(BinaryExpressionDefinition aUniqueExpr, Dictionary <string, string> attributes)
{
switch (aUniqueExpr.TypeOfBinaryExpression)
{
case TypesOfBinaryExpression.LeftComplex:
#region left complex
return(CheckIDNode(aUniqueExpr.Left, attributes));
#endregion
case TypesOfBinaryExpression.RightComplex:
#region right complex
return(CheckIDNode(aUniqueExpr.Right, attributes));
#endregion
case TypesOfBinaryExpression.Complex:
#region complex
#region Data
BinaryExpressionDefinition leftNode = null;
BinaryExpressionDefinition rightNode = null;
#endregion
#region get expr
#region left
if (aUniqueExpr.Left is BinaryExpressionDefinition)
{
leftNode = (BinaryExpressionDefinition)aUniqueExpr.Left;
}
else
{
return(false);
}
#endregion
#region right
if (aUniqueExpr.Right is BinaryExpressionDefinition)
{
rightNode = (BinaryExpressionDefinition)aUniqueExpr.Right;
}
else
{
return(false);
}
#endregion
#endregion
#region check
if ((leftNode != null) && (rightNode != null))
{
if (IsValidBinaryExpressionNode(leftNode, attributes) && IsValidBinaryExpressionNode(rightNode, attributes))
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
#endregion
#endregion
#region error cases
case TypesOfBinaryExpression.Atom:
default:
//in this kind of node it is not allowed to use Atom or complex expressions
return(false);
#endregion
}
}
