NavHint.h

Go to the documentation of this file.

//-*- Mode: C++ -*-
//
//  DDC originally by Alexey Sokirko
//  Changes and modifications 2018 by Bryan Jurish
//
//  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_NAV_HINT_H
#define DDC_NAV_HINT_H

#include "../ConcordLib/ConcCommon.h"
#include "../ConcordLib/LRUCache.h"
#include "../CommonLib/ddcThread.h"
#include <numeric> //-- for std::accumulate

//======================================================================

#define DDC_DEFAULT_NAV_HINT_CACHE_CAPACITY 1024

#define DDC_DEFAULT_NAV_HINT_CACHE_STEP 1000

//------------------------------------------------------
//#define DEBUG_NAVCACHE 1
#undef DEBUG_NAVCACHE
#ifdef DEBUG_NAVCACHE
# define NAVCACHE_DEBUG(x) x
#else
# define NAVCACHE_DEBUG(x)
#endif

//------------------------------------------------------
//#define TRACE_NAVCACHE 1
#undef TRACE_NAVCACHE
#ifdef TRACE_NAVCACHE
# define NAVCACHE_TRACE(x) x
#else
# define NAVCACHE_TRACE(x)
#endif

//======================================================================
struct NavHintKey {
    string m_QueryStr;    
    size_t m_HitNo;       

    NavHintKey(const string& qstr="", const size_t hitno=0)
        : m_QueryStr(qstr), m_HitNo(hitno)
    {};

    inline void clear()
    {
        ClearString(m_QueryStr);
        m_HitNo = 0;
    };

    inline bool operator< (const NavHintKey &X) const
    {
        return (m_QueryStr < X.m_QueryStr ? true                    //-- QueryStr is primary sort-key
                : (m_QueryStr==X.m_QueryStr ? (m_HitNo > X.m_HitNo) //-- ... only compare HitNo if QueryStr matches (otherwise map<> chokes)
                   : false));                                       //-- ... QueryStr>X.QueryStr
    };

    inline bool operator== (const NavHintKey &X) const
    { return m_HitNo == X.m_HitNo && m_QueryStr == X.m_QueryStr; };

    inline void assign(const string& qstr, const size_t hitno=0)
    {
        m_QueryStr = qstr;
        m_HitNo    = hitno;
    };
  
    inline NavHintKey& operator= (const NavHintKey &X)
    {
        assign(X.m_QueryStr, X.m_HitNo);
        return *this;
    };

    inline string toString() const
    { return Format("%zd %s", m_HitNo, m_QueryStr.c_str()); };

    void fromString(const char *s);
  
    string toJson() const;
};


//======================================================================
struct NavHint {
    string         m_SortKey;  
    size_t         m_Offset;   
    vector<string> m_DtrHints; 

    NavHint(size_t nDtrs=0)
        : m_SortKey(""), m_Offset(0), m_DtrHints(nDtrs,"")
    {};

    NavHint(size_t Offset, size_t nDtrs)
        : m_SortKey(""), m_Offset(Offset), m_DtrHints(nDtrs,"")
    {};

    NavHint(const string& SortKey, size_t Offset, size_t nDtrs)
        : m_SortKey(SortKey), m_Offset(Offset), m_DtrHints(nDtrs,"")
    {};

    NavHint(const string& SortKey, size_t Offset, const vector<string> DtrHints)
        : m_SortKey(SortKey), m_Offset(Offset), m_DtrHints(DtrHints)
    {};

    NavHint(const string& HintStr)
    { fromString(HintStr); };

    inline void clear(size_t nDtrs=0)
    {
        m_SortKey.clear();
        m_Offset = 0;
        m_DtrHints.assign(nDtrs,"");
    };

    inline bool empty() const
    { return m_SortKey.empty() && m_Offset==0; };

    size_t OffsetTotal() const;

    inline void UpdateOffset()
    { m_Offset = OffsetTotal(); };

    inline const char* DtrHint(size_t DtrNo) const
    { return (DtrNo < m_DtrHints.size() ? m_DtrHints[DtrNo].c_str() : ""); };
  
    inline size_t DtrOffset(size_t DtrNo) const
    { return (DtrNo < m_DtrHints.size() ? strtoul(m_DtrHints[DtrNo].c_str(),NULL,0) : 0); };
  
    inline NavHint& operator= (const NavHint &X)
    {
        m_SortKey  = X.m_SortKey;
        m_Offset   = X.m_Offset;
        m_DtrHints = X.m_DtrHints;
        return *this;
    };

    inline NavHint& operator= (const string& S)
    {
        fromString(S);
        return *this;
    };

    inline void update(const string& SortKey, size_t Offset, size_t nDtrs)
    {
        m_SortKey = SortKey;
        m_Offset  = Offset;
        m_DtrHints.resize(nDtrs);
    };

    string toString(bool includeSortKey=true) const;

    void fromString(const string& Str);

    string toJson() const;
};

//======================================================================
class NavHintCache : public ddcLockable
{
public:
    //------------------------------------------------------------
    // public typedefs
    typedef NavHintKey  KeyT; 
    typedef NavHint ValT; 

    //----------------------------------------------------
    typedef ddcLRUCache<KeyT,ValT> CacheT;

public:
    //------------------------------------------------------------
    // public data
    CacheT m_Cache;  

public:
    //------------------------------------------------------------
    // constructors etc.

    NavHintCache(size_t capacity=DDC_DEFAULT_NAV_HINT_CACHE_CAPACITY)
        : m_Cache(capacity, &m_Mutex)
    {};

    ~NavHintCache()
    {};

    //------------------------------------------------------------
    // API

    inline void reserve(size_t capacity_)
    {
        lock();
        try {
            m_Cache.reserve(capacity_);
        } catch (...) {
            unlock();
            throw;
        }
        unlock();
    };
  
    //----------------------------------------------------
    inline size_t size() const
    {
        size_t sz=0;
        lock();
        try {
            sz = m_Cache.size();
        } catch (...) {
            unlock();
            throw;
        }
        unlock();
        return sz;
    };

    //----------------------------------------------------
    inline void clear()
    {
        lock();
        try {
            m_Cache.clear();
        } catch (...) {
            unlock();
            throw;
        }
        unlock();
    };

    //----------------------------------------------------
    bool lower_bound(ValT& val, const KeyT& key, bool doPromote=true);

    //----------------------------------------------------
    inline ValT lower_bound(const KeyT& key, bool doPromote=true)
    {
        ValT val;
        lower_bound(val, key, doPromote);
        return val;
    };

    //----------------------------------------------------
    inline void insert(const KeyT& key, const ValT& val)
    {
        lock();
        try {
            NAVCACHE_TRACE(ddcLogTrace(Format("NavCache::insert(\"%s\",\"%s\")", escapeCString(key.toString()).c_str(), escapeCString(val.toString()).c_str())));
            m_Cache.insert(key,val);
        } catch (...) {
            unlock();
            throw;
        }
        unlock();
    };

    //------------------------------------------------------------
    // convenience API

    inline ValT lower_bound(const string& QueryStr, size_t HitNo)
    { return lower_bound(KeyT(QueryStr,HitNo)); };

    inline void insert(const string& QueryStr, size_t HitNo, const string& SortKey, const size_t Offset, const vector<string>& DtrHints)
    { insert(KeyT(QueryStr,HitNo), ValT(SortKey,Offset,DtrHints)); };

    //------------------------------------------------------------
    // debugging
    string toJson() const;
};


#endif /* DDC_NAV_HINT_H */

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