cpptoxml/parser/codemodel.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
   4 ** Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
   5 **
   6 ** This file is part of the Qt Script Generator project on Trolltech Labs.
   7 **
   8 ** This file may be used under the terms of the GNU General Public
   9 ** License version 2.0 as published by the Free Software Foundation
  10 ** and appearing in the file LICENSE.GPL included in the packaging of
  11 ** this file.  Please review the following information to ensure GNU
  12 ** General Public Licensing requirements will be met:
  13 ** http://www.trolltech.com/products/qt/opensource.html
  14 **
  15 ** If you are unsure which license is appropriate for your use, please
  16 ** review the following information:
  17 ** http://www.trolltech.com/products/qt/licensing.html or contact the
  18 ** sales department at sales@trolltech.com.
  19 **
  20 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  21 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  22 **
  23 ****************************************************************************/
  24
  25
  26 #include "codemodel.h"
  27
  28 // ---------------------------------------------------------------------------
  29 CodeModel::CodeModel()
  30   : _M_creation_id(0)
  31 {
  32   _M_globalNamespace = create<NamespaceModelItem>();
  33 }
  34
  35 CodeModel::~CodeModel()
  36 {
  37 }
  38
  39 void CodeModel::wipeout()
  40 {
  41   _M_globalNamespace = create<NamespaceModelItem>();
  42   _M_files.clear();
  43 }
  44
  45 FileList CodeModel::files() const
  46 {
  47   return _M_files.values();
  48 }
  49
  50 NamespaceModelItem CodeModel::globalNamespace() const
  51 {
  52   return _M_globalNamespace;
  53 }
  54
  55 void CodeModel::addFile(FileModelItem item)
  56 {
  57   _M_creation_id = 0; // reset the creation id
  58   _M_files.insert(item->name(), item);
  59 }
  60
  61 void CodeModel::removeFile(FileModelItem item)
  62 {
  63   QHash<QString, FileModelItem>::Iterator it = _M_files.find(item->name());
  64
  65   if (it != _M_files.end() && it.value() == item)
  66     _M_files.erase(it);
  67 }
  68
  69 FileModelItem CodeModel::findFile(const QString &name) const
  70 {
  71   return _M_files.value(name);
  72 }
  73
  74 QHash<QString, FileModelItem> CodeModel::fileMap() const
  75 {
  76   return _M_files;
  77 }
  78
  79 CodeModelItem CodeModel::findItem(const QStringList &qualifiedName, CodeModelItem scope) const
  80 {
  81   for (int i=0; i<qualifiedName.size(); ++i) {
  82     // ### Extend to look for members etc too.
  83     const QString &name = qualifiedName.at(i);
  84
  85     if (NamespaceModelItem ns = model_dynamic_cast<NamespaceModelItem>(scope))
  86       {
  87         if (NamespaceModelItem tmp_ns = ns->findNamespace(name)) {
  88           scope = tmp_ns;
  89           continue;
  90         }
  91       }
  92
  93     if (ScopeModelItem ss = model_dynamic_cast<ScopeModelItem>(scope))
  94       {
  95         if (ClassModelItem cs = ss->findClass(name))
  96           {
  97             scope = cs;
  98           }
  99         else if (EnumModelItem es = ss->findEnum(name))
 100           {
 101             if (i == qualifiedName.size () - 1)
 102               return es->toItem();
 103           }
 104         else if (TypeAliasModelItem tp = ss->findTypeAlias(name))
 105           {
 106             if (i == qualifiedName.size () - 1)
 107               return tp->toItem ();
 108           }
 109         else
 110           {
 111               // If we don't find the name in the scope chain we
 112               // need to return an empty item to indicate failure...
 113               return CodeModelItem();
 114           }
 115       }
 116   }
 117
 118   return scope;
 119 }
 120
 121
 122 // ---------------------------------------------------------------------------
 123 TypeInfo TypeInfo::combine (const TypeInfo &__lhs, const TypeInfo &__rhs)
 124 {
 125   TypeInfo __result = __lhs;
 126
 127   __result.setConstant (__result.isConstant () || __rhs.isConstant ());
 128   __result.setVolatile (__result.isVolatile () || __rhs.isVolatile ());
 129   __result.setReference (__result.isReference () || __rhs.isReference ());
 130   __result.setIndirections (__result.indirections () + __rhs.indirections ());
 131   __result.setArrayElements (__result.arrayElements () + __rhs.arrayElements ());
 132
 133   return __result;
 134 }
 135
 136 TypeInfo TypeInfo::resolveType (TypeInfo const &__type, CodeModelItem __scope)
 137 {
 138     CodeModel *__model = __scope->model ();
 139     Q_ASSERT (__model != 0);
 140
 141     CodeModelItem __item = __model->findItem (__type.qualifiedName (), __scope);
 142
 143     // Copy the type and replace with the proper qualified name. This
 144     // only makes sence to do if we're actually getting a resolved
 145     // type with a namespace. We only get this if the returned type
 146     // has more than 2 entries in the qualified name... This test
 147     // could be improved by returning if the type was found or not.
 148     TypeInfo otherType(__type);
 149     if (__item && __item->qualifiedName().size() > 1) {
 150         otherType.setQualifiedName(__item->qualifiedName());
 151     }
 152
 153     if (TypeAliasModelItem __alias = model_dynamic_cast<TypeAliasModelItem> (__item))
 154         return resolveType (TypeInfo::combine (__alias->type (), otherType), __scope);
 155
 156     return otherType;
 157 }
 158
 159 QString TypeInfo::toString() const
 160 {
 161   QString tmp;
 162
 163   tmp += m_qualifiedName.join("::");
 164   if (isConstant())
 165     tmp += QLatin1String(" const");
 166
 167   if (isVolatile())
 168     tmp += QLatin1String(" volatile");
 169
 170   if (indirections())
 171     tmp += QString(indirections(), QLatin1Char('*'));
 172
 173   if (isReference())
 174     tmp += QLatin1Char('&');
 175
 176   if (isFunctionPointer())
 177     {
 178       tmp += QLatin1String(" (*)(");
 179       for (int i=0; i<m_arguments.count(); ++i)
 180         {
 181           if (i != 0)
 182             tmp += QLatin1String(", ");
 183
 184           tmp += m_arguments.at(i).toString();
 185         }
 186       tmp += QLatin1String(")");
 187     }
 188
 189   foreach (const QString& elt, arrayElements ())
 190     {
 191       tmp += QLatin1String ("[");
 192       tmp += elt;
 193       tmp += QLatin1String ("]");
 194     }
 195
 196   return tmp;
 197 }
 198
 199 bool TypeInfo::operator==(const TypeInfo &other)
 200 {
 201   if (arrayElements().count() != other.arrayElements().count())
 202       return false;
 203
 204 #if defined (RXX_CHECK_ARRAY_ELEMENTS) // ### it'll break
 205   for (int i=0; i<arrayElements().count(); ++i)
 206     {
 207       QString elt1 = arrayElements ().at (i).trimmed ();
 208       QString elt2 = other.arrayElements ().at (i).trimmed ();
 209
 210       if (elt1 != elt2)
 211         return false;
 212     }
 213 #endif
 214
 215   return flags == other.flags
 216     && m_qualifiedName == other.m_qualifiedName
 217     && (!f.m_functionPointer || m_arguments == other.m_arguments);
 218 }
 219
 220 // ---------------------------------------------------------------------------
 221 _CodeModelItem::_CodeModelItem(CodeModel *model, int kind)
 222   : _M_model(model),
 223     _M_kind(kind),
 224     _M_startLine(0),
 225     _M_startColumn(0),
 226     _M_endLine(0),
 227     _M_endColumn(0),
 228     _M_creation_id(0)
 229 {
 230 }
 231
 232 _CodeModelItem::~_CodeModelItem()
 233 {
 234 }
 235
 236 CodeModelItem _CodeModelItem::toItem() const
 237 {
 238   return CodeModelItem(const_cast<_CodeModelItem*>(this));
 239 }
 240
 241 int _CodeModelItem::kind() const
 242 {
 243   return _M_kind;
 244 }
 245
 246 void _CodeModelItem::setKind(int kind)
 247 {
 248   _M_kind = kind;
 249 }
 250
 251 QStringList _CodeModelItem::qualifiedName() const
 252 {
 253   QStringList q = scope();
 254
 255   if (!name().isEmpty())
 256     q += name();
 257
 258   return q;
 259 }
 260
 261 QString _CodeModelItem::name() const
 262 {
 263   return _M_name;
 264 }
 265
 266 void _CodeModelItem::setName(const QString &name)
 267 {
 268   _M_name = name;
 269 }
 270
 271 QStringList _CodeModelItem::scope() const
 272 {
 273   return _M_scope;
 274 }
 275
 276 void _CodeModelItem::setScope(const QStringList &scope)
 277 {
 278   _M_scope = scope;
 279 }
 280
 281 QString _CodeModelItem::fileName() const
 282 {
 283   return _M_fileName;
 284 }
 285
 286 void _CodeModelItem::setFileName(const QString &fileName)
 287 {
 288   _M_fileName = fileName;
 289 }
 290
 291 FileModelItem _CodeModelItem::file() const
 292 {
 293   return model()->findFile(fileName());
 294 }
 295
 296 void _CodeModelItem::getStartPosition(int *line, int *column)
 297 {
 298   *line = _M_startLine;
 299   *column = _M_startColumn;
 300 }
 301
 302 void _CodeModelItem::setStartPosition(int line, int column)
 303 {
 304   _M_startLine = line;
 305   _M_startColumn = column;
 306 }
 307
 308 void _CodeModelItem::getEndPosition(int *line, int *column)
 309 {
 310   *line = _M_endLine;
 311   *column = _M_endColumn;
 312 }
 313
 314 void _CodeModelItem::setEndPosition(int line, int column)
 315 {
 316   _M_endLine = line;
 317   _M_endColumn = column;
 318 }
 319
 320 // ---------------------------------------------------------------------------
 321 QStringList _ClassModelItem::baseClasses() const
 322 {
 323   return _M_baseClasses;
 324 }
 325
 326 void _ClassModelItem::setBaseClasses(const QStringList &baseClasses)
 327 {
 328   _M_baseClasses = baseClasses;
 329   _M_baseModifiers = QStringList();
 330   while (_M_baseModifiers.size()>_M_baseClasses.size()) {
 331           _M_baseModifiers.pop_back();
 332   }
 333   while (_M_baseModifiers.size()<_M_baseClasses.size()) {
 334           _M_baseModifiers.push_back(QString());
 335   }
 336 }
 337
 338 QStringList _ClassModelItem::baseModifiers() const
 339 {
 340   return _M_baseModifiers;
 341 }
 342
 343 void _ClassModelItem::setBaseModifiers(const QStringList &baseModifiers)
 344 {
 345   _M_baseModifiers = baseModifiers;
 346   while (_M_baseModifiers.size()>_M_baseClasses.size()) {
 347           _M_baseModifiers.pop_back();
 348   }
 349   while (_M_baseModifiers.size()<_M_baseClasses.size()) {
 350           _M_baseModifiers.push_back(QString());
 351   }
 352 }
 353
 354 TemplateParameterList _ClassModelItem::templateParameters() const
 355 {
 356   return _M_templateParameters;
 357 }
 358
 359 void _ClassModelItem::setTemplateParameters(const TemplateParameterList &templateParameters)
 360 {
 361   _M_templateParameters = templateParameters;
 362 }
 363
 364 void _ClassModelItem::addBaseClass(const QString &baseClass, const QString &baseModifier)
 365 {
 366   _M_baseClasses.append(baseClass);
 367   _M_baseModifiers.append(baseModifier);
 368 }
 369
 370 void _ClassModelItem::removeBaseClass(const QString &baseClass)
 371 {
 372   int index = _M_baseClasses.indexOf(baseClass);
 373   _M_baseClasses.removeAt(index);
 374   _M_baseModifiers.removeAt(index);
 375 }
 376
 377 bool _ClassModelItem::extendsClass(const QString &name) const
 378 {
 379   return _M_baseClasses.contains(name);
 380 }
 381
 382 void _ClassModelItem::setClassType(CodeModel::ClassType type)
 383 {
 384   _M_classType = type;
 385 }
 386
 387 CodeModel::ClassType _ClassModelItem::classType() const
 388 {
 389   return _M_classType;
 390 }
 391
 392 void _ClassModelItem::addPropertyDeclaration(const QString &propertyDeclaration)
 393 {
 394     _M_propertyDeclarations << propertyDeclaration;
 395 }
 396
 397 CodeModel::AccessPolicy _ClassModelItem::accessPolicy() const
 398 {
 399   return _M_accessPolicy;
 400 }
 401
 402 void _ClassModelItem::setAccessPolicy(CodeModel::AccessPolicy accessPolicy)
 403 {
 404   _M_accessPolicy = accessPolicy;
 405 }
 406
 407
 408 // ---------------------------------------------------------------------------
 409 FunctionModelItem _ScopeModelItem::declaredFunction(FunctionModelItem item)
 410 {
 411   FunctionList function_list = findFunctions(item->name());
 412
 413   foreach (FunctionModelItem fun, function_list)
 414     {
 415       if (fun->isSimilar(item))
 416         return fun;
 417     }
 418
 419   return FunctionModelItem();
 420 }
 421
 422 ClassList _ScopeModelItem::classes() const
 423 {
 424   return _M_classes.values();
 425 }
 426
 427 TypeAliasList _ScopeModelItem::typeAliases() const
 428 {
 429   return _M_typeAliases.values();
 430 }
 431
 432 VariableList _ScopeModelItem::variables() const
 433 {
 434   return _M_variables.values();
 435 }
 436
 437 FunctionList _ScopeModelItem::functions() const
 438 {
 439   return _M_functions.values();
 440 }
 441
 442 void _ScopeModelItem::addEnumsDeclaration(const QString &enumsDeclaration)
 443 {
 444     _M_enumsDeclarations << enumsDeclaration;
 445 }
 446
 447 FunctionDefinitionList _ScopeModelItem::functionDefinitions() const
 448 {
 449   return _M_functionDefinitions.values();
 450 }
 451
 452 EnumList _ScopeModelItem::enums() const
 453 {
 454   return _M_enums.values();
 455 }
 456
 457 void _ScopeModelItem::addClass(ClassModelItem item)
 458 {
 459  QString name = item->name();
 460  int idx = name.indexOf("<");
 461  if (idx > 0)
 462      _M_classes.insert(name.left(idx), item);
 463   _M_classes.insert(name, item);
 464 }
 465
 466 void _ScopeModelItem::addFunction(FunctionModelItem item)
 467 {
 468   _M_functions.insert(item->name(), item);
 469 }
 470
 471 void _ScopeModelItem::addFunctionDefinition(FunctionDefinitionModelItem item)
 472 {
 473   _M_functionDefinitions.insert(item->name(), item);
 474 }
 475
 476 void _ScopeModelItem::addVariable(VariableModelItem item)
 477 {
 478   _M_variables.insert(item->name(), item);
 479 }
 480
 481 void _ScopeModelItem::addTypeAlias(TypeAliasModelItem item)
 482 {
 483   _M_typeAliases.insert(item->name(), item);
 484 }
 485
 486 void _ScopeModelItem::addEnum(EnumModelItem item)
 487 {
 488   _M_enums.insert(item->name(), item);
 489 }
 490
 491 void _ScopeModelItem::removeClass(ClassModelItem item)
 492 {
 493   QHash<QString, ClassModelItem>::Iterator it = _M_classes.find(item->name());
 494
 495   if (it != _M_classes.end() && it.value() == item)
 496     _M_classes.erase(it);
 497 }
 498
 499 void _ScopeModelItem::removeFunction(FunctionModelItem item)
 500 {
 501   QMultiHash<QString, FunctionModelItem>::Iterator it = _M_functions.find(item->name());
 502
 503   while (it != _M_functions.end() && it.key() == item->name()
 504          && it.value() != item)
 505     {
 506       ++it;
 507     }
 508
 509   if (it != _M_functions.end() && it.value() == item)
 510     {
 511       _M_functions.erase(it);
 512     }
 513 }
 514
 515 void _ScopeModelItem::removeFunctionDefinition(FunctionDefinitionModelItem item)
 516 {
 517   QMultiHash<QString, FunctionDefinitionModelItem>::Iterator it = _M_functionDefinitions.find(item->name());
 518
 519   while (it != _M_functionDefinitions.end() && it.key() == item->name()
 520          && it.value() != item)
 521     {
 522       ++it;
 523     }
 524
 525   if (it != _M_functionDefinitions.end() && it.value() == item)
 526     {
 527       _M_functionDefinitions.erase(it);
 528     }
 529 }
 530
 531 void _ScopeModelItem::removeVariable(VariableModelItem item)
 532 {
 533   QHash<QString, VariableModelItem>::Iterator it = _M_variables.find(item->name());
 534
 535   if (it != _M_variables.end() && it.value() == item)
 536     _M_variables.erase(it);
 537 }
 538
 539 void _ScopeModelItem::removeTypeAlias(TypeAliasModelItem item)
 540 {
 541   QHash<QString, TypeAliasModelItem>::Iterator it = _M_typeAliases.find(item->name());
 542
 543   if (it != _M_typeAliases.end() && it.value() == item)
 544     _M_typeAliases.erase(it);
 545 }
 546
 547 void _ScopeModelItem::removeEnum(EnumModelItem item)
 548 {
 549   QHash<QString, EnumModelItem>::Iterator it = _M_enums.find(item->name());
 550
 551   if (it != _M_enums.end() && it.value() == item)
 552     _M_enums.erase(it);
 553 }
 554
 555 ClassModelItem _ScopeModelItem::findClass(const QString &name) const
 556 {
 557   return _M_classes.value(name);
 558 }
 559
 560 VariableModelItem _ScopeModelItem::findVariable(const QString &name) const
 561 {
 562   return _M_variables.value(name);
 563 }
 564
 565 TypeAliasModelItem _ScopeModelItem::findTypeAlias(const QString &name) const
 566 {
 567   return _M_typeAliases.value(name);
 568 }
 569
 570 EnumModelItem _ScopeModelItem::findEnum(const QString &name) const
 571 {
 572   return _M_enums.value(name);
 573 }
 574
 575 FunctionList _ScopeModelItem::findFunctions(const QString &name) const
 576 {
 577   return _M_functions.values(name);
 578 }
 579
 580 FunctionDefinitionList _ScopeModelItem::findFunctionDefinitions(const QString &name) const
 581 {
 582   return _M_functionDefinitions.values(name);
 583 }
 584
 585 // ---------------------------------------------------------------------------
 586 NamespaceList _NamespaceModelItem::namespaces() const
 587 {
 588   return _M_namespaces.values();
 589 }
 590 void _NamespaceModelItem::addNamespace(NamespaceModelItem item)
 591 {
 592   _M_namespaces.insert(item->name(), item);
 593 }
 594 void _NamespaceModelItem::removeNamespace(NamespaceModelItem item)
 595 {
 596   QHash<QString, NamespaceModelItem>::Iterator it = _M_namespaces.find(item->name());
 597
 598   if (it != _M_namespaces.end() && it.value() == item)
 599     _M_namespaces.erase(it);
 600 }
 601
 602 NamespaceModelItem _NamespaceModelItem::findNamespace(const QString &name) const
 603 {
 604   return _M_namespaces.value(name);
 605 }
 606
 607 // ---------------------------------------------------------------------------
 608 TypeInfo _ArgumentModelItem::type() const
 609 {
 610   return _M_type;
 611 }
 612
 613 void _ArgumentModelItem::setType(const TypeInfo &type)
 614 {
 615   _M_type = type;
 616 }
 617
 618 bool _ArgumentModelItem::defaultValue() const
 619 {
 620   return _M_defaultValue;
 621 }
 622
 623 void _ArgumentModelItem::setDefaultValue(bool defaultValue)
 624 {
 625   _M_defaultValue = defaultValue;
 626 }
 627
 628 // ---------------------------------------------------------------------------
 629 bool _FunctionModelItem::isSimilar(FunctionModelItem other) const
 630 {
 631   if (name() != other->name())
 632     return false;
 633
 634   if (isConstant() != other->isConstant())
 635     return false;
 636
 637   if (isVariadics() != other->isVariadics())
 638     return false;
 639
 640   if (arguments().count() != other->arguments().count())
 641     return false;
 642
 643   // ### check the template parameters
 644
 645   for (int i=0; i<arguments().count(); ++i)
 646     {
 647       ArgumentModelItem arg1 = arguments().at(i);
 648       ArgumentModelItem arg2 = other->arguments().at(i);
 649
 650       if (arg1->type() != arg2->type())
 651         return false;
 652     }
 653
 654   return true;
 655 }
 656
 657 ArgumentList _FunctionModelItem::arguments() const
 658 {
 659   return _M_arguments;
 660 }
 661
 662 void _FunctionModelItem::addArgument(ArgumentModelItem item)
 663 {
 664   _M_arguments.append(item);
 665 }
 666
 667 void _FunctionModelItem::removeArgument(ArgumentModelItem item)
 668 {
 669   _M_arguments.removeAt(_M_arguments.indexOf(item));
 670 }
 671
 672 CodeModel::FunctionType _FunctionModelItem::functionType() const
 673 {
 674   return _M_functionType;
 675 }
 676
 677 void _FunctionModelItem::setFunctionType(CodeModel::FunctionType functionType)
 678 {
 679   _M_functionType = functionType;
 680 }
 681
 682 bool _FunctionModelItem::isVariadics() const
 683 {
 684   return f._M_isVariadics;
 685 }
 686
 687 void _FunctionModelItem::setVariadics(bool isVariadics)
 688 {
 689   f._M_isVariadics = isVariadics;
 690 }
 691
 692 bool _FunctionModelItem::isVirtual() const
 693 {
 694   return f._M_isVirtual;
 695 }
 696
 697 void _FunctionModelItem::setVirtual(bool isVirtual)
 698 {
 699   f._M_isVirtual = isVirtual;
 700 }
 701
 702 bool _FunctionModelItem::isInline() const
 703 {
 704   return f._M_isInline;
 705 }
 706
 707 void _FunctionModelItem::setInline(bool isInline)
 708 {
 709   f._M_isInline = isInline;
 710 }
 711
 712 bool _FunctionModelItem::isExplicit() const
 713 {
 714   return f._M_isExplicit;
 715 }
 716
 717 void _FunctionModelItem::setExplicit(bool isExplicit)
 718 {
 719   f._M_isExplicit = isExplicit;
 720 }
 721
 722 bool _FunctionModelItem::isAbstract() const
 723 {
 724   return f._M_isAbstract;
 725 }
 726
 727 void _FunctionModelItem::setAbstract(bool isAbstract)
 728 {
 729   f._M_isAbstract = isAbstract;
 730 }
 731
 732 // Qt
 733 bool _FunctionModelItem::isInvokable() const
 734 {
 735     return _M_isInvokable;
 736 }
 737
 738 void _FunctionModelItem::setInvokable(bool isInvokable)
 739 {
 740     _M_isInvokable = isInvokable;
 741 }
 742
 743 // ---------------------------------------------------------------------------
 744 TypeInfo _TypeAliasModelItem::type() const
 745 {
 746   return _M_type;
 747 }
 748
 749 void _TypeAliasModelItem::setType(const TypeInfo &type)
 750 {
 751   _M_type = type;
 752 }
 753
 754 // ---------------------------------------------------------------------------
 755 CodeModel::AccessPolicy _EnumModelItem::accessPolicy() const
 756 {
 757   return _M_accessPolicy;
 758 }
 759
 760 void _EnumModelItem::setAccessPolicy(CodeModel::AccessPolicy accessPolicy)
 761 {
 762   _M_accessPolicy = accessPolicy;
 763 }
 764
 765 EnumeratorList _EnumModelItem::enumerators() const
 766 {
 767   return _M_enumerators;
 768 }
 769
 770 void _EnumModelItem::addEnumerator(EnumeratorModelItem item)
 771 {
 772   _M_enumerators.append(item);
 773 }
 774
 775 void _EnumModelItem::removeEnumerator(EnumeratorModelItem item)
 776 {
 777   _M_enumerators.removeAt(_M_enumerators.indexOf(item));
 778 }
 779
 780 // ---------------------------------------------------------------------------
 781 QString _EnumeratorModelItem::value() const
 782 {
 783   return _M_value;
 784 }
 785
 786 void _EnumeratorModelItem::setValue(const QString &value)
 787 {
 788   _M_value = value;
 789 }
 790
 791 // ---------------------------------------------------------------------------
 792 TypeInfo _TemplateParameterModelItem::type() const
 793 {
 794   return _M_type;
 795 }
 796
 797 void _TemplateParameterModelItem::setType(const TypeInfo &type)
 798 {
 799   _M_type = type;
 800 }
 801
 802 bool _TemplateParameterModelItem::defaultValue() const
 803 {
 804   return _M_defaultValue;
 805 }
 806
 807 void _TemplateParameterModelItem::setDefaultValue(bool defaultValue)
 808 {
 809   _M_defaultValue = defaultValue;
 810 }
 811
 812 // ---------------------------------------------------------------------------
 813 ScopeModelItem _ScopeModelItem::create(CodeModel *model)
 814 {
 815   ScopeModelItem item(new _ScopeModelItem(model));
 816   return item;
 817 }
 818
 819 ClassModelItem _ClassModelItem::create(CodeModel *model)
 820 {
 821   ClassModelItem item(new _ClassModelItem(model));
 822   return item;
 823 }
 824
 825 NamespaceModelItem _NamespaceModelItem::create(CodeModel *model)
 826 {
 827   NamespaceModelItem item(new _NamespaceModelItem(model));
 828   return item;
 829 }
 830
 831 FileModelItem _FileModelItem::create(CodeModel *model)
 832 {
 833   FileModelItem item(new _FileModelItem(model));
 834   return item;
 835 }
 836
 837 ArgumentModelItem _ArgumentModelItem::create(CodeModel *model)
 838 {
 839   ArgumentModelItem item(new _ArgumentModelItem(model));
 840   return item;
 841 }
 842
 843 FunctionModelItem _FunctionModelItem::create(CodeModel *model)
 844 {
 845   FunctionModelItem item(new _FunctionModelItem(model));
 846   return item;
 847 }
 848
 849 FunctionDefinitionModelItem _FunctionDefinitionModelItem::create(CodeModel *model)
 850 {
 851   FunctionDefinitionModelItem item(new _FunctionDefinitionModelItem(model));
 852   return item;
 853 }
 854
 855 VariableModelItem _VariableModelItem::create(CodeModel *model)
 856 {
 857   VariableModelItem item(new _VariableModelItem(model));
 858   return item;
 859 }
 860
 861 TypeAliasModelItem _TypeAliasModelItem::create(CodeModel *model)
 862 {
 863   TypeAliasModelItem item(new _TypeAliasModelItem(model));
 864   return item;
 865 }
 866
 867 EnumModelItem _EnumModelItem::create(CodeModel *model)
 868 {
 869   EnumModelItem item(new _EnumModelItem(model));
 870   return item;
 871 }
 872
 873 EnumeratorModelItem _EnumeratorModelItem::create(CodeModel *model)
 874 {
 875   EnumeratorModelItem item(new _EnumeratorModelItem(model));
 876   return item;
 877 }
 878
 879 TemplateParameterModelItem _TemplateParameterModelItem::create(CodeModel *model)
 880 {
 881   TemplateParameterModelItem item(new _TemplateParameterModelItem(model));
 882   return item;
 883 }
 884
 885 // ---------------------------------------------------------------------------
 886 TypeInfo _MemberModelItem::type() const
 887 {
 888   return _M_type;
 889 }
 890
 891 void _MemberModelItem::setType(const TypeInfo &type)
 892 {
 893   _M_type = type;
 894 }
 895
 896 CodeModel::AccessPolicy _MemberModelItem::accessPolicy() const
 897 {
 898   return _M_accessPolicy;
 899 }
 900
 901 void _MemberModelItem::setAccessPolicy(CodeModel::AccessPolicy accessPolicy)
 902 {
 903   _M_accessPolicy = accessPolicy;
 904 }
 905
 906 bool _MemberModelItem::isStatic() const
 907 {
 908   return f._M_isStatic;
 909 }
 910
 911 void _MemberModelItem::setStatic(bool isStatic)
 912 {
 913   f._M_isStatic = isStatic;
 914 }
 915
 916 bool _MemberModelItem::isConstant() const
 917 {
 918   return f._M_isConstant;
 919 }
 920
 921 void _MemberModelItem::setConstant(bool isConstant)
 922 {
 923   f._M_isConstant = isConstant;
 924 }
 925
 926 bool _MemberModelItem::isVolatile() const
 927 {
 928   return f._M_isVolatile;
 929 }
 930
 931 void _MemberModelItem::setVolatile(bool isVolatile)
 932 {
 933   f._M_isVolatile = isVolatile;
 934 }
 935
 936 bool _MemberModelItem::isAuto() const
 937 {
 938   return f._M_isAuto;
 939 }
 940
 941 void _MemberModelItem::setAuto(bool isAuto)
 942 {
 943   f._M_isAuto = isAuto;
 944 }
 945
 946 bool _MemberModelItem::isFriend() const
 947 {
 948   return f._M_isFriend;
 949 }
 950
 951 void _MemberModelItem::setFriend(bool isFriend)
 952 {
 953   f._M_isFriend = isFriend;
 954 }
 955
 956 bool _MemberModelItem::isRegister() const
 957 {
 958   return f._M_isRegister;
 959 }
 960
 961 void _MemberModelItem::setRegister(bool isRegister)
 962 {
 963   f._M_isRegister = isRegister;
 964 }
 965
 966 bool _MemberModelItem::isExtern() const
 967 {
 968   return f._M_isExtern;
 969 }
 970
 971 void _MemberModelItem::setExtern(bool isExtern)
 972 {
 973   f._M_isExtern = isExtern;
 974 }
 975
 976 bool _MemberModelItem::isMutable() const
 977 {
 978   return f._M_isMutable;
 979 }
 980
 981 void _MemberModelItem::setMutable(bool isMutable)
 982 {
 983   f._M_isMutable = isMutable;
 984 }
 985
 986 // kate: space-indent on; indent-width 2; replace-tabs on;
 987