Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdevelop@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1612 insertions, 0 deletions

diff --git a/lib/interfaces/codemodel.h b/lib/interfaces/codemodel.h
new file mode 100644
index 00000000..b8c0c894
--- /dev/null
+++ b/lib/interfaces/codemodel.h
@@ -0,0 +1,1612 @@
+/* This file is part of KDevelop
+   Copyright (C) 2003 Roberto Raggi <roberto@kdevelop.org>
+   Copyright (C) 2004 Matt Rogers <mattr@kde.org> 
+   Copyright (C) 2004 Alexander Dymo <adymo@kdevelop.org>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   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., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.
+*/
+#ifndef CODEMODEL_H
+#define CODEMODEL_H
+
+/**
+@file codemodel.h
+Code Model - a memory symbol store.
+*/
+
+
+#include <qmap.h>
+#include <qstringlist.h>
+#include <ksharedptr.h>
+#include <qvaluevector.h>
+#include "hashedstring.h"
+
+#include <iostream>
+#include <ostream>
+#include <string>
+#include <sstream>
+#include <set>
+
+enum ParsedFileType {
+  CppParsedFile
+};
+
+class AbstractParseResult : public KShared {
+public:
+  virtual void read( QDataStream& stream ) = 0;
+
+  virtual void write( QDataStream& stream ) const = 0;
+
+  virtual ParsedFileType type() const = 0;
+};
+
+typedef KSharedPtr<AbstractParseResult> ParseResultPointer;
+  
+using namespace std;
+
+class CodeModel;
+class CodeModelItem;
+class FileModel;
+class NamespaceModel;
+class ClassModel;
+class FunctionModel;
+class FunctionDefinitionModel;
+class VariableModel;
+class ArgumentModel;
+class EnumModel;
+class EnumeratorModel;
+class TypeAliasModel;
+
+/**
+@class ItemDom
+Safe pointer to the @ref CodeModelItem.
+This is a type definition: @code typedef KSharedPtr<CodeModelItem> ItemDom; @endcode
+@sa KSharedPtr
+*/
+typedef KSharedPtr<CodeModelItem> ItemDom;
+
+/**
+@class FileDom
+Safe pointer to the @ref FileModel.
+This is a type definition: @code typedef KSharedPtr<FileModel> FileDom; @endcode
+@sa KSharedPtr
+*/
+typedef KSharedPtr<FileModel> FileDom;
+
+/**
+@class NamespaceDom
+Safe pointer to the @ref NamespaceModel.
+This is a type definition: @code typedef KSharedPtr<NamespaceModel> NamespaceDom; @endcode
+@sa KSharedPtr
+*/
+typedef KSharedPtr<NamespaceModel> NamespaceDom;
+
+/**
+@class ClassDom
+Safe pointer to the @ref ClassModel.
+This is a type definition: @code typedef KSharedPtr<ClassModel> ClassDom; @endcode
+@sa KSharedPtr
+*/
+typedef KSharedPtr<ClassModel> ClassDom;
+
+/**
+@class FunctionDom
+Safe pointer to the @ref FunctionModel.
+This is a type definition: @code typedef KSharedPtr<FunctionModel> FunctionDom; @endcode
+@sa KSharedPtr
+*/
+typedef KSharedPtr<FunctionModel> FunctionDom;
+
+/**
+@class FunctionDefinitionDom
+Safe pointer to the @ref FunctionDefinitionModel.
+This is a type definition: @code typedef KSharedPtr<FunctionDefinitionModel> FunctionDefinitionDom; @endcode
+@sa KSharedPtr
+*/
+typedef KSharedPtr<FunctionDefinitionModel> FunctionDefinitionDom;
+
+/**
+@class VariableDom
+Safe pointer to the @ref VariableModel.
+This is a type definition: @code typedef KSharedPtr<VariableModel> VariableDom; @endcode
+@sa KSharedPtr
+*/
+typedef KSharedPtr<VariableModel> VariableDom;
+
+/**
+@class ArgumentDom
+Safe pointer to the @ref ArgumentModel.
+This is a type definition: @code typedef KSharedPtr<ArgumentModel> ArgumentDom; @endcode
+@sa KSharedPtr
+*/
+typedef KSharedPtr<ArgumentModel> ArgumentDom;
+
+/**
+@class EnumDom
+Safe pointer to the @ref EnumModel.
+This is a type definition: @code typedef KSharedPtr<EnumModel> EnumDom; @endcode
+@sa KSharedPtr
+*/
+typedef KSharedPtr<EnumModel> EnumDom;
+
+/**
+@class TypeAliasDom
+Safe pointer to the @ref TypeAliasModel.
+This is a type definition: @code typedef KSharedPtr<TypeAliasModel> TypeAliasDom; @endcode
+@sa KSharedPtr
+*/
+typedef KSharedPtr<TypeAliasModel> TypeAliasDom;
+
+/**
+@class EnumeratorDom
+Safe pointer to the @ref EnumeratorModel.
+This is a type definition: @code typedef KSharedPtr<EnumeratorModel> EnumeratorDom; @endcode
+@sa KSharedPtr
+*/
+typedef KSharedPtr<EnumeratorModel> EnumeratorDom;
+
+/**
+@class ItemList
+The list of code model items.
+This is a type definition: @code typedef QValueList<ItemDom> ItemList; @endcode
+@sa QValueList
+*/
+typedef QValueList<ItemDom> ItemList;
+
+/**
+@class FileList
+The list of code model files.
+This is a type definition: @code typedef QValueList<FileDom> FileList; @endcode
+@sa QValueList
+*/
+typedef QValueList<FileDom> FileList;
+
+/**
+@class NamespaceList
+The list of code model namespaces.
+This is a type definition: @code typedef QValueList<NamespaceDom> NamespaceList; @endcode
+@sa QValueList
+*/
+typedef QValueList<NamespaceDom> NamespaceList;
+
+/**
+@class ClassList
+The list of code model classes.
+This is a type definition: @code typedef QValueList<ClassDom> ClassList; @endcode
+@sa QValueList
+*/
+typedef QValueList<ClassDom> ClassList;
+
+/**
+@class FunctionList
+The list of code model functions.
+This is a type definition: @code typedef QValueList<FunctionDom> FunctionList; @endcode
+@sa QValueList
+*/
+typedef QValueList<FunctionDom> FunctionList;
+
+/**
+@class FunctionDefinitionList
+The list of code model function definitions.
+This is a type definition: @code typedef QValueList<FunctionDefinitionDom> FunctionDefinitionList; @endcode
+@sa QValueList
+*/
+
+typedef QValueList<FunctionDefinitionDom> FunctionDefinitionList;
+/**
+@class VariableList
+The list of code model variables.
+This is a type definition: @code typedef QValueList<VariableDom> VariableList; @endcode
+@sa QValueList
+*/
+typedef QValueList<VariableDom> VariableList;
+
+/**
+@class ArgumentList
+The list of code model arguments.
+This is a type definition: @code typedef QValueList<ArgumentDom> ArgumentList; @endcode
+@sa QValueList
+*/
+typedef QValueList<ArgumentDom> ArgumentList;
+
+/**
+@class EnumList
+The list of code model enums.
+This is a type definition: @code typedef QValueList<EnumDom> EnumList; @endcode
+@sa QValueList
+*/
+typedef QValueList<EnumDom> EnumList;
+
+/**
+@class TypeAliasList
+The list of code model type aliases.
+This is a type definition: @code typedef QValueList<TypeAliasDom> TypeAliasList; @endcode
+@sa QValueList
+*/
+typedef QValueList<TypeAliasDom> TypeAliasList;
+
+/**
+@class EnumeratorList
+The list of code model enumerators.
+This is a type definition: @code typedef QValueList<EnumeratorDom> EnumeratorList; @endcode
+@sa QValueList
+*/
+typedef QValueList<EnumeratorDom> EnumeratorList;
+
+/**
+Iterates through @p lst and creates sorted list of code model item names.
+Can be used, for example, to get the list of classes in the store:
+@code
+QStringList classList = sortedNameList(codeModel()->globalNamespace()->classList());
+@endcode
+@param lst The list to iterate.
+@return Sorted list of code model item names.
+*/
+template <class ItemList>
+QStringList sortedNameList( const ItemList& lst )
+{
+    QStringList nameList;
+
+    typename ItemList::ConstIterator it = lst.begin();
+    while( it != lst.end() ){
+        if( !(*it)->name().isEmpty() )
+            nameList << (*it)->name();
+        ++it;
+    }
+
+    nameList.sort();
+    return nameList;
+}
+
+/**
+Casts safe code model pointers (@p KSharedPtr<T> objects like
+FileDom, NamespaceDom, etc.) to the @p Result type.
+
+Example:
+@code
+//ns is of type NamespaceDom
+ClassDom cl = model_cast<ClassDom>(ns);
+@endcode
+@param x Object to cast.
+*/
+template <class Result, class T>
+Result model_cast( KSharedPtr<T> x )
+{
+    Result r( static_cast<T*>(x) );
+    return r;
+}
+
+/**
+Casts code model pointers (objects like
+FileModel, NamespaceModel, etc.) to the @p Result type.
+
+Example:
+@code
+//ns is of type NamespaceModel*
+ClassDom cl = model_cast<ClassDom>(ns);
+@endcode
+@param x Object to cast.
+*/
+template <class Result, class T>
+Result model_cast( T* x )
+{
+    Result r( static_cast<T*>(x) );
+    return r;
+}
+
+
+/**
+Code Model - a memory symbol store.
+Symbol store (aka class store) is a database of symbols
+found in code with the important information about those symbols.
+
+For example, programming language support plugins use symbol store
+to remember information about classes, functions, etc. For each type
+of symbol a certain information can be stored - symbol name, the
+location in source file, etc.
+
+@sa codemodel.h documentation for a list of typedefs and other convenience functions.
+
+@sa codemodel_utils.h documentation for an additional code model utility functions and classes reference.
+*/
+class CodeModel
+{
+public:
+    /**Constructor.*/
+    CodeModel();
+    /**Destructor.*/
+    virtual ~CodeModel();
+
+    /**Creates a code model item. This should be used to create
+    code model items.
+    
+    For example, to create a class model somewhere in your plugin, use:
+    @code
+    klass = codeModel()->create<ClassModel>();
+    klass->setName("ClassName");
+    klass->setFileName("FileName");
+    klass->setStartPosition(line, column);
+    @endcode
+    @return Created code model item.*/
+    template <class T> typename T::Ptr create()
+    {
+        typename T::Ptr ptr( new T(this) );
+        return ptr;
+    }
+
+    /**Resets the CodeModel.*/
+    void wipeout();
+
+    /**Gets the list of files in the store.
+    @return The FileList object that contains the list of files.*/
+    FileList fileList();
+
+    /**Gets the list of files in the store.
+    This is a const version for convenience.
+    @return The FileList object that contains the list of files.*/
+    const FileList fileList() const;
+
+    /**Checks to see if a file is in the store.
+    @return true if @p name is in the file list.*/
+    bool hasFile( const QString& name ) const;
+
+    /**Gets the FileDom object for a file.
+    @param name The name of the file to get the FileDom object for.*/
+    FileDom fileByName( const QString& name );
+
+    /**Gets the FileDom object for a file.
+    This is a const version provided for convenience.
+    @param name the name of the file to get the FileDom object for.*/
+    const FileDom fileByName( const QString& name ) const;
+
+    /**Adds a file to the store.
+    @param file The FileDom object to add to the store.
+    @return true if the file was added successfully.*/
+    bool addFile( FileDom file );
+
+    /**Removes a file from the store.
+    @param file the FileDom object to remove from the store.*/
+    void removeFile( FileDom file  );
+
+    /**Gets the global namespace
+    @return The NamespaceDom object that represents the global namespace.*/
+    const NamespaceDom globalNamespace() const;
+
+    /**Reads the model from a stream.
+    Use this to save the memory symbol store to a file.
+    
+    Language support plugins usually save symbols from projects before the project is 
+    closed to avoid reparsing when the project is opened next time.
+    @param stream Stream to read from.
+    @return whether the read succeeded(may fail when the store-format is deprecated).*/
+    virtual void read( QDataStream& stream );
+    /**Writes the model to a stream.
+    Use this to restore the memory symbol store to a file.
+    
+    Language support plugins usually save symbols from projects before the project is 
+    closed to avoid reparsing when the project is opened next time.
+    @param stream Stream to write to.*/
+    virtual void write( QDataStream& stream ) const;
+    
+    /** this will dump the whole tree into dot-file-format so it can be inspected, not ready yet*/
+    virtual void dump( std::ostream& file, QString Info="" );
+    
+    /** Merges two groups, by changing the group-ids of the files.
+    Returns the id of the new group, or 0 on fail.
+    @param g1 first group
+    @param g2 second group */
+    int mergeGroups( int g1, int g2 );
+    
+    /** Returns all files within the given group 
+    it should be preferred calling FileModel::wholeGroup and 
+    FileModel::wholeGroupStrings because those return in constant
+    time if they are the only member of the group */
+    FileList getGroup( int gid ) const;
+    
+    FileList getGroup( const FileDom& file) const;
+    
+    /** Same as above, but returns the names instead of the objects */
+    virtual QStringList getGroupStrings( int gid ) const;
+    
+private:
+    /**Adds a namespace to the store.
+    @param target The NamespaceDom object that the namespace will be added to.
+    @param source The NamespaceDom object that contains the namespace to remove.*/
+    void addNamespace( NamespaceDom target, NamespaceDom source );
+
+    /**Removes a namespace from the store.
+    @param target The NamespaceDom object that the namespace will be removed from.
+    @param source The NamespaceDom object that contains the namespace to remove.*/
+    void removeNamespace( NamespaceDom target, NamespaceDom source );
+
+private:
+    QMap<QString, FileDom> m_files;
+    NamespaceDom m_globalNamespace;
+
+    virtual int newGroupId();
+    ///the groups were introduced to represent dependencies between different files.
+    ///Files can have slaves that are owned by other files within the same group.
+    ///While parsing, whole groups should always be parsed/reparsed together.
+    int m_currentGroupId;   ///normally, each file has its own group.
+    
+private:
+    CodeModel( const CodeModel& source );
+    void operator = ( const CodeModel& source );
+    friend class CodeModelItem;
+    friend class FileModel;
+};
+
+
+/**
+Item in code model (symbol store).
+Item is a symbol in a store. Code model provides several predefined classes
+for predefined item types (files, namespaces, classes, functions and function definitions,
+variables, arguments, enums and enumerators, type aliases.
+
+Instances of this class should be created using @ref CodeModel::create method but usually
+it is better to create instances of derived classes like ClassModel, NamespaceModel, FileModel, etc.
+*/
+class CodeModelItem: public KShared
+{
+public:
+    /**A definition of safe pointer to the code model item.*/
+    typedef ItemDom Ptr;
+
+    /**A type of a code model item.*/
+    enum Kind
+    {
+        File,                /**<File.*/
+        Namespace,           /**<Namespace.*/
+        Class,               /**<Class.*/
+        Function,            /**<Function or class method.*/
+        Variable,            /**<Variable.*/
+        Argument,            /**<Function or method parameter.*/
+        FunctionDefinition,  /**<Function definition.*/
+        Enum,                /**<Enum.*/
+        Enumerator,          /**<Enumerator - a member of an Enum (example: @code enum Type { A, B, C} @endcode 
+                                Type will be an Enum; A, B and C - Enumerators.*/
+        TypeAlias,           /**<Type alias (aka typedef in c++).*/
+    
+        Custom = 1000        /**<Custom model items should have type greater than 1000*/
+    };
+
+    /**An access to the code model item.*/
+    enum Access
+    {
+        Public,        /**<Public.*/
+        Protected,     /**<Protected.*/
+        Private        /**<Private.*/
+    };
+    void update( const CodeModelItem* i );
+    bool canUpdate( const CodeModelItem* i ) const;
+
+protected:
+    /**Constructor.
+    @param kind The type, see also @ref CodeModelItem::Kind.
+    @param model Code model which stores this item.*/
+    CodeModelItem( int kind, CodeModel* model );
+
+public:
+    /**Destructor.*/
+    virtual ~CodeModelItem();
+
+    /**@return The type (kind) of item.*/
+    int kind() const { return m_kind; }
+
+    /**Sets the type (kind) of item.
+    @param kind The type, see also @ref CodeModelItem::Kind.*/
+    void setKind( int kind ) { m_kind = kind; }
+
+    /**@return The name of the item.*/
+    QString name() const;
+
+    QString comment() const {
+        return m_comment;
+    }
+    
+    void setComment( QString comment ) {
+        m_comment = comment;
+    }
+    
+    /**Sets the name of the item.
+    @param name The name.*/
+    void setName( const QString& name );
+
+    /**Gets the file of the item.
+    @return The FileDom object for the item.*/
+    FileDom file();
+
+    /**Gets the file of the item
+    This is a const version provided for convenience.
+    @return The FileDom object for the item.*/
+    const FileDom file() const;
+
+    /**@return The filename of the item.*/
+    QString fileName() const;
+
+    /**Sets the filename of the item.
+    @param fileName The file name.*/
+    void setFileName( const QString& fileName );
+
+    /**Gets the start position of the item.
+    @param line Will be set to the line number of the items start position. Pass 0 if line number is not necessary.
+    @param col Will be set to the column number of the items start position. Pass 0 if column number is not necessary.*/
+    void getStartPosition( int* line, int* col ) const;
+
+    /**Sets the start position of the item.
+    @param line Line number.
+    @param col Column number.*/
+    void setStartPosition( int line, int col );
+
+    /**Get the end position of the item.
+    @param line Will be set to the line number of the items end position. Pass 0 if line number is not necessary.
+    @param col Will be set to the column number of the items end position. Pass 0 if column number is not necessary.*/
+    void getEndPosition( int* line, int* col ) const;
+
+    /**Set the end position of the item.
+    @param line Line number.
+    @param col Column number.*/
+    void setEndPosition( int line, int col );
+
+    /**@return true if an item is a FileModel.*/
+    virtual bool isFile() const { return false; }
+    /**@return true if an item is a NamespaceModel.*/
+    virtual bool isNamespace() const { return false; }
+    /**@return true if an item is a ClassModel.*/
+    virtual bool isClass() const { return false; }
+    /**@return true if an item is a FunctionModel.*/
+    virtual bool isFunction() const { return false; }
+    /**@return true if an item is a FileDefinitionModel.*/
+    virtual bool isFunctionDefinition() const { return false; }
+    /**@return true if an item is a VariableModel.*/
+    virtual bool isVariable() const { return false; }
+    /**@return true if an item is an ArgumentModel.*/
+    virtual bool isArgument() const { return false; }
+    /**@return true if an item is a EnumModel.*/
+    virtual bool isEnum() const { return false; }
+    /**@return true if an item is a EnumeratorModel.*/
+    virtual bool isEnumerator() const { return false; }
+    /**@return true if an item is a TypeAliasModel.*/
+    virtual bool isTypeAlias() const { return false; }
+    /**@return true if an item is a custom item.*/
+    virtual bool isCustom() const { return false; }
+    
+    virtual bool isTemplateable() const { return false; }
+
+    /**Reads an item from the stream.
+    @param stream The stream to read from.*/
+    virtual void read( QDataStream& stream );
+    /**Writes an item to the stream.
+    @param stream The stream to write to.*/
+    virtual void write( QDataStream& stream ) const;
+
+    virtual void dump( std::ostream& file, bool recurse=false, QString Info="" );
+    
+    /**@return The code model for this item.*/
+    CodeModel* codeModel() { return m_model; }
+
+    /**@note This is a const version provided for convenience.
+    @return The code model for this item*/
+    const CodeModel* codeModel() const { return m_model; }
+
+private:
+    int m_kind;
+    CodeModel* m_model;
+    QString m_name;
+    QString m_fileName;
+    QString m_comment; ///not stored yet
+    int m_startLine, m_startColumn;
+    int m_endLine, m_endColumn;
+
+private:
+    CodeModelItem( const CodeModelItem& source );
+    void operator = ( const CodeModelItem& source );
+};
+
+
+
+class TemplateModelItem {
+    public:
+        typedef QPair< QString, QString > ParamPair;
+        typedef QValueVector< ParamPair > ParamMap; ///The first is the name, and the second the default-parameter, or "" if there is none.
+        
+        virtual const ParamMap& getTemplateParams() {
+            return m_params;
+        }
+        
+        virtual void addTemplateParam( QString name, QString def = "" ) {
+            m_params.push_back( ParamPair( name, def ) );
+        }
+        
+        virtual void clearTemplateParams() {
+            m_params.clear();
+        }
+
+				bool hasSpecializationDeclaration() const {
+					return !m_specialization.isEmpty();
+				}
+
+				virtual QString getSpecializationDeclaration() const {
+					return m_specialization;
+				}
+
+				void setSpecializationDeclaration( const QString& str ) {
+					m_specialization = str;
+				}
+        
+        ///returns -1 if the parameter does not exist
+        virtual int findTemplateParam( const QString& name ) const {
+            for( unsigned int a = 0; a< m_params.size(); a++) 
+                if( m_params[a].first == name ) return a;
+            return -1;
+       }
+        
+       const ParamPair getParam( int index ) const {
+           return m_params[index];
+       }
+       
+       virtual bool isTemplateable() const  { return true; }
+    
+       void write(  QDataStream & stream ) const {
+			 		 stream << m_specialization;
+           stream << (int)m_params.size();
+           for( ParamMap::const_iterator it = m_params.begin(); it != m_params.end(); ++it ) {
+               stream << (*it).first;
+               stream << (*it).second;
+           }
+       }
+       
+       void read(  QDataStream & stream )  {
+           int count;
+					 stream >> m_specialization;
+           stream >> count;
+           for( int a = 0; a < count; a++ ) {
+               ParamPair tmp;
+               stream >> tmp.first;
+               stream >> tmp.second;
+               m_params.push_back( tmp );
+           }
+       }
+    
+    protected:
+        ParamMap m_params;
+				QString m_specialization;
+};
+
+
+
+/**
+Class model.
+Represents a class in the code model.
+
+Instances of this class should be created using @ref CodeModel::create method.
+*/
+class ClassModel: public CodeModelItem, public TemplateModelItem
+{
+protected:
+    /**Constructor.
+    @param model Code model which stores this item.*/
+    ClassModel( CodeModel* model );
+
+public:
+    /**A definition of safe pointer to the class model.*/
+    typedef ClassDom Ptr;
+
+    virtual bool isClass() const { return true; }
+
+    /**@return The scope of the class. Scope is a string list composed from names of parent classes and namespaces.*/
+    QStringList scope() const { return m_scope; }
+    /**Sets the scope of this class.
+    @param scope The scope - a list of parent classes and namespaces.*/
+    void setScope( const QStringList& scope ) { m_scope = scope; }
+
+    /**@return The list of base class names.*/
+    QStringList baseClassList() const;
+
+    /**Adds a base class to the list of base classes.
+    @param baseClass The base class name.*/
+    bool addBaseClass( const QString& baseClass );
+
+    /**Removes a base class from the list of base classes.
+    @param baseClass The base class name.*/
+    void removeBaseClass( const QString& baseClass );
+
+    /**@return The list of (sub)classes in this model.*/
+    ClassList classList();
+
+    /**@note This is a const version provided for convenience.
+    @return The list of (sub)classes in this model.*/
+    const ClassList classList() const;
+
+    /**Checks if the class specified by @p name is in this model.
+    @param name The name of a class to look for.
+    @return true if the model has a class.*/
+    bool hasClass( const QString& name ) const;
+
+    /**@param name The name of a class.
+    @return A list of classes that match the name given by @p name.*/
+    ClassList classByName( const QString& name );
+
+    /**@param name The name of a class.
+    @return A list of classes that match the name given by @p name.
+    @note This is a const version provided for convenience.*/
+    const ClassList classByName( const QString& name ) const;
+
+    /**Adds a class to the model.
+    @param klass The class model to add.
+    @return true if addition was successful.*/
+    bool addClass( ClassDom klass );
+
+    /**Removes a class from the model.
+    @param klass The class model to remove.*/    
+    void removeClass( ClassDom klass );
+
+    /**@return A list of functions in the model.*/
+    FunctionList functionList();
+
+    /**@return A list of functions in the model.
+    @note This is a const version provided for convenience.*/
+    const FunctionList functionList() const;
+
+    /**Check if the function specified by @p name is in the model.
+    @param name The name of a function to look for.
+    @return true if the model has a class.*/
+    bool hasFunction( const QString& name ) const;
+
+    /**@param name The name of a function to look for.
+    @return A list of functions that match the name given by @p name.*/
+    FunctionList functionByName( const QString& name );
+
+    /**@param name The name of a function to look for.
+    @return A list of functions that match the name given by @p name.
+    @note This is a const version provided for convenience.*/
+    const FunctionList functionByName( const QString& name ) const;
+
+    /**Adds a function to the class model.
+    @param fun The function model to add.
+    @return true if addition was successful.*/
+    bool addFunction( FunctionDom fun );
+
+    /**Removes a function from the class model.
+    @param fun The FunctionDom object to remove from the model.*/
+    void removeFunction( FunctionDom fun );
+
+    /**@return The list of function definitions in the model.*/
+    FunctionDefinitionList functionDefinitionList();
+
+    /**@return The list of function definitions
+    @note This is a const version provided for convenience.*/
+    const FunctionDefinitionList functionDefinitionList() const;
+
+    /**Checks if the function definition specified by \p name is in the model.
+    @param name The name of a function definition to look for.
+    @return true if the function definition was found.*/
+    bool hasFunctionDefinition( const QString& name ) const;
+
+    /**Gets the list of functions that match the name given by \p name.
+    If there are no matches, then the list returned is empty.
+    @param name The name of a function definition to look for.
+    @return The FunctionDefinitionList object containing the definitions that match.*/
+    FunctionDefinitionList functionDefinitionByName( const QString& name );
+
+    /**Gets the list of functions that match the name given by \p name.
+    If there are no matches, then the list returned is empty.
+    @param name The name of a function definition to look for.
+    @return The FunctionDefinitionList object containing the definitions that match.
+    @note This is a const version provided for convenience.*/
+    const FunctionDefinitionList functionDefinitionByName( const QString& name ) const;
+
+    /**Adds a function definition to the model.
+    @param fun The function fefinition model to add to the model.
+    @return true if the addition was successful.*/
+    bool addFunctionDefinition( FunctionDefinitionDom fun );
+
+    /**Removes a function definition from the model.
+    @param fun The function fefinition model to remove from the model.*/
+    void removeFunctionDefinition( FunctionDefinitionDom fun );
+
+    /**@return The list of variables in the model.*/
+    VariableList variableList();
+
+    /**@return The list of variables in the model.
+    @note This is a const version provided for convenience.*/
+    const VariableList variableList() const;
+
+    /**Checks if the variable specified by @p name is in the model.
+    @param name The name of a variable.
+    @return true if the variable was found.*/
+    bool hasVariable( const QString& name ) const;
+
+    /**Gets the variable specified by @p name.
+    If there are no matches, then the VariableDom object returned is empty.
+    @param name The name of a variable.
+    @return A VariableDom object that matches the name specified.*/
+    VariableDom variableByName( const QString& name );
+
+    /**Gets the variable specified by @p name.
+    If there are no matches, then the VariableDom object returned is empty.
+    @param name The name of a variable.
+    @return A VariableDom object that matches the name specified.
+    @note This is a const version provided for convenience.*/
+    const VariableDom variableByName( const QString& name ) const;
+
+    /**Adds a variable to the model.
+    @param var The variable model to add to the model.
+    @return true if the addition was successful.*/
+    bool addVariable( VariableDom var );
+
+    /**Removes a variable from the model.
+    @param var The variable model to remove from the model.*/
+    void removeVariable( VariableDom var );
+
+    /**@return The type alias list for this model.*/
+    TypeAliasList typeAliasList();
+
+    /**@return The type alias list for this model.
+    @note This is a const version provided for convenience.*/
+    const TypeAliasList typeAliasList() const;
+
+    /**Checks if the type alias specified by @p name is in the model.
+    @param name The name of a type alias.
+    @return true if the type alias was found.*/
+    bool hasTypeAlias( const QString& name ) const;
+
+    /**Gets the list of type aliases that match @p name.
+    If there are no matches, the TypeAliasList object is empty.
+    @param name The name of a type alias.
+    @return A TypeAliasList object that contains the matches.*/
+    TypeAliasList typeAliasByName( const QString& name );
+
+    /**Gets the list of type aliases that match @p name.
+    If there are no matches, the TypeAliasList object is empty.
+    @param name The name of a type alias.
+    @return A TypeAliasList object that contains the matches.
+    @note This is a const version provided for convenience.*/
+    const TypeAliasList typeAliasByName( const QString& name ) const;
+
+    /**Adds a type alias to the model.
+    @param typeAlias The type alias model to add to the model.
+    @return true if the addition was successful.*/
+    bool addTypeAlias( TypeAliasDom typeAlias );
+
+    /**Removes a type alias from the model.
+    @param typeAlias The TypeAliasDom object to remove from the model.*/
+    void removeTypeAlias( TypeAliasDom typeAlias );
+
+    /**@return The list of enums in the model.*/
+    EnumList enumList();
+
+    /**@return The list of enums in the model.
+    @note This is a const version provided for convenience.*/
+    const EnumList enumList() const;
+
+    /**Checks if the enum specified by @p name is in the model.
+    @param name The name of an enum.
+    @return true if the enum was found.*/
+    bool hasEnum( const QString& name ) const;
+
+    /**Gets the enum specified by @p name.
+    The EnumDom object returned will be empty if no match is found.
+    @param name The name of an enum.
+    @return The EnumDom object that contains the match.*/
+    EnumDom enumByName( const QString& name );
+
+    /**Gets the enum specified by @p name.
+    The EnumDom object returned will be empty if no match is found.
+    @param name The name of an enum.
+    @return The EnumDom object that contains the match.*/
+    const EnumDom enumByName( const QString& name ) const;
+
+    /**Adds an enum to the model.
+    @param e The enum model to add to the model.
+    @return true if the addition was successful.*/
+    bool addEnum( EnumDom e );
+
+    /**Removes an enum from the model.
+    @param e The enum model to remove from the model.*/
+    void removeEnum( EnumDom e );
+
+    void update( const ClassModel* i );
+    bool canUpdate( const ClassModel* i ) const;
+    
+    virtual void read( QDataStream& stream );
+    virtual void write( QDataStream& stream ) const;
+
+    virtual void dump( std::ostream& file, bool recurse=false, QString Info="" );
+    
+private:
+    QStringList m_scope;
+    QStringList m_baseClassList;
+    QMap<QString, ClassList> m_classes;
+    QMap<QString, FunctionList> m_functions;
+    QMap<QString, FunctionDefinitionList> m_functionDefinitions;
+    QMap<QString, VariableDom> m_variables;
+    QMap<QString, TypeAliasList> m_typeAliases;
+    QMap<QString, EnumDom> m_enumerators;
+
+private:
+    ClassModel( const ClassModel& source );
+    void operator = ( const ClassModel& source );
+    friend class CodeModel;
+};
+
+class NamespaceAliasModel {
+public:
+  virtual void read( QDataStream& stream );
+  virtual void write( QDataStream& stream ) const;
+
+  QString name() const {
+    return m_name;
+  }
+
+  void setName( const QString& name ) {
+    m_name = name;
+  }
+
+  void setAliasName( const QString& theValue ) {
+    m_aliasName = theValue;
+  }
+
+  QString aliasName() const {
+    return m_aliasName;
+  }
+
+  void setFileName( const HashedString& theValue ) {
+    m_fileName = theValue;
+  }
+
+  HashedString fileName() const {
+    return m_fileName;
+  }
+
+  bool operator < ( const NamespaceAliasModel& rhs ) const {
+    if( m_name < rhs.m_name ) return true;
+    if( m_name == rhs.m_name ) {
+      if( m_aliasName < rhs.m_aliasName ) return true;
+      if(  m_aliasName == rhs.m_aliasName && m_fileName < rhs.m_fileName ) return true;
+    }
+    return false;
+  }
+
+  bool operator == ( const NamespaceAliasModel& rhs ) const {
+    return m_name == rhs.m_name && m_aliasName == rhs.m_aliasName && m_fileName == rhs.m_fileName;
+  }
+  
+private:
+  QString m_name;
+  QString m_aliasName;
+  HashedString m_fileName;
+};
+
+class NamespaceImportModel {
+public:
+  virtual void read( QDataStream& stream );
+  virtual void write( QDataStream& stream ) const;
+  
+  QString name() const {
+    return m_name;
+  }
+  
+  HashedString fileName() const {
+    return m_fileName;
+  }
+
+  void setName( const QString& name ) {
+    m_name = name;
+  }
+
+  void setFileName( const HashedString& file ) {
+    m_fileName = file;
+  }
+  
+  bool operator < ( const NamespaceImportModel& rhs ) const {
+    if( m_name < rhs.m_name ) return true;
+    if( m_name == rhs.m_name )
+      if( m_fileName < rhs.m_fileName ) return true;
+
+    return false;
+  }
+  
+  bool operator == ( const NamespaceImportModel& rhs ) const {
+    return m_name == rhs.m_name && m_fileName == rhs.m_fileName;
+  }
+  
+private:
+  QString m_name;
+  HashedString m_fileName;
+};
+
+/**
+Namespace model.
+Represents a namespace in the code model.
+Namespace model can represent either usual c++ namespaces
+and packages or modules from other languages.
+
+Instances of this class should be created using @ref CodeModel::create method.
+*/
+class NamespaceModel: public ClassModel
+{
+protected:
+    /**Constructor.
+    @param model Code model which stores this item.*/
+    NamespaceModel( CodeModel* model );
+
+public:
+  typedef std::set<NamespaceAliasModel> NamespaceAliasModelList; ///I'm using std-sets here, because Qt-3 has no appropriate replacement
+  typedef std::set<NamespaceImportModel> NamespaceImportModelList;
+  
+    /**A definition of safe pointer to the namespace model.*/
+    typedef NamespaceDom Ptr;
+
+    virtual bool isClass() const { return false; }
+    virtual bool isNamespace() const { return true; }
+
+    /**@return The list of namespaces in this model.*/
+    NamespaceList namespaceList();
+
+    /**@return The list of namespaces in this model.
+    @note This is a const version provided for convenience.*/
+    const NamespaceList namespaceList() const;
+
+    /**Checks if the namespace referenced by @p name is in the model.
+    @param name The name of a namespace.
+    @return true if the namespace was found.*/
+    bool hasNamespace( const QString& name ) const;
+
+    /**Gets the namespace specified by @p name.
+    If there are no matches, then the NamespaceDom object returned is empty.
+    @param name The name of a namespace.
+    @return The NamespaceDom object that contains the match.*/
+    NamespaceDom namespaceByName( const QString& name );
+
+    /**Gets the namespace specified by @p name.
+    If there are no matches, then the NamespaceDom object returned is empty.
+    @param name The name of a namespace.
+    @return The NamespaceDom object that contains the match.
+    @note This is a const version provided for convenience.*/
+    const NamespaceDom namespaceByName( const QString& name ) const;
+
+    /**Adds a namespace to the model.
+    @param ns The namespace model to add to the model.
+    @return true if addition was successful.*/
+    bool addNamespace( NamespaceDom ns );
+
+    /**Removes the namespace from the model.
+    @param ns The namespace model to remove from the model.*/
+    void removeNamespace( NamespaceDom ns );
+
+    /**Updates this model so it has the same content as the other one. Only the line/column is updated. canUpdate(..) must be tested before.
+     * @param ns the namespace to match
+    */
+    void update( const NamespaceModel* ns );
+    bool canUpdate( const NamespaceModel* ns ) const;
+    
+    virtual void read( QDataStream& stream );
+    virtual void write( QDataStream& stream ) const;
+
+    virtual void dump( std::ostream& file, bool recurse=false, QString Info="" );
+
+    void addNamespaceImport( const NamespaceImportModel& import );
+    void addNamespaceAlias( const NamespaceAliasModel& alias );
+    void removeNamespaceImport( const NamespaceImportModel& import );
+    void removeNamespaceAlias( const NamespaceAliasModel& alias );
+
+    ///Must not be called on temporary objects because a reference is returned(for performance-reasons)
+    const NamespaceAliasModelList& namespaceAliases() const {
+      return m_namespaceAliases;
+    }
+  
+    ///Must not be called on temporary objects because a reference is returned(for performance-reasons)
+    const NamespaceImportModelList& namespaceImports() const {
+      return m_namespaceImports;
+    }
+private:
+    QMap<QString, NamespaceDom> m_namespaces;
+    NamespaceAliasModelList m_namespaceAliases;
+    NamespaceImportModelList m_namespaceImports;
+
+private:
+  
+    NamespaceModel( const NamespaceModel& source );
+    void operator = ( const NamespaceModel& source );
+    friend class CodeModel;
+};
+
+
+
+
+/**
+File model.
+Represents a file in the code model.
+Files in general contain classes, namespaces, functions,
+types, etc. Therefore FileModel is derived from NamespaceModel.
+
+Instances of this class should be created using @ref CodeModel::create method.
+*/
+class FileModel: public NamespaceModel
+{
+protected:
+    /**Constructor.
+    @param model Code model which stores this item.*/
+    FileModel( CodeModel* model );
+
+public:
+    /**A definition of safe pointer to the file model.*/
+    typedef FileDom Ptr;
+
+    virtual bool isFile() const { return true; }
+
+    virtual int groupId() const {
+        return m_groupId;
+    }
+    
+    virtual void setGroupId(int newId) {
+        m_groupId = newId;
+    }
+    
+    /** This function additionally does version-checking and
+        should be used instead of read when read should be called
+        from outside.
+    @return whether the read was successful */
+    
+    virtual void write( QDataStream& stream ) const;
+
+    FileList wholeGroup() ;
+    
+    QStringList wholeGroupStrings() const;
+    
+    virtual void read( QDataStream& stream );
+
+    ParseResultPointer parseResult() const;
+    void setParseResult( const ParseResultPointer& result );
+
+  void update( const FileModel* i );
+private:
+    int m_groupId;
+    ParseResultPointer m_parseResult;
+    FileModel( const FileModel& );
+    void operator = ( const FileModel& );
+    friend class CodeModel;
+};
+
+
+/**
+Function (procedure) argument model.
+Represents an argument in the function.
+
+Instances of this class should be created using @ref CodeModel::create method.
+*/
+class ArgumentModel: public CodeModelItem
+{
+protected:
+    ArgumentModel( CodeModel* model );
+
+public:
+    /**A definition of safe pointer to the argument model.*/
+    typedef ArgumentDom Ptr;
+
+    virtual bool isArgument() const { return true; }
+
+    /**@return The type of this argument.*/
+    QString type() const;
+
+    /**Sets the type of this argument.
+    @param type The type to set.*/
+    void setType( const QString& type );
+
+    /**@return The default value of this argument.*/
+    QString defaultValue() const;
+
+    /**Sets the default value of this argument.
+    @param defaultValue The default value to set.*/
+    void setDefaultValue( const QString& defaultValue );
+
+    virtual void read( QDataStream& stream );
+    virtual void write( QDataStream& stream ) const;
+
+    virtual void dump( std::ostream& file, bool recurse=false, QString Info="" );
+    
+private:
+    QString m_type;
+    QString m_defaultValue;
+
+private:
+    ArgumentModel( const ArgumentModel& source );
+    void operator = ( const ArgumentModel& source );
+    friend class CodeModel;
+};
+
+
+/**
+Function model.
+Represents:
+- functions;
+- procedures;
+- class methods;
+.
+In languages that have separate function declarations and definitions (c++)
+this represents only function declarations. @see FunctionDefinitionModel 
+for a model of function definitions.
+
+Instances of this class should be created using @ref CodeModel::create method.
+*/
+class FunctionModel: public CodeModelItem, public TemplateModelItem
+{
+protected:
+    /**Constructor.
+    @param model Code model which stores this item.*/
+    FunctionModel( CodeModel* model );
+
+public:
+    /**A definition of safe pointer to the function model.*/
+    typedef FunctionDom Ptr;
+
+    virtual bool isFunction() const { return true; }
+
+    /**@return The scope of the function. Scope is a string list composed 
+    from names of parent functions, classes and namespaces.*/
+    QStringList scope() const { return m_scope; }
+
+    /**Sets the scope of the function.
+    @param scope The scope to set.*/
+    void setScope( const QStringList& scope ) { m_scope = scope; }
+
+    /**@return The access level of the function. Can return either values of type @ref CodeModelItem::Access or 
+    other integers if the function has other access level (for example pascal methods can have "published"
+    access level).*/
+    int access() const;
+
+    /**Sets the access level of the function.
+    @param access The access level.*/
+    void setAccess( int access );
+
+    /**@return true if the function is a signal.*/
+    bool isSignal() const;
+    /**Sets the function to be a signal.
+    @param isSignal The signal flag.*/
+    void setSignal( bool isSignal );
+
+    /**@return true if the function is a slot.*/
+    bool isSlot() const;
+    /**Sets the function to be a slot.
+    @param isSlot The slot flag.*/
+    void setSlot( bool isSlot );
+
+    /**@return true if the function is a virtual function.*/
+    bool isVirtual() const;
+    /**Sets the function to be a virtual function.
+    @param isVirtual The virtual flag.*/
+    void setVirtual( bool isVirtual );
+
+    /**@return true if the function is a static function.*/
+    bool isStatic() const;
+    /**Sets the function to be a static function.
+    @param isStatic The static flag.*/
+    void setStatic( bool isStatic );
+
+    /**@return true if the function is an inline function.*/
+    bool isInline() const;
+    /**Sets the function to be an inline function.
+    @param isInline The inline flag.*/
+    void setInline( bool isInline );
+
+    /**@return true if the function is a constant function.*/
+    bool isConstant() const;
+    /**Sets the function to be a constant function.
+    @param isConstant The constant flag.*/
+    void setConstant( bool isConstant );
+
+    /**@return true if the function is an abstract function.*/
+    bool isAbstract() const;
+    /**Sets the function to be an inline function.
+    @param isAbstract The abstract flag.*/
+    void setAbstract( bool isAbstract );
+
+    /**@return The result type of a function.*/
+    QString resultType() const;
+    /**Sets the result type of a function.
+    @param type The type of a function result.*/
+    void setResultType( const QString& type );
+
+    /**Gets the list of arguments being passed to the function.
+    If there are no arguments, then the list is empty.
+    @return The ArgumentList object that contains the arguments for this function.*/
+    ArgumentList argumentList();
+
+    /**Gets the list of arguments being passed to the function.
+    If there are no arguments, then the list is empty.
+    @return The ArgumentList object that contains the arguments for this function.
+    @note This is a const version provided for convenience.*/
+    const ArgumentList argumentList() const;
+
+    /**Adds an argument to the function.
+    @param arg The argument model to add as an argument to the function.
+    @return true if the addition was successful.*/
+    bool addArgument( ArgumentDom arg );
+
+    /**Removes an argument from the function.
+    @param arg The argument model to remove from the function.*/
+    void removeArgument( ArgumentDom arg );
+
+    virtual void read( QDataStream& stream );
+    virtual void write( QDataStream& stream ) const;
+
+    virtual void dump( std::ostream& file, bool recurse=false, QString Info="" );
+    
+    void update( const FunctionModel* i );
+    bool canUpdate( const FunctionModel* i ) const;
+    
+private:
+    QStringList m_scope;
+    int m_access;
+
+    union {
+        struct {
+            int m_signal : 1;
+            int m_slot : 1;
+            int m_virtual : 1;
+            int m_static : 1;
+            int m_inline : 1;
+            int m_constant : 1;
+            int m_abstract : 1;
+        } v;
+        int flags;
+    } d;
+
+    QString m_resultType;
+    ArgumentList m_arguments;
+
+private:
+    FunctionModel( const FunctionModel& source );
+    void operator = ( const FunctionModel& source );
+    friend class CodeModel;
+};
+
+/**
+Function model.
+Represents function definition for languages that have such.
+
+Instances of this class should be created using @ref CodeModel::create method.
+*/
+class FunctionDefinitionModel: public FunctionModel
+{
+protected:
+    /**Constructor.
+    @param model Code model which stores this item.*/
+    FunctionDefinitionModel( CodeModel* model );
+
+public:
+    /**A definition of safe pointer to the function definition model.*/
+    typedef FunctionDefinitionDom Ptr;
+
+    virtual bool isFunctionDefinition() const { return true; }
+
+private:
+    FunctionDefinitionModel( const FunctionDefinitionModel& source );
+    void operator = ( const FunctionDefinitionModel& source );
+    friend class CodeModel;
+};
+
+
+/**
+Variable model.
+Represents variables and class attributes.
+
+Instances of this class should be created using @ref CodeModel::create method.
+*/
+class VariableModel: public CodeModelItem
+{
+protected:
+    /**Constructor.
+    @param model Code model which stores this item.*/
+    VariableModel( CodeModel* model );
+
+public:
+    /**A definition of safe pointer to the variable model.*/
+    typedef VariableDom Ptr;
+
+    virtual bool isVariable() const { return true; }
+
+    /**@return The access level of the variable. Can return either values of type @ref CodeModelItem::Access or 
+    other integers if the variable has other access level (for example pascal attributes can have "published"
+    access level).*/
+    int access() const;
+    /**Sets the access level of the variable.
+    @param access The access level.*/
+    void setAccess( int access );
+
+    /**@return true if the variable is a static variable.*/
+    bool isStatic() const;
+    /**Sets the variable to be a static variable.
+    @param isStatic The static flag.*/
+    void setStatic( bool isStatic );
+
+    /**@return A type of the variable.*/
+    QString type() const;
+    /**Sets the type of the variable.
+    @param type The type name.*/
+    void setType( const QString& type );
+
+		/**@return If this is an enumerator, the enum it is part of, else an empty string. This is just a hack, necessary because EnumeratorModel is not used at all by the cpp-code-model. */
+		bool isEnumeratorVariable() const;
+
+		void setEnumeratorVariable( bool b );
+
+    virtual void read( QDataStream& stream );
+    virtual void write( QDataStream& stream ) const;
+
+    virtual void dump( std::ostream& file, bool recurse=false, QString Info="" );
+
+    void update( const VariableModel* i );
+    bool canUpdate( const VariableModel* i ) const;
+    
+private:
+    int m_access;
+    int m_static;
+    QString m_type;
+		int m_isEnumeratorVariable;
+
+private:
+    VariableModel( const VariableModel& source );
+    void operator = ( const VariableModel& source );
+    friend class CodeModel;
+};
+
+
+/**
+Enum model.
+Represents enums.
+
+Instances of this class should be created using @ref CodeModel::create method.
+*/
+class EnumModel: public CodeModelItem
+{
+protected:
+    /**Constructor.
+    @param model Code model which stores this item.*/
+    EnumModel( CodeModel* model );
+
+public:
+    /**A definition of safe pointer to the enum model.*/
+    typedef EnumDom Ptr;
+
+    virtual bool isEnum() const { return true; }
+
+    /**@return The access level of the enum. Can return either values 
+    of type @ref CodeModelItem::Access or other integers if the enum has other access level.*/
+    int access() const;
+    /**Sets the access level of the enum.
+    @param access The access level.*/
+    void setAccess( int access );
+    
+    /**@return The list of enumerators in this enum.*/
+    EnumeratorList enumeratorList();
+    /**@return The list of enumerators in this enum.
+    @note This is a const version provided for convenience.*/
+    const EnumeratorList enumeratorList() const;
+    /**Adds an enumerator to the model.
+    @param e The enumerator model to add.*/
+    void addEnumerator( EnumeratorDom e );
+    /**Removes an enumerator from the model.
+    @param e The enumerator model to remove.*/
+    void removeEnumerator( EnumeratorDom e );
+
+    virtual void read( QDataStream& stream );
+    virtual void write( QDataStream& stream ) const;
+
+    ///The dump-function is not ready yet
+    virtual void dump( std::ostream& file, bool recurse=false, QString Info="" );
+
+    void update( const EnumModel* i );
+    bool canUpdate( const EnumModel* i ) const;
+    
+private:
+    int m_access;
+    QMap<QString, EnumeratorDom> m_enumerators;
+
+private:
+    EnumModel( const EnumModel& source );
+    void operator = ( const EnumModel& source );
+    friend class CodeModel;
+};
+
+
+/**
+Enumerator model.
+Represents enumerators. Enums consist of enumerators, for example in code:
+@code
+enum Type { A, B, C};
+@endcode
+Type is represented as EnumModel;\n
+A, B, C are represented with EnumeratorModel.
+
+Instances of this class should be created using @ref CodeModel::create method.
+*/
+class EnumeratorModel: public CodeModelItem
+{
+protected:
+    /**Constructor.
+    @param model Code model which stores this item.*/
+    EnumeratorModel( CodeModel* model );
+
+public:
+    /**A definition of safe pointer to the enumerator model.*/
+    typedef EnumeratorDom Ptr;
+
+    virtual bool isEnumerator() const { return true; }
+    
+    /**@return The value of an enumerator.*/
+    QString value() const;
+    /**Sets the value of an enumerator.
+    @param value The value.*/
+    void setValue( const QString& value );
+
+    virtual void read( QDataStream& stream );
+    virtual void write( QDataStream& stream ) const;
+
+    virtual void dump( std::ostream& file, bool recurse=false, QString Info="" );
+    
+private:
+    QString m_value;
+    
+private:
+    EnumeratorModel( const EnumeratorModel& source );
+    void operator = ( const EnumeratorModel& source );
+    friend class CodeModel;
+};
+
+
+/**
+Type alias model.
+Represents type aliases (like subtypes/derived types in Ada and typedefs in c++).
+*/
+class TypeAliasModel: public CodeModelItem
+{
+protected:
+    /**Constructor.
+    @param model Code model which stores this item.*/
+    TypeAliasModel( CodeModel* model );
+
+public:
+    /**A definition of safe pointer to the type alias model.*/
+    typedef TypeAliasDom Ptr;
+
+    virtual bool isTypeAlias() const { return true; }
+    
+    /**@return The actual type of an alias.*/
+    QString type() const;
+    /**Sets the type of an alias.
+    @param type The type name.*/
+    void setType( const QString& type );
+    
+    virtual void read( QDataStream& stream );
+    virtual void write( QDataStream& stream ) const;
+
+    
+    virtual void dump( std::ostream& file, bool recurse=false, QString Info="" );
+    
+    void update( const TypeAliasModel* i );
+    bool canUpdate( const TypeAliasModel* i ) const;
+
+private:
+    QString m_type;
+    
+private:
+    TypeAliasModel( const TypeAliasModel& source );
+    void operator = ( const TypeAliasModel& source );
+    friend class CodeModel;
+};
+
+#endif