Prevent code duplication for enum

Prevent some code duplication and more generic way to get string values

Author: albert-github

src/defgen.cpp

@@ -114,23 +114,8 @@ static void generateDEFForMember(const MemberDef *md,
     << md->getOutputFileBase() << "_1" << md->anchor()
     << "';\n";
 
-  t << memPrefix << "virt = ";
-  switch (md->virtualness())
-  {
-    case Specifier::Normal:  t << "normal;\n"; break;
-    case Specifier::Virtual: t << "virtual;\n"; break;
-    case Specifier::Pure:    t << "pure-virtual;\n"; break;
-    default: ASSERT(0);
-  }
-
-  t << memPrefix << "prot = ";
-  switch(md->protection())
-  {
-    case Protection::Public:    t << "public;\n"; break;
-    case Protection::Protected: t << "protected;\n"; break;
-    case Protection::Private:   t << "private;\n"; break;
-    case Protection::Package:   t << "package;\n"; break;
-  }
+  t << memPrefix << "virt = " << to_string_lower(md->virtualness()) << ";\n";
+  t << memPrefix << "prot = " << to_string_lower(md->protection()) << ";\n";
 
   if (md->memberType()!=MemberType::Define &&
       md->memberType()!=MemberType::Enumeration
@@ -341,47 +326,19 @@ static void generateDEFForClass(const ClassDef *cd,TextStream &t)
   for (const auto &bcd : cd->baseClasses())
   {
     t << "  cp-ref     = {\n" << "    ref-type = base;\n";
-    t << "    ref-id   = '"
-      << bcd.classDef->getOutputFileBase() << "';\n";
-    t << "    ref-prot = ";
-    switch (bcd.prot)
-    {
-      case Protection::Public:    t << "public;\n"; break;
-      case Protection::Package: // package scope is not possible
-      case Protection::Protected: t << "protected;\n"; break;
-      case Protection::Private:   t << "private;\n"; break;
-    }
-    t << "    ref-virt = ";
-    switch(bcd.virt)
-    {
-      case Specifier::Normal:  t << "non-virtual;";  break;
-      case Specifier::Virtual: t << "virtual;";      break;
-      case Specifier::Pure:    t << "pure-virtual;"; break;
-    }
-    t << "\n  };\n";
+    t << "    ref-id   = '" << bcd.classDef->getOutputFileBase() << "';\n";
+    t << "    ref-prot = " << to_string_lower_class(bcd.prot) << ";\n";
+    t << "    ref-virt = " << to_string_lower(bcd.virt) << ";\n";
+    t << "  };\n";
   }
 
   for (const auto &bcd : cd->subClasses())
   {
     t << "  cp-ref     = {\n" << "    ref-type = derived;\n";
-    t << "    ref-id   = '"
-      << bcd.classDef->getOutputFileBase() << "';\n";
-    t << "    ref-prot = ";
-    switch (bcd.prot)
-    {
-      case Protection::Public:    t << "public;\n"; break;
-      case Protection::Package: // packet scope is not possible!
-      case Protection::Protected: t << "protected;\n"; break;
-      case Protection::Private:   t << "private;\n"; break;
-    }
-    t << "    ref-virt = ";
-    switch (bcd.virt)
-    {
-      case Specifier::Normal:  t << "non-virtual;";  break;
-      case Specifier::Virtual: t << "virtual;";      break;
-      case Specifier::Pure:    t << "pure-virtual;"; break;
-    }
-    t << "\n  };\n";
+    t << "    ref-id   = '" << bcd.classDef->getOutputFileBase() << "';\n";
+    t << "    ref-prot = " << to_string_lower_class(bcd.prot) << ";\n";
+    t << "    ref-virt = " << to_string_lower(bcd.virt) << ";\n";
+    t << "  };\n";
   }
 
   size_t numMembers = 0;

src/message.h

@@ -156,108 +156,47 @@ template<> struct fmt::formatter<QCString> : formatter<std::string>
 template<> struct fmt::formatter<Protection> : formatter<std::string>
 {
   auto format(Protection prot, format_context& ctx) const {
-    std::string result="Unknown";
-    switch (prot)
-    {
-      case Protection::Public:    result="Public";     break;
-      case Protection::Protected: result="Protected";  break;
-      case Protection::Private:   result="Private";    break;
-      case Protection::Package:   result="Package";    break;
-    }
-    return formatter<std::string>::format(result, ctx);
+    return formatter<std::string>::format(to_string(prot), ctx);
   }
 };
 
 //! adds support for formatting Specifier
 template<> struct fmt::formatter<Specifier> : formatter<std::string>
 {
   auto format(Specifier spec, format_context& ctx) const {
-    std::string result="Unknown";
-    switch (spec)
-    {
-      case Specifier::Normal:   result="Normal";  break;
-      case Specifier::Virtual:  result="Virtual"; break;
-      case Specifier::Pure:     result="Pure";    break;
-    }
-    return formatter<std::string>::format(result, ctx);
+    return formatter<std::string>::format(to_string(spec), ctx);
   }
 };
 
 //! adds support for formatting MethodTypes
 template<> struct fmt::formatter<MethodTypes> : formatter<std::string>
 {
   auto format(MethodTypes mtype, format_context& ctx) const {
-    std::string result="Unknown";
-    switch (mtype)
-    {
-      case MethodTypes::Method:   result="Method";   break;
-      case MethodTypes::Signal:   result="Signal";   break;
-      case MethodTypes::Slot:     result="Slot";     break;
-      case MethodTypes::DCOP:     result="DCOP";     break;
-      case MethodTypes::Property: result="Property"; break;
-      case MethodTypes::Event:    result="Event";    break;
-    }
-    return formatter<std::string>::format(result, ctx);
+    return formatter<std::string>::format(to_string(mtype), ctx);
   }
 };
 
 //! adds support for formatting RelatesType
 template<> struct fmt::formatter<RelatesType> : formatter<std::string>
 {
   auto format(RelatesType type, format_context& ctx) const {
-    std::string result="Unknown";
-    switch (type)
-    {
-      case RelatesType::Simple:    result="Simple";    break;
-      case RelatesType::Duplicate: result="Duplicate"; break;
-      case RelatesType::MemberOf:  result="MemberOf";  break;
-    }
-    return formatter<std::string>::format(result, ctx);
+    return formatter<std::string>::format(to_string(type), ctx);
   }
 };
 
 //! adds support for formatting RelationShip
 template<> struct fmt::formatter<Relationship> : formatter<std::string>
 {
   auto format(Relationship relation, format_context& ctx) const {
-    std::string result="Unknown";
-    switch (relation)
-    {
-      case Relationship::Member:  result="Member";  break;
-      case Relationship::Related: result="Related"; break;
-      case Relationship::Foreign: result="Foreign"; break;
-    }
-    return formatter<std::string>::format(result, ctx);
+    return formatter<std::string>::format(to_string(relation), ctx);
   }
 };
 
 //! adds support for formatting SrcLangExt
 template<> struct fmt::formatter<SrcLangExt> : formatter<std::string>
 {
   auto format(SrcLangExt lang, format_context& ctx) const {
-    std::string result="Unknown";
-    switch (lang)
-    {
-      case SrcLangExt::Unknown:  result="Unknown";     break;
-      case SrcLangExt::IDL:      result="IDL";         break;
-      case SrcLangExt::Java:     result="Java";        break;
-      case SrcLangExt::CSharp:   result="C#";          break;
-      case SrcLangExt::D:        result="D";           break;
-      case SrcLangExt::PHP:      result="PHP";         break;
-      case SrcLangExt::ObjC:     result="Objective-C"; break;
-      case SrcLangExt::Cpp:      result="C++";         break;
-      case SrcLangExt::JS:       result="Javascript";  break;
-      case SrcLangExt::Python:   result="Python";      break;
-      case SrcLangExt::Fortran:  result="Fortran";     break;
-      case SrcLangExt::VHDL:     result="VHDL";        break;
-      case SrcLangExt::XML:      result="XML";         break;
-      //case SrcLangExt::Tcl:    result="Tcl";         break;
-      case SrcLangExt::Markdown: result="Markdown";    break;
-      case SrcLangExt::SQL:      result="SQL";         break;
-      case SrcLangExt::Slice:    result="Slice";       break;
-      case SrcLangExt::Lex:      result="Lex";         break;
-    }
-    return formatter<std::string>::format(result, ctx);
+    return formatter<std::string>::format(to_string(lang), ctx);
   }
 };
 

src/perlmodgen.cpp

@@ -1386,25 +1386,12 @@ static void addPerlModDocBlock(PerlModOutput &output,
 
 static const char *getProtectionName(Protection prot)
 {
-  switch (prot)
-  {
-    case Protection::Public:    return "public";
-    case Protection::Protected: return "protected";
-    case Protection::Private:   return "private";
-    case Protection::Package:   return "package";
-  }
-  return nullptr;
+  return to_string_lower(prot);
 }
 
 static const char *getVirtualnessName(Specifier virt)
 {
-  switch(virt)
-  {
-    case Specifier::Normal:  return "non_virtual";
-    case Specifier::Virtual: return "virtual";
-    case Specifier::Pure:    return "pure_virtual";
-  }
-  return nullptr;
+  return to_string_lower(virt);
 }
 
 static QCString pathDoxyfile;