codemodel.cpp
Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
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
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
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
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
This file is part of the documentation for KDevelop Version 3.1.2.