protected QGroupNode ComposeGroupNode(QNode node1, QNode node2, QGroupType groupType)
{
QGroupNode group1 = node1 as QGroupNode, group2 = node2 as QGroupNode;
if (group1 != null && group1.GroupType != groupType)
{
group1 = null;
}
if (group2 != null && group2.GroupType != groupType)
{
group2 = null;
}
// don't corrupt named groups
if (group1 != null && group1.Name != null || group2 != null && group2.Name != null)
{
group1 = group2 = null;
}
if (group1 == null)
{
if (group2 == null)
{
QGroupNode group = new QGroupNode(groupType);
group.Nodes.Add(node1);
group.Nodes.Add(node2);
return(group);
}
else
{
group2.Nodes.Insert(0, node1);
return(group2);
}
}
else
{
if (group2 == null)
{
group1.Nodes.Add(node2);
}
else
{
foreach (QNode qn in group2.Nodes)
{
group1.Nodes.Add(qn);
}
}
return(group1);
}
}
/// <summary>
/// Initializes a new instance of the QueryGroupNode with specified logical operator
/// </summary>
/// <param name="type">group logical operator (<see cref="NReco.Data.QGroupType"/>)</param>
public QGroupNode(QGroupType type)
{
GroupType = type;
_Nodes = new List <QNode>();
}
protected QNode ParseConditionGroup(string input, int startIdx, out int endIdx)
{
int nextEndIdx;
LexemType lexemType = GetLexemType(input, startIdx, out nextEndIdx);
string lexem = GetLexem(input, startIdx, nextEndIdx);
QNode node;
if (lexemType == LexemType.Delimiter && lexem == "(")
{
string nodeName = ParseNodeName(input, nextEndIdx, out endIdx);
nextEndIdx = endIdx;
// check for empty group
lexemType = GetLexemType(input, nextEndIdx, out endIdx);
if (lexemType == LexemType.Delimiter && GetLexem(input, nextEndIdx, endIdx) == ")")
{
node = null;
// push back
endIdx = nextEndIdx;
}
else
{
node = ParseConditionGroup(input, nextEndIdx, out endIdx);
}
if (nodeName != null)
{
if (node == null)
{
node = new QGroupNode(QGroupType.And);
}
if (node is QNode)
{
((QNode)node).Name = nodeName;
}
}
// read ')'
lexemType = GetLexemType(input, endIdx, out nextEndIdx);
if (lexemType != LexemType.Delimiter || GetLexem(input, endIdx, nextEndIdx) != ")")
{
throw new RelexParseException(
String.Format("Invalid syntax (position: {0}, expression: {1})", endIdx, input));
}
endIdx = nextEndIdx;
}
else
{
node = ParseCondition(input, startIdx, out nextEndIdx);
endIdx = nextEndIdx;
}
// check for group
lexemType = GetLexemType(input, endIdx, out nextEndIdx);
QGroupType groupType = QGroupType.And;
if (GetGroupType(lexemType, input, endIdx, ref nextEndIdx, ref groupType))
{
return(ComposeGroupNode(node, ParseConditionGroup(input, nextEndIdx, out endIdx), groupType));
}
return(node);
}
protected bool GetGroupType(LexemType lexemType, string s, int startIdx, ref int endIdx, ref QGroupType groupType)
{
string lexem = GetLexem(s, startIdx, endIdx).ToLower();
if (lexemType == LexemType.Name)
{
int idx = Array.IndexOf(nameGroups, lexem);
if (idx < 0)
{
return(false);
}
groupType = enumGroups[idx];
return(true);
}
if (lexemType == LexemType.Delimiter)
{
// read all available delimiters...
GetAllDelimiters(s, endIdx, out endIdx);
lexem = GetLexem(s, startIdx, endIdx);
int idx = Array.IndexOf(delimiterGroups, lexem);
if (idx < 0)
{
return(false);
}
groupType = enumGroups[idx];
return(true);
}
return(false);
}
