name_detector.h

Go to the documentation of this file.

/*
 * Copyright (C) 2026 by Thun Lu. All rights reserved.
 * Author: Thun Lu <thun.lu@zohomail.cn>
 * Repo:   https://github.com/thun-res/vlink
 *  _    __   __      _           __
 * | |  / /  / /     (_) ____    / /__
 * | | / /  / /     / / / __ \  / //_/
 * | |/ /  / /___  / / / / / / / ,<
 * |___/  /_____/ /_/ /_/ /_/ /_/|_|
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
/**
 * @file name_detector.h
 * @brief Compile-time type-name and enum-name detection utilities.
 *
 * @details
 * The @c vlink::NameDetector namespace wraps the third-party @c nameof library
 * to provide a portable, @c constexpr API for obtaining the string representation
 * of a type or an enumeration value at compile time.
 *
 * These utilities are used by the VLink plugin system to automatically derive
 * plugin identifiers from interface class names, avoiding error-prone manual
 * string registration.
 *
 * Platform notes:
 * - On Windows (MSVC / MSYS2) the @c nameof library may prefix types with
 *   @c "struct " or @c "class ".  @c NameDetector::get() strips these prefixes
 *   automatically to return only the unqualified type name.
 * - On GCC/Clang the result of @c nameof::nameof_type<T>() is used directly.
 *
 * @note
 * The @c get<T>() function returns a @c constexpr @c std::string_view that
 * points into static storage generated by the compiler.  The view is valid for
 * the entire program lifetime.
 *
 * @par Example
 * @code
 * // Check support and get the type name:
 * if constexpr (vlink::NameDetector::is_support<MyPlugin>()) {
 *   constexpr std::string_view name = vlink::NameDetector::get<MyPlugin>();
 *   // name == "MyPlugin"
 * }
 *
 * // Get enum value name at runtime:
 * enum class Color { Red, Green, Blue };
 * std::string_view name = vlink::NameDetector::get_enum(Color::Green);
 * // name == "Green"
 * @endcode
 */
 
#pragma once
 
#include <string_view>
 
#include "../thirdparty/nameof.h"
 
namespace vlink {
 
/**
 * @namespace vlink::NameDetector
 * @brief Compile-time type-name and enum-name detection utilities.
 */
namespace NameDetector {  // NOLINT(readability-identifier-naming)
 
/**
 * @brief Checks at compile time whether the @c nameof library can produce a
 *        type name for @p T.
 *
 * @details
 * Returns @c true when the underlying @c nameof::detail::nameof_type_supported
 * trait evaluates to @c true for @p T.  When this returns @c false, calling
 * @c get<T>() may produce an empty or implementation-defined string.
 *
 * @tparam T  The type to check.
 * @return @c true if type-name detection is supported for @p T.
 */
template <typename T>
[[nodiscard]] constexpr bool is_support() noexcept;
 
/**
 * @brief Returns the unqualified compile-time name of type @p T as a
 *        @c std::string_view.
 *
 * @details
 * On Windows, leading @c "struct " and @c "class " prefixes that MSVC may
 * inject are stripped before returning.  On other platforms the raw
 * @c nameof::nameof_type<T>() result is returned.
 *
 * The returned view points to static storage (lifetime of the program).
 * It is used by the VLink plugin system to register interfaces by their
 * type name rather than by a manually specified string.
 *
 * @tparam T  The type whose name is requested.
 * @return A @c constexpr @c std::string_view containing the type name.
 *
 * @note
 * This function is @c constexpr on supported compilers.  The result is
 * identical whether evaluated at compile time or runtime.
 */
template <typename T>
[[nodiscard]] constexpr std::string_view get() noexcept;
 
/**
 * @brief Returns the string representation of an enumeration value @p e.
 *
 * @details
 * Wraps @c nameof::nameof_enum to obtain the enumerator name.  Returns
 * an empty @c std::string_view if the value is out of the known range.
 *
 * @tparam T  The enumeration type.
 * @param  e  The enumeration value to name.
 * @return A @c std::string_view containing the enumerator name, or an
 *         empty view if @p e is not a named enumerator.
 */
template <typename T>
[[nodiscard]] std::string_view get_enum(T e) noexcept;
 
}  // namespace NameDetector
 
////////////////////////////////////////////////////////////////
/// Details
////////////////////////////////////////////////////////////////
 
template <typename T>
inline constexpr bool NameDetector::is_support() noexcept {
  if constexpr (nameof::detail::nameof_type_supported<T>::value) {
    return true;
  } else {
    return false;
  }
}
 
template <typename T>
inline constexpr std::string_view NameDetector::get() noexcept {
#if defined(_WIN32) || defined(__CYGWIN__)
  std::string_view type_sv = nameof::nameof_type<T>();
 
  constexpr std::string_view kStructPrefix = "struct ";
  if (type_sv.rfind(kStructPrefix, 0) == 0) {
    type_sv.remove_prefix(kStructPrefix.length());
  }
 
  constexpr std::string_view kClassPrefix = "class ";
  if (type_sv.rfind(kClassPrefix, 0) == 0) {
    type_sv.remove_prefix(kClassPrefix.length());
  }
 
  return type_sv;
#else
  return nameof::nameof_type<T>();
#endif
}
 
template <typename T>
inline std::string_view NameDetector::get_enum(T e) noexcept {
  return nameof::nameof_enum(e);
}
 
}  // namespace vlink