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
 398 // ---------------------------------------------------------------------------
 399 FunctionModelItem _ScopeModelItem::declaredFunction(FunctionModelItem item)
 400 {
 401   FunctionList function_list = findFunctions(item->name());
 402
 403   foreach (FunctionModelItem fun, function_list)
 404     {
 405       if (fun->isSimilar(item))
 406         return fun;
 407     }
 408
 409   return FunctionModelItem();
 410 }
 411
 412 ClassList _ScopeModelItem::classes() const
 413 {
 414   return _M_classes.values();
 415 }
 416
 417 TypeAliasList _ScopeModelItem::typeAliases() const
 418 {
 419   return _M_typeAliases.values();
 420 }
 421
 422 VariableList _ScopeModelItem::variables() const
 423 {
 424   return _M_variables.values();
 425 }
 426
 427 FunctionList _ScopeModelItem::functions() const
 428 {
 429   return _M_functions.values();
 430 }
 431
 432 void _ScopeModelItem::addEnumsDeclaration(const QString &enumsDeclaration)
 433 {
 434     _M_enumsDeclarations << enumsDeclaration;
 435 }
 436
 437 FunctionDefinitionList _ScopeModelItem::functionDefinitions() const
 438 {
 439   return _M_functionDefinitions.values();
 440 }
 441
 442 EnumList _ScopeModelItem::enums() const
 443 {
 444   return _M_enums.values();
 445 }
 446
 447 void _ScopeModelItem::addClass(ClassModelItem item)
 448 {
 449  QString name = item->name();
 450  int idx = name.indexOf("<");
 451  if (idx > 0)
 452      _M_classes.insert(name.left(idx), item);
 453   _M_classes.insert(name, item);
 454 }
 455
 456 void _ScopeModelItem::addFunction(FunctionModelItem item)
 457 {
 458   _M_functions.insert(item->name(), item);
 459 }
 460
 461 void _ScopeModelItem::addFunctionDefinition(FunctionDefinitionModelItem item)
 462 {
 463   _M_functionDefinitions.insert(item->name(), item);
 464 }
 465
 466 void _ScopeModelItem::addVariable(VariableModelItem item)
 467 {
 468   _M_variables.insert(item->name(), item);
 469 }
 470
 471 void _ScopeModelItem::addTypeAlias(TypeAliasModelItem item)
 472 {
 473   _M_typeAliases.insert(item->name(), item);
 474 }
 475
 476 void _ScopeModelItem::addEnum(EnumModelItem item)
 477 {
 478   _M_enums.insert(item->name(), item);
 479 }
 480
 481 void _ScopeModelItem::removeClass(ClassModelItem item)
 482 {
 483   QHash<QString, ClassModelItem>::Iterator it = _M_classes.find(item->name());
 484
 485   if (it != _M_classes.end() && it.value() == item)
 486     _M_classes.erase(it);
 487 }
 488
 489 void _ScopeModelItem::removeFunction(FunctionModelItem item)
 490 {
 491   QMultiHash<QString, FunctionModelItem>::Iterator it = _M_functions.find(item->name());
 492
 493   while (it != _M_functions.end() && it.key() == item->name()
 494          && it.value() != item)
 495     {
 496       ++it;
 497     }
 498
 499   if (it != _M_functions.end() && it.value() == item)
 500     {
 501       _M_functions.erase(it);
 502     }
 503 }
 504
 505 void _ScopeModelItem::removeFunctionDefinition(FunctionDefinitionModelItem item)
 506 {
 507   QMultiHash<QString, FunctionDefinitionModelItem>::Iterator it = _M_functionDefinitions.find(item->name());
 508
 509   while (it != _M_functionDefinitions.end() && it.key() == item->name()
 510          && it.value() != item)
 511     {
 512       ++it;
 513     }
 514
 515   if (it != _M_functionDefinitions.end() && it.value() == item)
 516     {
 517       _M_functionDefinitions.erase(it);
 518     }
 519 }
 520
 521 void _ScopeModelItem::removeVariable(VariableModelItem item)
 522 {
 523   QHash<QString, VariableModelItem>::Iterator it = _M_variables.find(item->name());
 524
 525   if (it != _M_variables.end() && it.value() == item)
 526     _M_variables.erase(it);
 527 }
 528
 529 void _ScopeModelItem::removeTypeAlias(TypeAliasModelItem item)
 530 {
 531   QHash<QString, TypeAliasModelItem>::Iterator it = _M_typeAliases.find(item->name());
 532
 533   if (it != _M_typeAliases.end() && it.value() == item)
 534     _M_typeAliases.erase(it);
 535 }
 536
 537 void _ScopeModelItem::removeEnum(EnumModelItem item)
 538 {
 539   QHash<QString, EnumModelItem>::Iterator it = _M_enums.find(item->name());
 540
 541   if (it != _M_enums.end() && it.value() == item)
 542     _M_enums.erase(it);
 543 }
 544
 545 ClassModelItem _ScopeModelItem::findClass(const QString &name) const
 546 {
 547   return _M_classes.value(name);
 548 }
 549
 550 VariableModelItem _ScopeModelItem::findVariable(const QString &name) const
 551 {
 552   return _M_variables.value(name);
 553 }
 554
 555 TypeAliasModelItem _ScopeModelItem::findTypeAlias(const QString &name) const
 556 {
 557   return _M_typeAliases.value(name);
 558 }
 559
 560 EnumModelItem _ScopeModelItem::findEnum(const QString &name) const
 561 {
 562   return _M_enums.value(name);
 563 }
 564
 565 FunctionList _ScopeModelItem::findFunctions(const QString &name) const
 566 {
 567   return _M_functions.values(name);
 568 }
 569
 570 FunctionDefinitionList _ScopeModelItem::findFunctionDefinitions(const QString &name) const
 571 {
 572   return _M_functionDefinitions.values(name);
 573 }
 574
 575 // ---------------------------------------------------------------------------
 576 NamespaceList _NamespaceModelItem::namespaces() const
 577 {
 578   return _M_namespaces.values();
 579 }
 580 void _NamespaceModelItem::addNamespace(NamespaceModelItem item)
 581 {
 582   _M_namespaces.insert(item->name(), item);
 583 }
 584 void _NamespaceModelItem::removeNamespace(NamespaceModelItem item)
 585 {
 586   QHash<QString, NamespaceModelItem>::Iterator it = _M_namespaces.find(item->name());
 587
 588   if (it != _M_namespaces.end() && it.value() == item)
 589     _M_namespaces.erase(it);
 590 }
 591
 592 NamespaceModelItem _NamespaceModelItem::findNamespace(const QString &name) const
 593 {
 594   return _M_namespaces.value(name);
 595 }
 596
 597 // ---------------------------------------------------------------------------
 598 TypeInfo _ArgumentModelItem::type() const
 599 {
 600   return _M_type;
 601 }
 602
 603 void _ArgumentModelItem::setType(const TypeInfo &type)
 604 {
 605   _M_type = type;
 606 }
 607
 608 bool _ArgumentModelItem::defaultValue() const
 609 {
 610   return _M_defaultValue;
 611 }
 612
 613 void _ArgumentModelItem::setDefaultValue(bool defaultValue)
 614 {
 615   _M_defaultValue = defaultValue;
 616 }
 617
 618 // ---------------------------------------------------------------------------
 619 bool _FunctionModelItem::isSimilar(FunctionModelItem other) const
 620 {
 621   if (name() != other->name())
 622     return false;
 623
 624   if (isConstant() != other->isConstant())
 625     return false;
 626
 627   if (isVariadics() != other->isVariadics())
 628     return false;
 629
 630   if (arguments().count() != other->arguments().count())
 631     return false;
 632
 633   // ### check the template parameters
 634
 635   for (int i=0; i<arguments().count(); ++i)
 636     {
 637       ArgumentModelItem arg1 = arguments().at(i);
 638       ArgumentModelItem arg2 = other->arguments().at(i);
 639
 640       if (arg1->type() != arg2->type())
 641         return false;
 642     }
 643
 644   return true;
 645 }
 646
 647 ArgumentList _FunctionModelItem::arguments() const
 648 {
 649   return _M_arguments;
 650 }
 651
 652 void _FunctionModelItem::addArgument(ArgumentModelItem item)
 653 {
 654   _M_arguments.append(item);
 655 }
 656
 657 void _FunctionModelItem::removeArgument(ArgumentModelItem item)
 658 {
 659   _M_arguments.removeAt(_M_arguments.indexOf(item));
 660 }
 661
 662 CodeModel::FunctionType _FunctionModelItem::functionType() const
 663 {
 664   return _M_functionType;
 665 }
 666
 667 void _FunctionModelItem::setFunctionType(CodeModel::FunctionType functionType)
 668 {
 669   _M_functionType = functionType;
 670 }
 671
 672 bool _FunctionModelItem::isVariadics() const
 673 {
 674   return f._M_isVariadics;
 675 }
 676
 677 void _FunctionModelItem::setVariadics(bool isVariadics)
 678 {
 679   f._M_isVariadics = isVariadics;
 680 }
 681
 682 bool _FunctionModelItem::isVirtual() const
 683 {
 684   return f._M_isVirtual;
 685 }
 686
 687 void _FunctionModelItem::setVirtual(bool isVirtual)
 688 {
 689   f._M_isVirtual = isVirtual;
 690 }
 691
 692 bool _FunctionModelItem::isInline() const
 693 {
 694   return f._M_isInline;
 695 }
 696
 697 void _FunctionModelItem::setInline(bool isInline)
 698 {
 699   f._M_isInline = isInline;
 700 }
 701
 702 bool _FunctionModelItem::isExplicit() const
 703 {
 704   return f._M_isExplicit;
 705 }
 706
 707 void _FunctionModelItem::setExplicit(bool isExplicit)
 708 {
 709   f._M_isExplicit = isExplicit;
 710 }
 711
 712 bool _FunctionModelItem::isAbstract() const
 713 {
 714   return f._M_isAbstract;
 715 }
 716
 717 void _FunctionModelItem::setAbstract(bool isAbstract)
 718 {
 719   f._M_isAbstract = isAbstract;
 720 }
 721
 722 // Qt
 723 bool _FunctionModelItem::isInvokable() const
 724 {
 725     return _M_isInvokable;
 726 }
 727
 728 void _FunctionModelItem::setInvokable(bool isInvokable)
 729 {
 730     _M_isInvokable = isInvokable;
 731 }
 732
 733 // ---------------------------------------------------------------------------
 734 TypeInfo _TypeAliasModelItem::type() const
 735 {
 736   return _M_type;
 737 }
 738
 739 void _TypeAliasModelItem::setType(const TypeInfo &type)
 740 {
 741   _M_type = type;
 742 }
 743
 744 // ---------------------------------------------------------------------------
 745 CodeModel::AccessPolicy _EnumModelItem::accessPolicy() const
 746 {
 747   return _M_accessPolicy;
 748 }
 749
 750 void _EnumModelItem::setAccessPolicy(CodeModel::AccessPolicy accessPolicy)
 751 {
 752   _M_accessPolicy = accessPolicy;
 753 }
 754
 755 EnumeratorList _EnumModelItem::enumerators() const
 756 {
 757   return _M_enumerators;
 758 }
 759
 760 void _EnumModelItem::addEnumerator(EnumeratorModelItem item)
 761 {
 762   _M_enumerators.append(item);
 763 }
 764
 765 void _EnumModelItem::removeEnumerator(EnumeratorModelItem item)
 766 {
 767   _M_enumerators.removeAt(_M_enumerators.indexOf(item));
 768 }
 769
 770 // ---------------------------------------------------------------------------
 771 QString _EnumeratorModelItem::value() const
 772 {
 773   return _M_value;
 774 }
 775
 776 void _EnumeratorModelItem::setValue(const QString &value)
 777 {
 778   _M_value = value;
 779 }
 780
 781 // ---------------------------------------------------------------------------
 782 TypeInfo _TemplateParameterModelItem::type() const
 783 {
 784   return _M_type;
 785 }
 786
 787 void _TemplateParameterModelItem::setType(const TypeInfo &type)
 788 {
 789   _M_type = type;
 790 }
 791
 792 bool _TemplateParameterModelItem::defaultValue() const
 793 {
 794   return _M_defaultValue;
 795 }
 796
 797 void _TemplateParameterModelItem::setDefaultValue(bool defaultValue)
 798 {
 799   _M_defaultValue = defaultValue;
 800 }
 801
 802 // ---------------------------------------------------------------------------
 803 ScopeModelItem _ScopeModelItem::create(CodeModel *model)
 804 {
 805   ScopeModelItem item(new _ScopeModelItem(model));
 806   return item;
 807 }
 808
 809 ClassModelItem _ClassModelItem::create(CodeModel *model)
 810 {
 811   ClassModelItem item(new _ClassModelItem(model));
 812   return item;
 813 }
 814
 815 NamespaceModelItem _NamespaceModelItem::create(CodeModel *model)
 816 {
 817   NamespaceModelItem item(new _NamespaceModelItem(model));
 818   return item;
 819 }
 820
 821 FileModelItem _FileModelItem::create(CodeModel *model)
 822 {
 823   FileModelItem item(new _FileModelItem(model));
 824   return item;
 825 }
 826
 827 ArgumentModelItem _ArgumentModelItem::create(CodeModel *model)
 828 {
 829   ArgumentModelItem item(new _ArgumentModelItem(model));
 830   return item;
 831 }
 832
 833 FunctionModelItem _FunctionModelItem::create(CodeModel *model)
 834 {
 835   FunctionModelItem item(new _FunctionModelItem(model));
 836   return item;
 837 }
 838
 839 FunctionDefinitionModelItem _FunctionDefinitionModelItem::create(CodeModel *model)
 840 {
 841   FunctionDefinitionModelItem item(new _FunctionDefinitionModelItem(model));
 842   return item;
 843 }
 844
 845 VariableModelItem _VariableModelItem::create(CodeModel *model)
 846 {
 847   VariableModelItem item(new _VariableModelItem(model));
 848   return item;
 849 }
 850
 851 TypeAliasModelItem _TypeAliasModelItem::create(CodeModel *model)
 852 {
 853   TypeAliasModelItem item(new _TypeAliasModelItem(model));
 854   return item;
 855 }
 856
 857 EnumModelItem _EnumModelItem::create(CodeModel *model)
 858 {
 859   EnumModelItem item(new _EnumModelItem(model));
 860   return item;
 861 }
 862
 863 EnumeratorModelItem _EnumeratorModelItem::create(CodeModel *model)
 864 {
 865   EnumeratorModelItem item(new _EnumeratorModelItem(model));
 866   return item;
 867 }
 868
 869 TemplateParameterModelItem _TemplateParameterModelItem::create(CodeModel *model)
 870 {
 871   TemplateParameterModelItem item(new _TemplateParameterModelItem(model));
 872   return item;
 873 }
 874
 875 // ---------------------------------------------------------------------------
 876 TypeInfo _MemberModelItem::type() const
 877 {
 878   return _M_type;
 879 }
 880
 881 void _MemberModelItem::setType(const TypeInfo &type)
 882 {
 883   _M_type = type;
 884 }
 885
 886 CodeModel::AccessPolicy _MemberModelItem::accessPolicy() const
 887 {
 888   return _M_accessPolicy;
 889 }
 890
 891 void _MemberModelItem::setAccessPolicy(CodeModel::AccessPolicy accessPolicy)
 892 {
 893   _M_accessPolicy = accessPolicy;
 894 }
 895
 896 bool _MemberModelItem::isStatic() const
 897 {
 898   return f._M_isStatic;
 899 }
 900
 901 void _MemberModelItem::setStatic(bool isStatic)
 902 {
 903   f._M_isStatic = isStatic;
 904 }
 905
 906 bool _MemberModelItem::isConstant() const
 907 {
 908   return f._M_isConstant;
 909 }
 910
 911 void _MemberModelItem::setConstant(bool isConstant)
 912 {
 913   f._M_isConstant = isConstant;
 914 }
 915
 916 bool _MemberModelItem::isVolatile() const
 917 {
 918   return f._M_isVolatile;
 919 }
 920
 921 void _MemberModelItem::setVolatile(bool isVolatile)
 922 {
 923   f._M_isVolatile = isVolatile;
 924 }
 925
 926 bool _MemberModelItem::isAuto() const
 927 {
 928   return f._M_isAuto;
 929 }
 930
 931 void _MemberModelItem::setAuto(bool isAuto)
 932 {
 933   f._M_isAuto = isAuto;
 934 }
 935
 936 bool _MemberModelItem::isFriend() const
 937 {
 938   return f._M_isFriend;
 939 }
 940
 941 void _MemberModelItem::setFriend(bool isFriend)
 942 {
 943   f._M_isFriend = isFriend;
 944 }
 945
 946 bool _MemberModelItem::isRegister() const
 947 {
 948   return f._M_isRegister;
 949 }
 950
 951 void _MemberModelItem::setRegister(bool isRegister)
 952 {
 953   f._M_isRegister = isRegister;
 954 }
 955
 956 bool _MemberModelItem::isExtern() const
 957 {
 958   return f._M_isExtern;
 959 }
 960
 961 void _MemberModelItem::setExtern(bool isExtern)
 962 {
 963   f._M_isExtern = isExtern;
 964 }
 965
 966 bool _MemberModelItem::isMutable() const
 967 {
 968   return f._M_isMutable;
 969 }
 970
 971 void _MemberModelItem::setMutable(bool isMutable)
 972 {
 973   f._M_isMutable = isMutable;
 974 }
 975
 976 // kate: space-indent on; indent-width 2; replace-tabs on;
 977