nameof_module/README.md

Nameof C++

 _   _                             __    _____
| \ | |                           / _|  / ____|_     _
|  \| | __ _ _ __ ___   ___  ___ | |_  | |   _| |_ _| |_
| . ` |/ _` | '_ ` _ \ / _ \/ _ \|  _| | |  |_   _|_   _|
| |\  | (_| | | | | | |  __/ (_) | |   | |____|_|   |_|
|_| \_|\__,_|_| |_| |_|\___|\___/|_|    \_____|

Branch	Linux/OSX	Windows	License	Codacy
master

Used to obtain the simple name of a variable, type, member, function, macros. Before, you had to use string literals to refer to definitions, which is brittle when renaming code elements because tools do not know to check these string literals.

Features

• C++17
• Header-only
• Dependency-free
• Compile-time
• Compilation check
• Name of variable
• Name of member
• Name of function
• Name of emum
• Name of macrose
• Name of type

Examples

• A nameof macros expression has this form

// Name of variable
NAMEOF(somevar) -> "somevar"
// Name of member
NAMEOF(person.address.zip_code) -> "zip_code"
// Name of function
NAMEOF(SomeMethod<int, float>) -> "SomeMethod"
NAMEOF_FULL(SomeMethod<int, float>) -> "SomeMethod4<int, float>"
// Name of enum
auto c = Color::RED;
NAMEOF_ENUM(c) -> "RED"
// Name of type
NAMEOF_TYPE(Color::RED) -> "Color"
NAMEOF_TYPE_T(int) -> "int"
// Name of macros
NAMEOF(__LINE__) -> "__LINE__"

• Constexpr

constexpr auto cx = NAMEOF(somevar); -> "somevar"
static_assert("somevar" == cx, "Wrong name!");

• Compilation check

NAMEOF_TYPE_T(std::stringgg) -> error namespace "std" has no member "stringgg"

• Validate parameters

void f(char* s) {
  if (s == nullptr)
    throw std::invalid_argument(NAMEOF(s).apend("with type = ").apend(NAMEOF_TYPE(s)));
}

• Serialization, for example json:

void to_json(json& j, const person& p) {
  j = json{{NAMEOF(p.name), p.name},
           {NAMEOF(p.address), p.address},
           {NAMEOF(p.age), p.age}};
}

void from_json(const json& j, person& p) {
  p.name =    j.at(NAMEOF(p.name));
  p.address = j.at(NAMEOF(p.address));
  p.age =     j.at(NAMEOF(p.age));
}

• Logging

template <typename T>
void f() {
  Log(NAMEOF(f) + " method entry with T = " + NAMEOF_TYPE_T(T));
}

Remarks

• Nameof return std::string_view.

• The argument expression identifies a code definition, but it is never evaluated.

• If you need raw fully-qualified name, use NAMEOF_RAW().

NAMEOF_RAW(somevar.somefield) -> "somevar.somefield"
NAMEOF_RAW(&SomeStruct::SomeMethod) -> "&SomeStruct::SomeMethod"

• Instead of macros NAMEOF_ENUM, you can use the function nameof::NameofEnum().

nameof::NameofEnum(Color::RED) -> "RED"
auto c = Color::RED;
nameof::NameofEnum(c) -> "RED"

• Instead of macros NAMEOF_TYPE, you can use the function nameof::NameofType<>.

nameof::NameofType(Color::RED) -> "Color"
nameof::NameofType<decltype(Color::RED)>() -> "Color"
nameof::NameofType<int> -> "int"

• NAMEOF_ENUM does not work on the GCC.

auto c = Color::RED;
NAMEOF_ENUM(c) -> "(Color)0"

• Spaces and Tabs ignored

NAMEOF(   somevar   ) -> "somevar"
NAMEOF(	somevar	) -> "somevar"

Integration

You should add required file nameof.hpp.

Compiler compatibility

• GCC
• Clang
• MSVC

Licensed under the MIT License