cpptoxml/parser/codemodel.h

   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 #ifndef CODEMODEL_H
  27 #define CODEMODEL_H
  28
  29 #include "codemodel_fwd.h"
  30 #include <codemodel_pointer.h>
  31
  32 #include <QtCore/QHash>
  33 #include <QtCore/QList>
  34 #include <QtCore/QString>
  35 #include <QtCore/QStringList>
  36 #include <QtCore/QVector>
  37
  38 #define DECLARE_MODEL_NODE(k) \
  39     enum { __node_kind = Kind_##k }; \
  40     typedef CodeModelPointer<k##ModelItem> Pointer;
  41
  42 template <class _Target, class _Source>
  43 _Target model_static_cast(_Source item)
  44 {
  45   typedef typename _Target::Type * _Target_pointer;
  46
  47   _Target ptr (static_cast<_Target_pointer>(item.data()));
  48   return ptr;
  49 }
  50
  51 class CodeModel
  52 {
  53 public:
  54   enum AccessPolicy
  55   {
  56     Public,
  57     Protected,
  58     Private
  59   };
  60
  61   enum FunctionType
  62   {
  63     Normal,
  64     Signal,
  65     Slot
  66   };
  67
  68   enum ClassType
  69   {
  70     Class,
  71     Struct,
  72     Union
  73   };
  74
  75 public:
  76   CodeModel();
  77   virtual ~CodeModel();
  78
  79   template <class _Target> _Target create()
  80   {
  81     typedef typename _Target::Type _Target_type;
  82
  83     _Target result = _Target_type::create(this);
  84     result->setCreationId(_M_creation_id++);
  85     return result;
  86   }
  87
  88   FileList files() const;
  89   NamespaceModelItem globalNamespace() const;
  90
  91   void addFile(FileModelItem item);
  92   void removeFile(FileModelItem item);
  93   FileModelItem findFile(const QString &name) const;
  94   QHash<QString, FileModelItem> fileMap() const;
  95
  96   CodeModelItem findItem(const QStringList &qualifiedName, CodeModelItem scope) const;
  97
  98   void wipeout();
  99
 100 private:
 101   QHash<QString, FileModelItem> _M_files;
 102   NamespaceModelItem _M_globalNamespace;
 103   std::size_t _M_creation_id;
 104
 105 private:
 106   CodeModel(const CodeModel &other);
 107   void operator = (const CodeModel &other);
 108 };
 109
 110 class TypeInfo
 111 {
 112 public:
 113   TypeInfo(const TypeInfo &other)
 114     : flags(other.flags),
 115       m_qualifiedName(other.m_qualifiedName),
 116       m_arrayElements(other.m_arrayElements),
 117       m_arguments(other.m_arguments)
 118   {
 119   }
 120
 121   TypeInfo():
 122     flags (0) {}
 123
 124   QStringList qualifiedName() const { return m_qualifiedName; }
 125   void setQualifiedName(const QStringList &qualified_name) { m_qualifiedName = qualified_name; }
 126
 127   bool isConstant() const { return m_constant; }
 128   void setConstant(bool is) { m_constant = is; }
 129
 130   bool isVolatile() const { return m_volatile; }
 131   void setVolatile(bool is) { m_volatile = is; }
 132
 133   bool isReference() const { return m_reference; }
 134   void setReference(bool is) { m_reference = is; }
 135
 136   int indirections() const { return m_indirections; }
 137   void setIndirections(int indirections) { m_indirections = indirections; }
 138
 139   bool isFunctionPointer() const { return m_functionPointer; }
 140   void setFunctionPointer(bool is) { m_functionPointer = is; }
 141
 142   QStringList arrayElements() const { return m_arrayElements; }
 143   void setArrayElements(const QStringList &arrayElements) { m_arrayElements = arrayElements; }
 144
 145   QList<TypeInfo> arguments() const { return m_arguments; }
 146   void setArguments(const QList<TypeInfo> &arguments);
 147   void addArgument(const TypeInfo &arg) { m_arguments.append(arg); }
 148
 149   bool operator==(const TypeInfo &other);
 150   bool operator!=(const TypeInfo &other) { return !(*this==other); }
 151
 152   // ### arrays and templates??
 153
 154   QString toString() const;
 155
 156   static TypeInfo combine (const TypeInfo &__lhs, const TypeInfo &__rhs);
 157   static TypeInfo resolveType (TypeInfo const &__type, CodeModelItem __scope);
 158
 159 private:
 160   union
 161   {
 162     uint flags;
 163
 164     struct
 165     {
 166       uint m_constant: 1;
 167       uint m_volatile: 1;
 168       uint m_reference: 1;
 169       uint m_functionPointer: 1;
 170       uint m_indirections: 6;
 171       uint m_padding: 22;
 172     };
 173   };
 174
 175   QStringList m_qualifiedName;
 176   QStringList m_arrayElements;
 177   QList<TypeInfo> m_arguments;
 178 };
 179
 180 class _CodeModelItem: public QSharedData
 181 {
 182 public:
 183   enum Kind
 184   {
 185     /* These are bit-flags resembling inheritance */
 186     Kind_Scope = 0x1,
 187     Kind_Namespace = 0x2 | Kind_Scope,
 188     Kind_Member = 0x4,
 189     Kind_Function = 0x8 | Kind_Member,
 190     KindMask = 0xf,
 191
 192     /* These are for classes that are not inherited from */
 193     FirstKind = 0x8,
 194     Kind_Argument = 1 << FirstKind,
 195     Kind_Class = 2 << FirstKind | Kind_Scope,
 196     Kind_Enum = 3 << FirstKind,
 197     Kind_Enumerator = 4 << FirstKind,
 198     Kind_File = 5 << FirstKind | Kind_Namespace,
 199     Kind_FunctionDefinition = 6 << FirstKind | Kind_Function,
 200     Kind_TemplateParameter = 7 << FirstKind,
 201     Kind_TypeAlias = 8 << FirstKind,
 202     Kind_Variable = 9 << FirstKind | Kind_Member
 203   };
 204
 205 public:
 206   virtual ~_CodeModelItem();
 207
 208   int kind() const;
 209
 210   QStringList qualifiedName() const;
 211
 212   QString name() const;
 213   void setName(const QString &name);
 214
 215   QStringList scope() const;
 216   void setScope(const QStringList &scope);
 217
 218   QString fileName() const;
 219   void setFileName(const QString &fileName);
 220
 221   FileModelItem file() const;
 222
 223   void getStartPosition(int *line, int *column);
 224   void setStartPosition(int line, int column);
 225
 226   void getEndPosition(int *line, int *column);
 227   void setEndPosition(int line, int column);
 228
 229   inline std::size_t creationId() const { return _M_creation_id; }
 230   inline void setCreationId(std::size_t creation_id) { _M_creation_id = creation_id; }
 231
 232   inline CodeModel *model() const { return _M_model; }
 233
 234   CodeModelItem toItem() const;
 235
 236 protected:
 237   _CodeModelItem(CodeModel *model, int kind);
 238   void setKind(int kind);
 239
 240 private:
 241   CodeModel *_M_model;
 242   int _M_kind;
 243   int _M_startLine;
 244   int _M_startColumn;
 245   int _M_endLine;
 246   int _M_endColumn;
 247   std::size_t _M_creation_id;
 248   QString _M_name;
 249   QString _M_fileName;
 250   QStringList _M_scope;
 251
 252 private:
 253   _CodeModelItem(const _CodeModelItem &other);
 254   void operator = (const _CodeModelItem &other);
 255 };
 256
 257 class _ScopeModelItem: public _CodeModelItem
 258 {
 259 public:
 260   DECLARE_MODEL_NODE(Scope)
 261
 262   static ScopeModelItem create(CodeModel *model);
 263
 264 public:
 265   ClassList classes() const;
 266   EnumList enums() const;
 267   FunctionDefinitionList functionDefinitions() const;
 268   FunctionList functions() const;
 269   TypeAliasList typeAliases() const;
 270   VariableList variables() const;
 271
 272   void addClass(ClassModelItem item);
 273   void addEnum(EnumModelItem item);
 274   void addFunction(FunctionModelItem item);
 275   void addFunctionDefinition(FunctionDefinitionModelItem item);
 276   void addTypeAlias(TypeAliasModelItem item);
 277   void addVariable(VariableModelItem item);
 278
 279   void removeClass(ClassModelItem item);
 280   void removeEnum(EnumModelItem item);
 281   void removeFunction(FunctionModelItem item);
 282   void removeFunctionDefinition(FunctionDefinitionModelItem item);
 283   void removeTypeAlias(TypeAliasModelItem item);
 284   void removeVariable(VariableModelItem item);
 285
 286   ClassModelItem findClass(const QString &name) const;
 287   EnumModelItem findEnum(const QString &name) const;
 288   FunctionDefinitionList findFunctionDefinitions(const QString &name) const;
 289   FunctionList findFunctions(const QString &name) const;
 290   TypeAliasModelItem findTypeAlias(const QString &name) const;
 291   VariableModelItem findVariable(const QString &name) const;
 292
 293   void addEnumsDeclaration(const QString &enumsDeclaration);
 294   QStringList enumsDeclarations() const { return _M_enumsDeclarations; }
 295
 296   inline QHash<QString, ClassModelItem> classMap() const { return _M_classes; }
 297   inline QHash<QString, EnumModelItem> enumMap() const { return _M_enums; }
 298   inline QHash<QString, TypeAliasModelItem> typeAliasMap() const { return _M_typeAliases; }
 299   inline QHash<QString, VariableModelItem> variableMap() const { return _M_variables; }
 300   inline QMultiHash<QString, FunctionDefinitionModelItem> functionDefinitionMap() const { return _M_functionDefinitions; }
 301   inline QMultiHash<QString, FunctionModelItem> functionMap() const { return _M_functions; }
 302
 303   FunctionModelItem declaredFunction(FunctionModelItem item);
 304
 305 protected:
 306   _ScopeModelItem(CodeModel *model, int kind = __node_kind)
 307     : _CodeModelItem(model, kind) {}
 308
 309 private:
 310   QHash<QString, ClassModelItem> _M_classes;
 311   QHash<QString, EnumModelItem> _M_enums;
 312   QHash<QString, TypeAliasModelItem> _M_typeAliases;
 313   QHash<QString, VariableModelItem> _M_variables;
 314   QMultiHash<QString, FunctionDefinitionModelItem> _M_functionDefinitions;
 315   QMultiHash<QString, FunctionModelItem> _M_functions;
 316
 317 private:
 318   _ScopeModelItem(const _ScopeModelItem &other);
 319   void operator = (const _ScopeModelItem &other);
 320
 321   QStringList _M_enumsDeclarations;
 322 };
 323
 324 class _ClassModelItem: public _ScopeModelItem
 325 {
 326 public:
 327   DECLARE_MODEL_NODE(Class)
 328
 329   static ClassModelItem create(CodeModel *model);
 330
 331 public:
 332   QStringList baseClasses() const;
 333   QStringList baseModifiers() const;
 334
 335   void setBaseClasses(const QStringList &baseClasses);
 336   void addBaseClass(const QString &baseClass, const QString &baseModifier = QString());
 337   void removeBaseClass(const QString &baseClass);
 338
 339   void setBaseModifiers(const QStringList &baseModifiers);
 340
 341   TemplateParameterList templateParameters() const;
 342   void setTemplateParameters(const TemplateParameterList &templateParameters);
 343
 344   bool extendsClass(const QString &name) const;
 345
 346   void setClassType(CodeModel::ClassType type);
 347   CodeModel::ClassType classType() const;
 348
 349   void addPropertyDeclaration(const QString &propertyDeclaration);
 350   QStringList propertyDeclarations() const { return _M_propertyDeclarations; }
 351
 352 protected:
 353   _ClassModelItem(CodeModel *model, int kind = __node_kind)
 354     : _ScopeModelItem(model, kind), _M_classType(CodeModel::Class) {}
 355
 356 private:
 357   QStringList _M_baseClasses;
 358   QStringList _M_baseModifiers;
 359   TemplateParameterList _M_templateParameters;
 360   CodeModel::ClassType _M_classType;
 361
 362   QStringList _M_propertyDeclarations;
 363
 364 private:
 365   _ClassModelItem(const _ClassModelItem &other);
 366   void operator = (const _ClassModelItem &other);
 367 };
 368
 369 class _NamespaceModelItem: public _ScopeModelItem
 370 {
 371 public:
 372   DECLARE_MODEL_NODE(Namespace)
 373
 374   static NamespaceModelItem create(CodeModel *model);
 375
 376 public:
 377   NamespaceList namespaces() const;
 378
 379   void addNamespace(NamespaceModelItem item);
 380   void removeNamespace(NamespaceModelItem item);
 381
 382   NamespaceModelItem findNamespace(const QString &name) const;
 383
 384   inline QHash<QString, NamespaceModelItem> namespaceMap() const { return _M_namespaces; };
 385
 386 protected:
 387   _NamespaceModelItem(CodeModel *model, int kind = __node_kind)
 388     : _ScopeModelItem(model, kind) {}
 389
 390 private:
 391   QHash<QString, NamespaceModelItem> _M_namespaces;
 392
 393 private:
 394   _NamespaceModelItem(const _NamespaceModelItem &other);
 395   void operator = (const _NamespaceModelItem &other);
 396 };
 397
 398 class _FileModelItem: public _NamespaceModelItem
 399 {
 400 public:
 401   DECLARE_MODEL_NODE(File)
 402
 403   static FileModelItem create(CodeModel *model);
 404
 405 protected:
 406   _FileModelItem(CodeModel *model, int kind = __node_kind)
 407     : _NamespaceModelItem(model, kind) {}
 408
 409 private:
 410   _FileModelItem(const _FileModelItem &other);
 411   void operator = (const _FileModelItem &other);
 412 };
 413
 414 class _ArgumentModelItem: public _CodeModelItem
 415 {
 416 public:
 417   DECLARE_MODEL_NODE(Argument)
 418
 419   static ArgumentModelItem create(CodeModel *model);
 420
 421 public:
 422   TypeInfo type() const;
 423   void setType(const TypeInfo &type);
 424
 425   bool defaultValue() const;
 426   void setDefaultValue(bool defaultValue);
 427
 428   QString defaultValueExpression() const { return _M_defaultValueExpression; }
 429   void setDefaultValueExpression(const QString &expr) { _M_defaultValueExpression = expr; }
 430
 431 protected:
 432   _ArgumentModelItem(CodeModel *model, int kind = __node_kind)
 433     : _CodeModelItem(model, kind), _M_defaultValue(false) {}
 434
 435 private:
 436   TypeInfo _M_type;
 437   QString _M_defaultValueExpression;
 438   bool _M_defaultValue;
 439
 440 private:
 441   _ArgumentModelItem(const _ArgumentModelItem &other);
 442   void operator = (const _ArgumentModelItem &other);
 443 };
 444
 445 class _MemberModelItem: public _CodeModelItem
 446 {
 447 public:
 448   DECLARE_MODEL_NODE(Member)
 449
 450   bool isConstant() const;
 451   void setConstant(bool isConstant);
 452
 453   bool isVolatile() const;
 454   void setVolatile(bool isVolatile);
 455
 456   bool isStatic() const;
 457   void setStatic(bool isStatic);
 458
 459   bool isAuto() const;
 460   void setAuto(bool isAuto);
 461
 462   bool isFriend() const;
 463   void setFriend(bool isFriend);
 464
 465   bool isRegister() const;
 466   void setRegister(bool isRegister);
 467
 468   bool isExtern() const;
 469   void setExtern(bool isExtern);
 470
 471   bool isMutable() const;
 472   void setMutable(bool isMutable);
 473
 474   CodeModel::AccessPolicy accessPolicy() const;
 475   void setAccessPolicy(CodeModel::AccessPolicy accessPolicy);
 476
 477   TemplateParameterList templateParameters() const
 478   { return _M_templateParameters; }
 479
 480   void setTemplateParameters(const TemplateParameterList &templateParameters)
 481   { _M_templateParameters = templateParameters; }
 482
 483   TypeInfo type() const;
 484   void setType(const TypeInfo &type);
 485
 486 protected:
 487   _MemberModelItem(CodeModel *model, int kind)
 488     : _CodeModelItem(model, kind),
 489       _M_accessPolicy(CodeModel::Public),
 490       _M_flags(0)
 491   {}
 492
 493 private:
 494   TemplateParameterList _M_templateParameters;
 495   TypeInfo _M_type;
 496   CodeModel::AccessPolicy _M_accessPolicy;
 497   union
 498   {
 499     struct
 500     {
 501       uint _M_isConstant: 1;
 502       uint _M_isVolatile: 1;
 503       uint _M_isStatic: 1;
 504       uint _M_isAuto: 1;
 505       uint _M_isFriend: 1;
 506       uint _M_isRegister: 1;
 507       uint _M_isExtern: 1;
 508       uint _M_isMutable: 1;
 509     };
 510     uint _M_flags;
 511   };
 512
 513 };
 514
 515 class _FunctionModelItem: public _MemberModelItem
 516 {
 517 public:
 518   DECLARE_MODEL_NODE(Function)
 519
 520   static FunctionModelItem create(CodeModel *model);
 521
 522 public:
 523   ArgumentList arguments() const;
 524
 525   void addArgument(ArgumentModelItem item);
 526   void removeArgument(ArgumentModelItem item);
 527
 528   CodeModel::FunctionType functionType() const;
 529   void setFunctionType(CodeModel::FunctionType functionType);
 530
 531   bool isVirtual() const;
 532   void setVirtual(bool isVirtual);
 533
 534   bool isInline() const;
 535   void setInline(bool isInline);
 536
 537   bool isExplicit() const;
 538   void setExplicit(bool isExplicit);
 539
 540   bool isInvokable() const; // Qt
 541   void setInvokable(bool isInvokable); // Qt
 542
 543   bool isAbstract() const;
 544   void setAbstract(bool isAbstract);
 545
 546   bool isVariadics() const;
 547   void setVariadics(bool isVariadics);
 548
 549   bool isSimilar(FunctionModelItem other) const;
 550
 551 protected:
 552   _FunctionModelItem(CodeModel *model, int kind = __node_kind)
 553     : _MemberModelItem(model, kind),
 554       _M_functionType(CodeModel::Normal),
 555       _M_flags(0)
 556   {}
 557
 558 private:
 559   ArgumentList _M_arguments;
 560   CodeModel::FunctionType _M_functionType;
 561   union
 562   {
 563     struct
 564     {
 565       uint _M_isVirtual: 1;
 566       uint _M_isInline: 1;
 567       uint _M_isAbstract: 1;
 568       uint _M_isExplicit: 1;
 569       uint _M_isVariadics: 1;
 570       uint _M_isInvokable : 1; // Qt
 571     };
 572     uint _M_flags;
 573   };
 574
 575 private:
 576   _FunctionModelItem(const _FunctionModelItem &other);
 577   void operator = (const _FunctionModelItem &other);
 578 };
 579
 580 class _FunctionDefinitionModelItem: public _FunctionModelItem
 581 {
 582 public:
 583   DECLARE_MODEL_NODE(FunctionDefinition)
 584
 585   static FunctionDefinitionModelItem create(CodeModel *model);
 586
 587 protected:
 588   _FunctionDefinitionModelItem(CodeModel *model, int kind = __node_kind)
 589     : _FunctionModelItem(model, kind) {}
 590
 591 private:
 592   _FunctionDefinitionModelItem(const _FunctionDefinitionModelItem &other);
 593   void operator = (const _FunctionDefinitionModelItem &other);
 594 };
 595
 596 class _VariableModelItem: public _MemberModelItem
 597 {
 598 public:
 599   DECLARE_MODEL_NODE(Variable)
 600
 601   static VariableModelItem create(CodeModel *model);
 602
 603 protected:
 604   _VariableModelItem(CodeModel *model, int kind = __node_kind)
 605     : _MemberModelItem(model, kind)
 606   {}
 607
 608 private:
 609   _VariableModelItem(const _VariableModelItem &other);
 610   void operator = (const _VariableModelItem &other);
 611 };
 612
 613 class _TypeAliasModelItem: public _CodeModelItem
 614 {
 615 public:
 616   DECLARE_MODEL_NODE(TypeAlias)
 617
 618   static TypeAliasModelItem create(CodeModel *model);
 619
 620 public:
 621   TypeInfo type() const;
 622   void setType(const TypeInfo &type);
 623
 624 protected:
 625   _TypeAliasModelItem(CodeModel *model, int kind = __node_kind)
 626     : _CodeModelItem(model, kind) {}
 627
 628 private:
 629   TypeInfo _M_type;
 630
 631 private:
 632   _TypeAliasModelItem(const _TypeAliasModelItem &other);
 633   void operator = (const _TypeAliasModelItem &other);
 634 };
 635
 636 class _EnumModelItem: public _CodeModelItem
 637 {
 638 public:
 639   DECLARE_MODEL_NODE(Enum)
 640
 641   static EnumModelItem create(CodeModel *model);
 642
 643 public:
 644   CodeModel::AccessPolicy accessPolicy() const;
 645   void setAccessPolicy(CodeModel::AccessPolicy accessPolicy);
 646
 647   EnumeratorList enumerators() const;
 648   void addEnumerator(EnumeratorModelItem item);
 649   void removeEnumerator(EnumeratorModelItem item);
 650
 651 protected:
 652   _EnumModelItem(CodeModel *model, int kind = __node_kind)
 653     : _CodeModelItem(model, kind),
 654       _M_accessPolicy(CodeModel::Public)
 655   {}
 656
 657 private:
 658   CodeModel::AccessPolicy _M_accessPolicy;
 659   EnumeratorList _M_enumerators;
 660
 661 private:
 662   _EnumModelItem(const _EnumModelItem &other);
 663   void operator = (const _EnumModelItem &other);
 664 };
 665
 666 class _EnumeratorModelItem: public _CodeModelItem
 667 {
 668 public:
 669   DECLARE_MODEL_NODE(Enumerator)
 670
 671   static EnumeratorModelItem create(CodeModel *model);
 672
 673 public:
 674   QString value() const;
 675   void setValue(const QString &value);
 676
 677 protected:
 678   _EnumeratorModelItem(CodeModel *model, int kind = __node_kind)
 679     : _CodeModelItem(model, kind) {}
 680
 681 private:
 682   QString _M_value;
 683
 684 private:
 685   _EnumeratorModelItem(const _EnumeratorModelItem &other);
 686   void operator = (const _EnumeratorModelItem &other);
 687 };
 688
 689 class _TemplateParameterModelItem: public _CodeModelItem
 690 {
 691 public:
 692   DECLARE_MODEL_NODE(TemplateParameter)
 693
 694   static TemplateParameterModelItem create(CodeModel *model);
 695
 696 public:
 697   TypeInfo type() const;
 698   void setType(const TypeInfo &type);
 699
 700   bool defaultValue() const;
 701   void setDefaultValue(bool defaultValue);
 702
 703 protected:
 704   _TemplateParameterModelItem(CodeModel *model, int kind = __node_kind)
 705     : _CodeModelItem(model, kind), _M_defaultValue(false) {}
 706
 707 private:
 708   TypeInfo _M_type;
 709   bool _M_defaultValue;
 710
 711 private:
 712   _TemplateParameterModelItem(const _TemplateParameterModelItem &other);
 713   void operator = (const _TemplateParameterModelItem &other);
 714 };
 715
 716 template <class _Target, class _Source>
 717 _Target model_safe_cast(_Source item)
 718 {
 719   typedef typename _Target::Type * _Target_pointer;
 720   typedef typename _Source::Type * _Source_pointer;
 721
 722   _Source_pointer source = item.data();
 723   if (source && source->kind() == _Target_pointer(0)->__node_kind)
 724     {
 725       _Target ptr(static_cast<_Target_pointer>(source));
 726       return ptr;
 727     }
 728
 729   return _Target();
 730 }
 731
 732 template <typename _Target, typename _Source>
 733 _Target model_dynamic_cast(_Source item)
 734 {
 735   typedef typename _Target::Type * _Target_pointer;
 736   typedef typename _Source::Type * _Source_pointer;
 737
 738   _Source_pointer source = item.data();
 739   if (source && (source->kind() == _Target_pointer(0)->__node_kind
 740          || (int(_Target_pointer(0)->__node_kind) <= int(_CodeModelItem::KindMask)
 741              && ((source->kind() & _Target_pointer(0)->__node_kind)
 742                   == _Target_pointer(0)->__node_kind))))
 743     {
 744       _Target ptr(static_cast<_Target_pointer>(source));
 745       return ptr;
 746     }
 747
 748   return _Target();
 749 }
 750 #endif // CODEMODEL_H
 751
 752 // kate: space-indent on; indent-width 2; replace-tabs on;