CLucene - a full-featured, c++ search engine
API Documentation

---

Sort.h

Go to the documentation of this file.

/*------------------------------------------------------------------------------
* Copyright (C) 2003-2006 Ben van Klinken and the CLucene Team
* 
* Distributable under the terms of either the Apache License (Version 2.0) or 
* the GNU Lesser General Public License, as specified in the COPYING file.
------------------------------------------------------------------------------*/
#ifndef _lucene_search_Sort_
#define _lucene_search_Sort_


//#include "CLucene/index/IndexReader.h"
//#include "SearchHeader.h"
//#include "CLucene/util/Equator.h"
CL_CLASS_DEF(index,IndexReader)
CL_CLASS_DEF(util,Comparable)

CL_NS_DEF(search)

 class SortField; //predefine
 class Sort;

 class CLUCENE_EXPORT ScoreDocComparator:LUCENE_BASE {
 protected:
         ScoreDocComparator(){}
 public:
         virtual ~ScoreDocComparator();
//    CL_NS(util)::Comparable** cachedValues;
//    ScoreDocComparator(CL_NS(util)::Comparable** cachedValues);

    virtual int32_t compare (struct ScoreDoc* i, struct ScoreDoc* j) = 0;

    virtual CL_NS(util)::Comparable* sortValue (struct ScoreDoc* i) = 0;

        
    virtual int32_t sortType() = 0;

        static ScoreDocComparator* RELEVANCE;

        static ScoreDocComparator* INDEXORDER;
 };

class CLUCENE_EXPORT SortComparatorSource:LUCENE_BASE {
public:
   virtual ~SortComparatorSource(){
   }

   virtual TCHAR* getName() = 0;

   virtual size_t hashCode() = 0;

   virtual ScoreDocComparator* newComparator (CL_NS(index)::IndexReader* reader, const TCHAR* fieldname) = 0;
};


class CLUCENE_EXPORT SortComparator: public SortComparatorSource {
public:
        virtual ScoreDocComparator* newComparator (CL_NS(index)::IndexReader* reader, const TCHAR* fieldname);
  
        SortComparator();
        virtual ~SortComparator();

   virtual CL_NS(util)::Comparable* getComparable (const TCHAR* termtext) = 0;

};


class CLUCENE_EXPORT SortField:LUCENE_BASE {
private:
  const TCHAR* field;
  int32_t type;  // defaults to determining type dynamically
  //Locale* locale;    // defaults to "natural order" (no Locale)
  bool reverse;  // defaults to natural order
  SortComparatorSource* factory;

protected:
  SortField (const SortField& clone);
public:
   virtual ~SortField();

   LUCENE_STATIC_CONSTANT(int32_t, DOCSCORE=0);
   
   LUCENE_STATIC_CONSTANT(int32_t, DOC=1);

   LUCENE_STATIC_CONSTANT(int32_t, AUTO=2);

   LUCENE_STATIC_CONSTANT(int32_t, STRING=3);

   LUCENE_STATIC_CONSTANT(int32_t, INT=4);

   LUCENE_STATIC_CONSTANT(int32_t, FLOAT=5);

   LUCENE_STATIC_CONSTANT(int32_t, CUSTOM=9);

  // IMPLEMENTATION NOTE: the FieldCache.STRING_INDEX is in the same "namespace"
  // as the above static int values.  Any new values must not have the same value
  // as FieldCache.STRING_INDEX.

  static SortField* FIELD_SCORE;

  static SortField* FIELD_DOC;

  SortField (const TCHAR* field);
  //SortField (const TCHAR* field, bool reverse);
  //todo: we cannot make reverse use default field of =false.
  //because bool and int are the same type in c, overloading is not possible
  
  SortField (const TCHAR* field, int32_t type, bool reverse); 

  /*
   SortField (TCHAR* field, Locale* locale) {
   SortField (TCHAR* field, Locale* locale, bool reverse);*/

  SortField (const TCHAR* field, SortComparatorSource* comparator, bool reverse=false);

  const TCHAR* getField() const { return field; }
  
  SortField* clone() const;

  int32_t getType() const { return type; }

  /*Locale getLocale() {
    return locale;
  }*/

  bool getReverse() const { return reverse; }

  SortComparatorSource* getFactory() const { return factory; }

  TCHAR* toString() const;
};



class CLUCENE_EXPORT Sort:LUCENE_BASE {
        // internal representation of the sort criteria
        SortField** fields;
        void clear();
public:
        ~Sort();

        static Sort* RELEVANCE;

        static Sort* INDEXORDER;


        Sort();

        Sort (const TCHAR* field, bool reverse=false);

        Sort (const TCHAR** fields);

        Sort (SortField* field);
        
        Sort (SortField** fields);
        
        void setSort (const TCHAR* field, bool reverse=false);
        
        void setSort (const TCHAR** fieldnames);
        
        void setSort (SortField* field);
        
        void setSort (SortField** fields);

    TCHAR* toString() const;
 
    SortField** getSort() const{ return fields; }
};



 

CL_NS_END
#endif

---

clucene.sourceforge.net