DefinitionContext< T > Class Template Reference

Classes
struct	Cachable

Public Member Functions
	DefinitionContext (Definition *d)
void	addBaseProperties (PropertyMapper< T > &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
Definition *	m_def

Detailed Description

template<typename T>
class DefinitionContext< T >

Definition at line 1357 of file context.cpp.

Constructor & Destructor Documentation

template<typename T>

DefinitionContext< T >::DefinitionContext ( Definition *  d )

inline

Definition at line 1360 of file context.cpp.

                                     : m_def(d)
    {
      assert(d!=0);
    }

Member Function Documentation

template<typename T>

void DefinitionContext< T >::addBaseProperties ( PropertyMapper< T > &  inst )

inline

Definition at line 1364 of file context.cpp.

    {
      //%% string name: the name of the symbol
      inst.addProperty("name",&DefinitionContext::name);
      //%% string bareName: the bare name of the symbol with scope info
      inst.addProperty("bareName",&DefinitionContext::bareName);
      //%% string relPath: the relative path to the root of the output (CREATE_SUBDIRS)
      inst.addProperty("relPath",&DefinitionContext::relPath);
      //%% string fileName: the file name of the output file associated with the symbol (without extension)
      inst.addProperty("fileName",&DefinitionContext::fileName);
      //%% string anchor: anchor within the page
      inst.addProperty("anchor",&DefinitionContext::anchor);
      //%% string details: the detailed documentation for this symbol
      inst.addProperty("details",&DefinitionContext::details);
      //%% string brief: the brief description for this symbol
      inst.addProperty("brief",&DefinitionContext::brief);
      //%% string inbodyDocs: the documentation found in the body
      inst.addProperty("inbodyDocs",&DefinitionContext::inbodyDocs);
      //%% string sourceFileName: the file name of the source file (without extension)
      inst.addProperty("sourceFileName",&DefinitionContext::sourceFileName);
      //%% bool isLinkable: can the symbol be linked to?
      inst.addProperty("isLinkable",&DefinitionContext::isLinkable);
      //%% bool isLinkableInProject: can the symbol be linked within this project?
      inst.addProperty("isLinkableInProject",&DefinitionContext::isLinkableInProject);
      //%% int dynSectionId: identifier that can be used for collapsable sections
      inst.addProperty("dynSectionId",&DefinitionContext::dynSectionId);
      //%% string language: the programming language in which the symbol is written
      inst.addProperty("language",&DefinitionContext::language);
      //%% string sourceDef: A link to the source definition
      inst.addProperty("sourceDef",&DefinitionContext::sourceDef);
      //%% list[Definition] navigationPath: Breadcrumb navigation path to this item
      inst.addProperty("navigationPath",&DefinitionContext::navigationPath);
      //%% string kind: Kind of compound object: class, namespace, module, package, page, dir
      inst.addProperty("compoundKind",&DefinitionContext::compoundKind);
      //%% bool isReference: is this definition imported via a tag file
      inst.addProperty("isReference",&DefinitionContext::isReference);
      //%% string externalReference: the link to the element in the remote documentation
      inst.addProperty("externalReference",&DefinitionContext::externalReference);
    }

template<typename T>

TemplateVariant DefinitionContext< T >::anchor ( ) const

inline

Definition at line 1407 of file context.cpp.

    {
      return m_def->anchor();
    }

template<typename T>

TemplateVariant DefinitionContext< T >::bareName ( ) const

inline

Definition at line 1427 of file context.cpp.

    {
      return m_def->displayName(FALSE);
    }

template<typename T>

TemplateVariant DefinitionContext< T >::brief ( ) const

inline

Definition at line 1451 of file context.cpp.

    {
      Cachable &cache = getCache();
      if (!cache.brief || g_globals.outputFormat!=cache.briefOutputFormat)
      {
        if (m_def->hasBriefDescription())
        {
          cache.brief.reset(new TemplateVariant(parseDoc(m_def,m_def->briefFile(),m_def->briefLine(),
                             relPathAsString(),m_def->briefDescription(),TRUE)));
          cache.briefOutputFormat = g_globals.outputFormat;
        }
        else
        {
          cache.brief.reset(new TemplateVariant(""));
        }
      }
      return *cache.brief;
    }

template<typename T>

TemplateVariant DefinitionContext< T >::compoundKind ( ) const

inline

Definition at line 1515 of file context.cpp.

    {
      QCString result = "unspecified";
      switch (m_def->definitionType())
      {
        case DefinitionIntf::TypeClass:     result="class";     break;
        case DefinitionIntf::TypeFile:      result="file";      break;
        case DefinitionIntf::TypeNamespace: result="namespace"; break;
        case DefinitionIntf::TypeGroup:     result="module";    break;
        case DefinitionIntf::TypePackage:   result="package";   break;
        case DefinitionIntf::TypePage:      result="page";      break;
        case DefinitionIntf::TypeDir:       result="dir";       break;
        case DefinitionIntf::TypeMember: // fall through
        case DefinitionIntf::TypeSymbolList:
                break;
      }
      return result;
    }

template<typename T>

TemplateVariant DefinitionContext< T >::details ( ) const

inline

Definition at line 1440 of file context.cpp.

    {
      Cachable &cache = getCache();
      if (!cache.details || g_globals.outputFormat!=cache.detailsOutputFormat)
      {
        cache.details.reset(new TemplateVariant(parseDoc(m_def,m_def->docFile(),m_def->docLine(),
                                            relPathAsString(),m_def->documentation(),FALSE)));
        cache.detailsOutputFormat = g_globals.outputFormat;
      }
      return *cache.details;
    }

template<typename T>

TemplateVariant DefinitionContext< T >::dynSectionId ( ) const

inline

Definition at line 1487 of file context.cpp.

    {
      return g_globals.dynSectionId;
    }

template<typename T>

TemplateVariant DefinitionContext< T >::externalReference ( ) const

inline

Definition at line 1581 of file context.cpp.

    {
      return m_def->externalReference(relPathAsString());
    }

template<typename T>

TemplateVariant DefinitionContext< T >::fileName ( ) const

inline

Definition at line 1403 of file context.cpp.

    {
      return m_def->getOutputFileBase();
    }

template<typename T>

void DefinitionContext< T >::fillPath ( Definition *  def, TemplateList *  list  ) const

inline

Definition at line 1545 of file context.cpp.

    {
      Definition *outerScope = def->getOuterScope();
      Definition::DefType type = def->definitionType();
      if (outerScope && outerScope!=Doxygen::globalScope)
      {
        fillPath(outerScope,list);
      }
      else if (type==Definition::TypeFile && ((const FileDef*)def)->getDirDef())
      {
        fillPath(((const FileDef*)def)->getDirDef(),list);
      }
      list->append(NavPathElemContext::alloc(def));
    }

template<typename T>

Cachable& DefinitionContext< T >::getCache ( ) const

inlineprivate

Definition at line 1640 of file context.cpp.

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

template<typename T>

TemplateVariant DefinitionContext< T >::inbodyDocs ( ) const

inline

Definition at line 1469 of file context.cpp.

    {
      Cachable &cache = getCache();
      if (!cache.inbodyDocs || g_globals.outputFormat!=cache.inbodyDocsOutputFormat)
      {
        if (!m_def->inbodyDocumentation().isEmpty())
        {
          cache.inbodyDocs.reset(new TemplateVariant(parseDoc(m_def,m_def->inbodyFile(),m_def->inbodyLine(),
                                           relPathAsString(),m_def->inbodyDocumentation(),FALSE)));
          cache.inbodyDocsOutputFormat = g_globals.outputFormat;
        }
        else
        {
          cache.inbodyDocs.reset(new TemplateVariant(""));
        }
      }
      return *cache.inbodyDocs;
    }

template<typename T>

TemplateVariant DefinitionContext< T >::isLinkable ( ) const

inline

Definition at line 1415 of file context.cpp.

    {
      return m_def->isLinkable();
    }

template<typename T>

TemplateVariant DefinitionContext< T >::isLinkableInProject ( ) const

inline

Definition at line 1419 of file context.cpp.

    {
      return m_def->isLinkableInProject();
    }

template<typename T>

TemplateVariant DefinitionContext< T >::isReference ( ) const

inline

Definition at line 1577 of file context.cpp.

    {
      return m_def->isReference();
    }

template<typename T>

TemplateVariant DefinitionContext< T >::language ( ) const

inline

Definition at line 1491 of file context.cpp.

    {
      SrcLangExt lang = m_def->getLanguage();
      QCString result = "unknown";
      switch (lang)
      {
        case SrcLangExt_Unknown:  break;
        case SrcLangExt_IDL:      result="idl";      break;
        case SrcLangExt_Java:     result="java";     break;
        case SrcLangExt_CSharp:   result="csharp";   break;
        case SrcLangExt_D:        result="d";        break;
        case SrcLangExt_PHP:      result="php";      break;
        case SrcLangExt_ObjC:     result="objc";     break;
        case SrcLangExt_Cpp:      result="cpp";      break;
        case SrcLangExt_JS:       result="js";       break;
        case SrcLangExt_Python:   result="python";   break;
        case SrcLangExt_Fortran:  result="fortran";  break;
        case SrcLangExt_VHDL:     result="vhdl";     break;
        case SrcLangExt_XML:      result="xml";      break;
        case SrcLangExt_Tcl:      result="tcl";      break;
        case SrcLangExt_Markdown: result="markdown"; break;
      }
      return result;
    }

template<typename T>

TemplateVariant DefinitionContext< T >::name ( ) const

inline

Definition at line 1423 of file context.cpp.

    {
      return m_def->displayName(TRUE);
    }

template<typename T>

TemplateVariant DefinitionContext< T >::navigationPath ( ) const

inline

Definition at line 1559 of file context.cpp.

    {
      Cachable &cache = getCache();
      if (!cache.navPath)
      {
        TemplateList *list = TemplateList::alloc();
        if (m_def->getOuterScope() && m_def->getOuterScope()!=Doxygen::globalScope)
        {
          fillPath(m_def->getOuterScope(),list);
        }
        else if (m_def->definitionType()==Definition::TypeFile && ((const FileDef *)m_def)->getDirDef())
        {
          fillPath(((const FileDef *)m_def)->getDirDef(),list);
        }
        cache.navPath.reset(list);
      }
      return cache.navPath.get();
    }

template<typename T>

virtual TemplateVariant DefinitionContext< T >::relPath ( ) const

inlinevirtual

Reimplemented in PageContext::Private, and DirContext::Private.

Definition at line 1436 of file context.cpp.

    {
      return relPathAsString();
    }

template<typename T>

QCString DefinitionContext< T >::relPathAsString ( ) const

inline

Definition at line 1431 of file context.cpp.

    {
      static bool createSubdirs = Config_getBool("CREATE_SUBDIRS");
      return createSubdirs ? QCString("../../") : QCString("");
    }

template<typename T>

TemplateVariant DefinitionContext< T >::sourceDef ( ) const

inline

Definition at line 1533 of file context.cpp.

    {
      Cachable &cache = getCache();
      if (cache.sourceDef->count()==2)
      {
        return cache.sourceDef.get();
      }
      else
      {
        return FALSE;
      }
    }

template<typename T>

TemplateVariant DefinitionContext< T >::sourceFileName ( ) const

inline

Definition at line 1411 of file context.cpp.

    {
      return m_def->getSourceFileBase();
    }

Member Data Documentation

template<typename T>

Definition* DefinitionContext< T >::m_def

private

Definition at line 1646 of file context.cpp.

---

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

• doxygen-1.8.11/src/context.cpp