public QueryBuilder Is(CompareType compareType, string value)
 {
     _compareCondition.Compare = compareType;
     _compareCondition.Value = value;
     _query.Conditions.Add(_compareCondition);
     return _queryBuilder;
 }

        public ComparePredicate(IDataSelector firstArgumentSelector, IDataSelector secondArgumentSelector, CompareType type)
        {
            Contract.Requires(firstArgumentSelector != null);
            Contract.Requires(secondArgumentSelector != null);

            _firstArgumentSelector = firstArgumentSelector;
            _secondArgumentSelector = secondArgumentSelector;

            switch (type)
            {
                case CompareType.Less:
                    _checkComparisonResult = r => r < 0;
                    break;
                case CompareType.LessOrEqual:
                    _checkComparisonResult = r => r <= 0;
                    break;
                case CompareType.Greater:
                    _checkComparisonResult = r => r > 0;
                    break;
                case CompareType.GreaterOrEqual:
                    _checkComparisonResult = r => r >= 0;
                    break;
                default:
                    throw new ArgumentOutOfRangeException("type");
            }
        }

 internal static Expression AttendanceTypeAsOf(
     ParameterExpression parm,
     DateTime? from,
     DateTime? to,
     int? progid,
     int? divid,
     int? org,
     int orgtype,
     CompareType op,
     params int[] ids)
 {
     to = to.HasValue ? to.Value.AddDays(1) : from.Value.AddDays(1);
     Expression<Func<Person, bool>> pred = p => (
         from a in p.Attends
         where a.MeetingDate >= @from
         where a.MeetingDate < to
         where (a.AttendanceFlag
                 || (ids.Length == 1 && ids[0] == AttendTypeCode.Offsite))
         where ids.Contains(a.AttendanceTypeId ?? 0)
         where orgtype == 0 || a.Meeting.Organization.OrganizationTypeId == orgtype
         where org == 0 || a.Meeting.OrganizationId == org
         where divid == 0 || a.Meeting.Organization.DivOrgs.Any(dg => dg.DivId == divid)
         where progid == 0 || a.Meeting.Organization.DivOrgs.Any(dg => dg.Division.ProgDivs.Any(pg => pg.ProgId == progid))
         select a
         ).Any();
     Expression expr = Expression.Invoke(pred, parm);
     if (op == CompareType.NotEqual || op == CompareType.NotOneOf)
         expr = Expression.Not(expr);
     return expr;
 }

        /// <summary>
        /// Get all attributes with probability comparison
        /// </summary>
        /// <param name="strJobTitle">Job title to get attributes</param>
        /// <param name="compareType">Compare Type</param>
        /// <param name="compareValue">Value to compare</param>
        /// <param name="compareValue2">Value to compare 2 [optional]</param>
        /// <returns>The attributes appropriate probability comparison</returns>
        public static List<DecisionTreeAnalysisResult> getAnalysisResults(string strModelName, CompareType compareType, double compareValue, double compareValue2 = -1)
        {
            if (compareValue < 0 || compareValue > 1)
            {
                throw new Exception("compareValue variable value must be between 0-1");
            }
            if ((compareType == CompareType.Between || compareType == CompareType.NotBetween) && (compareValue2 > 1 || compareValue2 < 0))
            {
                throw new Exception("compareValue2 variable value must be between 0-1");
            }

            if (!existsModelName(strModelName))
            {
                throw new Exception("Model Name doesn't exists! (If model name existed, please check connection!)");
            }
            try
            {
                //Get all leaves with Probability and Model Name
                List<DecisionTreeNode> nodes = getDecisionTreeNodeWithProbability(strModelName, compareType, compareValue, compareValue2);
                List<DecisionTreeAnalysisResult> results = new List<DecisionTreeAnalysisResult>();
                foreach (DecisionTreeNode node in nodes)
                {
                    DecisionTreeAnalysisResult result = new DecisionTreeAnalysisResult(new NodeDescription(node), node);
                    results.Add(result);
                }
                return results;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

 // Post: ((size() == 0) && ! locked())
 // Pre = PreCondition, Post = PostCondition
 public HeapArray(CompareType c)
 {
     m_Heap = new List<Linker>();
     m_Finder = new List<uint>();
     m_Locked = false;
     m_Compare = c;
 }

 public Compare(CompareType type, CompareOption option, string fieldName, params object[] compareValues)
 {
     this.Type = type;
     this.Field = fieldName;
     this.CompareValues = compareValues;
     this.Option = option;
 }

 public DateGreaterThanAttribute(string firstDate, string secondDate, CompareType type)
     : base()
 {
     FirstDate = firstDate;
     SecondDate = secondDate;
     Compare = type;
 }

 internal static Expression CompareConstant(ParameterExpression parm, string prop, CompareType op, object value)
 {
     if (value != null)
         if (value.GetType() == typeof(int[])) // use isarray?
             return CompareContains(parm, prop, op, value, typeof(int[]), typeof(int));
         else if (value.GetType() == typeof(string[]))
             return CompareContains(parm, prop, op, value, typeof(string[]), typeof(string));
     var left = Expression.Property(parm, prop);
     var right = Expression.Convert(Expression.Constant(value), left.Type);
     return Compare(parm, left, op, right);
 }

 public IVFilter()
 {
     hpValue = 0;
     hpCompare = CompareType.None;
     atkValue = 0;
     atkCompare = CompareType.None;
     defValue = 0;
     defCompare = CompareType.None;
     spaValue = 0;
     spaCompare = CompareType.None;
     spdValue = 0;
     spdCompare = CompareType.None;
     speValue = 0;
     speCompare = CompareType.None;
 }

 public static bool CompareAgainst(this int compareTo, CompareType compareType, int value)
 {
     switch (compareType)
     {
         case CompareType.Greater:
             return value > compareTo;
         case CompareType.GEqual:
             return value >= compareTo;
         case CompareType.Less:
             return value < compareTo;
         case CompareType.LEqual:
             return value <= compareTo;
         default: // EQUAL
             return value == compareTo;
     }
 }

 public bool checkFlag(string compareValue, CompareType compareType)
 {
     switch(this.flagType)
     {
         case FlagType.boolFlag:
             switch(compareType)
             {
                 case CompareType.Equal:
                     return checkFlag_BoolEqual(compareValue);
                 case CompareType.NotEqual:
                     return checkFlag_BoolNotEqual(compareValue);
                 default: return false;
             }
         case FlagType.intFlag:
             switch(compareType)
             {
                 case CompareType.Equal:
                     return checkFlag_IntEqual(compareValue);
                 case CompareType.Less:
                     return checkFlag_IntLess(compareValue);
                 case CompareType.LessEqual:
                     return checkFlag_IntLessEqual(compareValue);
                 case CompareType.Greater:
                     return checkFlag_IntGreater(compareValue);
                 case CompareType.GreaterEqual:
                     return checkFlag_IntGreaterEqal(compareValue);
                 default: return false;
             }
        
         case FlagType.stringFlag:
              switch(compareType)
             {
                  case CompareType.Equal:
                     return checkFlag_StringEqual(compareValue);
                  case CompareType.Contains:
                     return checkFlag_StringContains(compareValue);
                  case CompareType.Subset:
                     return checkFlag_StringSubstring(compareValue);
                  default:
                     return false;
             }
             
         default:
              return false;
     }
 }

 private int CompareName(string original, string compare, CompareType compareType)
 {
     original = original.ToLower();
     compare = compare.ToLower();
     int charInCommon = 0;
     if (compare != original)
     {
         foreach (char originalChar in original.ToCharArray())
         {
             int index;
             if ((index = compare.IndexOf(originalChar.ToString()))>=0 && originalChar != ' ')
             {
                 charInCommon++;
                 if(compareType == CompareType.Distinct)  compare = compare.Replace(originalChar, ' ');
                 if (compareType == CompareType.Total) compare.Remove(index, 1);
             }
         }
     }
     return charInCommon;
 }

 public CompareColor(CompareType value)
 {
     Value = value;
 }

 public RequireLevel(int level, CompareType type)
 {
     Instructions = new List<TreeCrayonInstruction>();
     Level = level;
     Type = type;
 }

 internal void SetPlusParentsOf(CompareType op, bool tf)
 {
     var c = this;
     while (c.Parent != null)
         c = c.Parent;
     c.PlusParentsOf = ((tf && op == CompareType.Equal) || (!tf && op == CompareType.NotEqual));
 }

 public void SetComparisonType(CompareType value)
 {
     Comparison = value.ToString();
     compare = null;
     compare = Compare2;
 }

 public Condition AddNewClause(QueryType type, CompareType op, object value = null)
 {
     var c = AddNewClause();
     c.SetQueryType(type);
     c.SetComparisonType(op);
     if (type == QueryType.MatchAnything || type == QueryType.MatchNothing)
     {
         c.CodeIdValue = "1,true";
         return c;
     }
     if (type == QueryType.HasMyTag)
     {
         c.Tags = value.ToString();
         c.CodeIdValue = "1,true";
         return c;
     }
     switch (c.FieldInfo.Type)
     {
         case FieldType.NullBit:
         case FieldType.Bit:
         case FieldType.Code:
         case FieldType.NullCode:
         case FieldType.CodeStr:
             c.CodeIdValue = value.ToString();
             break;
         case FieldType.Date:
         case FieldType.DateSimple:
             c.DateValue = (DateTime?)value;
             break;
         case FieldType.Number:
         case FieldType.NullNumber:
         case FieldType.NullInteger:
         case FieldType.String:
         case FieldType.StringEqual:
         case FieldType.Integer:
         case FieldType.IntegerSimple:
         case FieldType.IntegerEqual:
             c.TextValue = value.ToString();
             break;
         default:
             throw new ArgumentException("type not allowed");
     }
     return c;
 }

 protected string SelectOperation(CompareType compareType)
 {
     switch (compareType)
     {
         case CompareType.And:
             return "AND";
         case CompareType.Equal:
             return "=";
         case CompareType.GreaterThan:
             return ">";
         case CompareType.GreaterThanOrEqual:
             return ">=";
         case CompareType.LessThan:
             return "<";
         case CompareType.LessThanOrEqual:
             return "<=";
         case CompareType.Or:
             return "OR";
         case CompareType.Add:
             return "+";
         case CompareType.Substarct:
             return "-";
         case CompareType.Multiply:
             return "*";
         case CompareType.Divide:
             return "/";
         case CompareType.NotEqual:
             return "<>";
         default:
             throw new Exception();
     }
 }

 public void Find(string word, CompareType mode, Action<string> onFound)
 {
     switch (mode)
     {
         case CompareType.CaseInsensitive:
             word = word.ToLowerInvariant();
             break;
         case CompareType.IgnoreDiacritics:
             word = word.RemoveDiacritics();
             break;
         case CompareType.IgnoreCaseAndDiacritics:
             word = word.ToLowerInvariant().RemoveDiacritics();
             break;
     }
     var sb = new StringBuilder();
     Match(word, mode, sb, 0, ofs =>
     {
         if (word.Length != sb.Length) return;
         ofs = SinkTo(ofs, ':');
         if (ofs == -1) return;
         sb.Append(":");
         IterateRaw(sb, ofs, sb1 => onFound(ExpandByType(sb1)));
         sb.Length--;
     });
     Match(word, mode, sb, _nodePrefix, ofs =>
     {
         if (ofs != -1) ofs = SinkTo(ofs, ':');
         if (ofs == -1) return;
         Match(word, mode, sb, _nodePostfix, ofs2 =>
         {
             if (word.Length != sb.Length) return;
             ofs2 = SinkTo(ofs2, ':');
             if (ofs2 == -1) return;
             sb.Append(":");
             IterateRaw(sb, ofs2, sb1 => onFound(ExpandByType(sb1)));
             sb.Length--;
         });
     });
 }

 char DecodeChar(int ofs, CompareType mode)
 {
     return _id2ConvertedChar[(int)mode][_tree[ofs] & 127];
 }