abstracttype.h

Go to the documentation of this file.

/* This file is part of KDevelop
    Copyright 2006 Roberto Raggi <[email protected]>
    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_ABSTRACTTYPE_H
#define KDEVPLATFORM_ABSTRACTTYPE_H
 
#include "typepointer.h"
#include <language/languageexport.h>
 
class QString;
 
namespace KDevelop {
class AbstractTypeData;
 
class IndexedType;
 
class TypeVisitor;
class TypeExchanger;
 
#define TYPE_DECLARE_DATA(Class) \
    inline Class ## Data * d_func_dynamic() { makeDynamic(); return reinterpret_cast<Class ## Data*>(d_ptr); } \
    inline const Class ## Data* d_func() const { return reinterpret_cast<const Class ## Data*>(d_ptr); }
 
#define TYPE_D(Class) const Class ## Data * const d = d_func()
#define TYPE_D_DYNAMIC(Class) Class ## Data * const d = d_func_dynamic()
 
class KDEVPLATFORMLANGUAGE_EXPORT AbstractType
    : public QSharedData
{
public:
    using Ptr = TypePtr<AbstractType>;
 
    enum CommonModifiers : quint32 {
        NoModifiers                 = 0,
 
        ConstModifier               = 1 << 0,
        VolatileModifier            = 1 << 1,
        TransientModifier           = 1 << 2,
        NewModifier                 = 1 << 3,
        SealedModifier              = 1 << 4,
        UnsafeModifier              = 1 << 5,
        FixedModifier               = 1 << 6,
        ShortModifier               = 1 << 7,
        LongModifier                = 1 << 8,
        LongLongModifier            = 1 << 9,
        SignedModifier              = 1 << 10,
        UnsignedModifier            = 1 << 11,
 
        LanguageSpecificModifier    = 1 << 12
    };
 
    AbstractType();
    explicit AbstractType(AbstractTypeData& dd);
    virtual ~AbstractType ();
 
    AbstractType(const AbstractType& rhs) = delete;
    AbstractType& operator=(const AbstractType& rhs) = delete;
 
    quint32 modifiers() const;
 
    void setModifiers(quint32 modifiers);
 
    int64_t sizeOf() const;
 
    void setSizeOf(int64_t sizeOf);
 
    int64_t alignOf() const;
 
    void setAlignOf(int64_t alignedTo);
 
    void accept(TypeVisitor* v) const;
 
    static void acceptType(AbstractType::Ptr type, TypeVisitor* v);
 
    virtual QString toString() const;
 
    void makeDynamic();
 
    virtual bool equals(const AbstractType* rhs) const;
 
    virtual AbstractType* clone() const = 0;
 
    virtual uint hash() const;
 
    IndexedType indexed() const;
 
    enum WhichType : quint8 {
        TypeAbstract ,
        TypeIntegral ,
        TypePointer ,
        TypeReference ,
        TypeFunction ,
        TypeStructure ,
        TypeArray ,
        TypeDelayed ,
        TypeEnumeration ,
        TypeEnumerator ,
        TypeAlias ,
        TypeUnsure 
    };
 
    virtual WhichType whichType() const;
 
    enum {
        Identity = 1
    };
 
    virtual void exchangeTypes(TypeExchanger* exchanger);
 
    template <class Type>
    static typename Type::Data& copyData(const typename Type::Data& rhs)
    {
        uint size;
        if (!rhs.m_dynamic)
            size = sizeof(typename Type::Data); //Create a dynamic data instance
        else
            size = rhs.dynamicSize(); //Create a constant data instance, that holds all the data embedded.
 
        typename Type::Data& ret(*new (new char[size]) typename Type::Data(rhs));
        ret.template setTypeClassId<Type>();
        return ret;
    }
 
    template <class DataType>
    static DataType& copyDataDirectly(const DataType& rhs)
    {
        uint size;
        if (!rhs.m_dynamic)
            size = sizeof(DataType); //Create a dynamic data instance
        else
            size = rhs.dynamicSize(); //Create a constant data instance, that holds all the data embedded.
 
        return *new (new char[size]) DataType(rhs);
    }
 
    template <class Type>
    static typename Type::Data& createData()
    {
        typename Type::Data& ret(*new (new char[sizeof(typename Type::Data)]) typename Type::Data());
        ret.template setTypeClassId<Type>();
        return ret;
    }
 
    using Data = AbstractTypeData;
 
protected:
    virtual void accept0 (TypeVisitor* v) const = 0;
 
    QString toString(bool spaceOnLeft) const;
 
    AbstractTypeData* d_ptr;
 
    TYPE_DECLARE_DATA(AbstractType)
 
    friend class AbstractTypeDataRequest;
};
 
template <class To>
inline To fastCast(AbstractType* from)
{
    return dynamic_cast<To>(from);
}
 
template <class To>
inline const To fastCast(const AbstractType* from)
{
    return const_cast<const To>(fastCast<To>(const_cast<AbstractType*>(from))); //Hack so we don't need to define the functions twice, once for const, and once for not const
}
}
 
#endif