index.h

#ifndef LPC_INDEX_H1110724080_INCLUDE_GUARD_
#define LPC_INDEX_H1110724080_INCLUDE_GUARD_
 
/* This file is part of KMail
 * Copyright (C) 2005 Luís Pedro Coelho <luis@luispedro.org>
 * (based on the old kmmsgindex by Sam Magnuson)
 *
 * KMail is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License, version 2, as
 * published by the Free Software Foundation.
 *
 * KMail 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
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * In addition, as a special exception, the copyright holders give
 * permission to link the code of this program with any edition of
 * the TQt library by Trolltech AS, Norway (or with modified versions
 * of TQt that use the same license as TQt), and distribute linked
 * combinations including the two.  You must obey the GNU General
 * Public License in all respects for all of the code used other than
 * TQt.  If you modify this file, you may extend this exception to
 * your version of the file, but you are not obligated to do so.  If
 * you do not wish to do so, delete this exception statement from
 * your version.
 */
 
 
#include <tqobject.h>
#include <tqcstring.h>
#include <tqvaluelist.h>
#include <tqtimer.h>
#include <config.h>
#ifdef HAVE_INDEXLIB
#include <indexlib/index.h>
#include <indexlib/lockfile.h>
#endif
#include <vector>
#include <set>
 
class KMFolder;
 
class KMSearch;
class KMSearchRule;
class KMSearchPattern;
 
class KMMsgIndex : public TQObject {
    TQ_OBJECT
  
    public:
        explicit KMMsgIndex( TQObject* parent );
        ~KMMsgIndex();
 
    public:

        bool startQuery( KMSearch* );
        bool stopQuery( KMSearch* );

        std::vector<TQ_UINT32> simpleSearch( TQString, bool* ) const;

        bool isIndexable( KMFolder* folder ) const;

        bool isIndexed( KMFolder* folder ) const;

        bool isEnabled() const { return mState != s_disabled; }
    public slots:
        void setEnabled( bool );

        void setIndexingEnabled( KMFolder*, bool );
 
    private slots:
        void clear();
        void create();
        void maintenance();
 
        void act();
        void removeSearch( TQObject* );
 
        void continueCreation();
 
        void slotAddMessage( KMFolder*, TQ_UINT32 message );
        void slotRemoveMessage( KMFolder*, TQ_UINT32 message );
    private:
        static TQString defaultPath();
 
        bool canHandleQuery( const KMSearchPattern* ) const;
        int addMessage( TQ_UINT32 );
        void removeMessage( TQ_UINT32 );
 
        void scheduleAction();
        bool creating() const;
 
    public:
        class Search;
    private:
 
        std::vector<TQ_UINT32> mPendingMsgs;
        std::vector<KMFolder*> mPendingFolders;
        std::vector<TQ_UINT32> mAddedMsgs;
        std::vector<TQ_UINT32> mRemovedMsgs;
        std::vector<TQ_UINT32> mExisting;
 
        enum e_state {
            s_idle, // doing nothing, index waiting
            s_willcreate, // just constructed, create() scheduled (mIndex == 0)
            s_creating, // creating the index from the messages
            s_processing, // has messages to process
            s_error, // an error occurred
            s_disabled // disabled: the index is not working
        } mState;
 
        unsigned mMaintenanceCount;
 
#ifdef HAVE_INDEXLIB
        indexlib::detail::lockfile mLockFile;
        //enum e_syncState { ss_none, ss_started, ss_synced } mSyncState;
        //TQTimer* mSyncTimer;
 
        indexlib::index* mIndex;
#endif
        std::set<KMFolder*> mOpenedFolders;
        std::vector<Search*> mSearches;
        TQCString mIndexPath;
        TQTimer* mTimer;
        bool mSlowDown;
};
 
 
class KMMsgIndex::Search : public TQObject {
    TQ_OBJECT
  
    public:
        explicit Search( KMSearch* s );
        ~Search();
        KMSearch* search() const { return mSearch; }
    signals:
        void found( TQ_UINT32 );
        void finished( bool );
    private slots:
        void act();
    private:
        KMSearch* mSearch;
        TQTimer* mTimer;
        KMSearchPattern* mResidual;
        std::vector<TQ_UINT32> mValues;
        enum { s_none = 0, s_starting, s_emitting, s_emitstopped, s_done } mState;
};
 
#endif /* LPC_INDEX_H1110724080_INCLUDE_GUARD_ */