wip

arangodb · gnusi · Jan 31, 2022 · Jan 22, 2022 · Jan 23, 2022 · Jan 23, 2022
commit fc8a8671cd6f82e21d2a5f6adf669949ea143038
diff --git a/arangod/Agency/AgencyFeature.cpp b/arangod/Agency/AgencyFeature.cpp
@@ -297,23 +297,21 @@ void AgencyFeature::validateOptions(std::shared_ptr<ProgramOptions> options) {
   // - IResearchAnalyzer: analyzers are not needed by agency
   // - Action/Script/FoxxQueues/Frontend: Foxx and JavaScript APIs
   {
-    constexpr size_t kDisabledFeatures[]{
+    server().disableFeatures(std::array{
         ArangodServer::id<iresearch::IResearchFeature>(),
         ArangodServer::id<iresearch::IResearchAnalyzerFeature>(),
         ArangodServer::id<ActionFeature>(), ArangodServer::id<FoxxFeature>(),
-        ArangodServer::id<FrontendFeature>()};
-    server().disableFeatures(kDisabledFeatures);
+        ArangodServer::id<FrontendFeature>()});
   }
 
   if (!V8DealerFeature::javascriptRequestedViaOptions(options)) {
     // specifying --console requires JavaScript, so we can only turn Javascript
     // off if not requested
 
     // console mode inactive. so we can turn off V8
-    constexpr size_t kDisabledFeatures[]{ArangodServer::id<ScriptFeature>(),
-                                         ArangodServer::id<V8PlatformFeature>(),
-                                         ArangodServer::id<V8DealerFeature>()};
-    server().disableFeatures(kDisabledFeatures);
+    server().disableFeatures(std::array{ArangodServer::id<ScriptFeature>(),
+                                        ArangodServer::id<V8PlatformFeature>(),
+                                        ArangodServer::id<V8DealerFeature>()});
   }
 }
 

diff --git a/arangod/RestServer/CheckVersionFeature.cpp b/arangod/RestServer/CheckVersionFeature.cpp
@@ -99,8 +99,7 @@ void CheckVersionFeature::validateOptions(
 
   // we can turn off all warnings about environment here, because they
   // wil show up on a regular start later anyway
-  constexpr size_t kDisabledFeature[]{ArangodServer::id<EnvironmentFeature>()};
-  server().disableFeatures(kDisabledFeature);
+  server().disableFeatures(std::array{ArangodServer::id<EnvironmentFeature>()});
 }
 
 void CheckVersionFeature::start() {

diff --git a/arangod/RestServer/InitDatabaseFeature.cpp b/arangod/RestServer/InitDatabaseFeature.cpp
@@ -99,9 +99,8 @@ void InitDatabaseFeature::validateOptions(
 
     // we can turn off all warnings about environment here, because they
     // wil show up on a regular start later anyway
-    constexpr size_t kDisabledFeatures[]{
-        ArangodServer::id<EnvironmentFeature>()};
-    server().disableFeatures(kDisabledFeatures);
+    server().disableFeatures(
+        std::array{ArangodServer::id<EnvironmentFeature>()});
   }
 }
 

diff --git a/arangod/RestServer/ServerFeature.cpp b/arangod/RestServer/ServerFeature.cpp
@@ -198,24 +198,20 @@ void ServerFeature::validateOptions(std::shared_ptr<ProgramOptions> options) {
 
   auto disableDeamonAndSupervisor = [&]() {
     if constexpr (Server::contains<DaemonFeature>()) {
-      constexpr size_t kDisabledFeatures[]{Server::id<DaemonFeature>()};
-      server().disableFeatures(kDisabledFeatures);
+      server().disableFeatures(std::array{Server::id<DaemonFeature>()});
     }
     if constexpr (Server::contains<SupervisorFeature>()) {
-      constexpr size_t kDisabledFeatures[]{Server::id<SupervisorFeature>()};
-      server().disableFeatures(kDisabledFeatures);
+      server().disableFeatures(std::array{Server::id<SupervisorFeature>()});
     }
   };
 
   if (!_restServer) {
-    constexpr size_t kDisabledFeatures[]{
+    server().disableFeatures(std::array{
         Server::id<HttpEndpointProvider>(),
         Server::id<GeneralServerFeature>(),
         Server::id<SslServerFeature>(),
         Server::id<StatisticsFeature>(),
-    };
-
-    server().disableFeatures(kDisabledFeatures);
+    });
     disableDeamonAndSupervisor();
 
     if (!options->processingResult().touched("replication.auto-start")) {

diff --git a/arangod/RestServer/UpgradeFeature.cpp b/arangod/RestServer/UpgradeFeature.cpp
@@ -127,24 +127,21 @@ void UpgradeFeature::validateOptions(std::shared_ptr<ProgramOptions> options) {
   if (ServerState::instance()->isCoordinator()) {
     auto disableDeamonAndSupervisor = [&]() {
       if constexpr (Server::contains<DaemonFeature>()) {
-        constexpr size_t kDisabledFeatures[]{Server::id<DaemonFeature>()};
-        server().forceDisableFeatures(kDisabledFeatures);
+        server().forceDisableFeatures(std::array{Server::id<DaemonFeature>()});
       }
       if constexpr (Server::contains<SupervisorFeature>()) {
-        constexpr size_t kDisabledFeatures[]{Server::id<SupervisorFeature>()};
-        server().forceDisableFeatures(kDisabledFeatures);
+        server().forceDisableFeatures(
+            std::array{Server::id<SupervisorFeature>()});
       }
     };
 
-    constexpr size_t kOtherFeaturesToDisable[]{
-        Server::id<GreetingsFeature>(), Server::id<pregel::PregelFeature>()};
-    server().forceDisableFeatures(kOtherFeaturesToDisable);
+    server().forceDisableFeatures(std::array{
+        Server::id<GreetingsFeature>(), Server::id<pregel::PregelFeature>()});
     disableDeamonAndSupervisor();
   } else {
     server().forceDisableFeatures(_nonServerFeatures);
-    constexpr size_t kOtherFeaturesToDisable[]{
-        Server::id<BootstrapFeature>(), Server::id<HttpEndpointProvider>()};
-    server().forceDisableFeatures(kOtherFeaturesToDisable);
+    server().forceDisableFeatures(std::array{
+        Server::id<BootstrapFeature>(), Server::id<HttpEndpointProvider>()});
   }
 
   ReplicationFeature& replicationFeature =

diff --git a/arangod/RestServer/arangod.cpp b/arangod/RestServer/arangod.cpp
@@ -151,23 +151,23 @@
 using namespace arangodb;
 using namespace arangodb::application_features;
 
-constexpr size_t kNonServerFeatures[]{
-    ArangodServer::id<ActionFeature>(),
-    ArangodServer::id<AgencyFeature>(),
-    ArangodServer::id<ClusterFeature>(),
+constexpr auto kNonServerFeatures =
+    std::array{ArangodServer::id<ActionFeature>(),
+               ArangodServer::id<AgencyFeature>(),
+               ArangodServer::id<ClusterFeature>(),
 #ifdef ARANGODB_HAVE_FORK
-    ArangodServer::id<SupervisorFeature>(),
-    ArangodServer::id<DaemonFeature>(),
+               ArangodServer::id<SupervisorFeature>(),
+               ArangodServer::id<DaemonFeature>(),
 #endif
-    ArangodServer::id<FoxxFeature>(),
-    ArangodServer::id<GeneralServerFeature>(),
-    ArangodServer::id<GreetingsFeature>(),
-    ArangodServer::id<HttpEndpointProvider>(),
-    ArangodServer::id<LogBufferFeature>(),
-    ArangodServer::id<pregel::PregelFeature>(),
-    ArangodServer::id<ServerFeature>(),
-    ArangodServer::id<SslServerFeature>(),
-    ArangodServer::id<StatisticsFeature>()};
+               ArangodServer::id<FoxxFeature>(),
+               ArangodServer::id<GeneralServerFeature>(),
+               ArangodServer::id<GreetingsFeature>(),
+               ArangodServer::id<HttpEndpointProvider>(),
+               ArangodServer::id<LogBufferFeature>(),
+               ArangodServer::id<pregel::PregelFeature>(),
+               ArangodServer::id<ServerFeature>(),
+               ArangodServer::id<SslServerFeature>(),
+               ArangodServer::id<StatisticsFeature>()};
 
 static int runServer(int argc, char** argv, ArangoGlobalContext& context) {
   try {
@@ -191,55 +191,55 @@ static int runServer(int argc, char** argv, ArangoGlobalContext& context) {
          },
          {}});
 
-    server.addFeatures(Visitor{
-        []<typename T>(auto& server, TypeTag<T>) {
-          return std::make_unique<T>(server);
-        },
-        [](auto& server, TypeTag<GreetingsFeaturePhase>) {
-          return std::make_unique<GreetingsFeaturePhase>(server,
-                                                         std::false_type{});
-        },
-        [&ret](auto& server, TypeTag<CheckVersionFeature>) {
-          return std::make_unique<CheckVersionFeature>(server, &ret,
-                                                       kNonServerFeatures);
-        },
-        [&name](auto& server, TypeTag<ConfigFeature>) {
-          return std::make_unique<ConfigFeature>(server, name);
-        },
-        [](auto& server, TypeTag<InitDatabaseFeature>) {
-          return std::make_unique<InitDatabaseFeature>(server,
-                                                       kNonServerFeatures);
-        },
-        [](auto& server, TypeTag<LoggerFeature>) {
-          return std::make_unique<LoggerFeature>(server, true);
-        },
-        [&ret](auto& server, TypeTag<ScriptFeature>) {
-          return std::make_unique<ScriptFeature>(server, &ret);
-        },
-        [&ret](auto& server, TypeTag<ServerFeature>) {
-          return std::make_unique<ServerFeature>(server, &ret);
-        },
-        [](auto& server, TypeTag<ShutdownFeature>) {
-          constexpr size_t kFeatures[]{ArangodServer::id<ScriptFeature>()};
-          return std::make_unique<ShutdownFeature>(server, kFeatures);
-        },
-        [&name](auto& server, TypeTag<TempFeature>) {
-          return std::make_unique<TempFeature>(server, name);
-        },
-        [](auto& server, TypeTag<SslServerFeature>) {
+    server.addFeatures(
+        Visitor{[]<typename T>(auto& server, TypeTag<T>) {
+                  return std::make_unique<T>(server);
+                },
+                [](auto& server, TypeTag<GreetingsFeaturePhase>) {
+                  return std::make_unique<GreetingsFeaturePhase>(
+                      server, std::false_type{});
+                },
+                [&ret](auto& server, TypeTag<CheckVersionFeature>) {
+                  return std::make_unique<CheckVersionFeature>(
+                      server, &ret, kNonServerFeatures);
+                },
+                [&name](auto& server, TypeTag<ConfigFeature>) {
+                  return std::make_unique<ConfigFeature>(server, name);
+                },
+                [](auto& server, TypeTag<InitDatabaseFeature>) {
+                  return std::make_unique<InitDatabaseFeature>(
+                      server, kNonServerFeatures);
+                },
+                [](auto& server, TypeTag<LoggerFeature>) {
+                  return std::make_unique<LoggerFeature>(server, true);
+                },
+                [&ret](auto& server, TypeTag<ScriptFeature>) {
+                  return std::make_unique<ScriptFeature>(server, &ret);
+                },
+                [&ret](auto& server, TypeTag<ServerFeature>) {
+                  return std::make_unique<ServerFeature>(server, &ret);
+                },
+                [](auto& server, TypeTag<ShutdownFeature>) {
+                  return std::make_unique<ShutdownFeature>(
+                      server, std::array{ArangodServer::id<ScriptFeature>()});
+                },
+                [&name](auto& server, TypeTag<TempFeature>) {
+                  return std::make_unique<TempFeature>(server, name);
+                },
+                [](auto& server, TypeTag<SslServerFeature>) {
 #ifdef USE_ENTERPRISE
-          return std::make_unique<SslServerFeatureEE>(server);
+                  return std::make_unique<SslServerFeatureEE>(server);
 #else
-          return std::make_unique<SslServerFeature>(server);
+                  return std::make_unique<SslServerFeature>(server);
 #endif
-        },
-        [&ret](auto& server, TypeTag<UpgradeFeature>) {
-          return std::make_unique<UpgradeFeature>(server, &ret,
-                                                  kNonServerFeatures);
-        },
-        [](auto& server, TypeTag<HttpEndpointProvider>) {
-          return std::make_unique<EndpointFeature>(server);
-        }});
+                },
+                [&ret](auto& server, TypeTag<UpgradeFeature>) {
+                  return std::make_unique<UpgradeFeature>(server, &ret,
+                                                          kNonServerFeatures);
+                },
+                [](auto& server, TypeTag<HttpEndpointProvider>) {
+                  return std::make_unique<EndpointFeature>(server);
+                }});
 
     try {
       server.run(argc, argv);

diff --git a/arangod/V8Server/V8DealerFeature.cpp b/arangod/V8Server/V8DealerFeature.cpp
@@ -314,11 +314,10 @@ void V8DealerFeature::validateOptions(std::shared_ptr<ProgramOptions> options) {
   if (!_enableJS) {
     disable();
 
-    constexpr size_t kDisabledFeatures[]{
-        Server::id<V8PlatformFeature>(), Server::id<ActionFeature>(),
-        Server::id<ScriptFeature>(), Server::id<FoxxFeature>(),
-        Server::id<FrontendFeature>()};
-    server().disableFeatures(kDisabledFeatures);
+    server().disableFeatures(
+        std::array{Server::id<V8PlatformFeature>(), Server::id<ActionFeature>(),
+                   Server::id<ScriptFeature>(), Server::id<FoxxFeature>(),
+                   Server::id<FrontendFeature>()});
     return;
   }
 

diff --git a/client-tools/Backup/arangobackup.cpp b/client-tools/Backup/arangobackup.cpp
@@ -87,8 +87,8 @@ int main(int argc, char* argv[]) {
           return std::make_unique<BackupFeature>(server, ret);
         },
         [](ArangoBackupServer& server, TypeTag<ShutdownFeature>) {
-          constexpr size_t kFeatures[]{ArangoBackupServer::id<BackupFeature>()};
-          return std::make_unique<ShutdownFeature>(server, kFeatures);
+          return std::make_unique<ShutdownFeature>(
+              server, std::array{ArangoBackupServer::id<BackupFeature>()});
         }});
 
     try {

diff --git a/client-tools/Benchmark/arangobench.cpp b/client-tools/Benchmark/arangobench.cpp
@@ -93,8 +93,8 @@ int main(int argc, char* argv[]) {
           return std::make_unique<BenchFeature>(server, &ret);
         },
         [](ArangoBenchServer& server, TypeTag<ShutdownFeature>) {
-          constexpr size_t kFeatures[]{ArangoBenchServer::id<BenchFeature>()};
-          return std::make_unique<ShutdownFeature>(server, kFeatures);
+          return std::make_unique<ShutdownFeature>(
+              server, std::array{ArangoBenchServer::id<BenchFeature>()});
         },
         [&](ArangoBenchServer& server, TypeTag<TempFeature>) {
           return std::make_unique<TempFeature>(server, context.binaryName());

diff --git a/client-tools/Dump/arangodump.cpp b/client-tools/Dump/arangodump.cpp
@@ -96,8 +96,8 @@ int main(int argc, char* argv[]) {
           return std::make_unique<DumpFeature>(server, ret);
         },
         [](ArangoDumpServer& server, TypeTag<ShutdownFeature>) {
-          constexpr size_t kFeatures[]{ArangoDumpServer::id<DumpFeature>()};
-          return std::make_unique<ShutdownFeature>(server, kFeatures);
+          return std::make_unique<ShutdownFeature>(
+              server, std::array{ArangoDumpServer::id<DumpFeature>()});
         }});
 
     try {

diff --git a/client-tools/Export/arangoexport.cpp b/client-tools/Export/arangoexport.cpp
@@ -90,8 +90,8 @@ int main(int argc, char* argv[]) {
           return std::make_unique<ExportFeature>(server, &ret);
         },
         [](ArangoExportServer& server, TypeTag<ShutdownFeature>) {
-          constexpr size_t kFeatures[]{ArangoExportServer::id<ExportFeature>()};
-          return std::make_unique<ShutdownFeature>(server, kFeatures);
+          return std::make_unique<ShutdownFeature>(
+              server, std::array{ArangoExportServer::id<ExportFeature>()});
         },
         [&context](ArangoExportServer& server, TypeTag<TempFeature>) {
           return std::make_unique<TempFeature>(server, context.binaryName());

diff --git a/client-tools/Import/arangoimport.cpp b/client-tools/Import/arangoimport.cpp
@@ -90,8 +90,8 @@ int main(int argc, char* argv[]) {
           return std::make_unique<ImportFeature>(server, &ret);
         },
         [](ArangoImportServer& server, TypeTag<ShutdownFeature>) {
-          constexpr size_t kFeatures[]{ArangoImportServer::id<ImportFeature>()};
-          return std::make_unique<ShutdownFeature>(server, kFeatures);
+          return std::make_unique<ShutdownFeature>(
+              server, std::array{ArangoImportServer::id<ImportFeature>()});
         },
         [&](ArangoImportServer& server, TypeTag<TempFeature>) {
           return std::make_unique<TempFeature>(server, context.binaryName());

diff --git a/client-tools/Restore/arangorestore.cpp b/client-tools/Restore/arangorestore.cpp
@@ -88,9 +88,8 @@ int main(int argc, char* argv[]) {
           return std::make_unique<RestoreFeature>(server, ret);
         },
         [](ArangoRestoreServer& server, TypeTag<ShutdownFeature>) {
-          constexpr size_t kFeatures[]{
-              ArangoRestoreServer::id<RestoreFeature>()};
-          return std::make_unique<ShutdownFeature>(server, kFeatures);
+          return std::make_unique<ShutdownFeature>(
+              server, std::array{ArangoRestoreServer::id<RestoreFeature>()});
         },
         [&](ArangoRestoreServer& server, TypeTag<TempFeature>) {
           return std::make_unique<TempFeature>(server, context.binaryName());

diff --git a/client-tools/Shell/arangosh.cpp b/client-tools/Shell/arangosh.cpp
@@ -103,8 +103,8 @@ int main(int argc, char* argv[]) {
           return std::make_unique<TempFeature>(server, context.binaryName());
         },
         [](ArangoshServer& server, TypeTag<ShutdownFeature>) {
-          constexpr size_t kFeatures[]{ArangoshServer::id<ShellFeature>()};
-          return std::make_unique<ShutdownFeature>(server, kFeatures);
+          return std::make_unique<ShutdownFeature>(
+              server, std::array{ArangoshServer::id<ShellFeature>()});
         }});
 
     try {

diff --git a/client-tools/VPack/arangovpack.cpp b/client-tools/VPack/arangovpack.cpp
@@ -75,8 +75,8 @@ int main(int argc, char* argv[]) {
                                                  "none");
         },
         [](ArangoVPackServer& server, TypeTag<ShutdownFeature>) {
-          constexpr size_t kFeatures[]{ArangoVPackServer::id<VPackFeature>()};
-          return std::make_unique<ShutdownFeature>(server, kFeatures);
+          return std::make_unique<ShutdownFeature>(
+              server, std::array{ArangoVPackServer::id<VPackFeature>()});
         },
         [](ArangoVPackServer& server, TypeTag<GreetingsFeaturePhase>) {
           return std::make_unique<GreetingsFeaturePhase>(server,