vtkStringToken.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkStringToken_h
#define vtkStringToken_h
#include <token/Token.h>
 
#include "vtkCompiler.h"     // for VTK_COMPILER_GCC
#include "vtkSmartPointer.h" // for ivar
 
//clang-format off
#include <vtk_nlohmannjson.h>
#include VTK_NLOHMANN_JSON(json.hpp)
//clang-format on
 
#include <cstdint>       // for `std::uint*_t`
#include <unordered_set> // for membership API
 
// GCC 4.8.5 requires a space between the quotes and suffix operator.
// Whereas, C++23 deprecates the space here though.
#ifdef VTK_COMPILER_GCC
#if VTK_COMPILER_GCC_VERSION <= 40805
#define VTK_STRING_TOKEN_SPACE_BEFORE_SUFFIX 1
#else
#define VTK_STRING_TOKEN_SPACE_BEFORE_SUFFIX 0
#endif
#else
#define VTK_STRING_TOKEN_SPACE_BEFORE_SUFFIX 0
#endif
 
VTK_ABI_NAMESPACE_BEGIN
 
class VTKCOMMONCORE_EXPORT vtkStringToken
{
public:
  using Hash = std::uint32_t;
 
  VTK_WRAPEXCLUDE vtkStringToken(const char* data = nullptr, std::size_t size = std::string::npos);
  vtkStringToken(const std::string& data);
  inline constexpr vtkStringToken(Hash tokenId) noexcept
    : Id(tokenId)
  {
  }
 
  Hash GetId() const { return this->Id; }
  unsigned int GetHash() const { return static_cast<unsigned int>(this->Id); }
  const std::string& Data() const;
 
  bool IsValid() const;
  bool HasData() const;
 
  bool operator==(const vtkStringToken& other) const;
  bool operator!=(const vtkStringToken& other) const;
 
  bool operator<(const vtkStringToken& other) const;
  bool operator>(const vtkStringToken& other) const;
  bool operator<=(const vtkStringToken& other) const;
  bool operator>=(const vtkStringToken& other) const;
 
  inline static constexpr Hash StringHash(const char* data, std::size_t size) noexcept
  {
    return token_NAMESPACE::Token::stringHash(data, size);
  }
 
  static Hash InvalidHash();
 
  bool AddChild(vtkStringToken member);
  bool RemoveChild(vtkStringToken member);
  std::unordered_set<vtkStringToken> Children(bool recursive = true);
  static std::unordered_set<vtkStringToken> AllGroups();
 
protected:
  Hash Id;
};
 
inline void VTKCOMMONCORE_EXPORT from_json(const nlohmann::json& jj, vtkStringToken& tt)
{
  if (jj.is_number_integer())
  {
    tt = vtkStringToken(jj.get<vtkStringToken::Hash>());
  }
  else if (jj.is_string())
  {
    tt = jj.get<std::string>();
  }
  else
  {
    throw std::runtime_error("String tokens must be JSON integers or strings.");
  }
}
 
inline void VTKCOMMONCORE_EXPORT to_json(nlohmann::json& jj, const vtkStringToken& tt)
{
  if (tt.HasData())
  {
    jj = tt.Data();
  }
  else
  {
    jj = tt.GetId();
  }
}
 
VTK_ABI_NAMESPACE_END
 
namespace vtk
{
namespace literals
{
VTK_ABI_NAMESPACE_BEGIN
 
#if VTK_STRING_TOKEN_SPACE_BEFORE_SUFFIX
inline constexpr VTKCOMMONCORE_EXPORT vtkStringToken::Hash operator"" _hash(
  const char* data, std::size_t size)
#else
inline constexpr VTKCOMMONCORE_EXPORT vtkStringToken::Hash operator""_hash(
  const char* data, std::size_t size)
#endif
{
  return vtkStringToken::StringHash(data, size);
}
 
#if VTK_STRING_TOKEN_SPACE_BEFORE_SUFFIX
inline constexpr VTKCOMMONCORE_EXPORT vtkStringToken operator"" _token(
  const char* data, std::size_t size)
#else
inline constexpr VTKCOMMONCORE_EXPORT vtkStringToken operator""_token(
  const char* data, std::size_t size)
#endif
{
  return vtkStringToken(vtkStringToken::StringHash(data, size));
}
 
VTK_ABI_NAMESPACE_END
} // namespace literals
} // namespace vtk
 
VTK_ABI_NAMESPACE_BEGIN
bool VTKCOMMONCORE_EXPORT operator==(const std::string& a, const vtkStringToken& b);
bool VTKCOMMONCORE_EXPORT operator!=(const std::string& a, const vtkStringToken& b);
bool VTKCOMMONCORE_EXPORT operator>(const std::string& a, const vtkStringToken& b);
bool VTKCOMMONCORE_EXPORT operator<(const std::string& a, const vtkStringToken& b);
bool VTKCOMMONCORE_EXPORT operator>=(const std::string& a, const vtkStringToken& b);
bool VTKCOMMONCORE_EXPORT operator<=(const std::string& a, const vtkStringToken& b);
 
bool VTKCOMMONCORE_EXPORT operator==(const vtkStringToken& a, const std::string& b);
bool VTKCOMMONCORE_EXPORT operator!=(const vtkStringToken& a, const std::string& b);
bool VTKCOMMONCORE_EXPORT operator>(const vtkStringToken& a, const std::string& b);
bool VTKCOMMONCORE_EXPORT operator<(const vtkStringToken& a, const std::string& b);
bool VTKCOMMONCORE_EXPORT operator>=(const vtkStringToken& a, const std::string& b);
bool VTKCOMMONCORE_EXPORT operator<=(const vtkStringToken& a, const std::string& b);
 
bool VTKCOMMONCORE_EXPORT operator==(const char* a, const vtkStringToken& b);
bool VTKCOMMONCORE_EXPORT operator!=(const char* a, const vtkStringToken& b);
bool VTKCOMMONCORE_EXPORT operator>(const char* a, const vtkStringToken& b);
bool VTKCOMMONCORE_EXPORT operator<(const char* a, const vtkStringToken& b);
bool VTKCOMMONCORE_EXPORT operator>=(const char* a, const vtkStringToken& b);
bool VTKCOMMONCORE_EXPORT operator<=(const char* a, const vtkStringToken& b);
 
bool VTKCOMMONCORE_EXPORT operator==(const vtkStringToken& a, const char* b);
bool VTKCOMMONCORE_EXPORT operator!=(const vtkStringToken& a, const char* b);
bool VTKCOMMONCORE_EXPORT operator>(const vtkStringToken& a, const char* b);
bool VTKCOMMONCORE_EXPORT operator<(const vtkStringToken& a, const char* b);
bool VTKCOMMONCORE_EXPORT operator>=(const vtkStringToken& a, const char* b);
bool VTKCOMMONCORE_EXPORT operator<=(const vtkStringToken& a, const char* b);
VTK_ABI_NAMESPACE_END
 
namespace std
{
template <>
struct VTKCOMMONCORE_EXPORT hash<vtkStringToken>
{
  std::size_t operator()(const vtkStringToken& t) const { return t.GetId(); }
};
} // namespace std
 
#undef VTK_STRING_TOKEN_SPACE_BEFORE_SUFFIX
#endif // vtkStringToken_h