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 f.m_constant; }
 128   void setConstant(bool is) { f.m_constant = is; }
 129
 130   bool isVolatile() const { return f.m_volatile; }
 131   void setVolatile(bool is) { f.m_volatile = is; }
 132
 133   bool isReference() const { return f.m_reference; }
 134   void setReference(bool is) { f.m_reference = is; }
 135
 136   int indirections() const { return f.m_indirections; }
 137   void setIndirections(int indirections) { f.m_indirections = indirections; }
 138
 139   bool isFunctionPointer() const { return f.m_functionPointer; }
 140   void setFunctionPointer(bool is) { f.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     } f;
 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   CodeModel::AccessPolicy accessPolicy() const;
 353   void setAccessPolicy(CodeModel::AccessPolicy accessPolicy);
 354
 355 protected:
 356   _ClassModelItem(CodeModel *model, int kind = __node_kind)
 357     : _ScopeModelItem(model, kind), _M_classType(CodeModel::Class) {}
 358
 359 private:
 360   QStringList _M_baseClasses;
 361   QStringList _M_baseModifiers;
 362   TemplateParameterList _M_templateParameters;
 363   CodeModel::ClassType _M_classType;
 364
 365   QStringList _M_propertyDeclarations;
 366
 367   CodeModel::AccessPolicy _M_accessPolicy;
 368 private:
 369   _ClassModelItem(const _ClassModelItem &other);
 370   void operator = (const _ClassModelItem &other);
 371 };
 372
 373 class _NamespaceModelItem: public _ScopeModelItem
 374 {
 375 public:
 376   DECLARE_MODEL_NODE(Namespace)
 377
 378   static NamespaceModelItem create(CodeModel *model);
 379
 380 public:
 381   NamespaceList namespaces() const;
 382
 383   void addNamespace(NamespaceModelItem item);
 384   void removeNamespace(NamespaceModelItem item);
 385
 386   NamespaceModelItem findNamespace(const QString &name) const;
 387
 388   inline QHash<QString, NamespaceModelItem> namespaceMap() const { return _M_namespaces; };
 389
 390 protected:
 391   _NamespaceModelItem(CodeModel *model, int kind = __node_kind)
 392     : _ScopeModelItem(model, kind) {}
 393
 394 private:
 395   QHash<QString, NamespaceModelItem> _M_namespaces;
 396
 397 private:
 398   _NamespaceModelItem(const _NamespaceModelItem &other);
 399   void operator = (const _NamespaceModelItem &other);
 400 };
 401
 402 class _FileModelItem: public _NamespaceModelItem
 403 {
 404 public:
 405   DECLARE_MODEL_NODE(File)
 406
 407   static FileModelItem create(CodeModel *model);
 408
 409 protected:
 410   _FileModelItem(CodeModel *model, int kind = __node_kind)
 411     : _NamespaceModelItem(model, kind) {}
 412
 413 private:
 414   _FileModelItem(const _FileModelItem &other);
 415   void operator = (const _FileModelItem &other);
 416 };
 417
 418 class _ArgumentModelItem: public _CodeModelItem
 419 {
 420 public:
 421   DECLARE_MODEL_NODE(Argument)
 422
 423   static ArgumentModelItem create(CodeModel *model);
 424
 425 public:
 426   TypeInfo type() const;
 427   void setType(const TypeInfo &type);
 428
 429   bool defaultValue() const;
 430   void setDefaultValue(bool defaultValue);
 431
 432   QString defaultValueExpression() const { return _M_defaultValueExpression; }
 433   void setDefaultValueExpression(const QString &expr) { _M_defaultValueExpression = expr; }
 434
 435 protected:
 436   _ArgumentModelItem(CodeModel *model, int kind = __node_kind)
 437     : _CodeModelItem(model, kind), _M_defaultValue(false) {}
 438
 439 private:
 440   TypeInfo _M_type;
 441   QString _M_defaultValueExpression;
 442   bool _M_defaultValue;
 443
 444 private:
 445   _ArgumentModelItem(const _ArgumentModelItem &other);
 446   void operator = (const _ArgumentModelItem &other);
 447 };
 448
 449 class _MemberModelItem: public _CodeModelItem
 450 {
 451 public:
 452   DECLARE_MODEL_NODE(Member)
 453
 454   bool isConstant() const;
 455   void setConstant(bool isConstant);
 456
 457   bool isVolatile() const;
 458   void setVolatile(bool isVolatile);
 459
 460   bool isStatic() const;
 461   void setStatic(bool isStatic);
 462
 463   bool isAuto() const;
 464   void setAuto(bool isAuto);
 465
 466   bool isFriend() const;
 467   void setFriend(bool isFriend);
 468
 469   bool isRegister() const;
 470   void setRegister(bool isRegister);
 471
 472   bool isExtern() const;
 473   void setExtern(bool isExtern);
 474
 475   bool isMutable() const;
 476   void setMutable(bool isMutable);
 477
 478   CodeModel::AccessPolicy accessPolicy() const;
 479   void setAccessPolicy(CodeModel::AccessPolicy accessPolicy);
 480
 481   TemplateParameterList templateParameters() const
 482   { return _M_templateParameters; }
 483
 484   void setTemplateParameters(const TemplateParameterList &templateParameters)
 485   { _M_templateParameters = templateParameters; }
 486
 487   TypeInfo type() const;
 488   void setType(const TypeInfo &type);
 489
 490 protected:
 491   _MemberModelItem(CodeModel *model, int kind)
 492     : _CodeModelItem(model, kind),
 493       _M_accessPolicy(CodeModel::Public),
 494       _M_flags(0)
 495   {}
 496
 497 private:
 498   TemplateParameterList _M_templateParameters;
 499   TypeInfo _M_type;
 500   CodeModel::AccessPolicy _M_accessPolicy;
 501
 502 public:
 503   union
 504   {
 505     struct
 506     {
 507       uint _M_isConstant: 1;
 508       uint _M_isVolatile: 1;
 509       uint _M_isStatic: 1;
 510       uint _M_isAuto: 1;
 511       uint _M_isFriend: 1;
 512       uint _M_isRegister: 1;
 513       uint _M_isExtern: 1;
 514       uint _M_isMutable: 1;
 515       uint _M_isVariadics: 1;
 516       uint _M_isVirtual: 1;
 517       uint _M_isExplicit: 1;
 518       uint _M_isInline: 1;
 519       uint _M_isAbstract: 1;
 520     } f;
 521     uint _M_flags;
 522   };
 523
 524 };
 525
 526 class _FunctionModelItem: public _MemberModelItem
 527 {
 528 public:
 529   DECLARE_MODEL_NODE(Function)
 530
 531   static FunctionModelItem create(CodeModel *model);
 532
 533 public:
 534   ArgumentList arguments() const;
 535
 536   void addArgument(ArgumentModelItem item);
 537   void removeArgument(ArgumentModelItem item);
 538
 539   CodeModel::FunctionType functionType() const;
 540   void setFunctionType(CodeModel::FunctionType functionType);
 541
 542   bool isVirtual() const;
 543   void setVirtual(bool isVirtual);
 544
 545   bool isInline() const;
 546   void setInline(bool isInline);
 547
 548   bool isExplicit() const;
 549   void setExplicit(bool isExplicit);
 550
 551   bool isInvokable() const; // Qt
 552   void setInvokable(bool isInvokable); // Qt
 553
 554   bool isAbstract() const;
 555   void setAbstract(bool isAbstract);
 556
 557   bool isVariadics() const;
 558   void setVariadics(bool isVariadics);
 559
 560   bool isSimilar(FunctionModelItem other) const;
 561
 562 protected:
 563   _FunctionModelItem(CodeModel *model, int kind = __node_kind)
 564     : _MemberModelItem(model, kind),
 565       _M_functionType(CodeModel::Normal),
 566       _M_flags(0)
 567   {}
 568
 569 private:
 570   ArgumentList _M_arguments;
 571   CodeModel::FunctionType _M_functionType;
 572   union
 573   {
 574     struct
 575     {
 576       uint _M_isVirtual: 1;
 577       uint _M_isInline: 1;
 578       uint _M_isAbstract: 1;
 579       uint _M_isExplicit: 1;
 580       uint _M_isVariadics: 1;
 581       uint _M_isInvokable : 1; // Qt
 582     };
 583     uint _M_flags;
 584   };
 585
 586 private:
 587   _FunctionModelItem(const _FunctionModelItem &other);
 588   void operator = (const _FunctionModelItem &other);
 589 };
 590
 591 class _FunctionDefinitionModelItem: public _FunctionModelItem
 592 {
 593 public:
 594   DECLARE_MODEL_NODE(FunctionDefinition)
 595
 596   static FunctionDefinitionModelItem create(CodeModel *model);
 597
 598 protected:
 599   _FunctionDefinitionModelItem(CodeModel *model, int kind = __node_kind)
 600     : _FunctionModelItem(model, kind) {}
 601
 602 private:
 603   _FunctionDefinitionModelItem(const _FunctionDefinitionModelItem &other);
 604   void operator = (const _FunctionDefinitionModelItem &other);
 605 };
 606
 607 class _VariableModelItem: public _MemberModelItem
 608 {
 609 public:
 610   DECLARE_MODEL_NODE(Variable)
 611
 612   static VariableModelItem create(CodeModel *model);
 613
 614 protected:
 615   _VariableModelItem(CodeModel *model, int kind = __node_kind)
 616     : _MemberModelItem(model, kind)
 617   {}
 618
 619 private:
 620   _VariableModelItem(const _VariableModelItem &other);
 621   void operator = (const _VariableModelItem &other);
 622 };
 623
 624 class _TypeAliasModelItem: public _CodeModelItem
 625 {
 626 public:
 627   DECLARE_MODEL_NODE(TypeAlias)
 628
 629   static TypeAliasModelItem create(CodeModel *model);
 630
 631 public:
 632   TypeInfo type() const;
 633   void setType(const TypeInfo &type);
 634
 635 protected:
 636   _TypeAliasModelItem(CodeModel *model, int kind = __node_kind)
 637     : _CodeModelItem(model, kind) {}
 638
 639 private:
 640   TypeInfo _M_type;
 641
 642 private:
 643   _TypeAliasModelItem(const _TypeAliasModelItem &other);
 644   void operator = (const _TypeAliasModelItem &other);
 645 };
 646
 647 class _EnumModelItem: public _CodeModelItem
 648 {
 649 public:
 650   DECLARE_MODEL_NODE(Enum)
 651
 652   static EnumModelItem create(CodeModel *model);
 653
 654 public:
 655   CodeModel::AccessPolicy accessPolicy() const;
 656   void setAccessPolicy(CodeModel::AccessPolicy accessPolicy);
 657
 658   EnumeratorList enumerators() const;
 659   void addEnumerator(EnumeratorModelItem item);
 660   void removeEnumerator(EnumeratorModelItem item);
 661
 662 protected:
 663   _EnumModelItem(CodeModel *model, int kind = __node_kind)
 664     : _CodeModelItem(model, kind),
 665       _M_accessPolicy(CodeModel::Public)
 666   {}
 667
 668 private:
 669   CodeModel::AccessPolicy _M_accessPolicy;
 670   EnumeratorList _M_enumerators;
 671
 672 private:
 673   _EnumModelItem(const _EnumModelItem &other);
 674   void operator = (const _EnumModelItem &other);
 675 };
 676
 677 class _EnumeratorModelItem: public _CodeModelItem
 678 {
 679 public:
 680   DECLARE_MODEL_NODE(Enumerator)
 681
 682   static EnumeratorModelItem create(CodeModel *model);
 683
 684 public:
 685   QString value() const;
 686   void setValue(const QString &value);
 687
 688 protected:
 689   _EnumeratorModelItem(CodeModel *model, int kind = __node_kind)
 690     : _CodeModelItem(model, kind) {}
 691
 692 private:
 693   QString _M_value;
 694
 695 private:
 696   _EnumeratorModelItem(const _EnumeratorModelItem &other);
 697   void operator = (const _EnumeratorModelItem &other);
 698 };
 699
 700 class _TemplateParameterModelItem: public _CodeModelItem
 701 {
 702 public:
 703   DECLARE_MODEL_NODE(TemplateParameter)
 704
 705   static TemplateParameterModelItem create(CodeModel *model);
 706
 707 public:
 708   TypeInfo type() const;
 709   void setType(const TypeInfo &type);
 710
 711   bool defaultValue() const;
 712   void setDefaultValue(bool defaultValue);
 713
 714 protected:
 715   _TemplateParameterModelItem(CodeModel *model, int kind = __node_kind)
 716     : _CodeModelItem(model, kind), _M_defaultValue(false) {}
 717
 718 private:
 719   TypeInfo _M_type;
 720   bool _M_defaultValue;
 721
 722 private:
 723   _TemplateParameterModelItem(const _TemplateParameterModelItem &other);
 724   void operator = (const _TemplateParameterModelItem &other);
 725 };
 726
 727 template <class _Target, class _Source>
 728 _Target model_safe_cast(_Source item)
 729 {
 730   typedef typename _Target::Type * _Target_pointer;
 731   typedef typename _Source::Type * _Source_pointer;
 732
 733   _Source_pointer source = item.data();
 734   if (source && source->kind() == _Target_pointer(0)->__node_kind)
 735     {
 736       _Target ptr(static_cast<_Target_pointer>(source));
 737       return ptr;
 738     }
 739
 740   return _Target();
 741 }
 742
 743 template <typename _Target, typename _Source>
 744 _Target model_dynamic_cast(_Source item)
 745 {
 746   typedef typename _Target::Type * _Target_pointer;
 747   typedef typename _Source::Type * _Source_pointer;
 748
 749   _Source_pointer source = item.data();
 750   if (source && (source->kind() == _Target_pointer(0)->__node_kind
 751          || (int(_Target_pointer(0)->__node_kind) <= int(_CodeModelItem::KindMask)
 752              && ((source->kind() & _Target_pointer(0)->__node_kind)
 753                   == _Target_pointer(0)->__node_kind))))
 754     {
 755       _Target ptr(static_cast<_Target_pointer>(source));
 756       return ptr;
 757     }
 758
 759   return _Target();
 760 }
 761 #endif // CODEMODEL_H
 762
 763 // kate: space-indent on; indent-width 2; replace-tabs on;