Inheritance diagram for ModuleContext::Private:

Classes
struct	Cachable

Public Member Functions
	Private (GroupDef *gd)

virtual	~Private ()

TemplateVariant	get (const char *n) const

TemplateVariant	title () const

TemplateVariant	highlight () const

TemplateVariant	subHighlight () const

DotGroupCollaboration *	getGroupGraph () const

TemplateVariant	hasGroupGraph () const

TemplateVariant	groupGraph () const

TemplateVariant	hasDetails () const

TemplateVariant	modules () const

TemplateVariant	examples () const

TemplateVariant	pages () const

TemplateVariant	dirs () const

TemplateVariant	files () const

TemplateVariant	classes () const

TemplateVariant	namespaces () const

TemplateVariant	constantgroups () const

TemplateVariant	getMemberList (SharedPtr< MemberListInfoContext > &list, MemberListType type, const char *title, bool detailed=FALSE) const

TemplateVariant	macros () const

TemplateVariant	typedefs () const

TemplateVariant	enums () const

TemplateVariant	enumValues () const

TemplateVariant	functions () const

TemplateVariant	variables () const

TemplateVariant	signals () const

TemplateVariant	publicSlots () const

TemplateVariant	protectedSlots () const

TemplateVariant	privateSlots () const

TemplateVariant	events () const

TemplateVariant	properties () const

TemplateVariant	friends () const

TemplateVariant	memberGroups () const

TemplateVariant	detailedMacros () const

TemplateVariant	detailedTypedefs () const

TemplateVariant	detailedEnums () const

TemplateVariant	detailedEnumValues () const

TemplateVariant	detailedFunctions () const

TemplateVariant	detailedVariables () const

TemplateVariant	detailedSignals () const

TemplateVariant	detailedPublicSlots () const

TemplateVariant	detailedProtectedSlots () const

TemplateVariant	detailedPrivateSlots () const

TemplateVariant	detailedEvents () const

TemplateVariant	detailedProperties () const

TemplateVariant	detailedFriends () const

TemplateVariant	inlineClasses () const

TemplateVariant	compoundType () const

Public Member Functions inherited from DefinitionContext< ModuleContext::Private >
	DefinitionContext (Definition *d)

void	addBaseProperties (PropertyMapper< ModuleContext::Private > &inst)

TemplateVariant	fileName () const

TemplateVariant	anchor () const

TemplateVariant	sourceFileName () const

TemplateVariant	isLinkable () const

TemplateVariant	isLinkableInProject () const

TemplateVariant	name () const

TemplateVariant	bareName () const

QCString	relPathAsString () const

virtual TemplateVariant	relPath () const

TemplateVariant	details () const

TemplateVariant	brief () const

TemplateVariant	inbodyDocs () const

TemplateVariant	dynSectionId () const

TemplateVariant	language () const

TemplateVariant	compoundKind () const

TemplateVariant	sourceDef () const

void	fillPath (Definition def, TemplateList list) const

TemplateVariant	navigationPath () const

TemplateVariant	isReference () const

TemplateVariant	externalReference () const

Private Member Functions
Cachable &	getCache () const

Private Attributes
GroupDef *	m_groupDef

Static Private Attributes
static PropertyMapper< ModuleContext::Private >	s_inst

Detailed Description

Definition at line 5119 of file context.cpp.

Constructor & Destructor Documentation

ModuleContext::Private::Private ( GroupDef * gd )

inline

Definition at line 5122 of file context.cpp.

                           : DefinitionContext<ModuleContext::Private>(gd) , m_groupDef(gd)
     {
       static bool init=FALSE;
       if (!init)
       {
         addBaseProperties(s_inst);
         s_inst.addProperty("title",                     &Private::title);
         s_inst.addProperty("highlight",                 &Private::highlight);
         s_inst.addProperty("subhighlight",              &Private::subHighlight);
         s_inst.addProperty("hasGroupGraph",             &Private::hasGroupGraph);
         s_inst.addProperty("groupGraph",                &Private::groupGraph);
         s_inst.addProperty("hasDetails",                &Private::hasDetails);
         s_inst.addProperty("modules",                   &Private::modules);
         s_inst.addProperty("dirs",                      &Private::dirs);
         s_inst.addProperty("files",                     &Private::files);
         s_inst.addProperty("namespaces",                &Private::namespaces);
         s_inst.addProperty("classes",                   &Private::classes);
         s_inst.addProperty("constantgroups",            &Private::constantgroups);
         s_inst.addProperty("examples",                  &Private::examples);
         s_inst.addProperty("macros",                    &Private::macros);
         s_inst.addProperty("typedefs",                  &Private::typedefs);
         s_inst.addProperty("enums",                     &Private::enums);
         s_inst.addProperty("enumvalues",                &Private::enumValues);
         s_inst.addProperty("functions",                 &Private::functions);
         s_inst.addProperty("variables",                 &Private::variables);
         s_inst.addProperty("signals",                   &Private::signals);
         s_inst.addProperty("publicSlots",               &Private::publicSlots);
         s_inst.addProperty("protectedSlots",            &Private::protectedSlots);
         s_inst.addProperty("privateSlots",              &Private::privateSlots);
         s_inst.addProperty("events",                    &Private::events);
         s_inst.addProperty("properties",                &Private::properties);
         s_inst.addProperty("friends",                   &Private::friends);
         s_inst.addProperty("memberGroups",              &Private::memberGroups);
         s_inst.addProperty("detailedMacros",            &Private::detailedMacros);
         s_inst.addProperty("detailedTypedefs",          &Private::detailedTypedefs);
         s_inst.addProperty("detailedEnums",             &Private::detailedEnums);
         s_inst.addProperty("detailedEnumValues",        &Private::detailedEnumValues);
         s_inst.addProperty("detailedFunctions",         &Private::detailedFunctions);
         s_inst.addProperty("detailedVariables",         &Private::detailedVariables);
         s_inst.addProperty("detailedSignals",           &Private::detailedSignals);
         s_inst.addProperty("detailedPublicSlots",       &Private::detailedPublicSlots);
         s_inst.addProperty("detailedProtectedSlots",    &Private::detailedProtectedSlots);
         s_inst.addProperty("detailedPrivateSlots",      &Private::detailedPrivateSlots);
         s_inst.addProperty("detailedEvents",            &Private::detailedEvents);
         s_inst.addProperty("detailedProperties",        &Private::detailedProperties);
         s_inst.addProperty("detailedFriends",           &Private::detailedFriends);
         s_inst.addProperty("inlineClasses",             &Private::inlineClasses);
         s_inst.addProperty("compoundType",              &Private::compoundType);
         init=TRUE;
       }
       if (!gd->cookie()) { gd->setCookie(new ModuleContext::Private::Cachable(gd)); }
     }

virtual ModuleContext::Private::~Private ( )

inlinevirtual

Definition at line 5174 of file context.cpp.

5174 {}

Member Function Documentation

TemplateVariant ModuleContext::Private::classes ( ) const

inline

Definition at line 5356 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.classes)
       {
         TemplateList *classList = TemplateList::alloc();
         if (m_groupDef->getClasses())
         {
           ClassSDict::Iterator sdi(*m_groupDef->getClasses());
           ClassDef *cd;
           for (sdi.toFirst();(cd=sdi.current());++sdi)
           {
             if (cd->visibleInParentsDeclList())
             {
               classList->append(ClassContext::alloc(cd));
             }
           }
         }
         cache.classes.reset(classList);
       }
       return cache.classes.get();
     }

TemplateVariant ModuleContext::Private::compoundType ( ) const

inline

Definition at line 5595 of file context.cpp.

     {
       return "module"; //theTranslator->trGroup(FALSE,TRUE);
     }

TemplateVariant ModuleContext::Private::constantgroups ( ) const

inline

Definition at line 5400 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.constantgroups)
       {
         TemplateList *namespaceList = TemplateList::alloc();
         if (m_groupDef->getNamespaces())
         {
           NamespaceSDict::Iterator sdi(*m_groupDef->getNamespaces());
           NamespaceDef *nd;
           for (sdi.toFirst();(nd=sdi.current());++sdi)
           {
             if (nd->isLinkable() && nd->isConstantGroup())
             {
               namespaceList->append(NamespaceContext::alloc(nd));
             }
           }
         }
         cache.constantgroups.reset(namespaceList);
       }
       return cache.constantgroups.get();
     }

TemplateVariant ModuleContext::Private::detailedEnums ( ) const

inline

Definition at line 5523 of file context.cpp.

     {
       return getMemberList(getCache().detailedEnums,MemberListType_docEnumMembers,theTranslator->trEnumerationTypeDocumentation());
     }

TemplateVariant ModuleContext::Private::detailedEnumValues ( ) const

inline

Definition at line 5527 of file context.cpp.

     {
       return getMemberList(getCache().detailedEnumValues,MemberListType_docEnumValMembers,theTranslator->trEnumerationValueDocumentation());
     }

TemplateVariant ModuleContext::Private::detailedEvents ( ) const

inline

Definition at line 5558 of file context.cpp.

     {
       return getMemberList(getCache().detailedEvents,MemberListType_docEventMembers,theTranslator->trEventDocumentation(),TRUE);
     }

TemplateVariant ModuleContext::Private::detailedFriends ( ) const

inline

Definition at line 5566 of file context.cpp.

     {
       return getMemberList(getCache().detailedFriends,MemberListType_docFriendMembers,theTranslator->trFriends(),TRUE);
     }

TemplateVariant ModuleContext::Private::detailedFunctions ( ) const

inline

Definition at line 5531 of file context.cpp.

     {
       QCString title = theTranslator->trFunctionDocumentation();
       SrcLangExt lang = m_groupDef->getLanguage();
       if (lang==SrcLangExt_Fortran) title=theTranslator->trSubprogramDocumentation();
       return getMemberList(getCache().detailedFunctions,MemberListType_docFuncMembers,title);
     }

TemplateVariant ModuleContext::Private::detailedMacros ( ) const

inline

Definition at line 5515 of file context.cpp.

     {
       return getMemberList(getCache().detailedMacros,MemberListType_docDefineMembers,theTranslator->trDefineDocumentation());
     }

TemplateVariant ModuleContext::Private::detailedPrivateSlots ( ) const

inline

Definition at line 5554 of file context.cpp.

     {
       return getMemberList(getCache().detailedPrivateSlots,MemberListType_docPriSlotMembers,theTranslator->trPrivateSlots());
     }

TemplateVariant ModuleContext::Private::detailedProperties ( ) const

inline

Definition at line 5562 of file context.cpp.

     {
       return getMemberList(getCache().detailedProperties,MemberListType_docPropMembers,theTranslator->trPropertyDocumentation(),TRUE);
     }

TemplateVariant ModuleContext::Private::detailedProtectedSlots ( ) const

inline

Definition at line 5550 of file context.cpp.

     {
       return getMemberList(getCache().detailedProtectedSlots,MemberListType_docProSlotMembers,theTranslator->trProtectedSlots());
     }

TemplateVariant ModuleContext::Private::detailedPublicSlots ( ) const

inline

Definition at line 5546 of file context.cpp.

     {
       return getMemberList(getCache().detailedPublicSlots,MemberListType_docPubSlotMembers,theTranslator->trPublicSlots());
     }

TemplateVariant ModuleContext::Private::detailedSignals ( ) const

inline

Definition at line 5542 of file context.cpp.

     {
       return getMemberList(getCache().detailedSignals,MemberListType_docSignalMembers,theTranslator->trSignals());
     }

TemplateVariant ModuleContext::Private::detailedTypedefs ( ) const

inline

Definition at line 5519 of file context.cpp.

     {
       return getMemberList(getCache().detailedTypedefs,MemberListType_docTypedefMembers,theTranslator->trTypedefDocumentation());
     }

TemplateVariant ModuleContext::Private::detailedVariables ( ) const

inline

Definition at line 5538 of file context.cpp.

     {
       return getMemberList(getCache().detailedVariables,MemberListType_docVarMembers,theTranslator->trVariableDocumentation());
     }

TemplateVariant ModuleContext::Private::dirs ( ) const

inline

Definition at line 5318 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.dirs)
       {
         TemplateList *dirList = TemplateList::alloc();
         if (m_groupDef->getDirs())
         {
           QListIterator<DirDef> it(*m_groupDef->getDirs());
           DirDef *dd;
           for (it.toFirst();(dd=it.current());++it)
           {
             dirList->append(DirContext::alloc(dd));
           }
         }
         cache.dirs.reset(dirList);
       }
       return cache.dirs.get();
     }

TemplateVariant ModuleContext::Private::enums ( ) const

inline

Definition at line 5451 of file context.cpp.

     {
       return getMemberList(getCache().enums,MemberListType_decEnumMembers,theTranslator->trEnumerations());
     }

TemplateVariant ModuleContext::Private::enumValues ( ) const

inline

Definition at line 5455 of file context.cpp.

     {
       return getMemberList(getCache().enums,MemberListType_decEnumValMembers,theTranslator->trEnumerationValues());
     }

TemplateVariant ModuleContext::Private::events ( ) const

inline

Definition at line 5487 of file context.cpp.

     {
       return getMemberList(getCache().events,MemberListType_events,theTranslator->trEvents());
     }

TemplateVariant ModuleContext::Private::examples ( ) const

inline

Definition at line 5280 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.examples)
       {
         TemplateList *exampleList = TemplateList::alloc();
         if (m_groupDef->getExamples())
         {
           PageSDict::Iterator eli(*m_groupDef->getExamples());
           PageDef *ex;
           for (eli.toFirst();(ex=eli.current());++eli)
           {
             exampleList->append(PageContext::alloc(ex,FALSE,TRUE));
           }
         }
         cache.examples.reset(exampleList);
       }
       return cache.examples.get();
     }

TemplateVariant ModuleContext::Private::files ( ) const

inline

Definition at line 5337 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.files)
       {
         TemplateList *fileList = TemplateList::alloc();
         if (m_groupDef->getFiles())
         {
           QListIterator<FileDef> it(*m_groupDef->getFiles());
           FileDef *fd;
           for (it.toFirst();(fd=it.current());++it)
           {
             fileList->append(FileContext::alloc(fd));
           }
         }
         cache.files.reset(fileList);
       }
       return cache.files.get();
     }

TemplateVariant ModuleContext::Private::friends ( ) const

inline

Definition at line 5495 of file context.cpp.

     {
       return getMemberList(getCache().friends,MemberListType_friends,theTranslator->trFriends());
     }

TemplateVariant ModuleContext::Private::functions ( ) const

inline

Definition at line 5459 of file context.cpp.

     {
       QCString title = theTranslator->trFunctions();
       SrcLangExt lang = m_groupDef->getLanguage();
       if (lang==SrcLangExt_Fortran) title=theTranslator->trSubprograms();
       else if (lang==SrcLangExt_VHDL) title=VhdlDocGen::trFunctionAndProc();
       return getMemberList(getCache().functions,MemberListType_decFuncMembers,title);
     }

TemplateVariant ModuleContext::Private::get ( const char * n ) const

inline

Definition at line 5175 of file context.cpp.

     {
       return s_inst.get(this,n);
     }

Cachable& ModuleContext::Private::getCache ( ) const

inlineprivate

Definition at line 5642 of file context.cpp.

     {
       Cachable *c = static_cast<Cachable*>(m_groupDef->cookie());
       assert(c!=0);
       return *c;
     }

DotGroupCollaboration* ModuleContext::Private::getGroupGraph ( ) const

inline

Definition at line 5191 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.groupGraph)
       {
         cache.groupGraph.reset(new DotGroupCollaboration(m_groupDef));
       }
       return cache.groupGraph.get();
     }

TemplateVariant ModuleContext::Private::getMemberList	(	SharedPtr< MemberListInfoContext > &	list,
		MemberListType	type,
		const char *	title,
		bool	detailed = `FALSE`
	)		const

inline

Definition at line 5423 of file context.cpp.

     {
       if (!list)
       {
         MemberList *ml = m_groupDef->getMemberList(type);
         if (ml)
         {
           list.reset(MemberListInfoContext::alloc(m_groupDef,relPathAsString(),ml,title,""));
         }
       }
       if (list)
       {
         return list.get();
       }
       else
       {
         return TemplateVariant(FALSE);
       }
     }

TemplateVariant ModuleContext::Private::groupGraph ( ) const

inline

Definition at line 5212 of file context.cpp.

     {
       QGString result;
       static bool haveDot     = Config_getBool("HAVE_DOT");
       static bool groupGraphs = Config_getBool("GROUP_GRAPHS");
       if (haveDot && groupGraphs)
       {
         DotGroupCollaboration *graph = getGroupGraph();
         FTextStream t(&result);
         switch (g_globals.outputFormat)
         {
           case ContextOutputFormat_Html:
             {
               graph->writeGraph(t,GOF_BITMAP,
                                 EOF_Html,
                                 g_globals.outputDir,
                                 g_globals.outputDir+portable_pathSeparator()+m_groupDef->getOutputFileBase()+Doxygen::htmlFileExtension,
                                 relPathAsString(),
                                 TRUE,
                                 g_globals.dynSectionId);
             }
             break;
           case ContextOutputFormat_Latex:
             {
               graph->writeGraph(t,GOF_EPS,
                                 EOF_LaTeX,
                                 g_globals.outputDir,
                                 g_globals.outputDir+portable_pathSeparator()+m_groupDef->getOutputFileBase()+".tex",
                                 relPathAsString(),
                                 TRUE,
                                 g_globals.dynSectionId);
             }
             break;
             // TODO: support other generators
           default:
             err("context.cpp: output format not yet supported");
             break;
         }
         g_globals.dynSectionId++;
       }
       return TemplateVariant(result.data(),TRUE);
     }

TemplateVariant ModuleContext::Private::hasDetails ( ) const

inline

Definition at line 5254 of file context.cpp.

     {
       return m_groupDef->hasDetailedDescription();
     }

TemplateVariant ModuleContext::Private::hasGroupGraph ( ) const

inline

Definition at line 5200 of file context.cpp.

     {
       bool result=FALSE;
       static bool haveDot     = Config_getBool("HAVE_DOT");
       static bool groupGraphs = Config_getBool("GROUP_GRAPHS");
       if (haveDot && groupGraphs)
       {
         DotGroupCollaboration *graph = getGroupGraph();
         result = !graph->isTrivial();
       }
       return result;
     }

TemplateVariant ModuleContext::Private::highlight ( ) const

inline

Definition at line 5183 of file context.cpp.

     {
       return TemplateVariant("modules");
     }

TemplateVariant ModuleContext::Private::inlineClasses ( ) const

inline

Definition at line 5570 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.inlineClasses)
       {
         TemplateList *classList = TemplateList::alloc();
         if (m_groupDef->getClasses())
         {
           ClassSDict::Iterator sdi(*m_groupDef->getClasses());
           ClassDef *cd;
           for (sdi.toFirst();(cd=sdi.current());++sdi)
           {
             if (cd->name().find('@')==-1 &&
                 cd->isLinkableInProject() &&
                 cd->isEmbeddedInOuterScope() &&
                 cd->partOfGroups()==0)
             {
               classList->append(ClassContext::alloc(cd));
             }
           }
         }
         cache.inlineClasses.reset(classList);
       }
       return cache.inlineClasses.get();
     }

TemplateVariant ModuleContext::Private::macros ( ) const

inline

Definition at line 5443 of file context.cpp.

     {
       return getMemberList(getCache().macros,MemberListType_decDefineMembers,theTranslator->trDefines());
     }

TemplateVariant ModuleContext::Private::memberGroups ( ) const

inline

Definition at line 5499 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.memberGroups)
       {
         if (m_groupDef->getMemberGroupSDict())
         {
           cache.memberGroups.reset(MemberGroupListContext::alloc(m_groupDef,relPathAsString(),m_groupDef->getMemberGroupSDict(),m_groupDef->subGrouping()));
         }
         else
         {
           cache.memberGroups.reset(MemberGroupListContext::alloc());
         }
       }
       return cache.memberGroups.get();
     }

TemplateVariant ModuleContext::Private::modules ( ) const

inline

Definition at line 5258 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.modules)
       {
         TemplateList *moduleList = TemplateList::alloc();
         if (m_groupDef->getSubGroups())
         {
           GroupListIterator gli(*m_groupDef->getSubGroups());
           GroupDef *gd;
           for (gli.toFirst();(gd=gli.current());++gli)
           {
             if (gd->isVisible())
             {
               moduleList->append(ModuleContext::alloc(gd));
             }
           }
         }
         cache.modules.reset(moduleList);
       }
       return cache.modules.get();
     }

TemplateVariant ModuleContext::Private::namespaces ( ) const

inline

Definition at line 5378 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.namespaces)
       {
         TemplateList *namespaceList = TemplateList::alloc();
         if (m_groupDef->getNamespaces())
         {
           NamespaceSDict::Iterator sdi(*m_groupDef->getNamespaces());
           NamespaceDef *nd;
           for (sdi.toFirst();(nd=sdi.current());++sdi)
           {
             if (nd->isLinkable() && !nd->isConstantGroup())
             {
               namespaceList->append(NamespaceContext::alloc(nd));
             }
           }
         }
         cache.namespaces.reset(namespaceList);
       }
       return cache.namespaces.get();
     }

TemplateVariant ModuleContext::Private::pages ( ) const

inline

Definition at line 5299 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.pages)
       {
         TemplateList *pageList = TemplateList::alloc();
         if (m_groupDef->getExamples())
         {
           PageSDict::Iterator eli(*m_groupDef->getPages());
           PageDef *ex;
           for (eli.toFirst();(ex=eli.current());++eli)
           {
             pageList->append(PageContext::alloc(ex,FALSE,TRUE));
           }
         }
         cache.pages.reset(pageList);
       }
       return cache.pages.get();
     }

TemplateVariant ModuleContext::Private::privateSlots ( ) const

inline

Definition at line 5483 of file context.cpp.

     {
       return getMemberList(getCache().privateSlots,MemberListType_priSlots,theTranslator->trPrivateSlots());
     }

TemplateVariant ModuleContext::Private::properties ( ) const

inline

Definition at line 5491 of file context.cpp.

     {
       return getMemberList(getCache().properties,MemberListType_properties,theTranslator->trProperties());
     }

TemplateVariant ModuleContext::Private::protectedSlots ( ) const

inline

Definition at line 5479 of file context.cpp.

     {
       return getMemberList(getCache().protectedSlots,MemberListType_proSlots,theTranslator->trProtectedSlots());
     }

TemplateVariant ModuleContext::Private::publicSlots ( ) const

inline

Definition at line 5475 of file context.cpp.

     {
       return getMemberList(getCache().publicSlots,MemberListType_pubSlots,theTranslator->trPublicSlots());
     }

TemplateVariant ModuleContext::Private::signals ( ) const

inline

Definition at line 5471 of file context.cpp.

     {
       return getMemberList(getCache().signals,MemberListType_signals,theTranslator->trSignals());
     }

TemplateVariant ModuleContext::Private::subHighlight ( ) const

inline

Definition at line 5187 of file context.cpp.

     {
       return TemplateVariant("");
     }

TemplateVariant ModuleContext::Private::title ( ) const

inline

Definition at line 5179 of file context.cpp.

     {
       return TemplateVariant(m_groupDef->groupTitle());
     }

TemplateVariant ModuleContext::Private::typedefs ( ) const

inline

Definition at line 5447 of file context.cpp.

     {
       return getMemberList(getCache().typedefs,MemberListType_decTypedefMembers,theTranslator->trTypedefs());
     }

TemplateVariant ModuleContext::Private::variables ( ) const

inline

Definition at line 5467 of file context.cpp.

     {
       return getMemberList(getCache().variables,MemberListType_decVarMembers,theTranslator->trVariables());
     }

Member Data Documentation

GroupDef* ModuleContext::Private::m_groupDef

private

Definition at line 5600 of file context.cpp.

PropertyMapper< ModuleContext::Private > ModuleContext::Private::s_inst

staticprivate

Definition at line 5648 of file context.cpp.

The documentation for this class was generated from the following file:

doxygen-1.8.11/src/context.cpp

Classes

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation