context.h 33.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/******************************************************************************
 *
 * Copyright (C) 1997-2014 by Dimitri van Heesch.
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation under the terms of the GNU General Public License is hereby
 * granted. No representations are made about the suitability of this software
 * for any purpose. It is provided "as is" without express or implied warranty.
 * See the GNU General Public License for more details.
 *
 * Documents produced by Doxygen are derivative works derived from the
 * input used in their production; they are not affected by this license.
 *
 */

16 17 18
#ifndef CONTEXT_H
#define CONTEXT_H

19
#include "types.h"
20
#include "template.h"
21
#include <qlist.h>
22
#include <stdio.h>
23 24 25 26

class Definition;
class ClassDef;
class ClassSDict;
27
class BaseClassList;
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
class PageDef;
class GroupDef;
class NamespaceDef;
class BaseClassList;
class NamespaceSDict;
class FileDef;
class FileList;
class FileNameList;
class DirSDict;
class DirList;
class DirDef;
class PageSDict;
class GroupSDict;
class GroupDef;
class GroupList;
43 44
struct IncludeInfo;
class MemberList;
45
class MemberSDict;
46 47 48
class MemberDef;
struct Argument;
class ArgumentList;
49 50
class MemberNameInfoSDict;
struct MemberInfo;
51 52 53
class MemberGroup;
class MemberGroupSDict;
class MemberGroupList;
54 55 56

//----------------------------------------------------

57 58 59 60 61
#define DEBUG_REF 0

/** @brief Helper class to support reference counting */
#if DEBUG_REF
class RefCountedContext
62 63
{
  public:
64 65 66 67 68
    RefCountedContext(const char *className) : m_refCount(0)
    {
      m_className=className;
      m_insideRelease = FALSE;
    }
69
    ~RefCountedContext()
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
    {
      if (!m_insideRelease) abort();
    }
    int addRef()
    {
      ++s_totalCount;
      printf("%p:%s::addRef()=%d\n",this,m_className.data(),m_refCount);
      return ++m_refCount;
    }
    int release()
    {
      --s_totalCount;
      printf("%p:%s::release()=%d\n",this,m_className.data(),m_refCount-1);
      int count = --m_refCount;
      if (count<=0)
      {
        m_insideRelease=TRUE;
        delete this;
      }
      return count;
    }
  private:
    int m_refCount;
    QCString m_className;
    bool m_insideRelease;
  public:
    static int s_totalCount;
};

#else // release version

class RefCountedContext
{
  public:
    RefCountedContext(const char *) : m_refCount(0) {}
    virtual ~RefCountedContext() {}
    int addRef() { return ++m_refCount; }
    int release()
    {
      int count = --m_refCount;
      if (count<=0)
      {
        delete this;
      }
      return count;
    }
  private:
    int m_refCount;
};
#endif


//----------------------------------------------------

class ConfigContext : public RefCountedContext, public TemplateStructIntf
{
  public:
    static ConfigContext *alloc() { return new ConfigContext; }
128 129 130

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
131 132
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
133 134

  private:
135 136
    ConfigContext();
   ~ConfigContext();
137 138 139 140 141 142
    class Private;
    Private *p;
};

//----------------------------------------------------

143
class DoxygenContext : public RefCountedContext, public TemplateStructIntf
144 145
{
  public:
146
    static DoxygenContext *alloc() { return new DoxygenContext; }
147 148 149

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
150 151
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
152 153

  private:
154
    DoxygenContext();
155
    ~DoxygenContext();
156 157 158 159 160 161
    class Private;
    Private *p;
};

//----------------------------------------------------

162
class TranslateContext : public RefCountedContext, public TemplateStructIntf
163 164
{
  public:
165
    static TranslateContext *alloc() { return new TranslateContext; }
166 167 168

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
169 170
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
171 172

  private:
173 174
    TranslateContext();
   ~TranslateContext();
175 176 177 178 179 180
    class Private;
    Private *p;
};

//----------------------------------------------------

181
class UsedFilesContext : public RefCountedContext, public TemplateListIntf
182 183
{
  public:
184
    static UsedFilesContext *alloc(ClassDef *cd) { return new UsedFilesContext(cd); }
185 186 187 188 189

    // TemplateListIntf
    virtual int count() const;
    virtual TemplateVariant at(int index) const;
    virtual TemplateListIntf::ConstIterator *createIterator() const;
190 191
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
192 193 194 195

    void addFile(FileDef *fd);

  private:
196 197 198
    UsedFilesContext(ClassDef *cd);
   ~UsedFilesContext();

199 200 201 202 203 204
    class Private;
    Private *p;
};

//----------------------------------------------------

205
class IncludeInfoContext : public RefCountedContext, public TemplateStructIntf
206 207
{
  public:
208 209
    static IncludeInfoContext *alloc(const IncludeInfo *info,SrcLangExt lang)
    { return new IncludeInfoContext(info,lang); }
210 211 212

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
213 214
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
215 216

  private:
217 218
    IncludeInfoContext(const IncludeInfo *,SrcLangExt lang);
   ~IncludeInfoContext();
219 220 221 222
    class Private;
    Private *p;
};

223 224
//----------------------------------------------------

225
class IncludeInfoListContext : public RefCountedContext, public TemplateListIntf
226 227
{
  public:
228 229
    static IncludeInfoListContext *alloc(const QList<IncludeInfo> &list,SrcLangExt lang)
    { return new IncludeInfoListContext(list,lang); }
230 231 232 233 234

    // TemplateListIntf
    virtual int count() const;
    virtual TemplateVariant at(int index) const;
    virtual TemplateListIntf::ConstIterator *createIterator() const;
235 236
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
237 238

  private:
239 240
    IncludeInfoListContext(const QList<IncludeInfo> &list,SrcLangExt lang);
   ~IncludeInfoListContext();
241 242 243 244 245
    class Private;
    Private *p;
};


246 247
//----------------------------------------------------

248
class ClassContext : public RefCountedContext, public TemplateStructIntf
249 250
{
  public:
251
    static ClassContext *alloc(ClassDef *cd) { return new ClassContext(cd); }
252 253 254

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
255 256
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
257 258

  private:
259 260
    ClassContext(ClassDef *);
   ~ClassContext();
261 262 263 264 265 266
    class Private;
    Private *p;
};

//----------------------------------------------------

267
class NamespaceContext : public RefCountedContext, public TemplateStructIntf
268 269
{
  public:
270
    static NamespaceContext *alloc(NamespaceDef *nd) { return new NamespaceContext(nd); }
271 272 273

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
274 275
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
276 277

  private:
278 279
    NamespaceContext(NamespaceDef *);
   ~NamespaceContext();
280 281 282 283 284 285
    class Private;
    Private *p;
};

//----------------------------------------------------

286
class FileContext : public RefCountedContext, public TemplateStructIntf
287 288
{
  public:
289
    static FileContext *alloc(FileDef *fd) { return new FileContext(fd); }
290 291 292

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
293 294
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
295 296

  private:
297 298
    FileContext(FileDef *);
   ~FileContext();
299 300 301 302 303
    class Private;
    Private *p;
};
//----------------------------------------------------

304
class DirContext : public RefCountedContext, public TemplateStructIntf
305 306
{
  public:
307
    static DirContext *alloc(DirDef *dd) { return new DirContext(dd); }
308 309 310

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
311 312
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
313 314

  private:
315 316
    DirContext(DirDef *);
   ~DirContext();
317 318 319 320 321 322 323
    class Private;
    Private *p;
};


//----------------------------------------------------

324
class PageContext : public RefCountedContext, public TemplateStructIntf
325 326
{
  public:
327
    static PageContext *alloc(PageDef *pd,bool isMainPage=FALSE) { return new PageContext(pd,isMainPage); }
328 329 330

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
331 332
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
333 334

  private:
335
    PageContext(PageDef *,bool isMainPage);
336
   ~PageContext();
337 338 339 340
    class Private;
    Private *p;
};

341 342
//----------------------------------------------------

343
class MemberContext : public RefCountedContext, public TemplateStructIntf
344 345
{
  public:
346
    static MemberContext *alloc(MemberDef *md) { return new MemberContext(md); }
347 348 349

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
350 351
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
352 353

  private:
354 355
    MemberContext(MemberDef *);
   ~MemberContext();
356 357 358 359 360
    class Private;
    Private *p;
};


361 362
//----------------------------------------------------

363
class ModuleContext : public RefCountedContext, public TemplateStructIntf
364 365
{
  public:
366
    static ModuleContext *alloc(GroupDef *gd) { return new ModuleContext(gd); }
367 368 369

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
370 371
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
372 373

  private:
374 375
    ModuleContext(GroupDef *);
   ~ModuleContext();
376 377 378 379 380 381
    class Private;
    Private *p;
};

//----------------------------------------------------

382
class ClassListContext : public RefCountedContext, public TemplateListIntf
383 384
{
  public:
385
    static ClassListContext *alloc() { return new ClassListContext; }
386 387 388 389 390

    // TemplateListIntf
    virtual int  count() const;
    virtual TemplateVariant at(int index) const;
    virtual TemplateListIntf::ConstIterator *createIterator() const;
391 392
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
393 394

  private:
395 396
    ClassListContext();
   ~ClassListContext();
397 398 399 400 401 402
    class Private;
    Private *p;
};

//----------------------------------------------------

403
class ClassIndexContext : public RefCountedContext, public TemplateStructIntf
404 405
{
  public:
406
    static ClassIndexContext *alloc() { return new ClassIndexContext; }
407

408 409
    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
410 411
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
412 413

  private:
414 415
    ClassIndexContext();
   ~ClassIndexContext();
416 417 418 419 420 421
    class Private;
    Private *p;
};

//----------------------------------------------------

422
class ClassInheritanceNodeContext : public RefCountedContext, public TemplateStructIntf
423 424
{
  public:
425 426
    static ClassInheritanceNodeContext *alloc(ClassDef *cd)
    { return new ClassInheritanceNodeContext(cd); }
427 428 429

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
430 431
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
432 433

    void addChildren(const BaseClassList *bcl,bool hideSuper);
434

435
  private:
436 437
    ClassInheritanceNodeContext(ClassDef *);
   ~ClassInheritanceNodeContext();
438 439 440 441 442 443
    class Private;
    Private *p;
};

//----------------------------------------------------

444
class ClassInheritanceContext : public RefCountedContext, public TemplateListIntf
445 446
{
  public:
447
    static ClassInheritanceContext *alloc() { return new ClassInheritanceContext; }
448 449 450 451 452

    // TemplateListIntf
    virtual int  count() const;
    virtual TemplateVariant at(int index) const;
    virtual TemplateListIntf::ConstIterator *createIterator() const;
453 454
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
455 456

  private:
457 458
    ClassInheritanceContext();
   ~ClassInheritanceContext();
459 460 461 462 463 464
    class Private;
    Private *p;
};

//----------------------------------------------------

465
class ClassHierarchyContext : public RefCountedContext, public TemplateStructIntf
466 467
{
  public:
468
    static ClassHierarchyContext *alloc() { return new ClassHierarchyContext; }
469 470 471

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
472 473
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
474 475

  private:
476 477
    ClassHierarchyContext();
   ~ClassHierarchyContext();
478 479 480 481 482 483
    class Private;
    Private *p;
};

//----------------------------------------------------

484
class NestingNodeContext : public RefCountedContext, public TemplateStructIntf
485 486
{
  public:
487 488 489 490
    static NestingNodeContext *alloc(const NestingNodeContext *parent,Definition *def,
                                     int index,int level,bool addClasses)
    { return new NestingNodeContext(parent,def,index,level,addClasses); }

491
    QCString id() const;
492 493 494

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
495 496
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
497 498

  private:
499 500 501
    NestingNodeContext(const NestingNodeContext *parent,
                       Definition *,int index,int level,bool addClasses);
   ~NestingNodeContext();
502 503 504 505 506 507
    class Private;
    Private *p;
};

//----------------------------------------------------

508
class NestingContext : public RefCountedContext, public TemplateListIntf
509 510
{
  public:
511 512
    static NestingContext *alloc(const NestingNodeContext *parent,int level)
    { return new NestingContext(parent,level); }
513 514 515 516 517

    // TemplateListIntf
    virtual int  count() const;
    virtual TemplateVariant at(int index) const;
    virtual TemplateListIntf::ConstIterator *createIterator() const;
518 519
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
520 521 522

    void addNamespaces(const NamespaceSDict &nsDict,bool rootOnly,bool addClasses);
    void addClasses(const ClassSDict &clDict,bool rootOnly);
523 524 525 526
    void addDirs(const DirSDict &);
    void addDirs(const DirList &);
    void addFiles(const FileNameList &);
    void addFiles(const FileList &);
527
    void addPages(const PageSDict &pages,bool rootOnly);
528 529
    void addModules(const GroupSDict &modules);
    void addModules(const GroupList &modules);
530

531
  private:
532 533
    NestingContext(const NestingNodeContext *parent,int level);
   ~NestingContext();
534 535 536 537 538 539
    class Private;
    Private *p;
};

//----------------------------------------------------

540
class ClassTreeContext : public RefCountedContext, public TemplateStructIntf
541 542
{
  public:
543
    static ClassTreeContext *alloc() { return new ClassTreeContext; }
544 545 546

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
547 548
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
549 550

  private:
551 552
    ClassTreeContext();
   ~ClassTreeContext();
553 554 555 556 557 558
    class Private;
    Private *p;
};

//----------------------------------------------------

559
class NamespaceListContext : public RefCountedContext, public TemplateListIntf
560 561
{
  public:
562
    static NamespaceListContext *alloc() { return new NamespaceListContext; }
563 564 565 566 567

    // TemplateListIntf
    virtual int  count() const;
    virtual TemplateVariant at(int index) const;
    virtual TemplateListIntf::ConstIterator *createIterator() const;
568 569
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
570 571

  private:
572 573
    NamespaceListContext();
   ~NamespaceListContext();
574 575 576 577 578 579
    class Private;
    Private *p;
};

//----------------------------------------------------

580
class NamespaceTreeContext : public RefCountedContext, public TemplateStructIntf
581 582
{
  public:
583
    static NamespaceTreeContext *alloc() { return new NamespaceTreeContext; }
584 585 586

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
587 588
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
589 590

  private:
591 592
    NamespaceTreeContext();
   ~NamespaceTreeContext();
593 594 595 596 597 598
    class Private;
    Private *p;
};

//----------------------------------------------------

599
class DirListContext : public RefCountedContext, public TemplateListIntf
600 601
{
  public:
602
    static DirListContext *alloc() { return new DirListContext; }
603 604 605 606 607

    // TemplateListIntf
    virtual int  count() const;
    virtual TemplateVariant at(int index) const;
    virtual TemplateListIntf::ConstIterator *createIterator() const;
608 609
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
610 611

  private:
612 613 614 615 616 617 618 619
    DirListContext();
   ~DirListContext();
    class Private;
    Private *p;
};

//----------------------------------------------------

620
class FileListContext : public RefCountedContext, public TemplateListIntf
621 622
{
  public:
623
    static FileListContext *alloc() { return new FileListContext; }
624 625 626 627 628

    // TemplateListIntf
    virtual int  count() const;
    virtual TemplateVariant at(int index) const;
    virtual TemplateListIntf::ConstIterator *createIterator() const;
629 630
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
631 632

  private:
633 634
    FileListContext();
   ~FileListContext();
635 636 637 638 639 640
    class Private;
    Private *p;
};

//----------------------------------------------------

641
class FileTreeContext : public RefCountedContext, public TemplateStructIntf
642 643
{
  public:
644
    static FileTreeContext *alloc() { return new FileTreeContext; }
645 646 647

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
648 649
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
650 651

  private:
652 653
    FileTreeContext();
   ~FileTreeContext();
654 655 656 657 658 659
    class Private;
    Private *p;
};

//----------------------------------------------------

660
class PageListContext : public RefCountedContext, public TemplateListIntf
661 662
{
  public:
663
    static PageListContext *alloc(const PageSDict *pages) { return new PageListContext(pages); }
664

665
    // TemplateListIntf methods
666 667 668
    virtual int  count() const;
    virtual TemplateVariant at(int index) const;
    virtual TemplateListIntf::ConstIterator *createIterator() const;
669 670
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
671

672
    void addPages(const PageSDict &pages);
673 674

  private:
675
    PageListContext(const PageSDict *pages);
676
   ~PageListContext();
677 678 679 680 681 682
    class Private;
    Private *p;
};

//----------------------------------------------------

683
class PageTreeContext : public RefCountedContext, public TemplateStructIntf
684 685
{
  public:
686
    static PageTreeContext *alloc() { return new PageTreeContext; }
687 688 689

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
690 691
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
692 693

  private:
694 695
    PageTreeContext();
   ~PageTreeContext();
696 697 698 699 700 701
    class Private;
    Private *p;
};

//----------------------------------------------------

702
class ModuleNodeContext : public RefCountedContext, public TemplateStructIntf
703 704
{
  public:
705
    static ModuleNodeContext *alloc(GroupDef *gd) { return new ModuleNodeContext(gd); }
706 707 708

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
709 710
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
711 712

  private:
713 714
    ModuleNodeContext(GroupDef *);
   ~ModuleNodeContext();
715 716 717 718 719 720
    class Private;
    Private *p;
};

//----------------------------------------------------

721
class ModuleListContext : public RefCountedContext, public TemplateListIntf
722 723
{
  public:
724
    static ModuleListContext *alloc() { return new ModuleListContext(); }
725 726 727 728 729

    // TemplateListIntf
    virtual int  count() const;
    virtual TemplateVariant at(int index) const;
    virtual TemplateListIntf::ConstIterator *createIterator() const;
730 731
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
732 733 734

    void addModules(const GroupSDict &);
    void addModules(const GroupList &);
735

736
  private:
737 738
    ModuleListContext();
   ~ModuleListContext();
739 740 741 742 743 744
    class Private;
    Private *p;
};

//----------------------------------------------------

745
class ModuleTreeContext : public RefCountedContext, public TemplateStructIntf
746 747
{
  public:
748
    static ModuleTreeContext *alloc() { return new ModuleTreeContext(); }
749 750 751

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
752 753
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
754 755

  private:
756 757
    ModuleTreeContext();
   ~ModuleTreeContext();
758 759 760 761 762 763
    class Private;
    Private *p;
};

//----------------------------------------------------

764
class ExampleListContext : public RefCountedContext, public TemplateStructIntf
765 766
{
  public:
767
    static ExampleListContext *alloc() { return new ExampleListContext(); }
768 769 770

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
771 772
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
773 774

  private:
775 776
    ExampleListContext();
   ~ExampleListContext();
777 778 779 780
    class Private;
    Private *p;
};

781 782
//----------------------------------------------------

783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839
class GlobalsIndexContext : public RefCountedContext, public TemplateStructIntf
{
  public:
    static GlobalsIndexContext *alloc() { return new GlobalsIndexContext(); }

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }

  private:
    GlobalsIndexContext();
   ~GlobalsIndexContext();
    class Private;
    Private *p;
};

//----------------------------------------------------

class ClassMembersIndexContext : public RefCountedContext, public TemplateStructIntf
{
  public:
    static ClassMembersIndexContext *alloc() { return new ClassMembersIndexContext(); }

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }

  private:
    ClassMembersIndexContext();
   ~ClassMembersIndexContext();
    class Private;
    Private *p;
};

//----------------------------------------------------

class NamespaceMembersIndexContext : public RefCountedContext, public TemplateStructIntf
{
  public:
    static NamespaceMembersIndexContext *alloc() { return new NamespaceMembersIndexContext(); }

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }

  private:
    NamespaceMembersIndexContext();
   ~NamespaceMembersIndexContext();
    class Private;
    Private *p;
};

//----------------------------------------------------

840
class NavPathElemContext : public RefCountedContext, public TemplateStructIntf
841 842
{
  public:
843
    static NavPathElemContext *alloc(Definition *def) { return new NavPathElemContext(def); }
844 845 846

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
847 848
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
849 850

  private:
851 852
    NavPathElemContext(Definition *def);
   ~NavPathElemContext();
853 854 855 856 857
    class Private;
    Private *p;
};


858 859
//----------------------------------------------------

860
class InheritanceNodeContext : public RefCountedContext, public TemplateStructIntf
861 862
{
  public:
863 864
    static InheritanceNodeContext *alloc(ClassDef *cd,const QCString &name)
    { return new InheritanceNodeContext(cd,name); }
865 866 867

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
868 869
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
870 871

  private:
872 873
    InheritanceNodeContext(ClassDef *cd,const QCString &name);
   ~InheritanceNodeContext();
874 875 876 877 878 879
    class Private;
    Private *p;
};

//----------------------------------------------------

880
class InheritanceListContext : public RefCountedContext, public TemplateListIntf
881 882
{
  public:
883 884
    static InheritanceListContext *alloc(const BaseClassList *list,bool baseClasses)
    { return new InheritanceListContext(list,baseClasses); }
885 886 887 888 889

    // TemplateListIntf
    virtual int  count() const;
    virtual TemplateVariant at(int index) const;
    virtual TemplateListIntf::ConstIterator *createIterator() const;
890 891
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
892 893

  private:
894 895
    InheritanceListContext(const BaseClassList *list,bool baseClasses);
   ~InheritanceListContext();
896 897 898 899 900 901
    class Private;
    Private *p;
};

//----------------------------------------------------

902
class MemberListContext : public RefCountedContext, public TemplateListIntf
903 904
{
  public:
905 906 907 908 909 910
    static MemberListContext *alloc()
    { return new MemberListContext; }
    static MemberListContext *alloc(const MemberList *ml)
    { return new MemberListContext(ml); }
    static MemberListContext *alloc(MemberSDict *ml,bool doSort)
    { return new MemberListContext(ml,doSort); }
911 912 913 914 915

    // TemplateListIntf
    virtual int  count() const;
    virtual TemplateVariant at(int index) const;
    virtual TemplateListIntf::ConstIterator *createIterator() const;
916 917
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
918 919

  private:
920 921 922 923
    MemberListContext();
    MemberListContext(const MemberList *ml);
    MemberListContext(MemberSDict *ml,bool doSort);
   ~MemberListContext();
924 925 926 927
    class Private;
    Private *p;
};

928 929
//----------------------------------------------------

930
class MemberGroupInfoContext : public RefCountedContext, public TemplateStructIntf
931 932
{
  public:
933 934
    static MemberGroupInfoContext *alloc(Definition *def,const QCString &relPath,const MemberGroup *mg)
    { return new MemberGroupInfoContext(def,relPath,mg); }
935 936 937

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
938 939
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
940 941

  private:
942 943
    MemberGroupInfoContext(Definition *def,const QCString &relPath,const MemberGroup *mg);
   ~MemberGroupInfoContext();
944 945 946 947 948 949
    class Private;
    Private *p;
};

//----------------------------------------------------

950
class MemberGroupListContext : public RefCountedContext, public TemplateListIntf
951 952
{
  public:
953 954 955 956 957 958
    static MemberGroupListContext *alloc()
    { return new MemberGroupListContext; }
    static MemberGroupListContext *alloc(Definition *def,const QCString &relPath,const MemberGroupList *list)
    { return new MemberGroupListContext(def,relPath,list); }
    static MemberGroupListContext *alloc(Definition *def,const QCString &relPath,const MemberGroupSDict *dict,bool subGrouping)
    { return new MemberGroupListContext(def,relPath,dict,subGrouping); }
959 960 961 962 963

    // TemplateListIntf
    virtual int  count() const;
    virtual TemplateVariant at(int index) const;
    virtual TemplateListIntf::ConstIterator *createIterator() const;
964 965
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
966 967

  private:
968 969 970 971
    MemberGroupListContext();
    MemberGroupListContext(Definition *def,const QCString &relPath,const MemberGroupList *list);
    MemberGroupListContext(Definition *def,const QCString &relPath,const MemberGroupSDict *mgDict,bool subGrouping);
   ~MemberGroupListContext();
972 973 974 975 976
    class Private;
    Private *p;
};


977 978
//----------------------------------------------------

979
class MemberListInfoContext : public RefCountedContext, public TemplateStructIntf
980 981
{
  public:
982
    static MemberListInfoContext *alloc(Definition *def,const QCString &relPath,
983
                          const MemberList *ml,const QCString &title,
984 985
                          const QCString &subtitle=QCString())
    { return new MemberListInfoContext(def,relPath,ml,title,subtitle); }
986 987 988

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
989 990
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
991 992

  private:
993 994 995 996
    MemberListInfoContext(Definition *def,const QCString &relPath,
                          const MemberList *ml,const QCString &title,
                          const QCString &subtitle=QCString());
   ~MemberListInfoContext();
997 998 999 1000 1001 1002
    class Private;
    Private *p;
};

//----------------------------------------------------

1003
class MemberInfoContext : public RefCountedContext, public TemplateStructIntf
1004 1005
{
  public:
1006
    static MemberInfoContext *alloc(const MemberInfo *mi) { return new MemberInfoContext(mi); }
1007 1008 1009

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
1010 1011
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
1012 1013

  private:
1014 1015
    MemberInfoContext(const MemberInfo *mi);
   ~MemberInfoContext();
1016 1017 1018 1019 1020 1021
    class Private;
    Private *p;
};

//----------------------------------------------------

1022
class InheritedMemberInfoContext : public RefCountedContext, public TemplateStructIntf
1023 1024
{
  public:
1025 1026
    static InheritedMemberInfoContext *alloc(ClassDef *cd,MemberList *ml,const QCString &title)
    { return new InheritedMemberInfoContext(cd,ml,title); }
1027 1028 1029

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
1030 1031
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
1032 1033

  private:
1034 1035
    InheritedMemberInfoContext(ClassDef *cd,MemberList *ml,const QCString &title);
   ~InheritedMemberInfoContext();
1036 1037 1038 1039 1040 1041
    class Private;
    Private *p;
};

//----------------------------------------------------

1042
class InheritedMemberInfoListContext : public RefCountedContext, public TemplateListIntf
1043 1044
{
  public:
1045
    static InheritedMemberInfoListContext *alloc() { return new InheritedMemberInfoListContext; }
1046 1047 1048 1049 1050 1051
    void addMemberList(ClassDef *cd,MemberListType lt,const QCString &title,bool additionalList=TRUE);

    // TemplateListIntf
    virtual int  count() const;
    virtual TemplateVariant at(int index) const;
    virtual TemplateListIntf::ConstIterator *createIterator() const;
1052 1053
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
1054 1055

  private:
1056 1057
    InheritedMemberInfoListContext();
   ~InheritedMemberInfoListContext();
1058 1059 1060 1061 1062 1063
    class Private;
    Private *p;
};

//----------------------------------------------------

1064
class AllMembersListContext : public RefCountedContext, public TemplateListIntf
1065 1066
{
  public:
1067 1068 1069 1070
    static AllMembersListContext *alloc()
    { return new AllMembersListContext; }
    static AllMembersListContext *alloc(const MemberNameInfoSDict *ml)
    { return new AllMembersListContext(ml); }
1071 1072 1073 1074 1075

    // TemplateListIntf
    virtual int  count() const;
    virtual TemplateVariant at(int index) const;
    virtual TemplateListIntf::ConstIterator *createIterator() const;
1076 1077
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
1078 1079

  private:
1080 1081 1082
    AllMembersListContext();
    AllMembersListContext(const MemberNameInfoSDict *ml);
   ~AllMembersListContext();
1083 1084 1085 1086 1087 1088
    class Private;
    Private *p;
};

//----------------------------------------------------

1089
class ArgumentContext : public RefCountedContext, public TemplateStructIntf
1090 1091
{
  public:
1092 1093
    static ArgumentContext *alloc(const Argument *arg,Definition *def,const QCString &relPath)
    { return new ArgumentContext(arg,def,relPath); }
1094 1095 1096

    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
1097 1098
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
1099 1100

  private:
1101 1102
    ArgumentContext(const Argument *arg,Definition *def,const QCString &relPath);
   ~ArgumentContext();
1103 1104 1105 1106 1107 1108
    class Private;
    Private *p;
};

//----------------------------------------------------

1109
class ArgumentListContext : public RefCountedContext, public TemplateListIntf
1110 1111
{
  public:
1112 1113 1114
    static ArgumentListContext *alloc() { return new ArgumentListContext; }
    static ArgumentListContext *alloc(const ArgumentList *al,Definition *def,const QCString &relPath)
    { return new ArgumentListContext(al,def,relPath); }
1115 1116 1117 1118 1119

    // TemplateListIntf
    virtual int  count() const;
    virtual TemplateVariant at(int index) const;
    virtual TemplateListIntf::ConstIterator *createIterator() const;
1120 1121
    virtual int addRef()  { return RefCountedContext::addRef(); }
    virtual int release() { return RefCountedContext::release(); }
1122 1123

  private:
1124 1125 1126
    ArgumentListContext();
    ArgumentListContext(const ArgumentList *al,Definition *def,const QCString &relPath);
   ~ArgumentListContext();
1127 1128 1129 1130 1131 1132
    class Private;
    Private *p;
};

//----------------------------------------------------

1133 1134 1135
void generateOutputViaTemplate();

#endif