Skip to content

Parsing

Demonstration and test of some parsing capabilities, such as variables, functions, operators, classes, enums, namespaces, templates, concepts, macros, SFINAE, etc.

Types

Name Description
Class Test class.
ClassTemplate Test class template.
ClassTemplateWithMembers Class template with members.
ClassWithMembers Class with members.
Enum Test enumeration.
EnumAfter Test enumeration with values documented after.
EnumClass Test scoped enumeration.
EnumStruct Test scoped enumeration.
ForwardClass Forward class declaration.
Struct Test struct.
StructTemplate Test struct template.
TypeAlias Test type alias.
TypeAliasTemplate Test type alias template.
TypeDef Test typedef.
Union Test union.
UnionTemplate Test union template.

Concepts

Name Description
Concept Test concept.
TrivialConcept Test trivial concept.

Macros

Name Description
MACRO Test macro.
MACRO_AFTER Test macro, documented after entity with /// comment
MACRO_WITH_ARGS Test macro with arguments.
MACRO_WITH_ARGS_AFTER Test macro with arguments, documented after entity with /// comment

Variables

Name Description
a Documented with /** ... */ style preceding comment.
b Documented with /// style preceding comment.
c Documented with /// style preceding comment that wraps across multiple lines and has multiple paragraphs.
d Documented after entity with /// comment
ptr1 Test variable of pointer type.
ptr2 Test variable of pointer type with initializer.
ref1 Test variable of reference type.
ref2 Test variable of reference type with initializer.
w Test variable.
x Test variable with initializer.
y Test variable with parenthetical initializer.
z Test variable with brace initializer.
λ Test variable with unicode character.

Operators

Name Description
operator+ Test operator.
operator+ Test operator template.
operator+ Test operator template with SFINAE.
operator+ Test inline operator.
operator+ Test inline operator template.
operator+ Test inline operator template with SFINAE.

Functions

Name Description
f Test function.
f Test function that returns a reference.
f Test function that returns a pointer.
f Test function template.
f Test function template with SFINAE.
f Test inline function.
f Test inline function template.
f Test inline function template with SFINAE.

Concept Details

Concept

template<class T> concept Concept = std::is_arithmetic_v<T>

Test concept.

TrivialConcept

template<class T> concept TrivialConcept = true

Test trivial concept.

Macro Details

MACRO

#define MACRO

Test macro.

MACRO_AFTER

#define MACRO_AFTER

Test macro, documented after entity with /// comment

MACRO_WITH_ARGS

#define MACRO_WITH_ARGS(x, y)

Test macro with arguments.

MACRO_WITH_ARGS_AFTER

#define MACRO_WITH_ARGS_AFTER(x, y)

Test macro with arguments, documented after entity with /// comment

Variable Details

a

int a

Documented with /** ... */ style preceding comment.

b

int b

Documented with /// style preceding comment.

c

int c

Documented with /// style preceding comment that wraps across multiple lines and has multiple paragraphs.

This is the second paragraph.

This is the third paragraph.

d

int d

Documented after entity with /// comment

ptr1

int* ptr1

Test variable of pointer type.

ptr2

int* ptr2

Test variable of pointer type with initializer.

ref1

int& ref1

Test variable of reference type.

ref2

int& ref2

Test variable of reference type with initializer.

w

int w

Test variable.

x

int x

Test variable with initializer.

y

int y

Test variable with parenthetical initializer.

z

int z

Test variable with brace initializer.

λ

int λ

Test variable with unicode character.

Operator Details

operator+

int operator+(int x, int y)

Test operator.

template<class T> T operator+(T x, T y)

Test operator template.

template<class T, std::enable_if_t<std::is_integral_v<T>, int> = 0> T operator+(T x, T y)

Test operator template with SFINAE.

inline int operator+(int x, int y)

Test inline operator.

template<class T> T operator+(T x, T y)

Test inline operator template.

template<class T, std::enable_if_t<std::is_integral_v<T>, int> = 0> T operator+(T x, T y)

Test inline operator template with SFINAE.

Function Details

f

int f(int x, int y)

Test function.

int& f(int x, int y)

Test function that returns a reference.

int* f(int x, int y)

Test function that returns a pointer.

template<class T> T f(T x, T y)

Test function template.

template<class T, std::enable_if_t<std::is_integral_v<T>, int> = 0> T f(T x, T y)

Test function template with SFINAE.

inline int f(int x, int y)

Test inline function.

template<class T> T f(T x, T y)

Test inline function template.

template<class T, std::enable_if_t<std::is_integral_v<T>, int> = 0> T f(T x, T y)

Test inline function template with SFINAE.