QueryResult.h

Go to the documentation of this file.

//*-*- Mode: C++ -*- */
//
//  DDC originally by Alexey Sokirko
//  Changes and modifications 2011-2016 by Bryan Jurish (formerly in ConcHolder.h)
//
//  This file is part of DDC.
// 
//  DDC is free software: you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
// 
//  DDC is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
// 
//  You should have received a copy of the GNU Lesser General Public License
//  along with DDC.  If not, see <http://www.gnu.org/licenses/>.
//
#ifndef DDC_QUERY_RESULT_H
#define DDC_QUERY_RESULT_H

#include "ConcCommon.h"

//==============================================================================
// Typedefs

typedef map<string,size_t> CCountMap;

//==============================================================================
// Class Definitions

//----------------------------------------------------------------------
struct CQueryResult 
{
    vector<CHit>            m_Hits;

    vector<CTokenNo>        m_HighlightOccurs;

    vector<BYTE>            m_HighlightIds;

    size_t                  m_AllHitsCount;

    size_t                  m_RelevantDocumentCount;

    bool                    m_bSortByString : 1;

    bool                    m_bPrune : 1;

    HitSortOrderEnum        m_SortOrder : 4;

    mutable vector<BYTE>    m_DebugInfo;

    void ClearQueryResults();

    template <typename HitIndexLessThanT>
    inline void SortResultsByIndex(HitIndexLessThanT& HitIndexLess);

    template <typename HitLessThanT>
    inline void SortResultsByHit(HitLessThanT& HitLess);

    template <typename HitIndexLessThanT>
    inline void SortResultsByIndexP(HitIndexLessThanT HitIndexLess)
    { SortResultsByIndex(HitIndexLess); };

    template <typename HitLessThanT>
    inline void SortResultsByHitP(HitLessThanT HitLess)
    { SortResultsByHit(HitLess); };
};

//----------------------------------------------------------------------
template <typename HitLessThanT> struct CResultHitLess
{
    const CQueryResult& m_Result;

    HitLessThanT&       m_HitLess;

    CResultHitLess(const CQueryResult& Result, HitLessThanT& HitLess)
        : m_Result(Result), m_HitLess(HitLess)
    {};

    inline bool operator() (size_t i1, size_t i2) const
    { return m_HitLess(m_Result.m_Hits[i1], m_Result.m_Hits[i2]); }
};


//----------------------------------------------------------------------
struct CQueryResultIndex
{
    const CQueryResult& m_Result;

    vector<size_t>*     m_pHitIndex;

    bool                m_bLocalIndex;

    CQueryResultIndex(const CQueryResult& Result)
        : m_Result(Result), m_pHitIndex(NULL), m_bLocalIndex(false)
    { Reset(); }

    CQueryResultIndex(const CQueryResult& Result, vector<size_t>* HitIndex)
        : m_Result(Result), m_pHitIndex(HitIndex), m_bLocalIndex(false)
    {};

    CQueryResultIndex(const CQueryResult& Result, vector<size_t>& HitIndex)
        : m_Result(Result), m_pHitIndex(&HitIndex), m_bLocalIndex(false)
    {};

    ~CQueryResultIndex(void)
    { if (m_bLocalIndex) delete m_pHitIndex; };

    void Reset(void);

    inline size_t size(void) const
    { return m_pHitIndex==NULL ? 0 : m_pHitIndex->size(); };

    template <typename HitIndexLessThanT>
    inline void SortByIndex(HitIndexLessThanT& HitIndexLess)
    { stable_sort(m_pHitIndex->begin(), m_pHitIndex->end(), HitIndexLess); };

    template <typename HitLessThanT>
    inline void SortByHit(HitLessThanT& HitLess)
    {
        CResultHitLess<HitLessThanT> ResultLess(m_Result, HitLess);
        SortByIndex(ResultLess);
    };

    void Apply(CQueryResult &Dst, size_t Begin=0, size_t End=(size_t)-1);
};

//==============================================================================
// Template instantiations

//----------------------------------------------------------------------
// CQueryResult

//-- hit-sorting: result: by index: guts
template <typename HitIndexLessThanT>
inline void CQueryResult::SortResultsByIndex(HitIndexLessThanT& HitIndexLess)
{
    CQueryResultIndex ResultIndex(*this);
    ResultIndex.SortByIndex(HitIndexLess);
    ResultIndex.Apply(*this);
};

//-- hit-sorting: result: by hit: guts
template <typename HitLessThanT>
inline void CQueryResult::SortResultsByHit(HitLessThanT& HitLess)
{
    CQueryResultIndex ResultIndex(*this);
    ResultIndex.SortByHit(HitLess);
    ResultIndex.Apply(*this);
};



#endif /* DDC_QUERY_RESULT_H */

/*--- emacs style variables ---
 * Local Variables:
 *  mode: C++
 *  c-file-style: "ellemtel"
 *  c-basic-offset: 4
 *  tab-width: 8
 *  indent-tabs-mode: nil
 * End:
 */