public static Group createGroup(object[] items, LogicalOperator logicalOperator) { Group gr1 = new Group(); gr1.logicRelation = logicalOperator; gr1.Items = items; return gr1; }
/// <summary> /// Creates a new instance of a CriteriaValue object, and initializes it with the specified properties. /// </summary> /// <param name="logicalOperator"></param> /// <param name="key"></param> /// <param name="value"></param> public CriteriaValue(LogicalOperator logicalOperator, string key, object value) { this.LogicalOperator = LogicalOperator; this.Key = key; this.Value = $"{value}"; // TODO: serialize. this.ValueType = value?.GetType().FullName; }
public PrimitiveTask(string n, CompoundTask p) { name = n; arguments = new List <Term>(); arguments.Capacity = 3; preconditions = new List <Atom>(); effects = new List <Atom>(); cuncurrentTasks = new List <CuncurrentTask> (); cost = 1; loop = false; logicalOperator = LogicalOperator.AND; actionType = ActionTypes.MOVEMENT; groundData = new GroundData(); groundData.animationState = ""; groundData.name = ""; parent = p; }
/// <summary> /// Instantiates a new atom group. /// </summary> /// <param name="logicalOperator">The operator that characterizes the relationship between the atoms and atoms group.</param> /// <param name="members">An array containing atoms and atom groups.</param> internal AtomGroup(LogicalOperator logicalOperator, object[] members, object[] runningMembers) { // order atoms & groups so naf-atoms are at the end foreach(object o in members) { if (o == null) throw new BREException("An atom group can not contain a null member"); else if (o is AtomGroup) { if (((AtomGroup)o).logicalOperator == logicalOperator) throw new BREException("An atom group can not contain another group with the same logical operator"); } else if (o is Atom) { if (((Atom)o).HasFormula) throw new BREException("An atom group can not contain an atom that contains a formula"); } else throw new BREException("An atom group can not hold objects of type: " + o.GetType()); } this.logicalOperator = logicalOperator; this.members = members; orderedMembers = (object[])runningMembers.Clone(); Array.Sort(orderedMembers, new AtomComparer()); this.orderedMembers = orderedMembers; resolvedMembers = new object[orderedMembers.Length]; for(int i=0; i<orderedMembers.Length; i++) { if (orderedMembers[i] is Atom) resolvedMembers[i] = Atom.ResolveFunctions((Atom)orderedMembers[i]); else resolvedMembers[i] = orderedMembers[i]; } }
public PartExtractor(LogicalOperator logicalOperator) { if (logicalOperator == LogicalOperator.And) _operatorToBreakAt = BinaryOperator.LogicalAnd; else _operatorToBreakAt = BinaryOperator.LogicalOr; }
public FilterCondition(string fieldName, object value, FilterOperator @operator, LogicalOperator whereoperator) { FieldName = fieldName; Value = value; Operator = @operator; WhereOperator = whereoperator; }
/// <summary> /// 创建一个Between And条件 /// </summary> /// <param name="logicalOperator">与上个条件的关系</param> /// <param name="isNot">是否求反</param> /// <param name="propertyName">属性名称</param> /// <param name="startValue">起始值</param> /// <param name="endValue">结束值</param> /// <returns>创建的条件</returns> public static ICondition BetweenAnd(string propertyName, object startValue, object endValue, LogicalOperator logicalOperator = LogicalOperator.And, bool isNot = false) { return(new DoubleValueCondition(logicalOperator, isNot, propertyName, Operator.BetweenAnd, startValue, endValue)); }
protected override void AddBetweenFilterCondition <T, TMember>( Expression <Func <T, TMember> > selector, TMember start, TMember end, string alias = null, LogicalOperator logicalOperator = LogicalOperator.NotSet) { var conditions1 = currentFilterGroup.Conditions; var filterCondition1 = new FilterCondition(); filterCondition1.Alias = alias; filterCondition1.EntityType = typeof(T); filterCondition1.Operator = ">="; filterCondition1.Left = GetMemberName(selector); filterCondition1.LocigalOperator = logicalOperator; filterCondition1.Right = FormatValue(start); var filterCondition2 = filterCondition1; conditions1.Add(filterCondition2); var conditions2 = currentFilterGroup.Conditions; var filterCondition3 = new FilterCondition(); filterCondition3.Alias = alias; filterCondition3.EntityType = typeof(T); filterCondition3.Operator = "<="; filterCondition3.Left = GetMemberName(selector); filterCondition3.LocigalOperator = LogicalOperator.And; filterCondition3.Right = FormatValue(end); var filterCondition4 = filterCondition3; conditions2.Add(filterCondition4); }
// Constructors public QueryStrings(int fieldId, ComparisonOperator comparisonOp, string matchingValue, LogicalOperator logicalOp) { FieldId = fieldId; ComparisonOp = comparisonOp; MatchingValue = matchingValue; LogicalOp = logicalOp; }
private void ConcatConditionGroup(ref string conditionString, LogicalOperator concatOperator, IConditionGroup conditionGroup, string groupPrefix = "(", string groupPostfix = ")") { var groupString = string.Empty; foreach (var condition in conditionGroup.Conditions) { if (condition is IConditionGroup) { ConcatConditionGroup(ref groupString, conditionGroup.ConcatOperator, (IConditionGroup)condition); } else if (condition is IFieldCondition) { ConcatFieldCondition(ref groupString, conditionGroup.ConcatOperator, (IFieldCondition)condition); } else if (condition is IConditionString) { ConcatConditionString(ref groupString, conditionGroup.ConcatOperator, (IConditionString)condition); } } if (string.IsNullOrEmpty(groupString)) { return; } conditionString = string.Concat(conditionString, GetOperatorStringIfStringIsNotEmpty(conditionString, concatOperator), groupPrefix, groupString, groupPostfix); }
public QueryCriteria AddFilter(LogicalOperator logicalOperator) { var filter = new QueryCriteria(logicalOperator, EntityName); Filters.Add(filter); return(filter); }
/// <summary> /// 转换为sql条件字符串 /// </summary> /// <param name="key">关键字.</param> /// <param name="oper">条件运算符</param> /// <param name="link">操作类型.</param> /// <returns> /// System.String /// </returns> public string ToWhereString(string key, ConditionalOperator oper, LogicalOperator link) { if (Value == null) { return(""); } string result = ""; string column = !string.IsNullOrEmpty(key) ? key : Name; string query = ToCriteria(column, Value, oper); #region 处理逻辑运算符 if (query != "") { switch (link) { case LogicalOperator.Or: result = " OR (" + query + ")"; break; case LogicalOperator.And: default: result = " AND (" + query + ")"; break; } } #endregion return(result); }
public LogicalExpression MakeLogical(string op, LogicalExpression lhs, LogicalExpression rhs) { LogicalOperator logicalOp = new LogicalOperator(); if (op == "And") { logicalOp.AddAnd(new Altova.Types.SchemaString("And")); } else { logicalOp.AddOr(new Altova.Types.SchemaString("Or")); } LogicalType newLogicalExpression = new LogicalType(); newLogicalExpression.AddLHSLogicalExpression(lhs); newLogicalExpression.AddLogicalOperator(logicalOp); newLogicalExpression.AddRHSLogicalExpression(rhs); LogicalExpression newLogical = new LogicalExpression(); newLogical.AddLogical(newLogicalExpression); return(newLogical); }
private void AddBetweenFilterCondition <T, TMember>(Expression <Func <T, TMember> > selector, TMember start, TMember end, string @alias = null, LogicalOperator logicalOperator = LogicalOperator.NotSet) { this.currentFilterGroup.Conditions.Add(new FilterCondition { Alias = @alias, EntityType = typeof(T), Operator = ">=", Left = this.GetMemberName(selector), LocigalOperator = logicalOperator, Right = this.FormatValue(start) }); this.currentFilterGroup.Conditions.Add(new FilterCondition { Alias = @alias, EntityType = typeof(T), Operator = "<=", Left = this.GetMemberName(selector), LocigalOperator = LogicalOperator.And, Right = this.FormatValue(end) }); }
public ExpressionBlock(LogicalOperator _operator, List <ExpressionBase <T> > _expressions = null, List <ExpressionBlock <T> > _blocks = null) { id = Guid.NewGuid().ToString(); @operator = _operator; blocks = _blocks ?? new List <ExpressionBlock <T> >(); expressions = _expressions ?? new List <ExpressionBase <T> >(); }
private IWhereClauseBuilder AddConditionToCurrentGroup <TEntity>( Expression <Func <TEntity, bool> > expression, LogicalOperator locigalOperator, string alias = null, string tableName = null, string tableSchema = null) { ThrowIfNotInitialised(); IsClean = false; var operatorString = GetOperator(expression); var @value = FormatValue(GetExpressionValue(expression)); var actualOperator = GetActualOperator(operatorString, @value); currentGroup.Conditions.Add(new WhereClauseCondition { Alias = alias, LocigalOperator = locigalOperator, LeftTable = string.IsNullOrWhiteSpace(tableName) ? TableNameFromType <TEntity>() : tableName, LeftSchema = string.IsNullOrWhiteSpace(tableSchema) ? ClauseBuilder.DefaultSchema : tableSchema, Left = GetMemberName(expression), Operator = actualOperator, Right = @value }); return(this); }
protected override void AddBetweenConditionToCurrentGroup <TEntity, TMember>( Expression <Func <TEntity, TMember> > selector, TMember start, TMember end, LogicalOperator locigalOperator, string alias, string tableName, string tableSchema) { var conditions1 = currentGroup.Conditions; var whereClauseCondition1 = new WhereClauseCondition(); whereClauseCondition1.Alias = alias; whereClauseCondition1.LocigalOperator = locigalOperator; whereClauseCondition1.LeftTable = string.IsNullOrWhiteSpace(tableName) ? TableNameFromType <TEntity>() : tableName; whereClauseCondition1.LeftSchema = string.IsNullOrWhiteSpace(tableSchema) ? "dbo" : tableSchema; whereClauseCondition1.Left = GetMemberColumnName(ConvertExpression(selector)); whereClauseCondition1.Operator = ">="; whereClauseCondition1.Right = FormatValue(start); conditions1.Add(whereClauseCondition1); var conditions2 = currentGroup.Conditions; var whereClauseCondition2 = new WhereClauseCondition(); whereClauseCondition2.Alias = alias; whereClauseCondition2.LocigalOperator = LogicalOperator.And; whereClauseCondition2.LeftTable = string.IsNullOrWhiteSpace(tableName) ? TableNameFromType <TEntity>() : tableName; whereClauseCondition2.LeftSchema = string.IsNullOrWhiteSpace(tableSchema) ? "dbo" : tableSchema; whereClauseCondition2.Left = GetMemberColumnName(ConvertExpression(selector)); whereClauseCondition2.Operator = "<="; whereClauseCondition2.Right = FormatValue(end); conditions2.Add(whereClauseCondition2); IsClean = false; }
protected override void AddInConditionToCurrentGroup <TEntity, TMember>( Expression <Func <TEntity, TMember> > selector, TMember[] values, LogicalOperator locigalOperator, string alias, string tableName, string tableSchema) { if (values == null || !values.Any()) { return; } var conditions = currentGroup.Conditions; var whereClauseCondition = new WhereClauseCondition(); whereClauseCondition.Alias = alias; whereClauseCondition.LocigalOperator = locigalOperator; whereClauseCondition.LeftTable = string.IsNullOrWhiteSpace(tableName) ? TableNameFromType <TEntity>() : tableName; whereClauseCondition.LeftSchema = string.IsNullOrWhiteSpace(tableSchema) ? "dbo" : tableSchema; whereClauseCondition.Left = GetMemberColumnName(ConvertExpression(selector)); whereClauseCondition.Operator = "IN"; whereClauseCondition.Right = "(" + string.Join(", ", values.Select(v => FormatValue(v))) + ")"; conditions.Add(whereClauseCondition); IsClean = false; }
private LogicalExpression(LogicalOperator op, BooleanExpression oper1, BooleanExpression oper2) { boolean_expression_type = OperatorType.Logical; switch (op) { case LogicalOperator.True: boolean_operation_arity = OperatorArity.Zero; break; case LogicalOperator.False: boolean_operation_arity = OperatorArity.Zero; break; case LogicalOperator.And: boolean_operation_arity = OperatorArity.Two; break; case LogicalOperator.Or: boolean_operation_arity = OperatorArity.Two; break; case LogicalOperator.Not: boolean_operation_arity = OperatorArity.One; break; } logical_operator = op; operand1 = oper1; operand2 = oper2; boolean_operand1 = oper1; boolean_operand2 = oper2; }
public override string ToString() { var str1 = LogicalOperator == LogicalOperator.NotSet ? "ON" : LogicalOperator.ToString().ToUpperInvariant(); string str2; if (!string.IsNullOrWhiteSpace(LeftTableAlias)) { str2 = "[" + LeftTableAlias + "].[" + LeftIdentifier + "]"; } else { str2 = "[" + LeftTableSchema + "].[" + LeftTableName + "].[" + LeftIdentifier + "]"; } var str3 = str2; string str4; if (!string.IsNullOrWhiteSpace(RightTableAlias)) { str4 = "[" + RightTableAlias + "].[" + RightIdentifier + "]"; } else { str4 = "[" + RightTableSchema + "].[" + RightTableName + "].[" + RightIdentifier + "]"; } var str5 = str4; return(string.Format("{0} {1} {2} {3}", (object)str1, (object)str3, (object)Operator, (object)str5)); }
private Func <JObject, bool> BuildCompositeFilterDefinition(LogicalOperator logicalOperator, List <Func <JObject, bool> > filters) { return(logicalOperator switch { LogicalOperator.And => document => { var result = true; foreach (var filter in filters) { result = result && filter(document); } return result; } , LogicalOperator.Or => document => { var result = false; foreach (var filter in filters) { result = result || filter(document); } return result; } , LogicalOperator.Not => document => !filters.FirstOrDefault()(document), _ => throw new NotImplementedException(nameof(logicalOperator)), });
/// <summary> /// Gets a <c>QueryExpression</c> instance for retrieving a <c>uom</c>. /// </summary> /// <param name="operand">The <c>LogicalOperand</c> to use for this query.</param> /// <param name="entityName">The logical name for the entity to be queried for.</param> /// <param name="propertyValues">The array of <c>KeyValuePair</c>s that contains the properties and their values to be queried for.</param> /// <returns>An instance of a <c>QueryExpression</c> that can used as a parameter to a <c>RetrieveMultipleRequest</c>.</returns> /// <exception cref="ArgumentException">Thrown if the unitName or scheduleId parameters are null or empty.</exception> /// <remarks>This method sets the Distinct property of the returned <c>QueryExpression</c> to <c>true</c>.</remarks> public static QueryExpression GetMultipartQueryExpression(LogicalOperator operand, string entityName, KeyValuePair <string, string>[] propertyValues) { if (propertyValues == null) { throw new AdapterException(string.Format(CultureInfo.CurrentCulture, Resources.ArgumentNullExceptionMessage), new ArgumentNullException("propertyValues")) { ExceptionId = AdapterException.SystemExceptionGuid }; } QueryExpression queryHelper = new QueryExpression(entityName) { Distinct = false }; queryHelper.Criteria = new FilterExpression() { FilterOperator = operand }; queryHelper.ColumnSet.AllColumns = true; foreach (KeyValuePair <string, string> propertyValue in propertyValues) { ValidatePropertyQueryParameters(entityName, propertyValue.Key); queryHelper.Criteria.Conditions.Add(new ConditionExpression(propertyValue.Key, ConditionOperator.Equal, propertyValue.Value)); } return(queryHelper); }
private void AddInFilterCondition <T, TMember>(Expression <Func <T, TMember> > selector, TMember[] values, string alias = null, LogicalOperator locigalOperator = LogicalOperator.NotSet) { if (values != null && values.Any()) { this.currentFilterGroup.Conditions.Add(new FilterCondition { Alias = alias, EntityType = typeof(T), LocigalOperator = locigalOperator, Left = this.GetMemberName(this .ConvertExpression( selector)), Operator = "IN", Right = "(" + string.Join(", ", values.Select( v => this .FormatValue( v))) + ")" }); } }
/// <summary> /// 构造函数 /// </summary> /// <param name="name"></param> /// <param name="value"></param> /// <param name="oper"></param> /// <param name="link"></param> public Condition(string name, string value, ConditionalOperator oper, LogicalOperator link) { Name = name; Value = value; Oper = oper; Link = link; }
public SearchQueryGrouping(LogicalOperator logicalOperator, ICollection <ISearchQueryElement <T> > searchQueryElements) { Assert.ArgumentNotNull(searchQueryElements, "searchQueryElements"); LogicalOperator = logicalOperator; SearchQueryElements = searchQueryElements; }
private void AssertJoinConditionIsValid <TLeft, TRight>(int index, string expectedLeftIdentifier, string expectedOperator, string expectedRightIdentifier, string expectedRightTableAlias = null, string expectedLeftTableAlias = null, LogicalOperator expectedLogicalOperator = LogicalOperator.NotSet) { this.Statement.Specification.Joins.Should() .NotBeNullOrEmpty(); var condition = this.Statement.Specification.Joins[index]; condition.LeftEntityType.Should() .Be(typeof(TLeft)); condition.LeftIdentifier.Should() .Be(expectedLeftIdentifier); condition.LeftTableAlias.Should() .Be(expectedLeftTableAlias); condition.LogicalOperator.Should() .Be(expectedLogicalOperator); condition.Operator.Should() .Be(expectedOperator); condition.RightIdentifier.Should() .Be(expectedRightIdentifier); condition.RightTableAlias.Should() .Be(expectedRightTableAlias); condition.RightEntityType.Should() .Be(typeof(TRight)); }
protected abstract void AddInConditionToCurrentGroup <TEntity, TMember>( Expression <Func <TEntity, TMember> > selector, TMember[] values, LogicalOperator locigalOperator, string alias, string tableName, string tableSchema);
public Filter AddFilters(LogicalOperator logicalOperator, params Filter[] filters) { InnerFilter.FilterOperator = logicalOperator; InnerFilter.Filters.AddRange(filters.Select(f => f.InnerFilter)); return(this); }
private bool CompareFilter(QueryLogicalFilter filter, LogicalOperator logicalOperator, string field, ComparisonOperator comparisonOperator, string value) { return(filter.Operator == logicalOperator && filter.Filter.Field == field && filter.Filter.Operator == comparisonOperator && Enumerable.SequenceEqual(filter.Filter.Values, (value != null ? value.Split(',') : new string[] { }))); }
public void PushNAry(LogicalOperator logicalOperator) { BinaryOperator binaryOperator; if (logicalOperator == LogicalOperator.And) { binaryOperator = BinaryOperator.LogicalAnd; } else { binaryOperator = BinaryOperator.LogicalOr; } List <ExpressionNode> arguments = new List <ExpressionNode>(); while (_expressionStack.Count > 0) { arguments.Add(_expressionStack.Pop()); } foreach (ExpressionNode argument in arguments) { Push(argument); if (Count > 1) { PushBinary(binaryOperator); } } }
private void AddInConditionToCurrentGroup <TEntity, TMember>( Expression <Func <TEntity, TMember> > selector, TMember[] values, LogicalOperator locigalOperator, string alias, string tableName, string tableSchema) { if (values != null && values.Any()) { currentGroup.Conditions.Add(new WhereClauseCondition { Alias = alias, LocigalOperator = locigalOperator, LeftTable = string.IsNullOrWhiteSpace(tableName) ? TableNameFromType <TEntity>() : tableName, LeftSchema = string.IsNullOrWhiteSpace(tableSchema) ? ClauseBuilder.DefaultSchema : tableSchema, Left = GetMemberName(ConvertExpression(selector)), Operator = "IN", Right = "(" + string.Join(", ", values.Select(v => FormatValue(v))) + ")" }); IsClean = false; } }
public IConditionGroup BeginGroup(LogicalOperator concatOperator = LogicalOperator.And) { var group = new ConditionGroup(concatOperator); Add(group); return(group); }
//Match the rule condition against state, and return bindings public static bool MatchCondition(List <Atom> ruleConditions, State state, LogicalOperator op) { if (op == LogicalOperator.AND) { foreach (Atom condition in ruleConditions) { if (!condition.isVerified(state)) { return(false); } } } else { foreach (Atom condition in ruleConditions) { if (condition.isVerified(state)) { return(true); } } } return(true); }
/// <summary> /// Costruttore con tutti i parametri necessari per inzializzare la struttura prima di conoscere il valore dei parametri di filtro /// </summary> /// <param name="nometabella">Nome della tabella</param> /// <param name="nomeCampo">Nome del campo del dataset oggetto di filtro</param> /// <param name="operatore">Nome dell'operatore da applicare (es. "Like", "=", ">", ">=")</param> /// <param name="valore">Valore di confronto</param> public SQuery(string nomeTabella, string nomeCampo, string operatore, string valore) { _table = nomeTabella; _nomeCampo = nomeCampo; _operatore = operatore; _valore = valore; _externalOperatorBefore = LogicalOperator.And; }
/// <summary> /// Constructs the filter /// </summary> /// <param name="logicalOperator"> /// Logical operator used in the filter /// </param> /// <param name="innerFilters"> /// Collection of conditions or filters that will be merged /// with the and operator /// </param> public LogicalOperatorFilter(List<Filters.FilterBase> innerFilters, LogicalOperator logicalOperator) { if (innerFilters != null) { InnerFilters = innerFilters; } LogicalOperator = logicalOperator; }
/// <summary> /// Costruttore con tutti i parametri necessari per inzializzare la struttura prima di conoscere il valore dei parametri di filtro /// </summary> /// <param name="nomeCampo">Nome del campo del dataset oggetto di filtro</param> /// <param name="operatore">Nome dell'operatore da applicare (es. "Like", "=", ">", ">=")</param> /// <param name="type">Tipo di dato (es. "Numeric", "String", "Date")</param> public SQuery(string nomeCampo, string operatore, DataType type) { _table = string.Empty; _nomeCampo = nomeCampo; _operatore = operatore; _valore = string.Empty; _type = type; _externalOperatorBefore = LogicalOperator.And; }
public LogicalBindaryExpression(Expression left, Expression right, LogicalOperator @operator) { Require.NotNull(left, "left"); Require.NotNull(right, "right"); Left = left; Right = right; Operator = @operator; }
/// <summary> /// Costruttore con tutti i parametri necessari per inzializzare la struttura prima di conoscere il valore dei parametri di filtro /// </summary> /// <param name="nometabella">Nome della tabella</param> /// <param name="nomeCampo">Nome del campo del dataset oggetto di filtro</param> /// <param name="operatore">Nome dell'operatore da applicare (es. "Like", "=", ">", ">=")</param> /// <param name="valore">Valore di confronto</param> public SQuery(string nomeTabella, string nomeCampo, string operatore, string valore, DataType type, object valoreObject) { _table = nomeTabella; _nomeCampo = nomeCampo; _operatore = operatore; _valore = valore; _type = type; _valoreObject = valoreObject; _externalOperatorBefore = LogicalOperator.And; }
public FilterItem(string key, string value, SizeOperator op, string expression, SizeKeyType filterSizeKeyType, LogicalOperator logicalOperator) { _operator = op; _key = key; _value = value; _expression = expression; _logicalOperator = logicalOperator; _filterSizeKeyType = filterSizeKeyType; }
public FilterExpression ConditionHelper(LogicalOperator op, Dictionary<string, object> keyValues) { FilterExpression filter = new FilterExpression(); filter.FilterOperator = op; foreach (KeyValuePair<string, object> item in keyValues) { filter.Conditions.Add(new ConditionExpression(item.Key, ConditionOperator.Equal, item.Value)); } return filter; }
public SQueryCollection(LogicalOperator operatore) : base() { switch((int)operatore) { case 1: _operatore = "AND"; break; case 2: _operatore = "OR"; break; } }
public static string CombineQuery(IEnumerable<SearchCriteria> searches, LogicalOperator logical, IEnumerable<SortDescription> sorting, int? pageCount) { var queries = new List<string>(); if (pageCount.HasValue) queries.Add(GetPagingQueryString(pageCount.Value)); if (searches != null && searches.Count() > 0) queries.Add(searches.ConstructFilterQueryString(logical)); if (sorting != null && sorting.Count() > 0) queries.Add(sorting.ConstructOrderByQueryString()); return CombineQuery(queries); }
/// <summary> /// Instantiates a new atom group. /// </summary> /// <param name="logicalOperator">The operator that characterizes the relationship between the atoms and atoms group.</param> /// <param name="members">An array containing atoms and atom groups.</param> /// <param name="runningMembers">An array containing atoms and atom groups that will actually be run (they can be different /// from the members because of atom equivalence).</param> internal AtomGroup(LogicalOperator logicalOperator, object[] members, object[] runningMembers) { this.logicalOperator = logicalOperator; this.members = members; HashCodeBuilder hcb = new HashCodeBuilder(); hcb.Append(logicalOperator); SortedList<int, object> sortedMembers = new SortedList<int, object>(Comparer<int>.Default); // check the members, compute hashcode and build sorted members list for(int i=0; i < members.Length; i++) { object member =members[i]; if (member == null) { throw new BREException("An atom group can not contain a null member"); } else if (member is AtomGroup) { if (((AtomGroup)member).logicalOperator == logicalOperator) throw new BREException("An atom group can not contain another group with the same logical operator"); } else if (member is Atom) { if (((Atom)member).HasFormula) throw new BREException("An atom group can not contain an atom that contains a formula"); } else { throw new BREException("An atom group can not hold objects of type: " + member.GetType()); } hcb.Append(member); if (runningMembers == null) sortedMembers.Add(GetMemberSortedIndex(members, i), member); } hashCode = hcb.Value; // the members actually used when processing the atom group are not the ones defined in the rule file (usually because of equivalent atoms definitions) if (runningMembers != null) { for(int i=0; i < runningMembers.Length; i++) sortedMembers.Add(GetMemberSortedIndex(runningMembers, i), runningMembers[i]); } orderedMembers = sortedMembers.Values; allAtoms = new List<Atom>(); foreach(object member in orderedMembers) { if (member is Atom) allAtoms.Add((Atom)member); else if (member is AtomGroup) allAtoms.AddRange(((AtomGroup)member).AllAtoms); } }
public CriteriaItem(LogicalOperator logicalOperator, string parameter, Clause clause, object value) : base(logicalOperator) { Clause newClause = clause; if (value == null) { if (clause == Clause.Eq) { newClause = Clause.IsNull; } } this.clause = newClause; this.parameter = parameter; this.value = value; }
public void Logical(LogicalOperator op) { if (_ops.Count < 1 || (int)op != _ops.Peek()) { if (op == LogicalOperator.Not) { _ops.Push(_ops.Peek() | (int)op); _writer.Write(" NOT ("); } else { _ops.Push((int)op); _writer.Write(" ("); } } }
public static ExpressionNode CombineConditions(LogicalOperator logicalOperator, IList<ExpressionNode> conditions) { if (conditions == null || conditions.Count == 0) return null; ExpressionBuilder expressionBuilder = new ExpressionBuilder(); foreach (ExpressionNode condition in conditions) { if (condition != null) expressionBuilder.Push(condition); } if (expressionBuilder.Count == 0) return null; expressionBuilder.PushNAry(logicalOperator); return expressionBuilder.Pop(); }
public void PushNAry(LogicalOperator logicalOperator) { BinaryOperator binaryOperator; if (logicalOperator == LogicalOperator.And) binaryOperator = BinaryOperator.LogicalAnd; else binaryOperator = BinaryOperator.LogicalOr; List<ExpressionNode> arguments = new List<ExpressionNode>(); while (_expressionStack.Count > 0) arguments.Add(_expressionStack.Pop()); foreach (ExpressionNode argument in arguments) { Push(argument); if (Count > 1) PushBinary(binaryOperator); } }
public FilterExpression AddFilter(LogicalOperator logicalOperator) { FilterExpression filterExpression = new FilterExpression() { FilterOperator = logicalOperator }; this.Filters.Add(filterExpression); return filterExpression; }
public Criteria(LogicalOperator logicalOperator, string parameter, Clause clause, object value) : this(parameter, clause, value) { LogicalOperator = logicalOperator; }
public FilterExpression(LogicalOperator filterOperator) : this() { this.FilterOperator = filterOperator; }
internal LogicalExpression(LogicalOperator loperator, string expression) { this.loperator = loperator; this.expression = expression.Trim(); }
public static Group createGroup(Attribute attr, LogicalOperator logicalOperator) { return createGroup(new object[] { attr }, logicalOperator); }
public static Group createGroup(Association asso, LogicalOperator logicalOperator) { return createGroup(new object[] { asso }, logicalOperator); }
private void VisitBinaryLogicalOperator(BinaryExpression b, LogicalOperator logicalOperator) { //if it's empty just use it if (_filterExpression.Filters.Count == 0) _filterExpression.FilterOperator = logicalOperator; var epression = _filterExpression; //we are now in a "and" as part of an "or" chain if (_filterExpression.FilterOperator != logicalOperator) _filterExpression = new FilterExpression(logicalOperator); base.Visit(b.Left); base.Visit(b.Right); //restore the changed item _filterExpression = epression; }
/// <summary> /// Constructs the filter /// <para xml:lang="es"> /// Construye el filtro /// </para> /// </summary> /// <param name="logicalOperator"> /// Logical operator used in the filter /// <para xml:lang="es"> /// Operador logico utilizado en el filtro /// </para> /// </param> /// <param name="innerFilters"> /// Collection of conditions or filters that will be merged /// with the and operator /// <para xml:lang="es"> /// Coleccion de condiciones o filtros que se fucionan /// con el operador and. /// </para> /// </param> public LogicalOperatorFilter(List<Filter> innerFilters, LogicalOperator logicalOperator) { InnerFilters = innerFilters; LogicalOperator = logicalOperator; }
protected BaseCriteria(LogicalOperator logicalOperator) { LogicalOperator = logicalOperator; }
public Form1() { InitializeComponent(); processing = new LogicalOperator(); }
/// <summary> /// Instantiates a new atom group. /// </summary> /// <param name="logicalOperator">The operator that characterizes the relationship between the atoms and atoms group.</param> /// <param name="members">An array containing atoms and atom groups.</param> public AtomGroup(LogicalOperator logicalOperator, params object[] members) : this(logicalOperator, members, null) { }