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