codemodel.h

Go to the documentation of this file.

/* This file is part of TDevelop
   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., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/
#ifndef CODEMODEL_H
#define CODEMODEL_H

 
 
#include <tqmap.h>
#include <tqstringlist.h>
#include <ksharedptr.h>
#include <tqvaluevector.h>
#include "hashedstring.h"
 
#include <iostream>
#include <ostream>
#include <string>
#include <sstream>
#include <set>
 
enum ParsedFileType {
  CppParsedFile
};
 
class AbstractParseResult : public TDEShared {
public:
  virtual void read( TQDataStream& stream ) = 0;
 
  virtual void write( TQDataStream& stream ) const = 0;
 
  virtual ParsedFileType type() const = 0;
};
 
typedef TDESharedPtr<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;

typedef TDESharedPtr<CodeModelItem> ItemDom;

typedef TDESharedPtr<FileModel> FileDom;

typedef TDESharedPtr<NamespaceModel> NamespaceDom;

typedef TDESharedPtr<ClassModel> ClassDom;

typedef TDESharedPtr<FunctionModel> FunctionDom;

typedef TDESharedPtr<FunctionDefinitionModel> FunctionDefinitionDom;

typedef TDESharedPtr<VariableModel> VariableDom;

typedef TDESharedPtr<ArgumentModel> ArgumentDom;

typedef TDESharedPtr<EnumModel> EnumDom;

typedef TDESharedPtr<TypeAliasModel> TypeAliasDom;

typedef TDESharedPtr<EnumeratorModel> EnumeratorDom;

typedef TQValueList<ItemDom> ItemList;

typedef TQValueList<FileDom> FileList;

typedef TQValueList<NamespaceDom> NamespaceList;

typedef TQValueList<ClassDom> ClassList;

typedef TQValueList<FunctionDom> FunctionList;

 
typedef TQValueList<FunctionDefinitionDom> FunctionDefinitionList;
typedef TQValueList<VariableDom> VariableList;

typedef TQValueList<ArgumentDom> ArgumentList;

typedef TQValueList<EnumDom> EnumList;

typedef TQValueList<TypeAliasDom> TypeAliasList;

typedef TQValueList<EnumeratorDom> EnumeratorList;

template <class ItemList>
TQStringList sortedNameList( const ItemList& lst )
{
    TQStringList nameList;
 
    typename ItemList::ConstIterator it = lst.begin();
    while( it != lst.end() ){
        if( !(*it)->name().isEmpty() )
            nameList << (*it)->name();
        ++it;
    }
 
    nameList.sort();
    return nameList;
}

template <class Result, class T>
Result model_cast( TDESharedPtr<T> x )
{
    Result r( static_cast<T*>(x) );
    return r;
}

template <class Result, class T>
Result model_cast( T* x )
{
    Result r( static_cast<T*>(x) );
    return r;
}
 

class CodeModel
{
public:
    CodeModel();
    virtual ~CodeModel();

    template <class T> typename T::Ptr create()
    {
        typename T::Ptr ptr( new T(this) );
        return ptr;
    }

    void wipeout();

    FileList fileList();

    const FileList fileList() const;

    bool hasFile( const TQString& name ) const;

    FileDom fileByName( const TQString& name );

    const FileDom fileByName( const TQString& name ) const;

    bool addFile( FileDom file );

    void removeFile( FileDom file  );

    const NamespaceDom globalNamespace() const;

    virtual void read( TQDataStream& stream );
    virtual void write( TQDataStream& stream ) const;
    
    virtual void dump( std::ostream& file, TQString Info="" );
    
    int mergeGroups( int g1, int g2 );
    
    FileList getGroup( int gid ) const;
    
    FileList getGroup( const FileDom& file) const;
    
    virtual TQStringList getGroupStrings( int gid ) const;
    
private:
    void addNamespace( NamespaceDom target, NamespaceDom source );

    void removeNamespace( NamespaceDom target, NamespaceDom source );
 
private:
    TQMap<TQString, FileDom> m_files;
    NamespaceDom m_globalNamespace;
 
    virtual int newGroupId();
    int m_currentGroupId;   
    
private:
    CodeModel( const CodeModel& source );
    void operator = ( const CodeModel& source );
    friend class CodeModelItem;
    friend class FileModel;
};
 

class CodeModelItem: public TDEShared
{
public:
    typedef ItemDom Ptr;

    enum Kind
    {
        File,                
        Namespace,           
        Class,               
        Function,            
        Variable,            
        Argument,            
        FunctionDefinition,  
        Enum,                
        Enumerator,          
        TypeAlias,           
    
        Custom = 1000        
    };

    enum Access
    {
        Public,        
        Protected,     
        Private        
    };
    void update( const CodeModelItem* i );
    bool canUpdate( const CodeModelItem* i ) const;
 
protected:
    CodeModelItem( int kind, CodeModel* model );
 
public:
    virtual ~CodeModelItem();

    int kind() const { return m_kind; }

    void setKind( int kind ) { m_kind = kind; }

    TQString name() const;
 
    TQString comment() const {
        return m_comment;
    }
    
    void setComment( TQString comment ) {
        m_comment = comment;
    }
    
    void setName( const TQString& name );

    FileDom file();

    const FileDom file() const;

    TQString fileName() const;

    void setFileName( const TQString& fileName );

    void getStartPosition( int* line, int* col ) const;

    void setStartPosition( int line, int col );

    void getEndPosition( int* line, int* col ) const;

    void setEndPosition( int line, int col );

    virtual bool isFile() const { return false; }
    virtual bool isNamespace() const { return false; }
    virtual bool isClass() const { return false; }
    virtual bool isFunction() const { return false; }
    virtual bool isFunctionDefinition() const { return false; }
    virtual bool isVariable() const { return false; }
    virtual bool isArgument() const { return false; }
    virtual bool isEnum() const { return false; }
    virtual bool isEnumerator() const { return false; }
    virtual bool isTypeAlias() const { return false; }
    virtual bool isCustom() const { return false; }
    
    virtual bool isTemplateable() const { return false; }

    virtual void read( TQDataStream& stream );
    virtual void write( TQDataStream& stream ) const;
 
    virtual void dump( std::ostream& file, bool recurse=false, TQString Info="" );
    
    CodeModel* codeModel() { return m_model; }

    const CodeModel* codeModel() const { return m_model; }
 
private:
    int m_kind;
    CodeModel* m_model;
    TQString m_name;
    TQString m_fileName;
    TQString m_comment; 
    int m_startLine, m_startColumn;
    int m_endLine, m_endColumn;
 
private:
    CodeModelItem( const CodeModelItem& source );
    void operator = ( const CodeModelItem& source );
};
 
 
 
class TemplateModelItem {
    public:
        typedef TQPair< TQString, TQString > ParamPair;
        typedef TQValueVector< ParamPair > ParamMap; 
        
        virtual const ParamMap& getTemplateParams() {
            return m_params;
        }
        
        virtual void addTemplateParam( TQString name, TQString def = "" ) {
            m_params.push_back( ParamPair( name, def ) );
        }
        
        virtual void clearTemplateParams() {
            m_params.clear();
        }
 
                bool hasSpecializationDeclaration() const {
                    return !m_specialization.isEmpty();
                }
 
                virtual TQString getSpecializationDeclaration() const {
                    return m_specialization;
                }
 
                void setSpecializationDeclaration( const TQString& str ) {
                    m_specialization = str;
                }
        
        virtual int findTemplateParam( const TQString& 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(  TQDataStream & 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(  TQDataStream & 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;
                TQString m_specialization;
};
 
 

class ClassModel: public CodeModelItem, public TemplateModelItem
{
protected:
    ClassModel( CodeModel* model );
 
public:
    typedef ClassDom Ptr;
 
    virtual bool isClass() const { return true; }

    TQStringList scope() const { return m_scope; }
    void setScope( const TQStringList& scope ) { m_scope = scope; }

    TQStringList baseClassList() const;

    bool addBaseClass( const TQString& baseClass );

    void removeBaseClass( const TQString& baseClass );

    ClassList classList();

    const ClassList classList() const;

    bool hasClass( const TQString& name ) const;

    ClassList classByName( const TQString& name );

    const ClassList classByName( const TQString& name ) const;

    bool addClass( ClassDom klass );
    
    void removeClass( ClassDom klass );

    FunctionList functionList();

    const FunctionList functionList() const;

    bool hasFunction( const TQString& name ) const;

    FunctionList functionByName( const TQString& name );

    const FunctionList functionByName( const TQString& name ) const;

    bool addFunction( FunctionDom fun );

    void removeFunction( FunctionDom fun );

    FunctionDefinitionList functionDefinitionList();

    const FunctionDefinitionList functionDefinitionList() const;

    bool hasFunctionDefinition( const TQString& name ) const;

    FunctionDefinitionList functionDefinitionByName( const TQString& name );

    const FunctionDefinitionList functionDefinitionByName( const TQString& name ) const;

    bool addFunctionDefinition( FunctionDefinitionDom fun );

    void removeFunctionDefinition( FunctionDefinitionDom fun );

    VariableList variableList();

    const VariableList variableList() const;

    bool hasVariable( const TQString& name ) const;

    VariableDom variableByName( const TQString& name );

    const VariableDom variableByName( const TQString& name ) const;

    bool addVariable( VariableDom var );

    void removeVariable( VariableDom var );

    TypeAliasList typeAliasList();

    const TypeAliasList typeAliasList() const;

    bool hasTypeAlias( const TQString& name ) const;

    TypeAliasList typeAliasByName( const TQString& name );

    const TypeAliasList typeAliasByName( const TQString& name ) const;

    bool addTypeAlias( TypeAliasDom typeAlias );

    void removeTypeAlias( TypeAliasDom typeAlias );

    EnumList enumList();

    const EnumList enumList() const;

    bool hasEnum( const TQString& name ) const;

    EnumDom enumByName( const TQString& name );

    const EnumDom enumByName( const TQString& name ) const;

    bool addEnum( EnumDom e );

    void removeEnum( EnumDom e );
 
    void update( const ClassModel* i );
    bool canUpdate( const ClassModel* i ) const;
    
    virtual void read( TQDataStream& stream );
    virtual void write( TQDataStream& stream ) const;
 
    virtual void dump( std::ostream& file, bool recurse=false, TQString Info="" );
    
private:
    TQStringList m_scope;
    TQStringList m_baseClassList;
    TQMap<TQString, ClassList> m_classes;
    TQMap<TQString, FunctionList> m_functions;
    TQMap<TQString, FunctionDefinitionList> m_functionDefinitions;
    TQMap<TQString, VariableDom> m_variables;
    TQMap<TQString, TypeAliasList> m_typeAliases;
    TQMap<TQString, EnumDom> m_enumerators;
 
private:
    ClassModel( const ClassModel& source );
    void operator = ( const ClassModel& source );
    friend class CodeModel;
};
 
class NamespaceAliasModel {
public:
  virtual void read( TQDataStream& stream );
  virtual void write( TQDataStream& stream ) const;
 
  TQString name() const {
    return m_name;
  }
 
  void setName( const TQString& name ) {
    m_name = name;
  }
 
  void setAliasName( const TQString& theValue ) {
    m_aliasName = theValue;
  }
 
  TQString 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:
  TQString m_name;
  TQString m_aliasName;
  HashedString m_fileName;
};
 
class NamespaceImportModel {
public:
  virtual void read( TQDataStream& stream );
  virtual void write( TQDataStream& stream ) const;
  
  TQString name() const {
    return m_name;
  }
  
  HashedString fileName() const {
    return m_fileName;
  }
 
  void setName( const TQString& 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:
  TQString m_name;
  HashedString m_fileName;
};

class NamespaceModel: public ClassModel
{
protected:
    NamespaceModel( CodeModel* model );
 
public:
  typedef std::set<NamespaceAliasModel> NamespaceAliasModelList; 
  typedef std::set<NamespaceImportModel> NamespaceImportModelList;
  
    typedef NamespaceDom Ptr;
 
    virtual bool isClass() const { return false; }
    virtual bool isNamespace() const { return true; }

    NamespaceList namespaceList();

    const NamespaceList namespaceList() const;

    bool hasNamespace( const TQString& name ) const;

    NamespaceDom namespaceByName( const TQString& name );

    const NamespaceDom namespaceByName( const TQString& name ) const;

    bool addNamespace( NamespaceDom ns );

    void removeNamespace( NamespaceDom ns );

    void update( const NamespaceModel* ns );
    bool canUpdate( const NamespaceModel* ns ) const;
    
    virtual void read( TQDataStream& stream );
    virtual void write( TQDataStream& stream ) const;
 
    virtual void dump( std::ostream& file, bool recurse=false, TQString Info="" );
 
    void addNamespaceImport( const NamespaceImportModel& import );
    void addNamespaceAlias( const NamespaceAliasModel& alias );
    void removeNamespaceImport( const NamespaceImportModel& import );
    void removeNamespaceAlias( const NamespaceAliasModel& alias );

    const NamespaceAliasModelList& namespaceAliases() const {
      return m_namespaceAliases;
    }
  
    const NamespaceImportModelList& namespaceImports() const {
      return m_namespaceImports;
    }
private:
    TQMap<TQString, NamespaceDom> m_namespaces;
    NamespaceAliasModelList m_namespaceAliases;
    NamespaceImportModelList m_namespaceImports;
 
private:
  
    NamespaceModel( const NamespaceModel& source );
    void operator = ( const NamespaceModel& source );
    friend class CodeModel;
};
 
 
 

class FileModel: public NamespaceModel
{
protected:
    FileModel( CodeModel* model );
 
public:
    typedef FileDom Ptr;
 
    virtual bool isFile() const { return true; }
 
    virtual int groupId() const {
        return m_groupId;
    }
    
    virtual void setGroupId(int newId) {
        m_groupId = newId;
    }
    
    
    virtual void write( TQDataStream& stream ) const;
 
    FileList wholeGroup() ;
    
    TQStringList wholeGroupStrings() const;
    
    virtual void read( TQDataStream& 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;
};
 

class ArgumentModel: public CodeModelItem
{
protected:
    ArgumentModel( CodeModel* model );
 
public:
    typedef ArgumentDom Ptr;
 
    virtual bool isArgument() const { return true; }

    TQString type() const;

    void setType( const TQString& type );

    TQString defaultValue() const;

    void setDefaultValue( const TQString& defaultValue );
 
    virtual void read( TQDataStream& stream );
    virtual void write( TQDataStream& stream ) const;
 
    virtual void dump( std::ostream& file, bool recurse=false, TQString Info="" );
    
private:
    TQString m_type;
    TQString m_defaultValue;
 
private:
    ArgumentModel( const ArgumentModel& source );
    void operator = ( const ArgumentModel& source );
    friend class CodeModel;
};
 

class FunctionModel: public CodeModelItem, public TemplateModelItem
{
protected:
    FunctionModel( CodeModel* model );
 
public:
    typedef FunctionDom Ptr;
 
    virtual bool isFunction() const { return true; }

    TQStringList scope() const { return m_scope; }

    void setScope( const TQStringList& scope ) { m_scope = scope; }

    int access() const;

    void setAccess( int access );

    bool isSignal() const;
    void setSignal( bool isSignal );

    bool isSlot() const;
    void setSlot( bool isSlot );

    bool isVirtual() const;
    void setVirtual( bool isVirtual );

    bool isStatic() const;
    void setStatic( bool isStatic );

    bool isInline() const;
    void setInline( bool isInline );

    bool isConstant() const;
    void setConstant( bool isConstant );

    bool isAbstract() const;
    void setAbstract( bool isAbstract );

    TQString resultType() const;
    void setResultType( const TQString& type );

    ArgumentList argumentList();

    const ArgumentList argumentList() const;

    bool addArgument( ArgumentDom arg );

    void removeArgument( ArgumentDom arg );
 
    virtual void read( TQDataStream& stream );
    virtual void write( TQDataStream& stream ) const;
 
    virtual void dump( std::ostream& file, bool recurse=false, TQString Info="" );
    
    void update( const FunctionModel* i );
    bool canUpdate( const FunctionModel* i ) const;
    
private:
    TQStringList 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;
 
    TQString m_resultType;
    ArgumentList m_arguments;
 
private:
    FunctionModel( const FunctionModel& source );
    void operator = ( const FunctionModel& source );
    friend class CodeModel;
};

class FunctionDefinitionModel: public FunctionModel
{
protected:
    FunctionDefinitionModel( CodeModel* model );
 
public:
    typedef FunctionDefinitionDom Ptr;
 
    virtual bool isFunctionDefinition() const { return true; }
 
private:
    FunctionDefinitionModel( const FunctionDefinitionModel& source );
    void operator = ( const FunctionDefinitionModel& source );
    friend class CodeModel;
};
 

class VariableModel: public CodeModelItem
{
protected:
    VariableModel( CodeModel* model );
 
public:
    typedef VariableDom Ptr;
 
    virtual bool isVariable() const { return true; }

    int access() const;
    void setAccess( int access );

    bool isStatic() const;
    void setStatic( bool isStatic );

    TQString type() const;
    void setType( const TQString& type );

        bool isEnumeratorVariable() const;
 
        void setEnumeratorVariable( bool b );
 
    virtual void read( TQDataStream& stream );
    virtual void write( TQDataStream& stream ) const;
 
    virtual void dump( std::ostream& file, bool recurse=false, TQString Info="" );
 
    void update( const VariableModel* i );
    bool canUpdate( const VariableModel* i ) const;
    
private:
    int m_access;
    int m_static;
    TQString m_type;
        int m_isEnumeratorVariable;
 
private:
    VariableModel( const VariableModel& source );
    void operator = ( const VariableModel& source );
    friend class CodeModel;
};
 

class EnumModel: public CodeModelItem
{
protected:
    EnumModel( CodeModel* model );
 
public:
    typedef EnumDom Ptr;
 
    virtual bool isEnum() const { return true; }

    int access() const;
    void setAccess( int access );
    
    EnumeratorList enumeratorList();
    const EnumeratorList enumeratorList() const;
    void addEnumerator( EnumeratorDom e );
    void removeEnumerator( EnumeratorDom e );
 
    virtual void read( TQDataStream& stream );
    virtual void write( TQDataStream& stream ) const;

    virtual void dump( std::ostream& file, bool recurse=false, TQString Info="" );
 
    void update( const EnumModel* i );
    bool canUpdate( const EnumModel* i ) const;
    
private:
    int m_access;
    TQMap<TQString, EnumeratorDom> m_enumerators;
 
private:
    EnumModel( const EnumModel& source );
    void operator = ( const EnumModel& source );
    friend class CodeModel;
};
 

class EnumeratorModel: public CodeModelItem
{
protected:
    EnumeratorModel( CodeModel* model );
 
public:
    typedef EnumeratorDom Ptr;
 
    virtual bool isEnumerator() const { return true; }
    
    TQString value() const;
    void setValue( const TQString& value );
 
    virtual void read( TQDataStream& stream );
    virtual void write( TQDataStream& stream ) const;
 
    virtual void dump( std::ostream& file, bool recurse=false, TQString Info="" );
    
private:
    TQString m_value;
    
private:
    EnumeratorModel( const EnumeratorModel& source );
    void operator = ( const EnumeratorModel& source );
    friend class CodeModel;
};
 

class TypeAliasModel: public CodeModelItem
{
protected:
    TypeAliasModel( CodeModel* model );
 
public:
    typedef TypeAliasDom Ptr;
 
    virtual bool isTypeAlias() const { return true; }
    
    TQString type() const;
    void setType( const TQString& type );
    
    virtual void read( TQDataStream& stream );
    virtual void write( TQDataStream& stream ) const;
 
    
    virtual void dump( std::ostream& file, bool recurse=false, TQString Info="" );
    
    void update( const TypeAliasModel* i );
    bool canUpdate( const TypeAliasModel* i ) const;
 
private:
    TQString m_type;
    
private:
    TypeAliasModel( const TypeAliasModel& source );
    void operator = ( const TypeAliasModel& source );
    friend class CodeModel;
};
 
#endif