KDevelop API Documentation

lib/interfaces/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.0.4.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Tue Oct 19 08:01:48 2004 by doxygen 1.3.7 written by Dimitri van Heesch, © 1997-2003