Naming Convention - Revision history

Leigh at 22:04, 5 January 2026

2026-01-05T22:04:43Z

← Older revision		Revision as of 22:04, 5 January 2026
Line 1:		Line 1:
	The ''neoGFX'' naming convention is based on the idea that to aid readability of C++ code it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''Symbian OS''.		The ''neoGFX'' naming convention is based on the idea that to aid readability of C++ code it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''EPOC32'' (later ''Symbian OS'').

	The following table lists the various C++ syntactical constructs with their associated convention:		The following table lists the various C++ syntactical constructs with their associated convention:

Leigh at 22:03, 5 January 2026

2026-01-05T22:03:26Z

← Older revision		Revision as of 22:03, 5 January 2026
Line 36:		Line 36:
	\| event object \|\| upper camel case \|\| <code>FooBar</code>		\| event object \|\| upper camel case \|\| <code>FooBar</code>
	\|-		\|-
	\| event (virtual) getter function \|\| ~~snake_case~~ \|\| <code>foo_bar</code>		\| event (virtual) getter function \|\| snake case \|\| <code>foo_bar</code>
	\|}		\|}

Leigh at 22:02, 5 January 2026

2026-01-05T22:02:28Z

← Older revision		Revision as of 22:02, 5 January 2026
Line 8:		Line 8:
	! Construct !! Convention !! Example !! Note		! Construct !! Convention !! Example !! Note
	\|-		\|-
	\| macro \|\| ~~UPPER_SNAKE_CASE~~ \|\| <code>FOO_BAR</code> \|\| snake_case is used for in-class ''event definition'' macros		\| macro \|\| upper snake case \|\| <code>FOO_BAR</code> \|\| snake_case is used for in-class ''event definition'' macros
	\|-		\|-
	\| function name \|\| ~~snake_case~~ \|\| <code>foo_bar</code>		\| function name \|\| snake case \|\| <code>foo_bar</code>
	\|-		\|-
	\| struct/class name \|\| ~~snake_case~~ \|\| <code>foo_bar</code>		\| struct/class name \|\| snake case \|\| <code>foo_bar</code>
	\|-		\|-
	\| interface class name \|\| ~~snake_case~~; <code>i_</code> prefix \|\| <code>i_foo_bar</code> \|\| an ''interface class'' does not have any member variables, containing only pure virtual functions and any associated helper functions		\| interface class name \|\| snake case; <code>i_</code> prefix \|\| <code>i_foo_bar</code> \|\| an ''interface class'' does not have any member variables, containing only pure virtual functions and any associated helper functions
	\|-		\|-
	\| enum class name \|\| ~~snake_case~~ \|\| <code>foo_bar</code>		\| enum class name \|\| snake case \|\| <code>foo_bar</code>
	\|-		\|-
	\| enum name \|\| ~~snake_case~~; <code>_e</code> suffix \|\| <code>foo_bar_e</code> \|\| C-style enums		\| enum name \|\| snake case; <code>_e</code> suffix \|\| <code>foo_bar_e</code> \|\| C-style enums
	\|-		\|-
	\| enumerator \|\| ~~UpperCamelCase~~ \|\| <code>FooBar</code>		\| enumerator \|\| upper camel case \|\| <code>FooBar</code>
	\|-		\|-
	\| function parameter \|\| ~~CamelCase~~; <code>a</code> prefix \|\| <code>aFooBar</code> \|\| "a" for ''argument''		\| function parameter \|\| camel case; <code>a</code> prefix \|\| <code>aFooBar</code> \|\| "a" for ''argument''
	\|-		\|-
	\| local variable \|\| ~~lowerCamelCase~~ \|\| <code>fooBar</code>		\| local variable \|\| lower camel case \|\| <code>fooBar</code>
	\|-		\|-
	\| member variable (class) \|\| ~~CamelCase~~; <code>i</code> prefix \|\| <code>iFooBar</code> \|\| "i" for class ''instance'' variable		\| member variable (class) \|\| camel case; <code>i</code> prefix \|\| <code>iFooBar</code> \|\| "i" for class ''instance'' variable
	\|-		\|-
	\| member variable (struct) \|\| ~~lowerCamelCase~~ \|\| <code>fooBar</code> \|\| use <code>struct</code> for classes that don't have a ''class invariant''		\| member variable (struct) \|\| lower camel case \|\| <code>fooBar</code> \|\| use <code>struct</code> for classes that don't have a ''class invariant''
	\|-		\|-
	\| variable with static storage duration \|\| ~~CamelCase~~; <code>s</code> prefix \|\| <code>sFooBar</code>		\| variable with static storage duration \|\| camel case; <code>s</code> prefix \|\| <code>sFooBar</code>
	\|-		\|-
	\| variable with thread local storage duration \|\| ~~CamelCase~~; <code>t</code> prefix \|\| <code>tFooBar</code>		\| variable with thread local storage duration \|\| camel case; <code>t</code> prefix \|\| <code>tFooBar</code>
	\|-		\|-
	\| event object \|\| ~~UpperCamelCase~~ \|\| <code>FooBar</code>		\| event object \|\| upper camel case \|\| <code>FooBar</code>
	\|-		\|-
	\| event (virtual) getter function \|\| snake_case \|\| <code>foo_bar</code>		\| event (virtual) getter function \|\| snake_case \|\| <code>foo_bar</code>

Leigh at 19:47, 5 January 2026

2026-01-05T19:47:34Z

Leigh at 19:43, 5 January 2026

2026-01-05T19:43:33Z

← Older revision		Revision as of 19:43, 5 January 2026
Line 22:		Line 22:
	\| enumerator \|\| UpperCamelCase \|\| <code>MyEnumerator</code>		\| enumerator \|\| UpperCamelCase \|\| <code>MyEnumerator</code>
	\|-		\|-
	\| function parameter \|\| CamelCase; <code>a</code> prefix \|\| <code>~~myVariable~~</code> \|\| "a" for ''argument''		\| function parameter \|\| CamelCase; <code>a</code> prefix \|\| <code>aMyVariable</code> \|\| "a" for ''argument''
	\|-		\|-
	\| local variable \|\| lowerCamelCase \|\| <code>myVariable</code>		\| local variable \|\| lowerCamelCase \|\| <code>myVariable</code>

Leigh at 15:06, 5 May 2024

2024-05-05T15:06:02Z

← Older revision		Revision as of 15:06, 5 May 2024
Line 18:		Line 18:
	\| enum class name \|\| snake_case \|\| <code>my_enum</code>		\| enum class name \|\| snake_case \|\| <code>my_enum</code>
	\|-		\|-
	\| enum name \|\| snake_case; <code>_e</code> suffix \|\| <code>my_enum_e</code>		\| enum name \|\| snake_case; <code>_e</code> suffix \|\| <code>my_enum_e</code> \|\| C-style enums
	\|-		\|-
	\| enumerator \|\| UpperCamelCase \|\| <code>MyEnumerator</code>		\| enumerator \|\| UpperCamelCase \|\| <code>MyEnumerator</code>

Leigh at 15:04, 5 May 2024

2024-05-05T15:04:57Z

← Older revision		Revision as of 15:04, 5 May 2024
Line 1:		Line 1:
	The ''neoGFX'' naming convention is based on the idea that to aid readability it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''Symbian OS''.		The ''neoGFX'' naming convention is based on the idea that to aid readability of C++ code it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''Symbian OS''.

	The following table lists the various C++ syntactical constructs with their associated convention:		The following table lists the various C++ syntactical constructs with their associated convention:

Leigh at 15:04, 5 May 2024

2024-05-05T15:04:08Z

← Older revision		Revision as of 15:04, 5 May 2024
Line 36:		Line 36:
	\| event object \|\| UpperCamelCase \|\| <code>MyEvent</code>		\| event object \|\| UpperCamelCase \|\| <code>MyEvent</code>
	\|-		\|-
	\| event (virtual) function \|\| snake_case \|\| <code>my_event</code>		\| event (virtual) getter function \|\| snake_case \|\| <code>my_event</code>
	\|}		\|}

Leigh at 15:03, 5 May 2024

2024-05-05T15:03:17Z

← Older revision		Revision as of 15:03, 5 May 2024
Line 1:		Line 1:
	The neoGFX naming convention is based on the idea that to aid readability it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''Symbian OS''.		The ''neoGFX'' naming convention is based on the idea that to aid readability it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''Symbian OS''.

	The following table lists the various C++ syntactical constructs with their associated convention:		The following table lists the various C++ syntactical constructs with their associated convention:

Leigh: Created page with "The neoGFX naming convention is based on the idea that to aid readability it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''Symbian OS''. The following table lists the various C++ syntactical constructs with their associated convention: {| class="wikitable" style="margin-left: 0px; margin-right: auto;" |+ neoGFX Naming Convention |- ! Co..."

2024-05-05T15:02:40Z

Created page with "The neoGFX naming convention is based on the idea that to aid readability it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''Symbian OS''. The following table lists the various C++ syntactical constructs with their associated convention: {| class="wikitable" style="margin-left: 0px; margin-right: auto;" |+ neoGFX Naming Convention |- ! Co..."

New page

The neoGFX naming convention is based on the idea that to aid readability it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''Symbian OS''.

The following table lists the various C++ syntactical constructs with their associated convention:

{| class="wikitable" style="margin-left: 0px; margin-right: auto;"
|+ neoGFX Naming Convention
|-
! Construct !! Convention !! Example !! Note
|-
| macro || UPPER_SNAKE_CASE || <code>MY_MACRO</code> || snake_case is used for in-class ''event definition'' macros
|-
| function name || snake_case || <code>my_function</code>
|-
| struct/class name || snake_case || <code>my_class</code>
|-
| interface class name || snake_case; <code>i_</code> prefix || <code>i_my_interface</code> || an ''interface class'' does not have any member variables, containing only pure virtual functions and any associated helper functions
|-
| enum class name || snake_case || <code>my_enum</code>
|-
| enum name || snake_case; <code>_e</code> suffix || <code>my_enum_e</code>
|-
| enumerator || UpperCamelCase || <code>MyEnumerator</code>
|-
| function parameter || CamelCase; <code>a</code> prefix || <code>myVariable</code> || "a" for ''argument''
|-
| local variable || lowerCamelCase || <code>myVariable</code>
|-
| member variable (class) || CamelCase; <code>i</code> prefix || <code>iMyVariable</code> || "i" for class ''instance'' variable
|-
| member variable (struct) || lowerCamelCase || <code>myVariable</code> || use <code>struct</code> for classes that don't have a ''class invariant''
|-
| variable with static storage duration || CamelCase; <code>s</code> prefix || <code>sMyVariable</code>
|-
| variable with thread local storage duration || CamelCase; <code>t</code> prefix || <code>tMyVariable</code>
|-
| event object || UpperCamelCase || <code>MyEvent</code>
|-
| event (virtual) function || snake_case || <code>my_event</code>
|}

Example class:
<pre>
class foo
{
public:
foo(int aValue) : iValue{ aValue }
{
}
public:
int value() const
{
return iValue;
}
void something()
{
thread_local qux tQux;
/* ... code ... */
}
private:
int iValue;
};
</pre>

← Older revision		Revision as of 19:47, 5 January 2026
Line 8:		Line 8:
	! Construct !! Convention !! Example !! Note		! Construct !! Convention !! Example !! Note
	\|-		\|-
	\| macro \|\| UPPER_SNAKE_CASE \|\| <code>~~MY_MACRO~~</code> \|\| snake_case is used for in-class ''event definition'' macros		\| macro \|\| UPPER_SNAKE_CASE \|\| <code>FOO_BAR</code> \|\| snake_case is used for in-class ''event definition'' macros
	\|-		\|-
	\| function name \|\| snake_case \|\| <code>~~my_function~~</code>		\| function name \|\| snake_case \|\| <code>foo_bar</code>
	\|-		\|-
	\| struct/class name \|\| snake_case \|\| <code>~~my_class~~</code>		\| struct/class name \|\| snake_case \|\| <code>foo_bar</code>
	\|-		\|-
	\| interface class name \|\| snake_case; <code>i_</code> prefix \|\| <code>~~i_my_interface~~</code> \|\| an ''interface class'' does not have any member variables, containing only pure virtual functions and any associated helper functions		\| interface class name \|\| snake_case; <code>i_</code> prefix \|\| <code>i_foo_bar</code> \|\| an ''interface class'' does not have any member variables, containing only pure virtual functions and any associated helper functions
	\|-		\|-
	\| enum class name \|\| snake_case \|\| <code>~~my_enum~~</code>		\| enum class name \|\| snake_case \|\| <code>foo_bar</code>
	\|-		\|-
	\| enum name \|\| snake_case; <code>_e</code> suffix \|\| <code>~~my_enum_e~~</code> \|\| C-style enums		\| enum name \|\| snake_case; <code>_e</code> suffix \|\| <code>foo_bar_e</code> \|\| C-style enums
	\|-		\|-
	\| enumerator \|\| UpperCamelCase \|\| <code>~~MyEnumerator~~</code>		\| enumerator \|\| UpperCamelCase \|\| <code>FooBar</code>
	\|-		\|-
	\| function parameter \|\| CamelCase; <code>a</code> prefix \|\| <code>~~aMyVariable~~</code> \|\| "a" for ''argument''		\| function parameter \|\| CamelCase; <code>a</code> prefix \|\| <code>aFooBar</code> \|\| "a" for ''argument''
	\|-		\|-
	\| local variable \|\| lowerCamelCase \|\| <code>~~myVariable~~</code>		\| local variable \|\| lowerCamelCase \|\| <code>fooBar</code>
	\|-		\|-
	\| member variable (class) \|\| CamelCase; <code>i</code> prefix \|\| <code>~~iMyVariable~~</code> \|\| "i" for class ''instance'' variable		\| member variable (class) \|\| CamelCase; <code>i</code> prefix \|\| <code>iFooBar</code> \|\| "i" for class ''instance'' variable
	\|-		\|-
	\| member variable (struct) \|\| lowerCamelCase \|\| <code>~~myVariable~~</code> \|\| use <code>struct</code> for classes that don't have a ''class invariant''		\| member variable (struct) \|\| lowerCamelCase \|\| <code>fooBar</code> \|\| use <code>struct</code> for classes that don't have a ''class invariant''
	\|-		\|-
	\| variable with static storage duration \|\| CamelCase; <code>s</code> prefix \|\| <code>~~sMyVariable~~</code>		\| variable with static storage duration \|\| CamelCase; <code>s</code> prefix \|\| <code>sFooBar</code>
	\|-		\|-
	\| variable with thread local storage duration \|\| CamelCase; <code>t</code> prefix \|\| <code>~~tMyVariable~~</code>		\| variable with thread local storage duration \|\| CamelCase; <code>t</code> prefix \|\| <code>tFooBar</code>
	\|-		\|-
	\| event object \|\| UpperCamelCase \|\| <code>~~MyEvent~~</code>		\| event object \|\| UpperCamelCase \|\| <code>FooBar</code>
	\|-		\|-
	\| event (virtual) getter function \|\| snake_case \|\| <code>~~my_event~~</code>		\| event (virtual) getter function \|\| snake_case \|\| <code>foo_bar</code>
	\|}		\|}