Method generateStructCompareOperators

generator/VulkanHppGenerator.cpp:10484–10657

}

std::string VulkanHppGenerator::generateStructCompareOperators( std::pair<std::string, StructData> const & structData ) const
{
  static std::set<std::string> const simpleTypes = { "char",   "double",  "DWORD",    "float",    "HANDLE",  "HINSTANCE", "HMONITOR",
                                                     "HWND",   "int",     "int8_t",   "int16_t",  "int32_t", "int64_t",   "LPCWSTR",
                                                     "size_t", "uint8_t", "uint16_t", "uint32_t", "uint64_t" };
  // two structs are compared by comparing each of the elements
  std::string compareMembers, spaceshipMembers;
  std::string intro             = "";
  bool        nonDefaultCompare = false;
  std::string spaceshipOrdering = containsFloatingPoints( structData.second.members ) ? "std::partial_ordering" : "std::strong_ordering";
  for ( size_t i = 0; i < structData.second.members.size(); i++ )
  {
    MemberData const & member = structData.second.members[i];
    if ( member.deprecated.empty() )
    {
      auto typeIt = m_types.find( member.type.name );
      assert( typeIt != m_types.end() );
      if ( ( typeIt->second.category == TypeCategory::ExternalType ) && member.type.postfix.empty() && !simpleTypes.contains( member.type.name ) )
      {
        nonDefaultCompare = true;
        // this type might support operator==() or operator<=>()... that is, use memcmp
        compareMembers += intro + "( memcmp( &" + member.name + ", &rhs." + member.name + ", sizeof( " + member.type.name + " ) ) == 0 )";

        static std::string const spaceshipMemberTemplate =
          R"(      if ( auto cmp = memcmp( &${name}, &rhs.${name}, sizeof( ${type} ) ); cmp != 0 )
        return ( cmp < 0 ) ? ${ordering}::less : ${ordering}::greater;
)";
        spaceshipMembers +=
          replaceWithMap( spaceshipMemberTemplate, { { "name", member.name }, { "ordering", spaceshipOrdering }, { "type", member.type.name } } );
      }
      else if ( member.type.name == "char" && !member.lenExpressions.empty() )
      {
        // compare null-terminated strings
        nonDefaultCompare = true;
        assert( member.lenExpressions.size() < 3 );
        if ( member.lenExpressions.size() == 1 )
        {
          assert( member.lenExpressions[0] == "null-terminated" );
          if ( member.arraySizes.empty() )
          {
            compareMembers +=
              intro + "( ( " + member.name + " == rhs." + member.name + " ) || ( strcmp( " + member.name + ", rhs." + member.name + " ) == 0 ) )";

            static std::string const spaceshipMemberTemplate =
              R"(     if ( ${name} != rhs.${name} )
        if ( auto cmp = strcmp( ${name}, rhs.${name} ); cmp != 0 )
          return ( cmp < 0 ) ? ${ordering}::less : ${ordering}::greater;
)";
            spaceshipMembers += replaceWithMap( spaceshipMemberTemplate, { { "name", member.name }, { "ordering", spaceshipOrdering } } );
          }
          else
          {
            assert( member.arraySizes.size() == 1 );
            compareMembers += intro + "( strcmp( " + member.name + ", rhs." + member.name + " ) == 0 )";

            static std::string const spaceshipMemberTemplate =
              R"(     if ( auto cmp = strcmp( ${name}, rhs.${name} ); cmp != 0 )
          return ( cmp < 0 ) ? ${ordering}::less : ${ordering}::greater;