duchain.h

Go to the documentation of this file.

/* This file is part of KDevelop
    Copyright 2006-2008 Hamish Rodda <[email protected]>
    Copyright 2007-2008 David Nolden <[email protected]>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.
 
   This library 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
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
#ifndef KDEVPLATFORM_DUCHAIN_H
#define KDEVPLATFORM_DUCHAIN_H
 
#include <QObject>
 
#include "topducontext.h"
#include "parsingenvironment.h"
 
#include <interfaces/isessionlock.h>
 
class QUrl;
 
namespace KDevelop {
class IDocument;
class TopDUContext;
class DUChainLock;
 
class ParsingEnvironmentManager;
class ParsingEnvironment;
class ParsingEnvironmentFile;
using ParsingEnvironmentFilePointer = QExplicitlySharedDataPointer<ParsingEnvironmentFile>;
class Definitions;
class Uses;
 
class KDEVPLATFORMLANGUAGE_EXPORT DUChain
    : public QObject
{
    Q_OBJECT
 
public:
    static void initialize();
 
    QList<TopDUContext*> allChains() const;
 
    void updateContextForUrl(const IndexedString& document, TopDUContext::Features minFeatures,
                             QObject* notifyReady = nullptr, int priority = 1) const;
 
    KDevelop::ReferencedTopDUContext waitForUpdate(const KDevelop::IndexedString& document,
                                                   KDevelop::TopDUContext::Features minFeatures,
                                                   bool proxyContext = false);
 
    TopDUContext* chainForDocument(const QUrl& document, bool proxyContext = false) const;
    TopDUContext* chainForDocument(const IndexedString& document, bool proxyContext = false) const;
 
    QList<TopDUContext*> chainsForDocument(const QUrl& document) const;
 
    QList<TopDUContext*> chainsForDocument(const IndexedString& document) const;
 
    TopDUContext* chainForDocument(const QUrl& document, const ParsingEnvironment* environment,
                                   bool proxyContext = false) const;
 
    TopDUContext* chainForDocument(const IndexedString& document, const ParsingEnvironment* environment,
                                   bool proxyContext = false) const;
 
    ParsingEnvironmentFilePointer environmentFileForDocument(const IndexedString& document,
                                                             const ParsingEnvironment* environment,
                                                             bool proxyContext = false) const;
 
    ParsingEnvironmentFilePointer environmentFileForDocument(IndexedTopDUContext topContext) const;
 
    QList<ParsingEnvironmentFilePointer> allEnvironmentFiles(const IndexedString& document);
 
    inline TopDUContext* chainForIndex(uint index)
    {
        if (m_deleted)
            return nullptr;
 
        {
            QMutexLocker lock(&chainsByIndexLock);
 
            if (chainsByIndex.size() > index) {
                TopDUContext* top = chainsByIndex[index];
                if (top)
                    return top;
            }
        }
 
        //Load the top-context
        return loadChain(index);
    }
 
    IndexedString urlForIndex(uint index) const;
 
    QList<QUrl> documents() const;
 
    QList<IndexedString> indexedDocuments() const;
 
    void addDocumentChain(TopDUContext* chain);
 
    static bool deleted();
 
    static DUChain* self();
 
    static Definitions* definitions();
 
    static Uses* uses();
 
    static QString repositoryPathForSession(const KDevelop::ISessionLock::Ptr& session);
 
    static DUChainLock* lock();
 
    bool isInMemory(uint topContextIndex) const;
 
    void updateContextEnvironment(TopDUContext* context, ParsingEnvironmentFile* file);
 
    static uint newTopContextIndex();
 
    void disablePersistentStorage(bool disable = true);
 
    void storeToDisk();
 
    bool compareToDisk();
 
Q_SIGNALS:
    void declarationSelected(const KDevelop::DeclarationPointer& decl);
 
    void updateReady(const KDevelop::IndexedString& url, const KDevelop::ReferencedTopDUContext& topContext);
 
public Q_SLOTS:
    void removeDocumentChain(KDevelop::TopDUContext* document);
    void emitDeclarationSelected(const KDevelop::DeclarationPointer& decl);
 
    void emitUpdateReady(const KDevelop::IndexedString& url, const KDevelop::ReferencedTopDUContext& topContext);
 
    void shutdown();
 
private Q_SLOTS:
    void documentActivated(KDevelop::IDocument* doc);
    void documentLoadedPrepare(KDevelop::IDocument* document);
    void documentRenamed(KDevelop::IDocument* document);
    void documentClosed(KDevelop::IDocument*);
 
private:
    TopDUContext* loadChain(uint index);
    //These two are exported here so that the extremely frequently called chainForIndex(..) can be inlined
    static bool m_deleted;
    static std::vector<TopDUContext*> chainsByIndex;
    static QMutex chainsByIndexLock;
 
    void refCountUp(TopDUContext* top);
 
    void refCountDown(TopDUContext* top);
 
    void addToEnvironmentManager(TopDUContext* chain);
    void removeFromEnvironmentManager(TopDUContext* chain);
    DUChain();
    ~DUChain() override;
 
    friend class DUChainPrivate;
    friend class ReferencedTopDUContext;
};
}
 
#endif // KDEVPLATFORM_DUCHAIN_H