Skip to content

D
doxverilog
Commit ff00706a authored by Dimitri van Heesch's avatar Dimitri van Heesch
Browse files
Options

Added reference counting for all context objects

parent 425e64e2
Hide whitespace changes
Inline Side-by-side
Showing with 1119 additions and 723 deletions
src/context.cpp
View file @ ff00706a
This source diff could not be displayed because it is too large. You can view the blob instead.
src/context.h
View file @ ff00706a
......@@ -4,6 +4,7 @@
#include "types.h"
#include "template.h"
#include <qlist.h>
#include <stdio.h>
class Definition;
class ClassDef;
......@@ -38,102 +39,190 @@ class MemberGroupList;
//----------------------------------------------------
class ConfigContext : public TemplateStructIntf
#define DEBUG_REF 0
/** @brief Helper class to support reference counting */
#if DEBUG_REF
class RefCountedContext
{
public:
ConfigContext();
~ConfigContext();
RefCountedContext(const char *className) : m_refCount(0)
{
m_className=className;
m_insideRelease = FALSE;
}
virtual ~RefCountedContext()
{
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; }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
ConfigContext();
~ConfigContext();
class Private;
Private *p;
};
//----------------------------------------------------
class DoxygenContext : public TemplateStructIntf
class DoxygenContext : public RefCountedContext, public TemplateStructIntf
{
public:
DoxygenContext();
~DoxygenContext();
static DoxygenContext *alloc() { return new DoxygenContext; }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
DoxygenContext();
~DoxygenContext();
class Private;
Private *p;
};
//----------------------------------------------------
class TranslateContext : public TemplateStructIntf
class TranslateContext : public RefCountedContext, public TemplateStructIntf
{
public:
TranslateContext();
~TranslateContext();
static TranslateContext *alloc() { return new TranslateContext; }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
TranslateContext();
~TranslateContext();
class Private;
Private *p;
};
//----------------------------------------------------
class UsedFilesContext : public TemplateListIntf
class UsedFilesContext : public RefCountedContext, public TemplateListIntf
{
public:
UsedFilesContext(ClassDef *cd);
~UsedFilesContext();
static UsedFilesContext *alloc(ClassDef *cd) { return new UsedFilesContext(cd); }
// TemplateListIntf
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
void addFile(FileDef *fd);
private:
UsedFilesContext(ClassDef *cd);
~UsedFilesContext();
class Private;
Private *p;
};
//----------------------------------------------------
class IncludeInfoContext : public TemplateStructIntf
class IncludeInfoContext : public RefCountedContext, public TemplateStructIntf
{
public:
IncludeInfoContext(const IncludeInfo *,SrcLangExt lang);
~IncludeInfoContext();
static IncludeInfoContext *alloc(const IncludeInfo *info,SrcLangExt lang)
{ return new IncludeInfoContext(info,lang); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
IncludeInfoContext(const IncludeInfo *,SrcLangExt lang);
~IncludeInfoContext();
class Private;
Private *p;
};
//----------------------------------------------------
class IncludeInfoListContext : public TemplateListIntf
class IncludeInfoListContext : public RefCountedContext, public TemplateListIntf
{
public:
IncludeInfoListContext(const QList<IncludeInfo> &list,SrcLangExt lang);
~IncludeInfoListContext();
static IncludeInfoListContext *alloc(const QList<IncludeInfo> &list,SrcLangExt lang)
{ return new IncludeInfoListContext(list,lang); }
// TemplateListIntf
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
IncludeInfoListContext(const QList<IncludeInfo> &list,SrcLangExt lang);
~IncludeInfoListContext();
class Private;
Private *p;
};
......@@ -141,63 +230,75 @@ class IncludeInfoListContext : public TemplateListIntf
//----------------------------------------------------
class ClassContext : public TemplateStructIntf
class ClassContext : public RefCountedContext, public TemplateStructIntf
{
public:
ClassContext(ClassDef *);
~ClassContext();
static ClassContext *alloc(ClassDef *cd) { return new ClassContext(cd); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
ClassContext(ClassDef *);
~ClassContext();
class Private;
Private *p;
};
//----------------------------------------------------
class NamespaceContext : public TemplateStructIntf
class NamespaceContext : public RefCountedContext, public TemplateStructIntf
{
public:
NamespaceContext(NamespaceDef *);
~NamespaceContext();
static NamespaceContext *alloc(NamespaceDef *nd) { return new NamespaceContext(nd); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
NamespaceContext(NamespaceDef *);
~NamespaceContext();
class Private;
Private *p;
};
//----------------------------------------------------
class FileContext : public TemplateStructIntf
class FileContext : public RefCountedContext, public TemplateStructIntf
{
public:
FileContext(FileDef *);
~FileContext();
static FileContext *alloc(FileDef *fd) { return new FileContext(fd); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
FileContext(FileDef *);
~FileContext();
class Private;
Private *p;
};
//----------------------------------------------------
class DirContext : public TemplateStructIntf
class DirContext : public RefCountedContext, public TemplateStructIntf
{
public:
DirContext(DirDef *);
~DirContext();
static DirContext *alloc(DirDef *dd) { return new DirContext(dd); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
DirContext(DirDef *);
~DirContext();
class Private;
Private *p;
};
......@@ -205,32 +306,38 @@ class DirContext : public TemplateStructIntf
//----------------------------------------------------
class PageContext : public TemplateStructIntf
class PageContext : public RefCountedContext, public TemplateStructIntf
{
public:
PageContext(PageDef *);
~PageContext();
static PageContext *alloc(PageDef *pd) { return new PageContext(pd); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
PageContext(PageDef *);
~PageContext();
class Private;
Private *p;
};
//----------------------------------------------------
class MemberContext : public TemplateStructIntf
class MemberContext : public RefCountedContext, public TemplateStructIntf
{
public:
MemberContext(MemberDef *);
~MemberContext();
static MemberContext *alloc(MemberDef *md) { return new MemberContext(md); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
MemberContext(MemberDef *);
~MemberContext();
class Private;
Private *p;
};
......@@ -238,159 +345,190 @@ class MemberContext : public TemplateStructIntf
//----------------------------------------------------
class ModuleContext : public TemplateStructIntf
class ModuleContext : public RefCountedContext, public TemplateStructIntf
{
public:
ModuleContext(GroupDef *);
~ModuleContext();
static ModuleContext *alloc(GroupDef *gd) { return new ModuleContext(gd); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
ModuleContext(GroupDef *);
~ModuleContext();
class Private;
Private *p;
};
//----------------------------------------------------
class NestedClassListContext : public TemplateListIntf
class NestedClassListContext : public RefCountedContext, public TemplateListIntf
{
public:
NestedClassListContext();
~NestedClassListContext();
static NestedClassListContext *alloc() { return new NestedClassListContext; }
// TemplateListIntf
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
void append(ClassDef *cd);
private:
NestedClassListContext();
~NestedClassListContext();
class Private;
Private *p;
};
//----------------------------------------------------
class NestedNamespaceListContext : public TemplateListIntf
class NestedNamespaceListContext : public RefCountedContext, public TemplateListIntf
{
public:
NestedNamespaceListContext();
~NestedNamespaceListContext();
static NestedNamespaceListContext *alloc() { return new NestedNamespaceListContext; }
// TemplateListIntf
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
void append(NamespaceDef *cd);
private:
NestedNamespaceListContext();
~NestedNamespaceListContext();
class Private;
Private *p;
};
//----------------------------------------------------
class ClassListContext : public TemplateListIntf
class ClassListContext : public RefCountedContext, public TemplateListIntf
{
public:
ClassListContext();
~ClassListContext();
static ClassListContext *alloc() { return new ClassListContext; }
// TemplateListIntf
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
ClassListContext();
~ClassListContext();
class Private;
Private *p;
};
//----------------------------------------------------
class ClassInheritanceNodeContext : public TemplateStructIntf
class ClassInheritanceNodeContext : public RefCountedContext, public TemplateStructIntf
{
public:
ClassInheritanceNodeContext(ClassDef *);
~ClassInheritanceNodeContext();
static ClassInheritanceNodeContext *alloc(ClassDef *cd)
{ return new ClassInheritanceNodeContext(cd); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
void addChildren(const BaseClassList *bcl,bool hideSuper);
private:
ClassInheritanceNodeContext(ClassDef *);
~ClassInheritanceNodeContext();
class Private;
Private *p;
};
//----------------------------------------------------
class ClassInheritanceContext : public TemplateListIntf
class ClassInheritanceContext : public RefCountedContext, public TemplateListIntf
{
public:
ClassInheritanceContext();
~ClassInheritanceContext();
static ClassInheritanceContext *alloc() { return new ClassInheritanceContext; }
// TemplateListIntf
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
ClassInheritanceContext();
~ClassInheritanceContext();
class Private;
Private *p;
};
//----------------------------------------------------
class ClassHierarchyContext : public TemplateStructIntf
class ClassHierarchyContext : public RefCountedContext, public TemplateStructIntf
{
public:
ClassHierarchyContext();
~ClassHierarchyContext();
static ClassHierarchyContext *alloc() { return new ClassHierarchyContext; }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
ClassHierarchyContext();
~ClassHierarchyContext();
class Private;
Private *p;
};
//----------------------------------------------------
class NestingNodeContext : public TemplateStructIntf
class NestingNodeContext : public RefCountedContext, public TemplateStructIntf
{
public:
NestingNodeContext(const NestingNodeContext *parent,
Definition *,int index,int level,bool addClasses);
~NestingNodeContext();
static NestingNodeContext *alloc(const NestingNodeContext *parent,Definition *def,
int index,int level,bool addClasses)
{ return new NestingNodeContext(parent,def,index,level,addClasses); }
QCString id() const;
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
NestingNodeContext(const NestingNodeContext *parent,
Definition *,int index,int level,bool addClasses);
~NestingNodeContext();
class Private;
Private *p;
};
//----------------------------------------------------
class NestingContext : public TemplateListIntf
class NestingContext : public RefCountedContext, public TemplateListIntf
{
public:
NestingContext(const NestingNodeContext *parent,int level);
~NestingContext();
static NestingContext *alloc(const NestingNodeContext *parent,int level)
{ return new NestingContext(parent,level); }
// TemplateListIntf
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
void addNamespaces(const NamespaceSDict &nsDict,bool rootOnly,bool addClasses);
void addClasses(const ClassSDict &clDict,bool rootOnly);
......@@ -398,302 +536,310 @@ class NestingContext : public TemplateListIntf
void addDirs(const DirList &);
void addFiles(const FileNameList &);
void addFiles(const FileList &);
private:
NestingContext(const NestingNodeContext *parent,int level);
~NestingContext();
class Private;
Private *p;
};
//----------------------------------------------------
class ClassTreeContext : public TemplateStructIntf
class ClassTreeContext : public RefCountedContext, public TemplateStructIntf
{
public:
ClassTreeContext();
~ClassTreeContext();
static ClassTreeContext *alloc() { return new ClassTreeContext; }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
ClassTreeContext();
~ClassTreeContext();
class Private;
Private *p;
};
//----------------------------------------------------
class NamespaceListContext : public TemplateListIntf
class NamespaceListContext : public RefCountedContext, public TemplateListIntf
{
public:
NamespaceListContext();
~NamespaceListContext();
static NamespaceListContext *alloc() { return new NamespaceListContext; }
// TemplateListIntf
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
NamespaceListContext();
~NamespaceListContext();
class Private;
Private *p;
};
//----------------------------------------------------
class NamespaceTreeContext : public TemplateStructIntf
{
public:
NamespaceTreeContext();
~NamespaceTreeContext();
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
private:
class Private;
Private *p;
};
//----------------------------------------------------
#if 0
class DirFileNodeContext : public TemplateStructIntf
class NamespaceTreeContext : public RefCountedContext, public TemplateStructIntf
{
public:
DirFileNodeContext(const DirFileNodeContext *parent,
Definition *,int index,int level);
~DirFileNodeContext();
QCString id() const;
static NamespaceTreeContext *alloc() { return new NamespaceTreeContext; }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
NamespaceTreeContext();
~NamespaceTreeContext();
class Private;
Private *p;
};
//----------------------------------------------------
class DirFileContext : public TemplateListIntf
class DirListContext : public RefCountedContext, public TemplateListIntf
{
public:
DirFileContext(const DirFileNodeContext *parent,int level);
~DirFileContext();
static DirListContext *alloc() { return new DirListContext; }
// TemplateListIntf
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
void addDirs(const DirSDict &);
void addDirs(const DirList &);
void addFiles(const FileNameList &);
void addFiles(const FileList &);
private:
class Private;
Private *p;
};
#endif
//----------------------------------------------------
class DirListContext : public TemplateListIntf
{
public:
DirListContext();
~DirListContext();
// TemplateListIntf
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
private:
class Private;
Private *p;
};
//----------------------------------------------------
class FileListContext : public TemplateListIntf
class FileListContext : public RefCountedContext, public TemplateListIntf
{
public:
FileListContext();
~FileListContext();
static FileListContext *alloc() { return new FileListContext; }
// TemplateListIntf
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
FileListContext();
~FileListContext();
class Private;
Private *p;
};
//----------------------------------------------------
class FileTreeContext : public TemplateStructIntf
class FileTreeContext : public RefCountedContext, public TemplateStructIntf
{
public:
FileTreeContext();
~FileTreeContext();
static FileTreeContext *alloc() { return new FileTreeContext; }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
FileTreeContext();
~FileTreeContext();
class Private;
Private *p;
};
//----------------------------------------------------
class PageNodeContext : public TemplateStructIntf
class PageNodeContext : public RefCountedContext, public TemplateStructIntf
{
public:
PageNodeContext(PageDef *);
~PageNodeContext();
static PageNodeContext *alloc(PageDef *pd) { return new PageNodeContext(pd); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
PageNodeContext(PageDef *);
~PageNodeContext();
class Private;
Private *p;
};
//----------------------------------------------------
class PageNodeListContext : public TemplateListIntf
class PageNodeListContext : public RefCountedContext, public TemplateListIntf
{
public:
PageNodeListContext();
~PageNodeListContext();
static PageNodeListContext *alloc() { return new PageNodeListContext; }
// TemplateListIntf
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
void addPages(const PageSDict &,bool rootOnly);
private:
PageNodeListContext();
~PageNodeListContext();
class Private;
Private *p;
};
//----------------------------------------------------
class PageListContext : public TemplateStructIntf
class PageListContext : public RefCountedContext, public TemplateStructIntf
{
public:
PageListContext();
~PageListContext();
static PageListContext *alloc() { return new PageListContext; }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
PageListContext();
~PageListContext();
class Private;
Private *p;
};
//----------------------------------------------------
class PageTreeContext : public TemplateStructIntf
class PageTreeContext : public RefCountedContext, public TemplateStructIntf
{
public:
PageTreeContext();
~PageTreeContext();
static PageTreeContext *alloc() { return new PageTreeContext; }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
PageTreeContext();
~PageTreeContext();
class Private;
Private *p;
};
//----------------------------------------------------
class ModuleNodeContext : public TemplateStructIntf
class ModuleNodeContext : public RefCountedContext, public TemplateStructIntf
{
public:
ModuleNodeContext(GroupDef *);
~ModuleNodeContext();
static ModuleNodeContext *alloc(GroupDef *gd) { return new ModuleNodeContext(gd); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
ModuleNodeContext(GroupDef *);
~ModuleNodeContext();
class Private;
Private *p;
};
//----------------------------------------------------
class ModuleListContext : public TemplateListIntf
class ModuleListContext : public RefCountedContext, public TemplateListIntf
{
public:
ModuleListContext();
~ModuleListContext();
static ModuleListContext *alloc() { return new ModuleListContext(); }
// TemplateListIntf
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
void addModules(const GroupSDict &);
void addModules(const GroupList &);
private:
ModuleListContext();
~ModuleListContext();
class Private;
Private *p;
};
//----------------------------------------------------
class ModuleTreeContext : public TemplateStructIntf
class ModuleTreeContext : public RefCountedContext, public TemplateStructIntf
{
public:
ModuleTreeContext();
~ModuleTreeContext();
static ModuleTreeContext *alloc() { return new ModuleTreeContext(); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
ModuleTreeContext();
~ModuleTreeContext();
class Private;
Private *p;
};
//----------------------------------------------------
class ExampleListContext : public TemplateStructIntf
class ExampleListContext : public RefCountedContext, public TemplateStructIntf
{
public:
ExampleListContext();
~ExampleListContext();
static ExampleListContext *alloc() { return new ExampleListContext(); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
ExampleListContext();
~ExampleListContext();
class Private;
Private *p;
};
//----------------------------------------------------
class NavPathElemContext : public TemplateStructIntf
class NavPathElemContext : public RefCountedContext, public TemplateStructIntf
{
public:
NavPathElemContext(Definition *def);
~NavPathElemContext();
static NavPathElemContext *alloc(Definition *def) { return new NavPathElemContext(def); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
NavPathElemContext(Definition *def);
~NavPathElemContext();
class Private;
Private *p;
};
......@@ -701,90 +847,118 @@ class NavPathElemContext : public TemplateStructIntf
//----------------------------------------------------
class InheritanceNodeContext : public TemplateStructIntf
class InheritanceNodeContext : public RefCountedContext, public TemplateStructIntf
{
public:
InheritanceNodeContext(ClassDef *cd,const QCString &name);
~InheritanceNodeContext();
static InheritanceNodeContext *alloc(ClassDef *cd,const QCString &name)
{ return new InheritanceNodeContext(cd,name); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
InheritanceNodeContext(ClassDef *cd,const QCString &name);
~InheritanceNodeContext();
class Private;
Private *p;
};
//----------------------------------------------------
class InheritanceListContext : public TemplateListIntf
class InheritanceListContext : public RefCountedContext, public TemplateListIntf
{
public:
InheritanceListContext(const BaseClassList *list,bool baseClasses);
~InheritanceListContext();
static InheritanceListContext *alloc(const BaseClassList *list,bool baseClasses)
{ return new InheritanceListContext(list,baseClasses); }
// TemplateListIntf
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
InheritanceListContext(const BaseClassList *list,bool baseClasses);
~InheritanceListContext();
class Private;
Private *p;
};
//----------------------------------------------------
class MemberListContext : public TemplateListIntf
class MemberListContext : public RefCountedContext, public TemplateListIntf
{
public:
MemberListContext();
MemberListContext(const MemberList *ml);
MemberListContext(MemberSDict *ml,bool doSort);
~MemberListContext();
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); }
// TemplateListIntf
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
MemberListContext();
MemberListContext(const MemberList *ml);
MemberListContext(MemberSDict *ml,bool doSort);
~MemberListContext();
class Private;
Private *p;
};
//----------------------------------------------------
class MemberGroupInfoContext : public TemplateStructIntf
class MemberGroupInfoContext : public RefCountedContext, public TemplateStructIntf
{
public:
MemberGroupInfoContext(Definition *def,const QCString &relPath,const MemberGroup *mg);
~MemberGroupInfoContext();
static MemberGroupInfoContext *alloc(Definition *def,const QCString &relPath,const MemberGroup *mg)
{ return new MemberGroupInfoContext(def,relPath,mg); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
MemberGroupInfoContext(Definition *def,const QCString &relPath,const MemberGroup *mg);
~MemberGroupInfoContext();
class Private;
Private *p;
};
//----------------------------------------------------
class MemberGroupListContext : public TemplateListIntf
class MemberGroupListContext : public RefCountedContext, public TemplateListIntf
{
public:
MemberGroupListContext();
MemberGroupListContext(Definition *def,const QCString &relPath,const MemberGroupList *list);
MemberGroupListContext(Definition *def,const QCString &relPath,const MemberGroupSDict *mgDict,bool subGrouping);
~MemberGroupListContext();
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); }
// TemplateListIntf
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
MemberGroupListContext();
MemberGroupListContext(Definition *def,const QCString &relPath,const MemberGroupList *list);
MemberGroupListContext(Definition *def,const QCString &relPath,const MemberGroupSDict *mgDict,bool subGrouping);
~MemberGroupListContext();
class Private;
Private *p;
};
......@@ -792,123 +966,154 @@ class MemberGroupListContext : public TemplateListIntf
//----------------------------------------------------
class MemberListInfoContext : public TemplateStructIntf
class MemberListInfoContext : public RefCountedContext, public TemplateStructIntf
{
public:
MemberListInfoContext(Definition *def,const QCString &relPath,
static MemberListInfoContext *alloc(Definition *def,const QCString &relPath,
const MemberList *ml,const QCString &title,
const QCString &subtitle=QCString());
~MemberListInfoContext();
const QCString &subtitle=QCString())
{ return new MemberListInfoContext(def,relPath,ml,title,subtitle); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
MemberListInfoContext(Definition *def,const QCString &relPath,
const MemberList *ml,const QCString &title,
const QCString &subtitle=QCString());
~MemberListInfoContext();
class Private;
Private *p;
};
//----------------------------------------------------
class MemberInfoContext : public TemplateStructIntf
class MemberInfoContext : public RefCountedContext, public TemplateStructIntf
{
public:
MemberInfoContext(const MemberInfo *mi);
~MemberInfoContext();
static MemberInfoContext *alloc(const MemberInfo *mi) { return new MemberInfoContext(mi); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
MemberInfoContext(const MemberInfo *mi);
~MemberInfoContext();
class Private;
Private *p;
};
//----------------------------------------------------
class InheritedMemberInfoContext : public TemplateStructIntf
class InheritedMemberInfoContext : public RefCountedContext, public TemplateStructIntf
{
public:
InheritedMemberInfoContext(ClassDef *cd,MemberList *ml,const QCString &title);
~InheritedMemberInfoContext();
static InheritedMemberInfoContext *alloc(ClassDef *cd,MemberList *ml,const QCString &title)
{ return new InheritedMemberInfoContext(cd,ml,title); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
InheritedMemberInfoContext(ClassDef *cd,MemberList *ml,const QCString &title);
~InheritedMemberInfoContext();
class Private;
Private *p;
};
//----------------------------------------------------
class InheritedMemberInfoListContext : public TemplateListIntf
class InheritedMemberInfoListContext : public RefCountedContext, public TemplateListIntf
{
public:
InheritedMemberInfoListContext();
static InheritedMemberInfoListContext *alloc() { return new InheritedMemberInfoListContext; }
void addMemberList(ClassDef *cd,MemberListType lt,const QCString &title,bool additionalList=TRUE);
~InheritedMemberInfoListContext();
// TemplateListIntf
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
InheritedMemberInfoListContext();
~InheritedMemberInfoListContext();
class Private;
Private *p;
};
//----------------------------------------------------
class AllMembersListContext : public TemplateListIntf
class AllMembersListContext : public RefCountedContext, public TemplateListIntf
{
public:
AllMembersListContext();
AllMembersListContext(const MemberNameInfoSDict *ml);
~AllMembersListContext();
static AllMembersListContext *alloc()
{ return new AllMembersListContext; }
static AllMembersListContext *alloc(const MemberNameInfoSDict *ml)
{ return new AllMembersListContext(ml); }
// TemplateListIntf
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
AllMembersListContext();
AllMembersListContext(const MemberNameInfoSDict *ml);
~AllMembersListContext();
class Private;
Private *p;
};
//----------------------------------------------------
class ArgumentContext : public TemplateStructIntf
class ArgumentContext : public RefCountedContext, public TemplateStructIntf
{
public:
ArgumentContext(const Argument *arg,Definition *def,const QCString &relPath);
~ArgumentContext();
static ArgumentContext *alloc(const Argument *arg,Definition *def,const QCString &relPath)
{ return new ArgumentContext(arg,def,relPath); }
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
ArgumentContext(const Argument *arg,Definition *def,const QCString &relPath);
~ArgumentContext();
class Private;
Private *p;
};
//----------------------------------------------------
class ArgumentListContext : public TemplateListIntf
class ArgumentListContext : public RefCountedContext, public TemplateListIntf
{
public:
ArgumentListContext();
ArgumentListContext(const ArgumentList *al,Definition *def,const QCString &relPath);
~ArgumentListContext();
static ArgumentListContext *alloc() { return new ArgumentListContext; }
static ArgumentListContext *alloc(const ArgumentList *al,Definition *def,const QCString &relPath)
{ return new ArgumentListContext(al,def,relPath); }
// TemplateListIntf
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
private:
ArgumentListContext();
ArgumentListContext(const ArgumentList *al,Definition *def,const QCString &relPath);
~ArgumentListContext();
class Private;
Private *p;
};
......
src/ftextstream.cpp
View file @ ff00706a
......@@ -165,6 +165,7 @@ FTextStream::FTextStream( FILE *fh )
{
m_dev = new QFile;
((QFile *)m_dev)->open( IO_WriteOnly, fh);
m_owndev = TRUE;
}
FTextStream::~FTextStream()
......
src/template.cpp
View file @ ff00706a
......@@ -103,8 +103,8 @@ class TemplateVariant::Private
int intVal;
QCString strVal;
bool boolVal;
const TemplateStructIntf *strukt;
const TemplateListIntf *list;
TemplateStructIntf *strukt;
TemplateListIntf *list;
Delegate delegate;
bool raw;
};
......@@ -145,17 +145,20 @@ TemplateVariant::TemplateVariant(const QCString &s,bool raw)
p->raw = raw;
}
TemplateVariant::TemplateVariant(const TemplateStructIntf *s)
TemplateVariant::TemplateVariant(TemplateStructIntf *s)
{
p = new Private;
p->type = Struct;
p->strukt = s; }
p->strukt = s;
p->strukt->addRef();
}
TemplateVariant::TemplateVariant(const TemplateListIntf *l)
TemplateVariant::TemplateVariant(TemplateListIntf *l)
{
p = new Private;
p->type = List;
p->list = l;
p->list->addRef();
}
TemplateVariant::TemplateVariant(const TemplateVariant::Delegate &delegate)
......@@ -167,6 +170,8 @@ TemplateVariant::TemplateVariant(const TemplateVariant::Delegate &delegate)
TemplateVariant::~TemplateVariant()
{
if (p->type==Struct) p->strukt->release();
else if (p->type==List) p->list->release();
delete p;
}
......@@ -181,14 +186,20 @@ TemplateVariant::TemplateVariant(const TemplateVariant &v)
case Bool: p->boolVal = v.p->boolVal; break;
case Integer: p->intVal = v.p->intVal; break;
case String: p->strVal = v.p->strVal; break;
case Struct: p->strukt = v.p->strukt; break;
case List: p->list = v.p->list; break;
case Struct: p->strukt = v.p->strukt; p->strukt->addRef(); break;
case List: p->list = v.p->list; p->list->addRef(); break;
case Function: p->delegate= v.p->delegate;break;
}
}
TemplateVariant &TemplateVariant::operator=(const TemplateVariant &v)
{
// assignment can change the type of the variable, so we have to be
// careful with reference counted content.
TemplateStructIntf *tmpStruct = p->type==Struct ? p->strukt : 0;
TemplateListIntf *tmpList = p->type==List ? p->list : 0;
Type tmpType = p->type;
p->type = v.p->type;
p->raw = v.p->raw;
switch (p->type)
......@@ -197,10 +208,14 @@ TemplateVariant &TemplateVariant::operator=(const TemplateVariant &v)
case Bool: p->boolVal = v.p->boolVal; break;
case Integer: p->intVal = v.p->intVal; break;
case String: p->strVal = v.p->strVal; break;
case Struct: p->strukt = v.p->strukt; break;
case List: p->list = v.p->list; break;
case Struct: p->strukt = v.p->strukt; p->strukt->addRef(); break;
case List: p->list = v.p->list; p->list->addRef(); break;
case Function: p->delegate= v.p->delegate;break;
}
// release overwritten reference counted values
if (tmpType==Struct && tmpStruct) tmpStruct->release();
else if (tmpType==List && tmpList ) tmpList->release();
return *this;
}
......@@ -353,9 +368,10 @@ bool TemplateVariant::raw() const
class TemplateStruct::Private
{
public:
Private() : fields(17)
Private() : fields(17), refCount(0)
{ fields.setAutoDelete(TRUE); }
QDict<TemplateVariant> fields;
int refCount;
};
TemplateStruct::TemplateStruct()
......@@ -368,6 +384,21 @@ TemplateStruct::~TemplateStruct()
delete p;
}
int TemplateStruct::addRef()
{
return ++p->refCount;
}
int TemplateStruct::release()
{
int count = --p->refCount;
if (count<=0)
{
delete this;
}
return count;
}
void TemplateStruct::set(const char *name,const TemplateVariant &v)
{
TemplateVariant *pv = p->fields.find(name);
......@@ -387,6 +418,11 @@ TemplateVariant TemplateStruct::get(const char *name) const
return v ? *v : TemplateVariant();
}
TemplateStruct *TemplateStruct::alloc()
{
return new TemplateStruct;
}
//- Template list implementation ----------------------------------------------
......@@ -394,9 +430,10 @@ TemplateVariant TemplateStruct::get(const char *name) const
class TemplateList::Private
{
public:
Private() : index(-1) {}
Private() : index(-1), refCount(0) {}
QValueList<TemplateVariant> elems;
int index;
int refCount;
};
......@@ -410,6 +447,21 @@ TemplateList::~TemplateList()
delete p;
}
int TemplateList::addRef()
{
return ++p->refCount;
}
int TemplateList::release()
{
int count = --p->refCount;
if (count<=0)
{
delete this;
}
return count;
}
int TemplateList::count() const
{
return p->elems.count();
......@@ -492,6 +544,11 @@ TemplateVariant TemplateList::at(int index) const
}
}
TemplateList *TemplateList::alloc()
{
return new TemplateList;
}
//- Operator types ------------------------------------------------------------
/** @brief Class representing operators that can appear in template expressions */
......@@ -2156,14 +2213,14 @@ class TemplateNodeRepeat : public TemplateNodeCreator<TemplateNodeRepeat>
int i, n = v.toInt();
for (i=0;i<n;i++)
{
TemplateStruct s;
s.set("counter0", (int)i);
s.set("counter", (int)(i+1));
s.set("revcounter", (int)(n-i));
s.set("revcounter0", (int)(n-i-1));
s.set("first",i==0);
s.set("last", i==n-1);
c->set("repeatloop",&s);
TemplateAutoRef<TemplateStruct> s(TemplateStruct::alloc());
s->set("counter0", (int)i);
s->set("counter", (int)(i+1));
s->set("revcounter", (int)(n-i));
s->set("revcounter0", (int)(n-i-1));
s->set("first",i==0);
s->set("last", i==n-1);
c->set("repeatloop",s.get());
// render all items for this iteration of the loop
m_repeatNodes.render(ts,c);
}
......@@ -2285,15 +2342,15 @@ class TemplateNodeRange : public TemplateNodeCreator<TemplateNodeRange>
while (!done)
{
// set the forloop meta-data variable
TemplateStruct s;
s.set("counter0", (int)index);
s.set("counter", (int)(index+1));
s.set("revcounter", (int)(l-index));
s.set("revcounter0", (int)(l-index-1));
s.set("first",index==0);
s.set("last", (int)index==l-1);
s.set("parentloop",parentLoop ? *parentLoop : TemplateVariant());
c->set("forloop",&s);
TemplateAutoRef<TemplateStruct> s(TemplateStruct::alloc());
s->set("counter0", (int)index);
s->set("counter", (int)(index+1));
s->set("revcounter", (int)(l-index));
s->set("revcounter0", (int)(l-index-1));
s->set("first",index==0);
s->set("last", (int)index==l-1);
s->set("parentloop",parentLoop ? *parentLoop : TemplateVariant());
c->set("forloop",s.get());
// set the iterator variable
c->set(m_var,i);
......@@ -2447,15 +2504,15 @@ class TemplateNodeFor : public TemplateNodeCreator<TemplateNodeFor>
(it->current(v));
m_reversed ? it->toPrev() : it->toNext())
{
TemplateStruct s;
s.set("counter0", (int)index);
s.set("counter", (int)(index+1));
s.set("revcounter", (int)(listSize-index));
s.set("revcounter0", (int)(listSize-index-1));
s.set("first",index==0);
s.set("last", index==listSize-1);
s.set("parentloop",parentLoop ? *parentLoop : TemplateVariant());
c->set("forloop",&s);
TemplateAutoRef<TemplateStruct> s(TemplateStruct::alloc());
s->set("counter0", (int)index);
s->set("counter", (int)(index+1));
s->set("revcounter", (int)(listSize-index));
s->set("revcounter0", (int)(listSize-index-1));
s->set("first",index==0);
s->set("last", index==listSize-1);
s->set("parentloop",parentLoop ? *parentLoop : TemplateVariant());
c->set("forloop",s.get());
// add variables for this loop to the context
//obj->addVariableToContext(index,m_vars,c);
......@@ -2582,9 +2639,9 @@ class TemplateNodeBlock : public TemplateNodeCreator<TemplateNodeBlock>
m_nodes.render(ss,c); // render parent of nb to string
}
// add 'block.super' variable to allow access to parent block content
TemplateStruct superBlock;
superBlock.set("super",TemplateVariant(super.data(),TRUE));
ci->set("block",&superBlock);
TemplateAutoRef<TemplateStruct> superBlock(TemplateStruct::alloc());
superBlock->set("super",TemplateVariant(super.data(),TRUE));
ci->set("block",superBlock.get());
// render the overruled block contents
t->engine()->enterBlock(nb->m_templateName,nb->m_blockName,nb->m_line);
nb->m_nodes.render(ts,c);
......@@ -3235,9 +3292,9 @@ class TemplateNodeMarkers : public TemplateNodeCreator<TemplateNodeMarkers>
for (it->toFirst(); (it->current(var)) && i<entryIndex; it->toNext(),i++) {}
if (ok && i==entryIndex) // found element
{
TemplateStruct s;
s.set("id",(int)i);
c->set("markers",&s);
TemplateAutoRef<TemplateStruct> s(TemplateStruct::alloc());
s->set("id",(int)i);
c->set("markers",s.get());
c->set(m_var,var); // define local variable to hold element of list type
bool wasSpaceless = ci->spacelessEnabled();
ci->enableSpaceless(TRUE);
......
src/template.h
View file @ ff00706a
......@@ -145,16 +145,14 @@ class TemplateVariant
TemplateVariant(const QCString &s,bool raw=FALSE);
/** Constructs a new variant with a struct value \a s.
* @note. Only a pointer to the struct is stored. The caller
* is responsible to manage the memory for the struct object.
* @note. The variant will hold a reference to the object.
*/
TemplateVariant(const TemplateStructIntf *s);
TemplateVariant(TemplateStructIntf *s);
/** Constructs a new variant with a list value \a l.
* @note. Only a pointer to the struct is stored. The caller
* is responsible to manage the memory for the list object.
* @note. The variant will hold a reference to the object.
*/
TemplateVariant(const TemplateListIntf *l);
TemplateVariant(TemplateListIntf *l);
/** Constructs a new variant which represents a method call
* @param[in] delegate Delegate object to invoke when
......@@ -223,6 +221,27 @@ class TemplateVariant
//------------------------------------------------------------------------
template<class T> class TemplateAutoRef
{
public:
TemplateAutoRef(T *obj) : m_obj(obj)
{
m_obj->addRef();
}
~TemplateAutoRef()
{
m_obj->release();
}
T &operator*() const { return *m_obj; }
T *operator->() const { return m_obj; }
T *get() const { return m_obj; }
private:
T *m_obj;
};
//------------------------------------------------------------------------
/** @brief Abstract read-only interface for a context value of type list.
* @note The values of the list are TemplateVariants.
*/
......@@ -264,26 +283,37 @@ class TemplateListIntf
* @note the user should call delete on the returned pointer.
*/
virtual TemplateListIntf::ConstIterator *createIterator() const = 0;
/** Increase object's reference count */
virtual int addRef() = 0;
/** Decreases object's referenc count, destroy object if 0 */
virtual int release() = 0;
};
/** @brief Default implementation of a context value of type list. */
class TemplateList : public TemplateListIntf
{
public:
/** Creates a list */
TemplateList();
/** Destroys the list */
~TemplateList();
// TemplateListIntf methods
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef();
virtual int release();
/** Creates an instance with ref count set to 0 */
static TemplateList *alloc();
/** Appends element \a v to the end of the list */
virtual void append(const TemplateVariant &v);
private:
/** Creates a list */
TemplateList();
/** Destroys the list */
~TemplateList();
friend class TemplateListConstIterator;
class Private;
Private *p;
......@@ -302,6 +332,12 @@ class TemplateStructIntf
* @param[in] name The name of the field.
*/
virtual TemplateVariant get(const char *name) const = 0;
/** Increase object's reference count */
virtual int addRef() = 0;
/** Decreases object's referenc count, destroy object if 0 */
virtual int release() = 0;
};
......@@ -309,13 +345,13 @@ class TemplateStructIntf
class TemplateStruct : public TemplateStructIntf
{
public:
/** Creates a struct */
TemplateStruct();
/** Destroys the struct */
virtual ~TemplateStruct();
// TemplateStructIntf methods
virtual TemplateVariant get(const char *name) const;
virtual int addRef();
virtual int release();
/** Creates an instance with ref count set to 0. */
static TemplateStruct *alloc();
/** Sets the value the field of a struct
* @param[in] name The name of the field.
......@@ -323,7 +359,13 @@ class TemplateStruct : public TemplateStructIntf
*/
virtual void set(const char *name,const TemplateVariant &v);
private:
/** Creates a struct */
TemplateStruct();
/** Destroys the struct */
virtual ~TemplateStruct();
class Private;
Private *p;
};
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment