KDevelop API Documentation

codemodel.cpp

Go to the documentation of this file.
00001 /* This file is part of KDevelop
00002     Copyright (C) 2003 Roberto Raggi <roberto@kdevelop.org>
00003 
00004     This library is free software; you can redistribute it and/or
00005     modify it under the terms of the GNU Library General Public
00006     License as published by the Free Software Foundation; either
00007     version 2 of the License, or (at your option) any later version.
00008 
00009     This library is distributed in the hope that it will be useful,
00010     but WITHOUT ANY WARRANTY; without even the implied warranty of
00011     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012     Library General Public License for more details.
00013 
00014     You should have received a copy of the GNU Library General Public License
00015     along with this library; see the file COPYING.LIB.  If not, write to
00016     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00017     Boston, MA 02111-1307, USA.
00018 */
00019 
00020 #include "codemodel.h"
00021 #include <kdebug.h>
00022 
00023 CodeModel::CodeModel()
00024 {
00025     wipeout();
00026 }
00027 
00028 CodeModel::~ CodeModel( )
00029 {
00030 }
00031 
00032 void CodeModel::wipeout()
00033 {
00034     m_files.clear();
00035     NamespaceDom ns = create<NamespaceModel>();
00036     ns->setName( "::" );
00037 
00038     m_globalNamespace = ns;
00039 }
00040 
00041 #if QT_VERSION < 0x030005
00042 template<class Key, class T>
00043 QValueList<T> QMap_values (QMap<Key, T> tcQMap) {
00044     QValueList<T> values;
00045     QMap<Key, T>::Iterator it;
00046     for (it=tcQMap.begin(); it!=tcQMap.end(); ++it)
00047       { values.append(*it); }
00048     return values;
00049 }
00050 #endif
00051 
00052 FileList CodeModel::fileList( )
00053 {
00054 #if QT_VERSION >= 0x030005
00055     return m_files.values();
00056 #else
00057     return QMap_values<QString, FileDom>(m_files);
00058 #endif
00059 }
00060 
00061 const FileList CodeModel::fileList( ) const
00062 {
00063 #if QT_VERSION >= 0x030005
00064     return m_files.values();
00065 #else
00066     return QMap_values<QString, FileDom>(m_files);
00067 #endif
00068 }
00069 
00070 bool CodeModel::hasFile( const QString & name ) const
00071 {
00072     return m_files.contains( name );
00073 }
00074 
00075 FileDom CodeModel::fileByName( const QString & name )
00076 {
00077     return m_files.contains(name) ? m_files[ name ] : FileDom();
00078 }
00079 
00080 const FileDom CodeModel::fileByName( const QString & name ) const
00081 {
00082     return m_files.contains(name) ? m_files[ name ] : FileDom();
00083 }
00084 
00085 void CodeModel::addNamespace( NamespaceDom target, NamespaceDom source )
00086 {
00087     if( source->name().isEmpty() ){
00088     return;
00089     } else if( !target->hasNamespace(source->name()) ){
00090     NamespaceDom ns = this->create<NamespaceModel>();
00091     ns->setName( source->name() );
00092     ns->setFileName( source->fileName() ); 
00093     ns->setScope( source->scope() );
00094     target->addNamespace( ns );
00095     }
00096 
00097     NamespaceDom ns = target->namespaceByName( source->name() );
00098 
00099     NamespaceList namespaceList = source->namespaceList();
00100     ClassList classList = source->classList();
00101     FunctionList functionList = source->functionList();
00102     FunctionDefinitionList functionDefinitionList = source->functionDefinitionList();
00103     VariableList variableList = source->variableList();
00104     EnumList enumList = source->enumList();
00105     TypeAliasList typeAliasList = source->typeAliasList();
00106 
00107     for( NamespaceList::Iterator it=namespaceList.begin(); it!=namespaceList.end(); ++it )
00108     addNamespace( ns, *it );
00109     for( ClassList::Iterator it=classList.begin(); it!=classList.end(); ++it )
00110     ns->addClass( *it );
00111     for( FunctionList::Iterator it=functionList.begin(); it!=functionList.end(); ++it )
00112     ns->addFunction( *it );
00113     for( FunctionDefinitionList::Iterator it=functionDefinitionList.begin(); it!=functionDefinitionList.end(); ++it )
00114     ns->addFunctionDefinition( *it );
00115     for( VariableList::Iterator it=variableList.begin(); it!=variableList.end(); ++it )
00116     ns->addVariable( *it );
00117     for( EnumList::Iterator it=enumList.begin(); it!=enumList.end(); ++it )
00118     ns->addEnum( *it );
00119     for( TypeAliasList::Iterator it=typeAliasList.begin(); it!=typeAliasList.end(); ++it )
00120     ns->addTypeAlias( *it );
00121 }
00122 
00123 void CodeModel::removeNamespace( NamespaceDom target, NamespaceDom source )
00124 {
00125     if( source->name().isEmpty() || !target->hasNamespace(source->name()) )
00126     return;
00127 
00128     NamespaceDom ns = target->namespaceByName( source->name() );
00129 
00130     NamespaceList namespaceList = source->namespaceList();
00131     ClassList classList = source->classList();
00132     FunctionList functionList = source->functionList();
00133     FunctionDefinitionList functionDefinitionList = source->functionDefinitionList();
00134     VariableList variableList = source->variableList();
00135     EnumList enumList = source->enumList();
00136     TypeAliasList typeAliasList = source->typeAliasList();
00137 
00138     for( NamespaceList::Iterator it=namespaceList.begin(); it!=namespaceList.end(); ++it )
00139     removeNamespace( ns, *it );
00140     for( ClassList::Iterator it=classList.begin(); it!=classList.end(); ++it )
00141     ns->removeClass( *it );
00142     for( FunctionList::Iterator it=functionList.begin(); it!=functionList.end(); ++it )
00143     ns->removeFunction( *it );
00144     for( FunctionDefinitionList::Iterator it=functionDefinitionList.begin(); it!=functionDefinitionList.end(); ++it )
00145     ns->removeFunctionDefinition( *it );
00146     for( VariableList::Iterator it=variableList.begin(); it!=variableList.end(); ++it )
00147     ns->removeVariable( *it );
00148     for( EnumList::Iterator it=enumList.begin(); it!=enumList.end(); ++it )
00149     ns->removeEnum( *it );
00150     for( TypeAliasList::Iterator it=typeAliasList.begin(); it!=typeAliasList.end(); ++it )
00151     ns->removeTypeAlias( *it );
00152 
00153     if( ns->namespaceList().isEmpty() && 
00154         ns->classList().isEmpty() && 
00155     ns->functionList().isEmpty() && 
00156     ns->functionDefinitionList().isEmpty() && 
00157     ns->variableList().isEmpty() &&
00158     ns->enumList().isEmpty() && 
00159     ns->typeAliasList().isEmpty() )
00160     {
00161         target->removeNamespace( ns );
00162     }
00163 }
00164 
00165 bool CodeModel::addFile( FileDom file )
00166 {
00167     if( file->name().isEmpty() )
00168     return false;
00169 
00170     // update global namespace
00171     NamespaceList namespaceList = file->namespaceList();
00172     ClassList classList = file->classList();
00173     FunctionList functionList = file->functionList();
00174     FunctionDefinitionList functionDefinitionList = file->functionDefinitionList();
00175     VariableList variableList = file->variableList();
00176     EnumList enumList = file->enumList();
00177     TypeAliasList typeAliasList = file->typeAliasList();
00178 
00179     for( NamespaceList::Iterator it=namespaceList.begin(); it!=namespaceList.end(); ++it )
00180     addNamespace( m_globalNamespace, *it );
00181     for( ClassList::Iterator it=classList.begin(); it!=classList.end(); ++it )
00182     m_globalNamespace->addClass( *it );
00183     for( FunctionList::Iterator it=functionList.begin(); it!=functionList.end(); ++it )
00184     m_globalNamespace->addFunction( *it );
00185     for( FunctionDefinitionList::Iterator it=functionDefinitionList.begin(); it!=functionDefinitionList.end(); ++it )
00186     m_globalNamespace->addFunctionDefinition( *it );
00187     for( VariableList::Iterator it=variableList.begin(); it!=variableList.end(); ++it )
00188     m_globalNamespace->addVariable( *it );
00189     for( EnumList::Iterator it=enumList.begin(); it!=enumList.end(); ++it )
00190     m_globalNamespace->addEnum( *it );
00191     for( TypeAliasList::Iterator it=typeAliasList.begin(); it!=typeAliasList.end(); ++it )
00192     m_globalNamespace->addTypeAlias( *it );
00193 
00194     m_files.insert( file->name(), file );
00195     return true;
00196 }
00197 
00198 void CodeModel::removeFile( FileDom file )
00199 {
00200     // update global namespace
00201     NamespaceList namespaceList = file->namespaceList();
00202     ClassList classList = file->classList();
00203     FunctionList functionList = file->functionList();
00204     FunctionDefinitionList functionDefinitionList = file->functionDefinitionList();
00205     VariableList variableList = file->variableList();
00206     EnumList enumList = file->enumList();
00207     TypeAliasList typeAliasList = file->typeAliasList();
00208 
00209     for( NamespaceList::Iterator it=namespaceList.begin(); it!=namespaceList.end(); ++it )
00210     removeNamespace( m_globalNamespace, *it );
00211     for( ClassList::Iterator it=classList.begin(); it!=classList.end(); ++it )
00212     m_globalNamespace->removeClass( *it );
00213     for( FunctionList::Iterator it=functionList.begin(); it!=functionList.end(); ++it )
00214     m_globalNamespace->removeFunction( *it );
00215     for( FunctionDefinitionList::Iterator it=functionDefinitionList.begin(); it!=functionDefinitionList.end(); ++it )
00216     m_globalNamespace->removeFunctionDefinition( *it );
00217     for( VariableList::Iterator it=variableList.begin(); it!=variableList.end(); ++it )
00218     m_globalNamespace->removeVariable( *it );
00219     for( EnumList::Iterator it=enumList.begin(); it!=enumList.end(); ++it )
00220     m_globalNamespace->removeEnum( *it );
00221     for( TypeAliasList::Iterator it=typeAliasList.begin(); it!=typeAliasList.end(); ++it )
00222     m_globalNamespace->removeTypeAlias( *it );
00223     
00224     m_files.remove( file->name() );
00225 }
00226 
00227 // ------------------------------------------------------------------------
00228 CodeModelItem::CodeModelItem( int kind, CodeModel* model )
00229     : m_kind( kind ), m_model( model )
00230 {
00231     //kdDebug() << "CodeModelItem::CodeModelItem()" << endl;
00232     m_startLine = 0;
00233     m_startColumn = 0;
00234     m_endLine = 0;
00235     m_endColumn = 0;
00236 }
00237 
00238 CodeModelItem::~ CodeModelItem( )
00239 {
00240 }
00241 
00242 QString CodeModelItem::name( ) const
00243 {
00244     return m_name;
00245 }
00246 
00247 void CodeModelItem::setName( const QString & name )
00248 {
00249     m_name = name;
00250 }
00251 
00252 const FileDom CodeModelItem::file( ) const
00253 {
00254     return m_model->fileByName( m_fileName );
00255 }
00256 
00257 FileDom CodeModelItem::file( )
00258 {
00259     return m_model->fileByName( m_fileName );
00260 }
00261 
00262 QString CodeModelItem::fileName() const
00263 {
00264     return m_fileName;
00265 }
00266 
00267 void CodeModelItem::setFileName( const QString& fileName )
00268 {
00269     m_fileName = fileName;
00270 }
00271 
00272 void CodeModelItem::getStartPosition( int * line, int * column ) const
00273 {
00274     if( line ) *line = m_startLine;
00275     if( column ) *column = m_startColumn;
00276 }
00277 
00278 void CodeModelItem::setStartPosition( int line, int column )
00279 {
00280     m_startLine = line;
00281     m_startColumn = column;
00282 }
00283 
00284 void CodeModelItem::getEndPosition( int * line, int * column ) const
00285 {
00286     if( line ) *line = m_endLine;
00287     if( column ) *column = m_endColumn;
00288 }
00289 
00290 void CodeModelItem::setEndPosition( int line, int column )
00291 {
00292     m_endLine = line;
00293     m_endColumn = column;
00294 }
00295 
00296 // ------------------------------------------------------------------------
00297 NamespaceModel::NamespaceModel( CodeModel* model )
00298     : ClassModel( model )
00299 {
00300     setKind( Namespace );
00301 }
00302 
00303 NamespaceList NamespaceModel::namespaceList( )
00304 {
00305 #if QT_VERSION >= 0x030005
00306     return m_namespaces.values();
00307 #else
00308     return QMap_values<QString, NamespaceDom> (m_namespaces);
00309 #endif
00310 }
00311 
00312 const NamespaceList NamespaceModel::namespaceList( ) const
00313 {
00314 #if QT_VERSION >= 0x030005
00315     return m_namespaces.values();
00316 #else
00317     return QMap_values<QString, NamespaceDom> (m_namespaces);
00318 #endif
00319 }
00320 
00321 NamespaceDom NamespaceModel::namespaceByName( const QString & name )
00322 {
00323     return m_namespaces.contains( name ) ? m_namespaces[ name ] : NamespaceDom();
00324 }
00325 
00326 const NamespaceDom NamespaceModel::namespaceByName( const QString & name ) const
00327 {
00328     return m_namespaces.contains( name ) ? m_namespaces[ name ] : NamespaceDom();
00329 }
00330 
00331 bool NamespaceModel::hasNamespace( const QString & name ) const
00332 {
00333     return m_namespaces.contains( name );
00334 }
00335 
00336 bool NamespaceModel::addNamespace( NamespaceDom ns )
00337 {
00338     if( ns->name().isEmpty() )
00339     return false;
00340 
00341     m_namespaces[ ns->name() ] = ns;
00342     return true;
00343 }
00344 
00345 void NamespaceModel::removeNamespace( NamespaceDom ns )
00346 {
00347     m_namespaces.remove( ns->name() );
00348 }
00349 
00350 // ------------------------------------------------------------------------
00351 FileModel::FileModel( CodeModel* model )
00352     : NamespaceModel( model)
00353 {
00354 }
00355 
00356 // ------------------------------------------------------------------------
00357 ClassModel::ClassModel( CodeModel* model )
00358     : CodeModelItem( Class, model)
00359 {
00360 }
00361 
00362 QStringList ClassModel::baseClassList( ) const
00363 {
00364     return m_baseClassList;
00365 }
00366 
00367 bool ClassModel::addBaseClass( const QString & baseClass )
00368 {
00369     m_baseClassList.push_back( baseClass );
00370     return true;
00371 }
00372 
00373 void ClassModel::removeBaseClass( const QString & baseClass )
00374 {
00375     m_baseClassList.remove( baseClass );
00376 }
00377 
00378 ClassList ClassModel::classList( )
00379 {
00380     ClassList l;
00381     QMap<QString, ClassList>::Iterator it = m_classes.begin();
00382     while( it != m_classes.end() ){
00383     l += *it;
00384     ++it;
00385     }
00386 
00387     return l;
00388 }
00389 
00390 const ClassList ClassModel::classList( ) const
00391 {
00392     ClassList l;
00393     QMap<QString, ClassList>::ConstIterator it = m_classes.begin();
00394     while( it != m_classes.end() ){
00395     l += *it;
00396     ++it;
00397     }
00398 
00399     return l;
00400 }
00401 
00402 bool ClassModel::hasClass( const QString & name ) const
00403 {
00404     return m_classes.contains( name );
00405 }
00406 
00407 ClassList ClassModel::classByName( const QString & name )
00408 {
00409     return m_classes.contains( name ) ? m_classes[ name ] : ClassList();
00410 }
00411 
00412 const ClassList ClassModel::classByName( const QString & name ) const
00413 {
00414     return m_classes.contains( name ) ? m_classes[ name ] : ClassList();
00415 }
00416 
00417 bool ClassModel::addClass( ClassDom klass )
00418 {
00419     if( klass->name().isEmpty() )
00420     return false;
00421 
00422     m_classes[ klass->name() ].push_back( klass );
00423     return true;
00424 }
00425 
00426 void ClassModel::removeClass( ClassDom klass )
00427 {
00428     m_classes[ klass->name() ].remove( klass );
00429 
00430     if( m_classes[klass->name()].isEmpty() )
00431     m_classes.remove( klass->name() );
00432 }
00433 
00434 FunctionList ClassModel::functionList( )
00435 {
00436     FunctionList l;
00437     QMap<QString, FunctionList>::Iterator it = m_functions.begin();
00438     while( it != m_functions.end() ){
00439     l += *it;
00440     ++it;
00441     }
00442 
00443     return l;
00444 }
00445 
00446 const FunctionList ClassModel::functionList( ) const
00447 {
00448     FunctionList l;
00449     QMap<QString, FunctionList>::ConstIterator it = m_functions.begin();
00450     while( it != m_functions.end() ){
00451     l += *it;
00452     ++it;
00453     }
00454 
00455     return l;
00456 }
00457 
00458 bool ClassModel::hasFunction( const QString & name ) const
00459 {
00460     return m_functions.contains( name );
00461 }
00462 
00463 FunctionList ClassModel::functionByName( const QString & name )
00464 {
00465     return m_functions.contains( name ) ? m_functions[ name ] : FunctionList();
00466 }
00467 
00468 const FunctionList ClassModel::functionByName( const QString & name ) const
00469 {
00470     return m_functions.contains( name ) ? m_functions[ name ] : FunctionList();
00471 }
00472 
00473 bool ClassModel::addFunction( FunctionDom fun )
00474 {
00475     if( fun->name().isEmpty() )
00476     return false;
00477 
00478     m_functions[ fun->name() ].push_back( fun );
00479     return true;
00480 }
00481 
00482 void ClassModel::removeFunction( FunctionDom fun )
00483 {
00484     m_functions[ fun->name() ].remove( fun );
00485 
00486     if( m_functions[fun->name()].isEmpty() )
00487     m_functions.remove( fun->name() );
00488 }
00489 
00490 FunctionDefinitionList ClassModel::functionDefinitionList( )
00491 {
00492     FunctionDefinitionList l;
00493     QMap<QString, FunctionDefinitionList>::Iterator it = m_functionDefinitions.begin();
00494     while( it != m_functionDefinitions.end() ){
00495     l += *it;
00496     ++it;
00497     }
00498 
00499     return l;
00500 }
00501 
00502 const FunctionDefinitionList ClassModel::functionDefinitionList( ) const
00503 {
00504     FunctionDefinitionList l;
00505     QMap<QString, FunctionDefinitionList>::ConstIterator it = m_functionDefinitions.begin();
00506     while( it != m_functionDefinitions.end() ){
00507     l += *it;
00508     ++it;
00509     }
00510 
00511     return l;
00512 }
00513 
00514 bool ClassModel::hasFunctionDefinition( const QString & name ) const
00515 {
00516     return m_functionDefinitions.contains( name );
00517 }
00518 
00519 FunctionDefinitionList ClassModel::functionDefinitionByName( const QString & name )
00520 {
00521     return m_functionDefinitions.contains( name ) ? m_functionDefinitions[ name ] : FunctionDefinitionList();
00522 }
00523 
00524 const FunctionDefinitionList ClassModel::functionDefinitionByName( const QString & name ) const
00525 {
00526     return m_functionDefinitions.contains( name ) ? m_functionDefinitions[ name ] : FunctionDefinitionList();
00527 }
00528 
00529 bool ClassModel::addFunctionDefinition( FunctionDefinitionDom fun )
00530 {
00531     if( fun->name().isEmpty() )
00532     return false;
00533 
00534     m_functionDefinitions[ fun->name() ].push_back( fun );
00535     return true;
00536 }
00537 
00538 void ClassModel::removeFunctionDefinition( FunctionDefinitionDom fun )
00539 {
00540     m_functionDefinitions[ fun->name() ].remove( fun );
00541 
00542     if( m_functionDefinitions[fun->name()].isEmpty() )
00543     m_functionDefinitions.remove( fun->name() );
00544 }
00545 
00546 VariableList ClassModel::variableList( )
00547 {
00548 #if QT_VERSION >= 0x030005
00549     return m_variables.values();
00550 #else
00551     return QMap_values<QString, VariableDom> (m_variables);
00552 #endif
00553 }
00554 
00555 const VariableList ClassModel::variableList( ) const
00556 {
00557 #if QT_VERSION >= 0x030005
00558     return m_variables.values();
00559 #else
00560     return QMap_values<QString, VariableDom> (m_variables);
00561 #endif
00562 }
00563 
00564 VariableDom ClassModel::variableByName( const QString & name )
00565 {
00566     return m_variables.contains( name ) ? m_variables[ name ] : VariableDom();
00567 }
00568 
00569 const VariableDom ClassModel::variableByName( const QString & name ) const
00570 {
00571     return m_variables.contains( name ) ? m_variables[ name ] : VariableDom();
00572 }
00573 
00574 bool ClassModel::hasVariable( const QString & name ) const
00575 {
00576     return m_variables.contains( name );
00577 }
00578 
00579 bool ClassModel::addVariable( VariableDom var )
00580 {
00581     if( var->name().isEmpty() )
00582     return false;
00583 
00584     m_variables.insert( var->name(), var );
00585     return true;
00586 }
00587 
00588 void ClassModel::removeVariable( VariableDom var )
00589 {
00590     m_variables.remove( var->name() );
00591 }
00592 
00593 EnumList ClassModel::enumList( )
00594 {
00595 #if QT_VERSION >= 0x030005
00596     return m_enumerators.values();
00597 #else
00598     return QMap_values<QString, EnumDom> (m_enumerators);
00599 #endif
00600 }
00601 
00602 const EnumList ClassModel::enumList( ) const
00603 {
00604 #if QT_VERSION >= 0x030005
00605     return m_enumerators.values();
00606 #else
00607     return QMap_values<QString, EnumDom> (m_enumerators);
00608 #endif
00609 }
00610 
00611 EnumDom ClassModel::enumByName( const QString & name )
00612 {
00613     return m_enumerators.contains( name ) ? m_enumerators[ name ] : EnumDom();
00614 }
00615 
00616 const EnumDom ClassModel::enumByName( const QString & name ) const
00617 {
00618     return m_enumerators.contains( name ) ? m_enumerators[ name ] : EnumDom();
00619 }
00620 
00621 bool ClassModel::hasEnum( const QString & name ) const
00622 {
00623     return m_enumerators.contains( name );
00624 }
00625 
00626 bool ClassModel::addEnum( EnumDom e )
00627 {
00628     if( e->name().isEmpty() )
00629     return false;
00630 
00631     m_enumerators.insert( e->name(), e );
00632     return true;
00633 }
00634 
00635 void ClassModel::removeEnum( EnumDom e )
00636 {
00637     m_enumerators.remove( e->name() );
00638 }
00639 
00640 TypeAliasList ClassModel::typeAliasList( )
00641 {
00642     TypeAliasList l;
00643     QMap<QString, TypeAliasList>::Iterator it = m_typeAliases.begin();
00644     while( it != m_typeAliases.end() ){
00645     l += *it;
00646     ++it;
00647     }
00648 
00649     return l;
00650 }
00651 
00652 const TypeAliasList ClassModel::typeAliasList( ) const
00653 {
00654     TypeAliasList l;
00655     QMap<QString, TypeAliasList>::ConstIterator it = m_typeAliases.begin();
00656     while( it != m_typeAliases.end() ){
00657     l += *it;
00658     ++it;
00659     }
00660 
00661     return l;
00662 }
00663 
00664 bool ClassModel::hasTypeAlias( const QString & name ) const
00665 {
00666     return m_typeAliases.contains( name );
00667 }
00668 
00669 TypeAliasList ClassModel::typeAliasByName( const QString & name )
00670 {
00671     return m_typeAliases.contains( name ) ? m_typeAliases[ name ] : TypeAliasList();
00672 }
00673 
00674 const TypeAliasList ClassModel::typeAliasByName( const QString & name ) const
00675 {
00676     return m_typeAliases.contains( name ) ? m_typeAliases[ name ] : TypeAliasList();
00677 }
00678 
00679 bool ClassModel::addTypeAlias( TypeAliasDom typeAlias )
00680 {
00681     if( typeAlias->name().isEmpty() )
00682     return false;
00683 
00684     m_typeAliases[ typeAlias->name() ].push_back( typeAlias );
00685     return true;
00686 }
00687 
00688 void ClassModel::removeTypeAlias( TypeAliasDom typeAlias )
00689 {
00690     m_typeAliases[ typeAlias->name() ].remove( typeAlias );
00691 
00692     if( m_typeAliases[typeAlias->name()].isEmpty() )
00693     m_typeAliases.remove( typeAlias->name() );
00694 }
00695 
00696 
00697 
00698 // ------------------------------------------------------------------------
00699 ArgumentModel::ArgumentModel( CodeModel* model )
00700     : CodeModelItem( Argument, model)
00701 {
00702 }
00703 
00704 QString ArgumentModel::type( ) const
00705 {
00706     return m_type;
00707 }
00708 
00709 void ArgumentModel::setType( const QString& type )
00710 {
00711     m_type = type;
00712 }
00713 
00714 QString ArgumentModel::defaultValue( ) const
00715 {
00716     return m_defaultValue;
00717 }
00718 
00719 void ArgumentModel::setDefaultValue( const QString & defaultValue )
00720 {
00721     m_defaultValue = defaultValue;
00722 }
00723 
00724 // ------------------------------------------------------------------------
00725 FunctionModel::FunctionModel( CodeModel* model )
00726     : CodeModelItem( Function, model)
00727 {
00728     m_access = Public;
00729     d.v.m_signal = false;
00730     d.v.m_slot = false;
00731     d.v.m_virtual = false;
00732     d.v.m_static = false;
00733     d.v.m_inline = false;
00734     d.v.m_constant = false;
00735     d.v.m_abstract = false;
00736 }
00737 
00738 bool FunctionModel::isVirtual( ) const
00739 {
00740     return d.v.m_virtual;
00741 }
00742 
00743 void FunctionModel::setVirtual( bool isVirtual )
00744 {
00745     d.v.m_virtual = isVirtual;
00746 }
00747 
00748 bool FunctionModel::isStatic( ) const
00749 {
00750     return d.v.m_static;
00751 }
00752 
00753 void FunctionModel::setStatic( bool isStatic )
00754 {
00755     d.v.m_static = isStatic;
00756 }
00757 
00758 bool FunctionModel::isInline( ) const
00759 {
00760     return d.v.m_inline;
00761 }
00762 
00763 void FunctionModel::setInline( bool isInline )
00764 {
00765     d.v.m_inline = isInline;
00766 }
00767 
00768 bool FunctionModel::isConstant( ) const
00769 {
00770     return d.v.m_constant;
00771 }
00772 
00773 void FunctionModel::setConstant( bool isConstant )
00774 {
00775     d.v.m_constant = isConstant;
00776 }
00777 
00778 bool FunctionModel::isAbstract( ) const
00779 {
00780     return d.v.m_abstract;
00781 }
00782 
00783 void FunctionModel::setAbstract( bool isAbstract )
00784 {
00785     d.v.m_abstract = isAbstract;
00786 }
00787 
00788 QString FunctionModel::resultType( ) const
00789 {
00790     return m_resultType;
00791 }
00792 
00793 void FunctionModel::setResultType( const QString& type )
00794 {
00795     m_resultType = type;
00796 }
00797 
00798 ArgumentList FunctionModel::argumentList( )
00799 {
00800     return m_arguments;
00801 }
00802 
00803 const ArgumentList FunctionModel::argumentList( ) const
00804 {
00805     return m_arguments;
00806 }
00807 
00808 bool FunctionModel::addArgument( ArgumentDom arg )
00809 {
00810     m_arguments.push_back( arg );
00811     return true;
00812 }
00813 
00814 void FunctionModel::removeArgument( ArgumentDom arg )
00815 {
00816     m_arguments.remove( arg );
00817 }
00818 
00819 // ------------------------------------------------------------------------
00820 VariableModel::VariableModel( CodeModel* model )
00821     : CodeModelItem( Variable, model)
00822 {
00823     m_access = Public;
00824     m_static = false;
00825 }
00826 
00827 bool VariableModel::isStatic( ) const
00828 {
00829     return m_static;
00830 }
00831 
00832 void VariableModel::setStatic( bool isStatic )
00833 {
00834     m_static = isStatic;
00835 }
00836 
00837 QString VariableModel::type( ) const
00838 {
00839     return m_type;
00840 }
00841 
00842 void VariableModel::setType( const QString& type )
00843 {
00844     m_type = type;
00845 }
00846 
00847 int FunctionModel::access( ) const
00848 {
00849     return m_access;
00850 }
00851 
00852 void FunctionModel::setAccess( int access )
00853 {
00854     m_access = access;
00855 }
00856 
00857 bool FunctionModel::isSignal( ) const
00858 {
00859     return d.v.m_signal;
00860 }
00861 
00862 void FunctionModel::setSignal( bool isSignal )
00863 {
00864     d.v.m_signal = isSignal;
00865 }
00866 
00867 bool FunctionModel::isSlot( ) const
00868 {
00869     return d.v.m_slot;
00870 }
00871 
00872 void FunctionModel::setSlot( bool isSlot )
00873 {
00874     d.v.m_slot = isSlot;
00875 }
00876 
00877 FunctionDefinitionModel::FunctionDefinitionModel( CodeModel* model )
00878     : FunctionModel( model )
00879 {
00880 }
00881 
00882 int VariableModel::access( ) const
00883 {
00884     return m_access;
00885 }
00886 
00887 void VariableModel::setAccess( int access )
00888 {
00889     m_access = access;
00890 }
00891 
00892 const NamespaceDom CodeModel::globalNamespace( ) const
00893 {
00894     return m_globalNamespace;
00895 }
00896 
00897 void CodeModelItem::read( QDataStream & stream )
00898 {
00899     stream
00900     >> m_kind
00901     >> m_name
00902     >> m_fileName
00903     >> m_startLine
00904     >> m_startColumn
00905     >> m_endLine
00906     >> m_endColumn;
00907 }
00908 
00909 void CodeModelItem::write( QDataStream & stream ) const
00910 {
00911     stream
00912     << m_kind
00913     << m_name
00914     << m_fileName
00915     << m_startLine
00916     << m_startColumn
00917     << m_endLine
00918     << m_endColumn;
00919 }
00920 
00921 void ClassModel::read( QDataStream & stream )
00922 {
00923     CodeModelItem::read( stream );
00924 
00925     stream >> m_scope >> m_baseClassList;
00926 
00927     int n;
00928 
00929     m_classes.clear();
00930     stream >> n;
00931     for( int i=0; i<n; ++i ){
00932     ClassDom klass = codeModel()->create<ClassModel>();
00933     klass->read( stream );
00934     addClass( klass );
00935     }
00936 
00937     m_functions.clear();
00938     stream >> n;
00939     for( int i=0; i<n; ++i ){
00940     FunctionDom fun = codeModel()->create<FunctionModel>();
00941     fun->read( stream );
00942     addFunction( fun );
00943     }
00944 
00945     m_functionDefinitions.clear();
00946     stream >> n;
00947     for( int i=0; i<n; ++i ){
00948     FunctionDefinitionDom fun = codeModel()->create<FunctionDefinitionModel>();
00949     fun->read( stream );
00950     addFunctionDefinition( fun );
00951     }
00952 
00953     m_variables.clear();
00954     stream >> n;
00955     for( int i=0; i<n; ++i ){
00956     VariableDom var = codeModel()->create<VariableModel>();
00957     var->read( stream );
00958     addVariable( var );
00959     }
00960     
00961     m_enumerators.clear();
00962     stream >> n;
00963     for( int i=0; i<n; ++i ){
00964     EnumDom e = codeModel()->create<EnumModel>();
00965     e->read( stream );
00966     addEnum( e );
00967     }
00968 
00969     m_typeAliases.clear();
00970     stream >> n;
00971     for( int i=0; i<n; ++i ){
00972     TypeAliasDom typeAlias = codeModel()->create<TypeAliasModel>();
00973     typeAlias->read( stream );
00974     addTypeAlias( typeAlias );
00975     }
00976 }
00977 
00978 void ClassModel::write( QDataStream & stream ) const
00979 {
00980     CodeModelItem::write( stream );
00981 
00982     stream << m_scope << m_baseClassList;
00983 
00984     const ClassList class_list = classList();
00985     stream << int( class_list.size() );
00986     for( ClassList::ConstIterator it = class_list.begin(); it!=class_list.end(); ++it )
00987     (*it)->write( stream );
00988 
00989     const FunctionList function_list = functionList();
00990     stream << int( function_list.size() );
00991     for( FunctionList::ConstIterator it = function_list.begin(); it!=function_list.end(); ++it )
00992     (*it)->write( stream );
00993 
00994     const FunctionDefinitionList function_definition_list = functionDefinitionList();
00995     stream << int( function_definition_list.size() );
00996     for( FunctionDefinitionList::ConstIterator it = function_definition_list.begin(); it!=function_definition_list.end(); ++it )
00997     (*it)->write( stream );
00998 
00999     const VariableList variable_list = variableList();
01000     stream << int( variable_list.size() );
01001     for( VariableList::ConstIterator it = variable_list.begin(); it!=variable_list.end(); ++it )
01002     (*it)->write( stream );
01003     
01004     const EnumList enum_list = enumList();
01005     stream << int( enum_list.size() );
01006     for( EnumList::ConstIterator it = enum_list.begin(); it!=enum_list.end(); ++it )
01007     (*it)->write( stream );    
01008     
01009     const TypeAliasList type_alias_list = typeAliasList();
01010     stream << int( type_alias_list.size() );
01011     for( TypeAliasList::ConstIterator it = type_alias_list.begin(); it!=type_alias_list.end(); ++it )
01012     (*it)->write( stream );    
01013     
01014 }
01015 
01016 void NamespaceModel::read( QDataStream & stream )
01017 {
01018     ClassModel::read( stream );
01019 
01020     int n;
01021 
01022     m_namespaces.clear();
01023     stream >> n;
01024     for( int i=0; i<n; ++i ){
01025     NamespaceDom ns = codeModel()->create<NamespaceModel>();
01026     ns->read( stream );
01027     addNamespace( ns );
01028     }
01029 }
01030 
01031 void NamespaceModel::write( QDataStream & stream ) const
01032 {
01033     ClassModel::write( stream );
01034 
01035     const NamespaceList namespace_list = namespaceList();
01036     stream << int( namespace_list.size() );
01037     for( NamespaceList::ConstIterator it = namespace_list.begin(); it!=namespace_list.end(); ++it )
01038     (*it)->write( stream );
01039 }
01040 
01041 void FileModel::read( QDataStream & stream )
01042 {
01043     NamespaceModel::read( stream );
01044 }
01045 
01046 void FileModel::write( QDataStream & stream ) const
01047 {
01048     NamespaceModel::write( stream );
01049 }
01050 
01051 void ArgumentModel::read( QDataStream & stream )
01052 {
01053     CodeModelItem::read( stream );
01054 
01055     stream >> m_type >> m_defaultValue;
01056 }
01057 
01058 void ArgumentModel::write( QDataStream & stream ) const
01059 {
01060     CodeModelItem::write( stream );
01061 
01062     stream << m_type << m_defaultValue;
01063 }
01064 
01065 void FunctionModel::read( QDataStream & stream )
01066 {
01067     CodeModelItem::read( stream );
01068 
01069     stream >> m_scope;
01070     stream >> d.flags;
01071 
01072     int n;
01073 
01074     m_arguments.clear();
01075     stream >> n;
01076     for( int i=0; i<n; ++i ){
01077     ArgumentDom arg = codeModel()->create<ArgumentModel>();
01078     arg->read( stream );
01079     addArgument( arg );
01080     }
01081 
01082     stream
01083     >> m_resultType;
01084 }
01085 
01086 void FunctionModel::write( QDataStream & stream ) const
01087 {
01088     CodeModelItem::write( stream );
01089 
01090     stream << m_scope;
01091     stream << d.flags;
01092 
01093     const ArgumentList argument_list = argumentList();
01094     stream << int( argument_list.size() );
01095     for( ArgumentList::ConstIterator it = argument_list.begin(); it!=argument_list.end(); ++it )
01096     (*it)->write( stream );
01097 
01098     stream
01099     << m_resultType;
01100 }
01101 
01102 void CodeModel::read( QDataStream & stream )
01103 {
01104     int n;
01105 
01106     m_files.clear();
01107 
01108     stream >> n;
01109     for( int i=0; i<n; ++i ){
01110     FileDom file = this->create<FileModel>();
01111     file->read( stream );
01112     addFile( file );
01113     }
01114 }
01115 
01116 void CodeModel::write( QDataStream & stream ) const
01117 {
01118     const FileList file_list = fileList();
01119     stream << int( file_list.size() );
01120     for( FileList::ConstIterator it = file_list.begin(); it!=file_list.end(); ++it )
01121     (*it)->write( stream );
01122 }
01123 
01124 void VariableModel::read( QDataStream & stream )
01125 {
01126     CodeModelItem::read( stream );
01127     stream >> m_access >> m_static >> m_type;
01128 }
01129 
01130 void VariableModel::write( QDataStream & stream ) const
01131 {
01132     CodeModelItem::write( stream );
01133     stream << m_access << m_static << m_type;
01134 }
01135 
01136 // -------------------------------------------------------
01137 EnumModel::EnumModel( CodeModel * model )
01138     : CodeModelItem( Enum, model)
01139 {
01140 }
01141 
01142 int EnumModel::access( ) const
01143 {
01144     return m_access;
01145 }
01146 
01147 void EnumModel::setAccess( int access )
01148 {
01149     m_access = access;
01150 }
01151 
01152 EnumeratorList EnumModel::enumeratorList( )
01153 {
01154 #if QT_VERSION >= 0x030005
01155     return m_enumerators.values();
01156 #else
01157     return QMap_values<QString, EnumeratorDom> (m_enumerators);
01158 #endif
01159 }
01160 
01161 const EnumeratorList EnumModel::enumeratorList( ) const
01162 {
01163 #if QT_VERSION >= 0x030005
01164     return m_enumerators.values();
01165 #else
01166     return QMap_values<QString, EnumeratorDom> (m_enumerators);
01167 #endif
01168 }
01169 
01170 void EnumModel::addEnumerator( EnumeratorDom enumerator )
01171 {
01172     m_enumerators.insert( enumerator->name(), enumerator );
01173 }
01174 
01175 void EnumModel::read( QDataStream & stream )
01176 {
01177     CodeModelItem::read( stream );
01178     stream >> m_access;
01179     
01180     int n;
01181     stream >> n;
01182     for( int i=0; i<n; ++i ){
01183     EnumeratorDom e = codeModel()->create<EnumeratorModel>();
01184     e->read( stream );
01185     addEnumerator( e );
01186     }
01187 }
01188 
01189 void EnumModel::write( QDataStream & stream ) const
01190 {
01191     CodeModelItem::write( stream );
01192     
01193     stream << m_access;
01194     const EnumeratorList enumerator_list = enumeratorList();
01195     stream << int( enumerator_list.size() );
01196     for( EnumeratorList::ConstIterator it = enumerator_list.begin(); it!=enumerator_list.end(); ++it )
01197     (*it)->write( stream );
01198 }
01199 
01200 EnumeratorModel::EnumeratorModel( CodeModel * model )
01201     : CodeModelItem( Enumerator, model )
01202 {
01203 }
01204 
01205 QString EnumeratorModel::value( ) const
01206 {
01207     return m_value;
01208 }
01209 
01210 void EnumeratorModel::setValue( const QString & value )
01211 {
01212     m_value = value;
01213 }
01214 
01215 void EnumeratorModel::read( QDataStream & stream )
01216 {
01217     CodeModelItem::read( stream );
01218     stream >> m_value;
01219 }
01220 
01221 void EnumeratorModel::write( QDataStream & stream ) const
01222 {
01223     CodeModelItem::write( stream );
01224     stream << m_value;
01225 }
01226 
01227 void EnumModel::removeEnumerator( EnumeratorDom e )
01228 {
01229     m_enumerators.remove( e->name() );
01230 }
01231 
01232 // ---------------------------------------------------------------
01233 TypeAliasModel::TypeAliasModel( CodeModel * model )
01234     : CodeModelItem( TypeAlias, model )
01235 {
01236 }
01237 
01238 void TypeAliasModel::read( QDataStream & stream )
01239 {
01240     CodeModelItem::read( stream );
01241     
01242     stream >> m_type;
01243 }
01244 
01245 void TypeAliasModel::write( QDataStream & stream ) const
01246 {
01247     CodeModelItem::write( stream );
01248     
01249     stream << m_type;
01250 }
01251 
01252 QString TypeAliasModel::type( ) const
01253 {
01254     return m_type;
01255 }
01256 
01257 void TypeAliasModel::setType( const QString & type )
01258 {
01259     m_type = type;
01260 }
01261 
KDE Logo
This file is part of the documentation for KDevelop Version 3.1.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed Mar 23 00:03:51 2005 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003