declarationid.h

Go to the documentation of this file.

/* This file is part of KDevelop
    Copyright 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_DECLARATION_ID_H
#define KDEVPLATFORM_DECLARATION_ID_H
 
#include "indexeddeclaration.h"
#include "identifier.h"
#include "instantiationinformation.h"
#include <language/util/kdevhash.h>
 
//krazy:excludeall=dpointer
 
namespace KDevelop {
class Declaration;
class TopDUContext;
 
class KDEVPLATFORMLANGUAGE_EXPORT DeclarationId
{
public:
    explicit DeclarationId(const IndexedQualifiedIdentifier& id = IndexedQualifiedIdentifier(),
                           uint additionalId = 0,
                           const IndexedInstantiationInformation& specialization = IndexedInstantiationInformation());
 
    explicit DeclarationId(const IndexedDeclaration& decl,
                           const IndexedInstantiationInformation& specialization = IndexedInstantiationInformation());
 
    DeclarationId(const DeclarationId& rhs);
 
    ~DeclarationId();
 
    DeclarationId& operator=(const DeclarationId& rhs);
 
    bool operator==(const DeclarationId& rhs) const
    {
        if (m_isDirect != rhs.m_isDirect)
            return false;
 
        if (!m_isDirect)
            return m_indirectData.identifier == rhs.m_indirectData.identifier
                   && m_indirectData.additionalIdentity == rhs.m_indirectData.additionalIdentity
                   && m_specialization == rhs.m_specialization;
        else
            return m_directData == rhs.m_directData && m_specialization == rhs.m_specialization;
    }
 
    bool operator!=(const DeclarationId& rhs) const
    {
        return !operator==(rhs);
    }
 
    bool isValid() const
    {
        return (m_isDirect && m_directData.isValid()) || m_indirectData.identifier.isValid();
    }
 
    uint hash() const
    {
        if (m_isDirect)
            return KDevHash() << m_directData.hash() << m_specialization.index();
        else
            return KDevHash() << m_indirectData.identifier.index() << m_indirectData.additionalIdentity <<
                   m_specialization.index();
    }
 
    Declaration* declaration(const TopDUContext* context, bool instantiateIfRequired = true) const;
 
    KDevVarLengthArray<Declaration*> declarations(const TopDUContext* context) const;
 
    void setSpecialization(const IndexedInstantiationInformation& spec);
 
    IndexedInstantiationInformation specialization() const;
 
    bool isDirect() const;
 
    QualifiedIdentifier qualifiedIdentifier() const;
 
private:
    struct Indirect
    {
        IndexedQualifiedIdentifier identifier;
        uint additionalIdentity;
 
        Indirect& operator=(const Indirect& rhs) = default;
    };
 
    union {
        Indirect m_indirectData;
        IndexedDeclaration m_directData;
    };
    bool m_isDirect;
 
    // Can be used in a language-specific way to pick other versions of the declaration.
    // When the declaration is found, pickSpecialization is called on the found declaration
    // with this value, and the returned value is the actually found declaration.
    IndexedInstantiationInformation m_specialization;
};
 
inline uint qHash(const KDevelop::DeclarationId& id)
{
    return id.hash();
}
}
 
Q_DECLARE_TYPEINFO(KDevelop::DeclarationId, Q_MOVABLE_TYPE);
 
#endif