Lucene.Net.Search.SortField.GetComparator C# (CSharp) Méthode

        public virtual FieldComparator GetComparator(int numHits, int sortPos)
        {
            switch (type)
            {
                case Type_e.SCORE:
                    return new FieldComparator.RelevanceComparator(numHits);

                case Type_e.DOC:
                    return new FieldComparator.DocComparator(numHits);

                case Type_e.INT:
                    return new FieldComparator.IntComparator(numHits, field, parser, (int?)missingValue);

                case Type_e.FLOAT:
                    return new FieldComparator.FloatComparator(numHits, field, parser, (float?)missingValue);

                case Type_e.LONG:
                    return new FieldComparator.LongComparator(numHits, field, parser, (long?)missingValue);

                case Type_e.DOUBLE:
                    return new FieldComparator.DoubleComparator(numHits, field, parser, (double?)missingValue);

                case Type_e.BYTE:
                    return new FieldComparator.ByteComparator(numHits, field, parser, (sbyte?)missingValue);

                case Type_e.SHORT:
                    return new FieldComparator.ShortComparator(numHits, field, parser, (short?)missingValue);

                case Type_e.CUSTOM:
                    Debug.Assert(comparatorSource != null);
                    return comparatorSource.NewComparator(field, numHits, sortPos, reverse);

                case Type_e.STRING:
                    return new FieldComparator.TermOrdValComparator(numHits, field, missingValue == STRING_LAST);

                case Type_e.STRING_VAL:
                    // TODO: should we remove this?  who really uses it?
                    return new FieldComparator.TermValComparator(numHits, field);

                case Type_e.REWRITEABLE:
                    throw new InvalidOperationException("SortField needs to be rewritten through Sort.rewrite(..) and SortField.rewrite(..)");

                default:
                    throw new InvalidOperationException("Illegal sort type: " + type);
            }
        }

            public MultiComparatorsFieldValueHitQueue(SortField[] fields, int size)
                : base(fields, size)
            {
                int numComparators = comparators.Length;

                for (int i = 0; i < numComparators; ++i)
                {
                    SortField field = fields[i];

                    ReverseMul[i] = field.reverse ? -1 : 1;
                    SetComparator(i, field.GetComparator(size, i));
                }
            }