public static string TranslateCriteriaOperator(CriteriaOperator criteriaOperator)
        {
            if (criteriaOperator == CriteriaOperator.Equal)
                return "=";
            if (criteriaOperator == CriteriaOperator.NotEqual)
                return "<>";
            if (criteriaOperator == CriteriaOperator.GreaterThan)
                return ">";
            if (criteriaOperator == CriteriaOperator.GreaterThanOrEqual)
                return ">=";
            if (criteriaOperator == CriteriaOperator.LesserThan)
                return "<";
            if (criteriaOperator == CriteriaOperator.LesserThanOrEqual)
                return "<=";
            if (criteriaOperator == CriteriaOperator.Like)
                return " LIKE ";
            if (criteriaOperator == CriteriaOperator.NotLike)
                return " NOT LIKE ";
            if (criteriaOperator == CriteriaOperator.IsNull)
                return " IS NULL ";
            if (criteriaOperator == CriteriaOperator.IsNotNull)
                return " IS NOT NULL ";

            throw new ArgumentException("CriteriaOperator not supported", "criteriaOperator");
        }

 public Criteria(String propertyName, String value, CriteriaOperator criteriaOperator, LogicalOperation logicalOperation = Core.Query.LogicalOperation.And)
 {
     this.PropertyName = propertyName;
     this.Value = value;
     this.Operator = criteriaOperator;
     this.LogicalOperation = logicalOperation;
 }

 public Criterion(string fieldName, string parameterName, object parameterValue, CriteriaOperator criterriaOperator)
 {
     _fieldName = fieldName;
     _parameterName = parameterName;
     _parameterValue = parameterValue;
     _criteriaOperator = criterriaOperator;
 }

        private void ApplyCustomFilter()
        {
            if (Frame.View == null)
                return;

            switch (Frame.View.Id)
            {
                case "WHHistory_ListView_ThisMonth":
                    DateTime thisMonth;
                    thisMonth = DateTime.Today;
                    thisMonth = thisMonth.AddDays((thisMonth.Day -1) * -1);

                    criteria = CriteriaOperator.Parse(string.Format("Date >= '{0}'", thisMonth));
                    break;
                case "WHHistory_ListView_ThisWeek":
                    criteria = CriteriaOperator.Parse(string.Format("Date >= '{0}'", DateTime.Today.AddDays(-7)));
                    break;
                case "WHHistory_ListView_ThisYear":
                    DateTime thisYear;
                    thisYear = DateTime.Today;
                    thisYear = thisYear.AddMonths((thisYear.Month - 1) * -1);
                    thisYear = thisYear.AddDays((thisYear.Day -1 )* -1);
                    criteria = CriteriaOperator.Parse(string.Format("Date >= '{0}'", thisYear));
                    break;
                case "WHHistory_ListView":
                    criteria = null;
                    break;
            }

            ((ListView)Frame.View).CollectionSource.Criteria["MyFilter"] = criteria;
        }

        CriteriaOperator CreateFilterCriteria()
        {
            if (!Filter_words)
            { // точное совпадение
                CriteriaOperator[] operators = new CriteriaOperator[_View.VisibleColumns.Count];
                for (int i = 0; i < _View.VisibleColumns.Count; i++)
                {
                    if (Filter_Plus)
                        operators[i] = new BinaryOperator(_View.VisibleColumns[i].FieldName, String.Format("%{0}%", _ActiveFilter), BinaryOperatorType.Like);
                    else
                        operators[i] = new BinaryOperator(_View.VisibleColumns[i].FieldName, String.Format("{0}%", _ActiveFilter), BinaryOperatorType.Like);
                }
                return new GroupOperator(GroupOperatorType.Or, operators);
            }
            else
            { // любое слово
                CriteriaOperator[] levels = new CriteriaOperator[FilterText.Length];

                for (int i = 0; i < FilterText.Length; i++)
                {
                    CriteriaOperator[] operators = new CriteriaOperator[_View.VisibleColumns.Count + 1]; // Тэги + 1
                    for (int j = 0; j < _View.VisibleColumns.Count; j++)
                    {
                        operators[j] = new BinaryOperator(_View.VisibleColumns[j].FieldName, String.Format("%{0}%", FilterText[i]), BinaryOperatorType.Like);
                    }
                    // Тэги
                    operators[_View.VisibleColumns.Count] = new BinaryOperator("TagComments", String.Format("%{0}%", FilterText[i]), BinaryOperatorType.Like);

                    levels[i] = new GroupOperator(GroupOperatorType.Or, operators);
                }
                return new GroupOperator(GroupOperatorType.And, levels);
            }
        }

 public MasterDetailRuleInfo(IModelListView childListView, IModelMember collectionMember, ITypeInfo typeInfo, CriteriaOperator criteria, bool synchronizeActions) {
     ChildListView = childListView;
     CollectionMember = collectionMember;
     TypeInfo = typeInfo;
     _criteria = criteria;
     _synchronizeActions = synchronizeActions;
 }

 public CriteriaOperator PrepareCriteria(CriteriaOperator op)
 {
     if (op is FunctionOperator)
     {
         var funcOp = new FunctionOperator();
         for (int i = 0; i < (op as FunctionOperator).Operands.Count; i++)
             funcOp.Operands.Add(PrepareCriteria((op as FunctionOperator).Operands[i]));
         return funcOp;
     }
     else if (op is ConstantValue)
     {
         var cnst = new ConstantValue((op as ConstantValue).Value);
         if (String.Concat((op as ConstantValue).Value).ToLower().IndexOf("@this") > -1)
         {
             IMemberInfo info;
             cnst.Value = ObjectFormatValues.GetValueRecursive((op as ConstantValue).Value.ToString().Replace("@This.", "").Replace("@This", "").Replace("@this.", "").Replace("@this", ""), CurrentObject, out info);
         }
         return cnst;
     }
     else if (op is BinaryOperator)
     {
         var binary = new BinaryOperator();
         binary.LeftOperand = PrepareCriteria((op as BinaryOperator).LeftOperand);
         binary.RightOperand = PrepareCriteria((op as BinaryOperator).RightOperand);
         return binary;
     }
     else
     {
         return op;
     }
 }

 /// <summary>
 /// Initializes a new instance of the Idiorm.Criterion class that uses the property name, the value and the operator of the new Idiorm.Criterion.
 /// </summary>
 /// <param name="propertyName">The name of the property to map.</param>
 /// <param name="operator">The operator of the new Idiorm.Criterion object.</param>
 /// <param name="value">The value of the new Idiorm.Criterion object.</param>
 public Criterion(string propertyName, CriteriaOperator @operator, object value)
     : this()
 {
     this.propertyName = propertyName;
     this.value = value;
     [email protected] = @operator;
 }

 private static BinaryOperator getGroupOperator(out BinaryOperator binaryOperator2,
                                                out CriteriaOperator groupOperator)
 {
     var binaryOperator = new BinaryOperator("dfs", 324);
     binaryOperator2 = new BinaryOperator("sdfs", 3455);
     groupOperator = new GroupOperator(binaryOperator, binaryOperator2);
     return binaryOperator;
 }

 private bool IsFullIndexed(CriteriaOperator theOperator){
     var queryOperand = theOperator as QueryOperand;
     if (!ReferenceEquals(queryOperand, null)){
         return IsFullIndexedCore(queryOperand.ColumnName);
     }
     var operandProperty = theOperator as OperandProperty;
     return !ReferenceEquals(operandProperty, null) && IsFullIndexedCore(operandProperty.PropertyName);
 }

 public void Replace(ref CriteriaOperator criteriaOperator, string matchString, CriteriaOperator replaceOperator)
 {
     if (criteriaOperator.ToString() == matchString)
     {
         criteriaOperator = replaceOperator;
         return;
     }
     Extract(criteriaOperator, matchString, replaceOperator);
 }

 public void Remove(ref CriteriaOperator criteriaOperator, string removeString)
 {
     if (criteriaOperator.ToString() == removeString)
     {
         criteriaOperator = null;
         return;
     }
     Extract(criteriaOperator, removeString);
 }

 private ExpressionEvaluator GetExpressionEvaluator(CriteriaOperator criteria)
 {
     if (criteria.ToString() == lastCriteria)
         return lastEvaluator;
     lastCriteria = criteria.ToString();
     PropertyDescriptorCollection pdc = ((ITypedList)_View.DataSource).GetItemProperties(null);
     lastEvaluator = new ExpressionEvaluator(pdc, criteria, false);
     return lastEvaluator;
 }

        private CriteriaOperator Extract(CriteriaOperator criteriaOperator, string matchString,
                                         CriteriaOperator replaceOperator)
        {
            if (criteriaOperator is BinaryOperator)
            {
                var binaryOperator = (BinaryOperator) criteriaOperator;
                binaryOperators.Add(binaryOperator);

                return binaryOperator;
            }
            if (criteriaOperator is NullOperator)
            {
                nullOperators.Add((NullOperator) criteriaOperator);
                return criteriaOperator;
            }
            if (criteriaOperator is NotOperator)
            {
                var notOperator = (NotOperator) criteriaOperator;
                notOperators.Add(notOperator);
                Extract(notOperator.Operand);
            }
            else if (criteriaOperator is UnaryOperator)
            {
                unaryOperators.Add((UnaryOperator) criteriaOperator);
                return criteriaOperator;
            }

            else if (criteriaOperator is GroupOperator)
            {
                var groupOperator = (GroupOperator) criteriaOperator;
                CriteriaOperatorCollection operands = groupOperator.Operands;
                var indexesToremove = new List<int>();
                for (int i = 0; i < operands.Count; i++){
                    CriteriaOperator operand = operands[i];
                    if (operand.ToString() == matchString){
                        if (ReferenceEquals(replaceOperator,null))
                            indexesToremove.Add(i);
                        else
                            operands[i] = replaceOperator;
                    }
                    else{
                        CriteriaOperator extract = Extract(operand);
                        operands.RemoveAt(i);
                        operands.Insert(i, extract);
                    }
                }
                foreach (int i in indexesToremove)
                    operands.RemoveAt(i);
            }
            else if (criteriaOperator is ContainsOperator)
            {
                var containsOperator = (ContainsOperator) criteriaOperator;
                CriteriaOperator condition = containsOperator.Condition;
                Extract(condition);
            }
            return criteriaOperator;
        }

 public void Process(CriteriaOperator operand, bool mustBeLogical)
 {
     if (ReferenceEquals(operand, null)) return;
     if (mustBeLogical) {
         if ((BooleanCriteriaState)operand.Accept(this) == BooleanCriteriaState.Value) throw new ArgumentException(MustBeLogical);
     } else {
         if ((BooleanCriteriaState)operand.Accept(this) == BooleanCriteriaState.Logical) throw new ArgumentException(MustBeArithmetical);
     }
 }

 XPBaseObject CreateObject(XElement element, UnitOfWork nestedUnitOfWork, ITypeInfo typeInfo, CriteriaOperator objectKeyCriteria){
     XPBaseObject xpBaseObject = GetObject(nestedUnitOfWork, typeInfo,objectKeyCriteria) ;
     var keyValuePair = new KeyValuePair<ITypeInfo, CriteriaOperator>(typeInfo, objectKeyCriteria);
     if (!importedObjecs.ContainsKey(keyValuePair)) {
         importedObjecs.Add(keyValuePair, null);
         ImportProperties(nestedUnitOfWork, xpBaseObject, element);
     }
     return xpBaseObject;
 }

 public Criterion(string propertyName, CriteriaOperator @operator, object value,
     StringMatchMode matchMode, bool caseInsensitive)
     : this(propertyName, @operator, value)
 {
     if (@operator != CriteriaOperator.Like && @operator != CriteriaOperator.NotLike)
         throw new ArgumentException();
     this.matchMode = matchMode;
     this.caseInsensitive = caseInsensitive;
 }

        public UnaryCriteria(CriteriaOperator op, BaseCriteria operand)
        {
            if (Object.ReferenceEquals(operand, null))
                throw new ArgumentNullException("operand");

            if (op < CriteriaOperator.Paren || op > CriteriaOperator.Exists)
                throw new ArgumentOutOfRangeException("op");

            this.op = op;
            this.operand = operand;
        }

 XPBaseObject createObject(XElement element, UnitOfWork nestedUnitOfWork, ITypeInfo typeInfo, CriteriaOperator objectKeyCriteria)
 {
     XPBaseObject xpBaseObject = findObject(nestedUnitOfWork, typeInfo,objectKeyCriteria) ??
                                 (XPBaseObject) Activator.CreateInstance(typeInfo.Type, nestedUnitOfWork);
     if (!importingObjecs.Contains(xpBaseObject)) {
         importingObjecs.Add(xpBaseObject);
         importProperties(nestedUnitOfWork, xpBaseObject, element);
         importingObjecs.Remove(xpBaseObject);
     }
     return xpBaseObject;
 }

        public FilterEvaluator(EvaluatorContextDescriptor descriptor, CriteriaOperator filterCriteria)
        {
            this.evaluatorCore = new ExpressionEvaluatorCore(true);
            this.descriptor = descriptor;
            this.filterCriteria = filterCriteria;

            this.contexts = typeof (ExpressionEvaluatorCore).GetField("contexts", BindingFlags.Instance | BindingFlags.NonPublic);

            FieldInfo fieldInfo = typeof(ExpressionEvaluatorCore).GetField("LikeDataCache", BindingFlags.Instance | BindingFlags.NonPublic);
            likeDataCache = (LikeDataCache) fieldInfo.GetValue(this.evaluatorCore);
        }