Inheritance diagram for ClassContext::Private:

Classes
struct	Cachable

Public Member Functions
	Private (ClassDef *cd)

virtual	~Private ()

TemplateVariant	get (const char *n) const

TemplateVariant	title () const

TemplateVariant	highlight () const

TemplateVariant	subHighlight () const

TemplateVariant	hasDetails () const

TemplateVariant	generatedFromFiles () const

TemplateVariant	usedFiles () const

DotClassGraph *	getClassGraph () const

int	numInheritanceNodes () const

TemplateVariant	hasInheritanceDiagram () const

TemplateVariant	inheritanceDiagram () const

DotClassGraph *	getCollaborationGraph () const

TemplateVariant	hasCollaborationDiagram () const

TemplateVariant	collaborationDiagram () const

TemplateVariant	includeInfo () const

TemplateVariant	inherits () const

TemplateVariant	inheritedBy () const

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

TemplateVariant	unoIDLServices () const

TemplateVariant	unoIDLInterfaces () const

TemplateVariant	signals () const

TemplateVariant	publicTypes () const

TemplateVariant	publicMethods () const

TemplateVariant	publicStaticMethods () const

TemplateVariant	publicAttributes () const

TemplateVariant	publicStaticAttributes () const

TemplateVariant	publicSlots () const

TemplateVariant	protectedTypes () const

TemplateVariant	protectedMethods () const

TemplateVariant	protectedStaticMethods () const

TemplateVariant	protectedAttributes () const

TemplateVariant	protectedStaticAttributes () const

TemplateVariant	protectedSlots () const

TemplateVariant	privateTypes () const

TemplateVariant	privateSlots () const

TemplateVariant	privateMethods () const

TemplateVariant	privateStaticMethods () const

TemplateVariant	privateAttributes () const

TemplateVariant	privateStaticAttributes () const

TemplateVariant	packageTypes () const

TemplateVariant	packageMethods () const

TemplateVariant	packageStaticMethods () const

TemplateVariant	packageAttributes () const

TemplateVariant	packageStaticAttributes () const

TemplateVariant	properties () const

TemplateVariant	events () const

TemplateVariant	friends () const

TemplateVariant	related () const

TemplateVariant	detailedTypedefs () const

TemplateVariant	detailedEnums () const

TemplateVariant	detailedServices () const

TemplateVariant	detailedInterfaces () const

TemplateVariant	detailedConstructors () const

TemplateVariant	detailedMethods () const

TemplateVariant	detailedRelated () const

TemplateVariant	detailedVariables () const

TemplateVariant	detailedProperties () const

TemplateVariant	detailedEvents () const

TemplateVariant	classes () const

TemplateVariant	innerClasses () const

TemplateVariant	compoundType () const

void	addTemplateDecls (Definition d, TemplateList tl) const

void	addExamples (TemplateList *list) const

TemplateVariant	templateDecls () const

TemplateVariant	typeConstraints () const

TemplateVariant	examples () const

void	addMembers (ClassDef *cd, MemberListType lt) const

TemplateVariant	members () const

TemplateVariant	allMembersList () const

TemplateVariant	allMembersFileName () const

TemplateVariant	memberGroups () const

TemplateVariant	additionalInheritedMembers () const

TemplateVariant	isSimple () const

TemplateVariant	categoryOf () const

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

void	addBaseProperties (PropertyMapper< ClassContext::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
ClassDef *	m_classDef

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

Detailed Description

Definition at line 1778 of file context.cpp.

Constructor & Destructor Documentation

ClassContext::Private::Private ( ClassDef * cd )

inline

Definition at line 1781 of file context.cpp.

                           : DefinitionContext<ClassContext::Private>(cd),
        m_classDef(cd)
     {
       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("hasDetails",                &Private::hasDetails);
         s_inst.addProperty("generatedFromFiles",        &Private::generatedFromFiles);
         s_inst.addProperty("usedFiles",                 &Private::usedFiles);
         s_inst.addProperty("hasInheritanceDiagram",     &Private::hasInheritanceDiagram);
         s_inst.addProperty("inheritanceDiagram",        &Private::inheritanceDiagram);
         s_inst.addProperty("hasCollaborationDiagram",   &Private::hasCollaborationDiagram);
         s_inst.addProperty("collaborationDiagram",      &Private::collaborationDiagram);
         s_inst.addProperty("includeInfo",               &Private::includeInfo);
         s_inst.addProperty("inherits",                  &Private::inherits);
         s_inst.addProperty("inheritedBy",               &Private::inheritedBy);
         s_inst.addProperty("unoIDLServices",            &Private::unoIDLServices);
         s_inst.addProperty("unoIDLInterfaces",          &Private::unoIDLInterfaces);
         s_inst.addProperty("signals",                   &Private::signals);
         s_inst.addProperty("publicTypes",               &Private::publicTypes);
         s_inst.addProperty("publicMethods",             &Private::publicMethods);
         s_inst.addProperty("publicStaticMethods",       &Private::publicStaticMethods);
         s_inst.addProperty("publicAttributes",          &Private::publicAttributes);
         s_inst.addProperty("publicStaticAttributes",    &Private::publicStaticAttributes);
         s_inst.addProperty("publicSlots",               &Private::publicSlots);
         s_inst.addProperty("protectedTypes",            &Private::protectedTypes);
         s_inst.addProperty("protectedMethods",          &Private::protectedMethods);
         s_inst.addProperty("protectedStaticMethods",    &Private::protectedStaticMethods);
         s_inst.addProperty("protectedAttributes",       &Private::protectedAttributes);
         s_inst.addProperty("protectedStaticAttributes", &Private::protectedStaticAttributes);
         s_inst.addProperty("protectedSlots",            &Private::protectedSlots);
         s_inst.addProperty("privateTypes",              &Private::privateTypes);
         s_inst.addProperty("privateMethods",            &Private::privateMethods);
         s_inst.addProperty("privateStaticMethods",      &Private::privateStaticMethods);
         s_inst.addProperty("privateAttributes",         &Private::privateAttributes);
         s_inst.addProperty("privateStaticAttributes",   &Private::privateStaticAttributes);
         s_inst.addProperty("privateSlots",              &Private::privateSlots);
         s_inst.addProperty("packageTypes",              &Private::packageTypes);
         s_inst.addProperty("packageMethods",            &Private::packageMethods);
         s_inst.addProperty("packageStaticMethods",      &Private::packageStaticMethods);
         s_inst.addProperty("packageAttributes",         &Private::packageAttributes);
         s_inst.addProperty("packageStaticAttributes",   &Private::packageStaticAttributes);
         s_inst.addProperty("properties",                &Private::properties);
         s_inst.addProperty("events",                    &Private::events);
         s_inst.addProperty("friends",                   &Private::friends);
         s_inst.addProperty("related",                   &Private::related);
         s_inst.addProperty("detailedTypedefs",          &Private::detailedTypedefs);
         s_inst.addProperty("detailedEnums",             &Private::detailedEnums);
         s_inst.addProperty("detailedServices",          &Private::detailedServices);
         s_inst.addProperty("detailedInterfaces",        &Private::detailedInterfaces);
         s_inst.addProperty("detailedConstructors",      &Private::detailedConstructors);
         s_inst.addProperty("detailedMethods",           &Private::detailedMethods);
         s_inst.addProperty("detailedRelated",           &Private::detailedRelated);
         s_inst.addProperty("detailedVariables",         &Private::detailedVariables);
         s_inst.addProperty("detailedProperties",        &Private::detailedProperties);
         s_inst.addProperty("detailedEvents",            &Private::detailedEvents);
         s_inst.addProperty("classes",                   &Private::classes);
         s_inst.addProperty("innerClasses",              &Private::innerClasses);
         s_inst.addProperty("compoundType",              &Private::compoundType);
         s_inst.addProperty("templateDecls",             &Private::templateDecls);
         s_inst.addProperty("typeConstraints",           &Private::typeConstraints);
         s_inst.addProperty("examples",                  &Private::examples);
         s_inst.addProperty("members",                   &Private::members);
         s_inst.addProperty("allMembersList",            &Private::allMembersList);
         s_inst.addProperty("allMembersFileName",        &Private::allMembersFileName);
         s_inst.addProperty("memberGroups",              &Private::memberGroups);
         s_inst.addProperty("additionalInheritedMembers",&Private::additionalInheritedMembers);
         s_inst.addProperty("isSimple",                  &Private::isSimple);
         s_inst.addProperty("categoryOf",                &Private::categoryOf);
         init=TRUE;
       }
       if (!cd->cookie()) { cd->setCookie(new ClassContext::Private::Cachable(cd)); }
     }

virtual ClassContext::Private::~Private ( )

inlinevirtual

Definition at line 1858 of file context.cpp.

1858 {}

Member Function Documentation

void ClassContext::Private::addExamples ( TemplateList * list ) const

inline

Definition at line 2339 of file context.cpp.

     {
       if (m_classDef->hasExamples())
       {
         ExampleSDict::Iterator it(*m_classDef->exampleList());
         Example *ex;
         for (it.toFirst();(ex=it.current());++it)
         {
           TemplateStruct *s = TemplateStruct::alloc();
           s->set("text",ex->name);
           s->set("isLinkable",TRUE);
           s->set("anchor",ex->anchor);
           s->set("fileName",ex->file);
           s->set("isReference",FALSE);
           s->set("externalReference","");
           list->append(s);
         }
       }
     }

TemplateVariant ClassContext::Private::additionalInheritedMembers ( ) const

inline

Definition at line 2485 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.additionalInheritedMembers)
       {
         InheritedMemberInfoListContext *ctx = InheritedMemberInfoListContext::alloc();
         ctx->addMemberList(m_classDef,MemberListType_pubTypes,theTranslator->trPublicTypes());
         ctx->addMemberList(m_classDef,MemberListType_services,theTranslator->trServices());
         ctx->addMemberList(m_classDef,MemberListType_interfaces,theTranslator->trInterfaces());
         ctx->addMemberList(m_classDef,MemberListType_pubSlots,theTranslator->trPublicSlots());
         ctx->addMemberList(m_classDef,MemberListType_signals,theTranslator->trSignals());
         ctx->addMemberList(m_classDef,MemberListType_pubMethods,
           m_classDef->getLanguage()==SrcLangExt_ObjC ? theTranslator->trInstanceMethods()
                                                      : theTranslator->trPublicMembers());
         ctx->addMemberList(m_classDef,MemberListType_pubStaticMethods,
           m_classDef->getLanguage()==SrcLangExt_ObjC ? theTranslator->trClassMethods()
                                                      : theTranslator->trStaticPublicMembers());
         ctx->addMemberList(m_classDef,MemberListType_pubAttribs,theTranslator->trPublicAttribs());
         ctx->addMemberList(m_classDef,MemberListType_pubStaticAttribs,theTranslator->trStaticPublicAttribs());
         ctx->addMemberList(m_classDef,MemberListType_proTypes,theTranslator->trProtectedTypes());
         ctx->addMemberList(m_classDef,MemberListType_proSlots,theTranslator->trProtectedSlots());
         ctx->addMemberList(m_classDef,MemberListType_proMethods,theTranslator->trProtectedMembers());
         ctx->addMemberList(m_classDef,MemberListType_proStaticMethods,theTranslator->trStaticProtectedMembers());
         ctx->addMemberList(m_classDef,MemberListType_proAttribs,theTranslator->trProtectedAttribs());
         ctx->addMemberList(m_classDef,MemberListType_proStaticAttribs,theTranslator->trStaticProtectedAttribs());
         ctx->addMemberList(m_classDef,MemberListType_pacTypes,theTranslator->trPackageTypes());
         ctx->addMemberList(m_classDef,MemberListType_pacMethods,theTranslator->trPackageMembers());
         ctx->addMemberList(m_classDef,MemberListType_pacStaticMethods,theTranslator->trStaticPackageMembers());
         ctx->addMemberList(m_classDef,MemberListType_pacAttribs,theTranslator->trPackageAttribs());
         ctx->addMemberList(m_classDef,MemberListType_pacStaticAttribs,theTranslator->trStaticPackageAttribs());
         ctx->addMemberList(m_classDef,MemberListType_properties,theTranslator->trProperties());
         ctx->addMemberList(m_classDef,MemberListType_events,theTranslator->trEvents());
         ctx->addMemberList(m_classDef,MemberListType_priTypes,theTranslator->trPrivateTypes());
         ctx->addMemberList(m_classDef,MemberListType_priSlots,theTranslator->trPrivateSlots());
         ctx->addMemberList(m_classDef,MemberListType_priMethods,theTranslator->trPrivateMembers());
         ctx->addMemberList(m_classDef,MemberListType_priStaticMethods,theTranslator->trStaticPrivateMembers());
         ctx->addMemberList(m_classDef,MemberListType_priAttribs,theTranslator->trPrivateAttribs());
         ctx->addMemberList(m_classDef,MemberListType_priStaticAttribs,theTranslator->trStaticPrivateAttribs());
         ctx->addMemberList(m_classDef,MemberListType_related,theTranslator->trRelatedFunctions());
         cache.additionalInheritedMembers.reset(ctx);
       }
       return cache.additionalInheritedMembers.get();
     }

void ClassContext::Private::addMembers	(	ClassDef *	cd,
		MemberListType	lt
	)		const

inline

Definition at line 2393 of file context.cpp.

     {
       MemberList *ml = cd->getMemberList(lt);
       if (ml)
       {
         Cachable &cache = getCache();
         MemberListIterator li(*ml);
         const MemberDef *md;
         for (li.toFirst();(md=li.current());++li)
         {
           if (md->isBriefSectionVisible())
           {
             cache.allMembers.append(md);
           }
         }
       }
     }

void ClassContext::Private::addTemplateDecls	(	Definition *	d,
		TemplateList *	tl
	)		const

inline

Definition at line 2320 of file context.cpp.

     {
       if (d->definitionType()==Definition::TypeClass)
       {
         Definition *parent = d->getOuterScope();
         if (parent)
         {
           addTemplateDecls(parent,tl);
         }
         ClassDef *cd=(ClassDef *)d;
         if (cd->templateArguments())
         {
           ArgumentListContext *al = ArgumentListContext::alloc(cd->templateArguments(),cd,relPathAsString());
           // since a TemplateVariant does take ownership of the object, we add it
           // a separate list just to be able to delete it and avoid a memory leak
           tl->append(al);
         }
       }
     }

TemplateVariant ClassContext::Private::allMembersFileName ( ) const

inline

Definition at line 2465 of file context.cpp.

     {
       return m_classDef->getMemberListFileName();
     }

TemplateVariant ClassContext::Private::allMembersList ( ) const

inline

Definition at line 2448 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.allMembersList)
       {
         if (m_classDef->memberNameInfoSDict())
         {
           AllMembersListContext *ml = AllMembersListContext::alloc(m_classDef->memberNameInfoSDict());
           cache.allMembersList.reset(ml);
         }
         else
         {
           cache.allMembersList.reset(AllMembersListContext::alloc());
         }
       }
       return cache.allMembersList.get();
     }

TemplateVariant ClassContext::Private::categoryOf ( ) const

inline

Definition at line 2532 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.categoryOf && m_classDef->categoryOf())
       {
         cache.categoryOf.reset(ClassContext::alloc(m_classDef->categoryOf()));
       }
       if (cache.categoryOf)
       {
         return cache.categoryOf.get();
       }
       else
       {
         return TemplateVariant(FALSE);
       }
     }

TemplateVariant ClassContext::Private::classes ( ) const

inline

Definition at line 2268 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.classes)
       {
         TemplateList *classList = TemplateList::alloc();
         if (m_classDef->getClassSDict())
         {
           ClassSDict::Iterator sdi(*m_classDef->getClassSDict());
           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 ClassContext::Private::collaborationDiagram ( ) const

inline

Definition at line 2012 of file context.cpp.

     {
       static bool haveDot = Config_getBool("HAVE_DOT");
       QGString result;
       if (haveDot)
       {
         DotClassGraph *cg = getCollaborationGraph();
         FTextStream t(&result);
         switch (g_globals.outputFormat)
         {
           case ContextOutputFormat_Html:
             {
               cg->writeGraph(t,GOF_BITMAP,EOF_Html,
                              g_globals.outputDir,
                              g_globals.outputDir+portable_pathSeparator()+m_classDef->getOutputFileBase()+Doxygen::htmlFileExtension,
                              relPathAsString(),TRUE,TRUE,g_globals.dynSectionId
                             );
             }
             break;
           case ContextOutputFormat_Latex:
             {
               cg->writeGraph(t,GOF_EPS,EOF_LaTeX,
                              g_globals.outputDir,
                              g_globals.outputDir+portable_pathSeparator()+m_classDef->getOutputFileBase()+".tex",
                              relPathAsString(),TRUE,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 ClassContext::Private::compoundType ( ) const

inline

Definition at line 2316 of file context.cpp.

     {
       return m_classDef->compoundTypeString();
     }

TemplateVariant ClassContext::Private::detailedConstructors ( ) const

inline

Definition at line 2244 of file context.cpp.

     {
       return getMemberList(getCache().detailedConstructors,MemberListType_constructors,theTranslator->trConstructorDocumentation(),TRUE);
     }

TemplateVariant ClassContext::Private::detailedEnums ( ) const

inline

Definition at line 2232 of file context.cpp.

     {
       return getMemberList(getCache().detailedEnums,MemberListType_enumMembers,theTranslator->trMemberEnumerationDocumentation(),TRUE);
     }

TemplateVariant ClassContext::Private::detailedEvents ( ) const

inline

Definition at line 2264 of file context.cpp.

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

TemplateVariant ClassContext::Private::detailedInterfaces ( ) const

inline

Definition at line 2240 of file context.cpp.

     {
       return getMemberList(getCache().detailedInterfaces,MemberListType_interfaceMembers,theTranslator->trInterfaces(),TRUE);
     }

TemplateVariant ClassContext::Private::detailedMethods ( ) const

inline

Definition at line 2248 of file context.cpp.

     {
       return getMemberList(getCache().detailedMethods,MemberListType_functionMembers,theTranslator->trMemberFunctionDocumentation(),TRUE);
     }

TemplateVariant ClassContext::Private::detailedProperties ( ) const

inline

Definition at line 2260 of file context.cpp.

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

TemplateVariant ClassContext::Private::detailedRelated ( ) const

inline

Definition at line 2252 of file context.cpp.

     {
       return getMemberList(getCache().detailedRelated,MemberListType_relatedMembers,theTranslator->trRelatedFunctionDocumentation(),TRUE);
     }

TemplateVariant ClassContext::Private::detailedServices ( ) const

inline

Definition at line 2236 of file context.cpp.

     {
       return getMemberList(getCache().detailedServices,MemberListType_serviceMembers,theTranslator->trServices(),TRUE);
     }

TemplateVariant ClassContext::Private::detailedTypedefs ( ) const

inline

Definition at line 2228 of file context.cpp.

     {
       return getMemberList(getCache().detailedTypedefs,MemberListType_typedefMembers,theTranslator->trMemberTypedefDocumentation(),TRUE);
     }

TemplateVariant ClassContext::Private::detailedVariables ( ) const

inline

Definition at line 2256 of file context.cpp.

     {
       return getMemberList(getCache().detailedVariables,MemberListType_variableMembers,theTranslator->trMemberDataDocumentation(),TRUE);
     }

TemplateVariant ClassContext::Private::events ( ) const

inline

Definition at line 2216 of file context.cpp.

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

TemplateVariant ClassContext::Private::examples ( ) const

inline

Definition at line 2382 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.examples)
       {
         TemplateList *exampleList = TemplateList::alloc();
         addExamples(exampleList);
         cache.examples.reset(exampleList);
       }
       return cache.examples.get();
     }

TemplateVariant ClassContext::Private::friends ( ) const

inline

Definition at line 2220 of file context.cpp.

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

TemplateVariant ClassContext::Private::generatedFromFiles ( ) const

inline

Definition at line 1879 of file context.cpp.

     {
       return m_classDef->generatedFromFiles();
     }

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

inline

Definition at line 1859 of file context.cpp.

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

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

inlineprivate

Definition at line 2615 of file context.cpp.

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

DotClassGraph* ClassContext::Private::getClassGraph ( ) const

inline

Definition at line 1892 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.classGraph)
       {
         cache.classGraph.reset(new DotClassGraph(m_classDef,DotNode::Inheritance));
       }
       return cache.classGraph.get();
     }

DotClassGraph* ClassContext::Private::getCollaborationGraph ( ) const

inline

Definition at line 1998 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.collaborationGraph)
       {
         cache.collaborationGraph.reset(new DotClassGraph(m_classDef,DotNode::Collaboration));
       }
       return cache.collaborationGraph.get();
     }

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

inline

Definition at line 2084 of file context.cpp.

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

TemplateVariant ClassContext::Private::hasCollaborationDiagram ( ) const

inline

Definition at line 2007 of file context.cpp.

     {
       static bool haveDot = Config_getBool("HAVE_DOT");
       return haveDot && !getCollaborationGraph()->isTrivial();
     }

TemplateVariant ClassContext::Private::hasDetails ( ) const

inline

Definition at line 1875 of file context.cpp.

     {
       return m_classDef->hasDetailedDescription();
     }

TemplateVariant ClassContext::Private::hasInheritanceDiagram ( ) const

inline

Definition at line 1910 of file context.cpp.

     {
       bool result=FALSE;
       static bool haveDot       = Config_getBool("HAVE_DOT");
       static bool classDiagrams = Config_getBool("CLASS_DIAGRAMS");
       static bool classGraph    = Config_getBool("CLASS_GRAPH");
       if (haveDot && (classDiagrams || classGraph))
       {
         DotClassGraph *cg = getClassGraph();
         result = !cg->isTrivial() && !cg->isTooBig();
       }
       else if (classDiagrams)
       {
         result = numInheritanceNodes()>0;
       }
       return result;
     }

TemplateVariant ClassContext::Private::highlight ( ) const

inline

Definition at line 1867 of file context.cpp.

     {
       return TemplateVariant("classes");
     }

TemplateVariant ClassContext::Private::includeInfo ( ) const

inline

Definition at line 2050 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.includeInfo && m_classDef->includeInfo())
       {
         cache.includeInfo.reset(IncludeInfoContext::alloc(m_classDef->includeInfo(),m_classDef->getLanguage()));
       }
       if (cache.includeInfo)
       {
         return cache.includeInfo.get();
       }
       else
       {
         return TemplateVariant(FALSE);
       }
     }

TemplateVariant ClassContext::Private::inheritanceDiagram ( ) const

inline

Definition at line 1927 of file context.cpp.

     {
       QGString result;
       static bool haveDot       = Config_getBool("HAVE_DOT");
       static bool classDiagrams = Config_getBool("CLASS_DIAGRAMS");
       static bool classGraph    = Config_getBool("CLASS_GRAPH");
       if (haveDot && (classDiagrams || classGraph))
       {
         DotClassGraph *cg = getClassGraph();
         FTextStream t(&result);
         switch (g_globals.outputFormat)
         {
           case ContextOutputFormat_Html:
             {
               cg->writeGraph(t,GOF_BITMAP,EOF_Html,
                              g_globals.outputDir,
                              g_globals.outputDir+portable_pathSeparator()+m_classDef->getOutputFileBase()+Doxygen::htmlFileExtension,
                              relPathAsString(),TRUE,TRUE,g_globals.dynSectionId
                             );
             }
             break;
           case ContextOutputFormat_Latex:
             {
               cg->writeGraph(t,GOF_EPS,EOF_LaTeX,
                              g_globals.outputDir,
                              g_globals.outputDir+portable_pathSeparator()+m_classDef->getOutputFileBase()+".tex",
                              relPathAsString(),TRUE,TRUE,g_globals.dynSectionId
                             );
             }
             break;
             // TODO: support other generators
           default:
             err("context.cpp: output format not yet supported");
             break;
         }
         g_globals.dynSectionId++;
       }
       else if (classDiagrams)
       {
         ClassDiagram d(m_classDef);
         FTextStream t(&result);
         switch (g_globals.outputFormat)
         {
           case ContextOutputFormat_Html:
             {
               QCString name = convertToHtml(m_classDef->displayName());
               t << "<div class=\"center\">" << endl;
               t << "<img src=\"";
               t << relPathAsString() << m_classDef->getOutputFileBase();
               t << ".png\" usemap=\"#" << convertToId(name) << "_map\" alt=\"\"/>" << endl;
               t << "<map id=\"" << convertToId(name) << "_map\" name=\"" << name << "_map\">" << endl;
               d.writeImage(t,g_globals.outputDir,
                            relPathAsString(),
                            m_classDef->getOutputFileBase());
               t << "</div>";
             }
             break;
           case ContextOutputFormat_Latex:
             {
               d.writeFigure(t,g_globals.outputDir,m_classDef->getOutputFileBase());
             }
             break;
             // TODO: support other generators
           default:
             err("context.cpp: output format not yet supported");
             break;
         }
         g_globals.dynSectionId++;
       }
       return TemplateVariant(result.data(),TRUE);
     }

TemplateVariant ClassContext::Private::inheritedBy ( ) const

inline

Definition at line 2075 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.inheritedByList)
       {
         cache.inheritedByList.reset(InheritanceListContext::alloc(m_classDef->subClasses(),FALSE));
       }
       return cache.inheritedByList.get();
     }

TemplateVariant ClassContext::Private::inherits ( ) const

inline

Definition at line 2066 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.inheritsList)
       {
         cache.inheritsList.reset(InheritanceListContext::alloc(m_classDef->baseClasses(),TRUE));
       }
       return cache.inheritsList.get();
     }

TemplateVariant ClassContext::Private::innerClasses ( ) const

inline

Definition at line 2290 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.innerClasses)
       {
         TemplateList *classList = TemplateList::alloc();
         if (m_classDef->getClassSDict())
         {
           ClassSDict::Iterator sdi(*m_classDef->getClassSDict());
           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.innerClasses.reset(classList);
       }
       return cache.innerClasses.get();
     }

TemplateVariant ClassContext::Private::isSimple ( ) const

inline

Definition at line 2528 of file context.cpp.

     {
       return m_classDef->isSimple();
     }

TemplateVariant ClassContext::Private::memberGroups ( ) const

inline

Definition at line 2469 of file context.cpp.

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

TemplateVariant ClassContext::Private::members ( ) const

inline

Definition at line 2410 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.members)
       {
         addMembers(m_classDef,MemberListType_pubTypes);
         addMembers(m_classDef,MemberListType_services);
         addMembers(m_classDef,MemberListType_interfaces);
         addMembers(m_classDef,MemberListType_pubSlots);
         addMembers(m_classDef,MemberListType_signals);
         addMembers(m_classDef,MemberListType_pubMethods);
         addMembers(m_classDef,MemberListType_pubStaticMethods);
         addMembers(m_classDef,MemberListType_pubAttribs);
         addMembers(m_classDef,MemberListType_pubStaticAttribs);
         addMembers(m_classDef,MemberListType_proTypes);
         addMembers(m_classDef,MemberListType_proSlots);
         addMembers(m_classDef,MemberListType_proMethods);
         addMembers(m_classDef,MemberListType_proStaticMethods);
         addMembers(m_classDef,MemberListType_proAttribs);
         addMembers(m_classDef,MemberListType_proStaticAttribs);
         addMembers(m_classDef,MemberListType_pacTypes);
         addMembers(m_classDef,MemberListType_pacMethods);
         addMembers(m_classDef,MemberListType_pacStaticMethods);
         addMembers(m_classDef,MemberListType_pacAttribs);
         addMembers(m_classDef,MemberListType_pacStaticAttribs);
         addMembers(m_classDef,MemberListType_properties);
         addMembers(m_classDef,MemberListType_events);
         addMembers(m_classDef,MemberListType_priTypes);
         addMembers(m_classDef,MemberListType_priSlots);
         addMembers(m_classDef,MemberListType_priMethods);
         addMembers(m_classDef,MemberListType_priStaticMethods);
         addMembers(m_classDef,MemberListType_priAttribs);
         addMembers(m_classDef,MemberListType_priStaticAttribs);
         addMembers(m_classDef,MemberListType_related);
         cache.members.reset(MemberListContext::alloc(&cache.allMembers));
       }
       return cache.members.get();
     }

int ClassContext::Private::numInheritanceNodes ( ) const

inline

Definition at line 1901 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (cache.inheritanceNodes==-1)
       {
         cache.inheritanceNodes=m_classDef->countInheritanceNodes();
       }
       return cache.inheritanceNodes>0;
     }

TemplateVariant ClassContext::Private::packageAttributes ( ) const

inline

Definition at line 2204 of file context.cpp.

     {
       return getMemberList(getCache().packageAttributes,MemberListType_pacAttribs,theTranslator->trPackageAttribs());
     }

TemplateVariant ClassContext::Private::packageMethods ( ) const

inline

Definition at line 2196 of file context.cpp.

     {
       return getMemberList(getCache().packageMethods,MemberListType_pacMethods,theTranslator->trPackageMembers());
     }

TemplateVariant ClassContext::Private::packageStaticAttributes ( ) const

inline

Definition at line 2208 of file context.cpp.

     {
       return getMemberList(getCache().packageStaticAttributes,MemberListType_pacStaticAttribs,theTranslator->trStaticPackageAttribs());
     }

TemplateVariant ClassContext::Private::packageStaticMethods ( ) const

inline

Definition at line 2200 of file context.cpp.

     {
       return getMemberList(getCache().packageStaticMethods,MemberListType_pacStaticMethods,theTranslator->trStaticPackageMembers());
     }

TemplateVariant ClassContext::Private::packageTypes ( ) const

inline

Definition at line 2192 of file context.cpp.

     {
       return getMemberList(getCache().packageTypes,MemberListType_pacTypes,theTranslator->trPackageTypes());
     }

TemplateVariant ClassContext::Private::privateAttributes ( ) const

inline

Definition at line 2184 of file context.cpp.

     {
       return getMemberList(getCache().privateAttributes,MemberListType_priAttribs,theTranslator->trPrivateAttribs());
     }

TemplateVariant ClassContext::Private::privateMethods ( ) const

inline

Definition at line 2176 of file context.cpp.

     {
       return getMemberList(getCache().privateMethods,MemberListType_priMethods,theTranslator->trPrivateMembers());
     }

TemplateVariant ClassContext::Private::privateSlots ( ) const

inline

Definition at line 2172 of file context.cpp.

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

TemplateVariant ClassContext::Private::privateStaticAttributes ( ) const

inline

Definition at line 2188 of file context.cpp.

     {
       return getMemberList(getCache().privateStaticAttributes,MemberListType_priStaticAttribs,theTranslator->trStaticPrivateAttribs());
     }

TemplateVariant ClassContext::Private::privateStaticMethods ( ) const

inline

Definition at line 2180 of file context.cpp.

     {
       return getMemberList(getCache().privateStaticMethods,MemberListType_priStaticMethods,theTranslator->trStaticPrivateMembers());
     }

TemplateVariant ClassContext::Private::privateTypes ( ) const

inline

Definition at line 2168 of file context.cpp.

     {
       return getMemberList(getCache().privateTypes,MemberListType_priTypes,theTranslator->trPrivateTypes());
     }

TemplateVariant ClassContext::Private::properties ( ) const

inline

Definition at line 2212 of file context.cpp.

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

TemplateVariant ClassContext::Private::protectedAttributes ( ) const

inline

Definition at line 2156 of file context.cpp.

     {
       return getMemberList(getCache().protectedAttributes,MemberListType_proAttribs,theTranslator->trProtectedAttribs());
     }

TemplateVariant ClassContext::Private::protectedMethods ( ) const

inline

Definition at line 2148 of file context.cpp.

     {
       return getMemberList(getCache().protectedMethods,MemberListType_proMethods,theTranslator->trProtectedMembers());
     }

TemplateVariant ClassContext::Private::protectedSlots ( ) const

inline

Definition at line 2164 of file context.cpp.

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

TemplateVariant ClassContext::Private::protectedStaticAttributes ( ) const

inline

Definition at line 2160 of file context.cpp.

     {
       return getMemberList(getCache().protectedStaticAttributes,MemberListType_proStaticAttribs,theTranslator->trStaticProtectedAttribs());
     }

TemplateVariant ClassContext::Private::protectedStaticMethods ( ) const

inline

Definition at line 2152 of file context.cpp.

     {
       return getMemberList(getCache().protectedStaticMethods,MemberListType_proStaticMethods,theTranslator->trStaticProtectedMembers());
     }

TemplateVariant ClassContext::Private::protectedTypes ( ) const

inline

Definition at line 2144 of file context.cpp.

     {
       return getMemberList(getCache().protectedTypes,MemberListType_proTypes,theTranslator->trProtectedTypes());
     }

TemplateVariant ClassContext::Private::publicAttributes ( ) const

inline

Definition at line 2132 of file context.cpp.

     {
       return getMemberList(getCache().publicAttributes,MemberListType_pubAttribs,theTranslator->trPublicAttribs());
     }

TemplateVariant ClassContext::Private::publicMethods ( ) const

inline

Definition at line 2120 of file context.cpp.

     {
       return getMemberList(getCache().publicMethods,MemberListType_pubMethods,
           m_classDef->getLanguage()==SrcLangExt_ObjC ? theTranslator->trInstanceMethods()
                                                      : theTranslator->trPublicMembers());
     }

TemplateVariant ClassContext::Private::publicSlots ( ) const

inline

Definition at line 2140 of file context.cpp.

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

TemplateVariant ClassContext::Private::publicStaticAttributes ( ) const

inline

Definition at line 2136 of file context.cpp.

     {
       return getMemberList(getCache().publicStaticAttributes,MemberListType_pubStaticAttribs,theTranslator->trStaticPublicAttribs());
     }

TemplateVariant ClassContext::Private::publicStaticMethods ( ) const

inline

Definition at line 2126 of file context.cpp.

     {
       return getMemberList(getCache().publicStaticMethods,MemberListType_pubStaticMethods,
           m_classDef->getLanguage()==SrcLangExt_ObjC ? theTranslator->trClassMethods()
                                                      : theTranslator->trStaticPublicMembers());
     }

TemplateVariant ClassContext::Private::publicTypes ( ) const

inline

Definition at line 2116 of file context.cpp.

     {
       return getMemberList(getCache().publicTypes,MemberListType_pubTypes,theTranslator->trPublicTypes());
     }

TemplateVariant ClassContext::Private::related ( ) const

inline

Definition at line 2224 of file context.cpp.

     {
       return getMemberList(getCache().related,MemberListType_related,theTranslator->trRelatedFunctions());
     }

TemplateVariant ClassContext::Private::signals ( ) const

inline

Definition at line 2112 of file context.cpp.

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

TemplateVariant ClassContext::Private::subHighlight ( ) const

inline

Definition at line 1871 of file context.cpp.

     {
       return TemplateVariant("");
     }

TemplateVariant ClassContext::Private::templateDecls ( ) const

inline

Definition at line 2358 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.templateDecls)
       {
         TemplateList *tl = TemplateList::alloc();
         addTemplateDecls(m_classDef,tl);
         cache.templateDecls.reset(tl);
       }
       return cache.templateDecls.get();
     }

TemplateVariant ClassContext::Private::title ( ) const

inline

Definition at line 1863 of file context.cpp.

     {
       return TemplateVariant(m_classDef->title());
     }

TemplateVariant ClassContext::Private::typeConstraints ( ) const

inline

Definition at line 2369 of file context.cpp.

     {
       if (m_classDef->typeConstraints())
       {
         Cachable &cache = getCache();
         if (!cache.typeConstraints && m_classDef->typeConstraints())
         {
           cache.typeConstraints.reset(ArgumentListContext::alloc(m_classDef->typeConstraints(),m_classDef,relPathAsString()));
         }
         return cache.typeConstraints.get();
       }
       return FALSE;
     }

TemplateVariant ClassContext::Private::unoIDLInterfaces ( ) const

inline

Definition at line 2108 of file context.cpp.

     {
       return getMemberList(getCache().unoIDLInterfaces,MemberListType_interfaces,theTranslator->trInterfaces());
     }

TemplateVariant ClassContext::Private::unoIDLServices ( ) const

inline

Definition at line 2104 of file context.cpp.

     {
       return getMemberList(getCache().unoIDLServices,MemberListType_services,theTranslator->trServices());
     }

TemplateVariant ClassContext::Private::usedFiles ( ) const

inline

Definition at line 1883 of file context.cpp.

     {
       Cachable &cache = getCache();
       if (!cache.usedFiles)
       {
         cache.usedFiles.reset(UsedFilesContext::alloc(m_classDef));
       }
       return cache.usedFiles.get();
     }

Member Data Documentation

ClassDef* ClassContext::Private::m_classDef

private

Definition at line 2550 of file context.cpp.

PropertyMapper< ClassContext::Private > ClassContext::Private::s_inst

staticprivate

Definition at line 2621 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