FieldComparator.h

Go to the documentation of this file.

// Copyright (c) 2009-2014 Alan Wright. All rights reserved.
// Distributable under the terms of either the Apache License (Version 2.0)
// or the GNU Lesser General Public License.

#ifndef FIELDCOMPARATOR_H
#define FIELDCOMPARATOR_H

#include "LuceneObject.h"

namespace Lucene {

class LPPAPI FieldComparator : public LuceneObject {
public:
    virtual ~FieldComparator();
    LUCENE_CLASS(FieldComparator);

public:
    virtual int32_t compare(int32_t slot1, int32_t slot2) = 0;

    virtual void setBottom(int32_t slot) = 0;

    virtual int32_t compareBottom(int32_t doc) = 0;

    virtual void copy(int32_t slot, int32_t doc) = 0;

    virtual void setNextReader(const IndexReaderPtr& reader, int32_t docBase) = 0;

    virtual void setScorer(const ScorerPtr& scorer);

    virtual ComparableValue value(int32_t slot) = 0;
};

template <typename TYPE>
class NumericComparator : public FieldComparator {
public:
    NumericComparator(int32_t numHits, const String& field = EmptyString) {
        this->values = Collection<TYPE>::newInstance(numHits);
        this->field = field;
        this->bottom = 0;
    }

    virtual ~NumericComparator() {
    }

protected:
    Collection<TYPE> values;
    Collection<TYPE> currentReaderValues;
    String field;
    TYPE bottom;

public:
    virtual int32_t compare(int32_t slot1, int32_t slot2) {
        return (int32_t)(values[slot1] - values[slot2]);
    }

    virtual int32_t compareBottom(int32_t doc) {
        return (int32_t)(bottom - currentReaderValues[doc]);
    }

    virtual void copy(int32_t slot, int32_t doc) {
        values[slot] = currentReaderValues[doc];
    }

    virtual void setBottom(int32_t slot) {
        bottom = values[slot];
    }

    virtual ComparableValue value(int32_t slot) {
        return ComparableValue(values[slot]);
    }
};

class LPPAPI ByteComparator : public NumericComparator<uint8_t> {
public:
    ByteComparator(int32_t numHits, const String& field, const ParserPtr& parser);
    virtual ~ByteComparator();

    LUCENE_CLASS(ByteComparator);

protected:
    ByteParserPtr parser;

public:
    virtual void setNextReader(const IndexReaderPtr& reader, int32_t docBase);
};

class LPPAPI DocComparator : public NumericComparator<int32_t> {
public:
    DocComparator(int32_t numHits);
    virtual ~DocComparator();

    LUCENE_CLASS(DocComparator);

protected:
    int32_t docBase;

public:
    virtual int32_t compareBottom(int32_t doc);
    virtual void copy(int32_t slot, int32_t doc);
    virtual void setNextReader(const IndexReaderPtr& reader, int32_t docBase);
};

class LPPAPI DoubleComparator : public NumericComparator<double> {
public:
    DoubleComparator(int32_t numHits, const String& field, const ParserPtr& parser);
    virtual ~DoubleComparator();

    LUCENE_CLASS(DoubleComparator);

protected:
    DoubleParserPtr parser;

public:
    virtual int32_t compare(int32_t slot1, int32_t slot2);
    virtual int32_t compareBottom(int32_t doc);
    virtual void setNextReader(const IndexReaderPtr& reader, int32_t docBase);
};

class LPPAPI IntComparator : public NumericComparator<int32_t> {
public:
    IntComparator(int32_t numHits, const String& field, const ParserPtr& parser);
    virtual ~IntComparator();

    LUCENE_CLASS(IntComparator);

protected:
    IntParserPtr parser;

public:
    virtual int32_t compare(int32_t slot1, int32_t slot2);
    virtual int32_t compareBottom(int32_t doc);
    virtual void setNextReader(const IndexReaderPtr& reader, int32_t docBase);
};

class LPPAPI LongComparator : public NumericComparator<int64_t> {
public:
    LongComparator(int32_t numHits, const String& field, const ParserPtr& parser);
    virtual ~LongComparator();

    LUCENE_CLASS(LongComparator);

protected:
    LongParserPtr parser;

public:
    virtual int32_t compare(int32_t slot1, int32_t slot2);
    virtual int32_t compareBottom(int32_t doc);
    virtual void setNextReader(const IndexReaderPtr& reader, int32_t docBase);
};

class LPPAPI RelevanceComparator : public NumericComparator<double> {
public:
    RelevanceComparator(int32_t numHits);
    virtual ~RelevanceComparator();

    LUCENE_CLASS(RelevanceComparator);

protected:
    ScorerPtr scorer;

public:
    virtual int32_t compare(int32_t slot1, int32_t slot2);
    virtual int32_t compareBottom(int32_t doc);
    virtual void copy(int32_t slot, int32_t doc);
    virtual void setNextReader(const IndexReaderPtr& reader, int32_t docBase);
    virtual void setScorer(const ScorerPtr& scorer);
};

class LPPAPI StringComparatorLocale : public FieldComparator {
public:
    StringComparatorLocale(int32_t numHits, const String& field, const std::locale& locale);
    virtual ~StringComparatorLocale();

    LUCENE_CLASS(StringComparatorLocale);

protected:
    Collection<String> values;
    Collection<String> currentReaderValues;
    String field;
    CollatorPtr collator;
    String bottom;

public:
    virtual int32_t compare(int32_t slot1, int32_t slot2);
    virtual int32_t compareBottom(int32_t doc);
    virtual void copy(int32_t slot, int32_t doc);
    virtual void setNextReader(const IndexReaderPtr& reader, int32_t docBase);
    virtual void setBottom(int32_t slot);
    virtual ComparableValue value(int32_t slot);
};

class LPPAPI StringOrdValComparator : public FieldComparator {
public:
    StringOrdValComparator(int32_t numHits, const String& field, int32_t sortPos, bool reversed);
    virtual ~StringOrdValComparator();

    LUCENE_CLASS(StringOrdValComparator);

protected:
    Collection<int32_t> ords;
    Collection<String> values;
    Collection<int32_t> readerGen;

    int32_t currentReaderGen;
    Collection<String> lookup;
    Collection<int32_t> order;
    String field;

    int32_t bottomSlot;
    int32_t bottomOrd;
    String bottomValue;
    bool reversed;
    int32_t sortPos;

public:
    virtual int32_t compare(int32_t slot1, int32_t slot2);
    virtual int32_t compareBottom(int32_t doc);
    virtual void copy(int32_t slot, int32_t doc);
    virtual void setNextReader(const IndexReaderPtr& reader, int32_t docBase);
    virtual void setBottom(int32_t slot);
    virtual ComparableValue value(int32_t slot);
    virtual Collection<String> getValues();
    virtual int32_t getBottomSlot();
    virtual String getField();

protected:
    void convert(int32_t slot);
    int32_t binarySearch(Collection<String> lookup, const String& key, int32_t low, int32_t high);
};

class LPPAPI StringValComparator : public FieldComparator {
public:
    StringValComparator(int32_t numHits, const String& field);
    virtual ~StringValComparator();

    LUCENE_CLASS(StringOrdValComparator);

protected:
    Collection<String> values;
    Collection<String> currentReaderValues;
    String field;
    String bottom;

public:
    virtual int32_t compare(int32_t slot1, int32_t slot2);
    virtual int32_t compareBottom(int32_t doc);
    virtual void copy(int32_t slot, int32_t doc);
    virtual void setNextReader(const IndexReaderPtr& reader, int32_t docBase);
    virtual void setBottom(int32_t slot);
    virtual ComparableValue value(int32_t slot);
};

}

#endif