Domains

Breathe has some limited support for Sphinx domains. It tries to output targets that the Sphinx domain references expect. This should allow you to use Sphinx domain roles like :c:func:`foo` to link to output from Breathe.

The following targets are supported:

• C & C++ functions

• C++ classes

Class Example

Given the following Breathe directives:

.. doxygenclass:: TestNamespaceClasses::NamespacedClassTest
   :path: ../../examples/specific/class/xml

Which create formatted output like:

class NamespacedClassTest

first class inside of namespace

We can refer to NamespacedClassTest using:

:cpp:class:`TestNamespaceClasses::NamespacedClassTest`

which renders as TestNamespaceClasses::NamespacedClassTest, or using:

:cpp:class:`another reference <TestNamespaceClasses::NamespacedClassTest>`

which renders as: another reference.

Inner Class Example

Given the following Breathe directive:

.. doxygenclass:: OuterClass
   :path: ../../examples/specific/class/xml
   :members:

Which create formatted output like:

class OuterClass

class outside of namespace

class InnerClass

inner class

We can refer to OuterClass::InnerClass using:

:cpp:class:`OuterClass::InnerClass`

which renders as OuterClass::InnerClass.

Function Examples

Given the following Breathe directives:

.. doxygenfunction:: TestNamespaceClasses::NamespacedClassTest::function
   :path: ../../examples/specific/class/xml

.. doxygenfunction:: frob_foos
   :path: ../../examples/specific/alias/xml

Which create formatted output like:

virtual void TestNamespaceClasses::NamespacedClassTest::function() const = 0

namespaced class function

void frob_foos(void *Frobs)

Foo frob routine.

bob this something else

Side Effects

Frobs any foos.

bob this something else

Side Effects

Frobs any foos.

Parameters:

• Frobs – [out] any foos.

We can refer to namespaceFunc using:

:cpp:func:`TestNamespaceFunction::namespaceFunc()`

which renders as TestNamespaceFunction::namespaceFunc(), or using:

:cpp:func:`another reference <namespaceFunc()>`

which renders as: another reference. Note the use of the cpp domain.

And we can refer to frob_foos using:

:c:func:`frob_foos()`

which renders as: frob_foos(), or using:

:c:func:`another reference <frob_foos()>`

which renders as: another reference. Note the use of the c domain.

Typedef Examples

Given the following Breathe directives:

.. doxygentypedef:: TestTypedef
   :path: ../../examples/specific/typedef/xml

.. doxygennamespace:: TypeDefNamespace
   :path: ../../examples/specific/typedef/xml

.. doxygenclass:: TestClass
   :path: ../../examples/specific/typedef/xml
   :members:

which create formatted output like:

typedef int TestTypedef

namespace TypeDefNamespace

Typedefs

typedef char *AnotherTypedef

class TestClass

Public Types

typedef void *MemberTypedef

A typedef defined in a class.

We can refer to TestTypedef using:

:cpp:type:`TestTypedef`

which renders as TestTypedef, to TypeDefNamespace::AnotherTypedef using:

:cpp:type:`TypeDefNamespace::AnotherTypedef`

which renders as TypeDefNamespace::AnotherTypedef and to TestClass::MemberTypedef using:

:cpp:type:`TestClass::MemberTypedef`

which renders as TestClass::MemberTypedef.

Enum Value Examples

Given the following Breathe directives:

.. doxygenenumvalue:: VALUE
   :path: ../../examples/specific/enum/xml

.. doxygenenumvalue:: TestEnumNamespace::FIRST
   :path: ../../examples/specific/enum/xml

Which create formatted output like:

enumerator VALUE

enum value

enumerator FIRST

namespaced enum value

We can refer to VALUE using:

:cpp:enumerator:`VALUE`

which renders as VALUE and to TestEnumNamespace::FIRST using:

:cpp:enumerator:`TestEnumNamespace::FIRST`

which renders as TestEnumNamespace::FIRST.