• Skip to content
• Skip to link menu

KDE 4.4 API Reference

• KDE API Reference
• KDevelop Platform Libraries

• Sitemap
• Contact Us

 

language/duchain

abstracttype.h

/* This file is part of KDevelop
    Copyright 2006 Roberto Raggi <roberto@kdevelop.org>
    Copyright 2006-2008 Hamish Rodda <rodda@kde.org>
    Copyright 2007-2008 David Nolden <david.nolden.kdevelop@art-master.de>

   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 ABSTRACTTYPE_H
#define ABSTRACTTYPE_H

#include <QtCore/QString>
#include "typepointer.h"
#include "../../languageexport.h"

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 TypeShared
{
public:
  typedef TypePtr<AbstractType> Ptr;

  enum CommonModifiers {
    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 //TODO make this support 64 bit values
  };

  AbstractType();
  AbstractType(AbstractTypeData& dd);
  virtual ~AbstractType ();

  quint64 modifiers() const;

  void setModifiers(quint64 modifiers);

  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 {
    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) {
    size_t 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) {
    size_t 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;
  }

  typedef AbstractTypeData Data;

protected:
  virtual void accept0 (TypeVisitor *v) const = 0;

  QString toString(bool spaceOnLeft) const;

  AbstractTypeData* d_ptr;

  TYPE_DECLARE_DATA(AbstractType)

  friend class AbstractTypeDataRequest;

private:
  AbstractType(const AbstractType& rhs);
};

template <class T>
uint qHash(const TypePtr<T>& type) { return (uint)((size_t)type.unsafeData()); }


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

// kate: space-indent on; indent-width 2; tab-width 4; replace-tabs on; auto-insert-doxygen on

language/duchain

Skip menu "language/duchain"

• Main Page
• Namespace List
• Class Hierarchy
• Alphabetical List
• Class List
• File List
• Namespace Members
• Class Members
• Related Pages

KDevelop Platform Libraries

Skip menu "KDevelop Platform Libraries"

• interfaces
• language
•   codegen
•   duchain
•   editor
• outputview
• project
• shell
• sublime
• util
• vcs

Generated for KDevelop Platform Libraries by doxygen 1.5.9-20090814
This website is maintained by Adriaan de Groot and Allen Winter.
KDE^® and the K Desktop Environment^® logo are registered trademarks of KDE e.V. | Legal