Rewritten FeatureConfig into set of functions

src/FeatureConfig.cc

@@ -2,7 +2,7 @@
 /*
  * aria2 - The high speed download utility
  *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
+ * Copyright (C) 2012 Tatsuhiro Tsujikawa
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -34,133 +34,106 @@
 /* copyright --> */
 #include "FeatureConfig.h"
 
-#include <numeric>
-
-#include "array_fun.h"
 #include "util.h"
-#include "Request.h"
 
 namespace aria2 {
 
-SharedHandle<FeatureConfig> FeatureConfig::featureConfig_;
+uint16_t getDefaultPort(const std::string& protocol)
+{
+  if(protocol == "http") {
+    return 80;
+  } else if(protocol == "https") {
+    return 443;
+  } else if(protocol == "ftp") {
+    return 21;
+  } else {
+    return 0;
+  }
+}
 
-const std::string FeatureConfig::FEATURE_HTTPS("HTTPS");
-const std::string FeatureConfig::FEATURE_BITTORRENT("BitTorrent");
-const std::string FeatureConfig::FEATURE_METALINK("Metalink");
-const std::string FeatureConfig::FEATURE_MESSAGE_DIGEST("Message Digest");
-const std::string FeatureConfig::FEATURE_ASYNC_DNS("Async DNS");
-const std::string FeatureConfig::FEATURE_XML_RPC("XML-RPC");
-const std::string FeatureConfig::FEATURE_GZIP("GZip");
-const std::string FeatureConfig::FEATURE_FIREFOX3_COOKIE("Firefox3 Cookie");
+std::string featureSummary()
+{
+  std::string s;
+  for(int i = 0; i < MAX_FEATURE; ++i) {
+    const char* name = strSupportedFeature(i);
+    if(name) {
+      s += name;
+      s += ", ";
+    }
+  }
+  return util::strip(s, ", ");
+}
 
-#ifdef ENABLE_SSL
-# define HTTPS_ENABLED true
-#else // !ENABLE_SSL
-# define HTTPS_ENABLED false
-#endif // !ENABLE_SSL
+const char* strSupportedFeature(int feature)
+{
+  switch(feature) {
+  case(FEATURE_ASYNC_DNS):
+#ifdef ENABLE_ASYNC_DNS
+    return "Async DNS";
+#else // !ENABLE_ASYNC_DNS
+    return 0;
+#endif // !ENABLE_ASYNC_DNS
+    break;
 
+  case(FEATURE_BITTORRENT):
 #ifdef ENABLE_BITTORRENT
-# define BITTORRENT_ENABLED true
+    return "BitTorrent";
 #else // !ENABLE_BITTORRENT
-# define BITTORRENT_ENABLED false
+    return 0;
 #endif // !ENABLE_BITTORRENT
+    break;
 
-#ifdef ENABLE_METALINK
-# define METALINK_ENABLED true
-#else // !ENABLE_METALINK
-# define METALINK_ENABLED false
-#endif // !ENABLE_METALINK
+  case(FEATURE_FF3_COOKIE):
+#ifdef HAVE_SQLITE3
+    return "Firefox3 Cookie";
+#else // !HAVE_SQLITE3
+    return 0;
+#endif // !HAVE_SQLITE3
+    break;
+
+  case(FEATURE_GZIP):
+#ifdef HAVE_ZLIB
+    return "GZip";
+#else // !HAVE_ZLIB
+    return 0;
+#endif // !HAVE_ZLIB
+    break;
+
+  case(FEATURE_HTTPS):
+#ifdef ENABLE_SSL
+    return "HTTPS";
+#else // !ENABLE_SSL
+    return 0;
+#endif // !ENABLE_SSL
+    break;
 
+  case(FEATURE_MESSAGE_DIGEST):
 #ifdef ENABLE_MESSAGE_DIGEST
-# define MESSAGE_DIGEST_ENABLED true
+    return "Message Digest";
 #else // !ENABLE_MESSAGE_DIGEST
-# define MESSAGE_DIGEST_ENABLED false
+    return 0;
 #endif // !ENABLE_MESSAGE_DIGEST
+    break;
 
-#ifdef ENABLE_ASYNC_DNS
-# define ASYNC_DNS_ENABLED true
-#else // !ENABLE_ASYNC_DNS
-# define ASYNC_DNS_ENABLED false
-#endif // !ENABLE_ASYNC_DNS
+  case(FEATURE_METALINK):
+#ifdef ENABLE_METALINK
+    return "Metalink";
+#else // !ENABLE_METALINK
+    return 0;
+#endif // !ENABLE_METALINK
+    break;
 
+  case(FEATURE_XML_RPC):
 #ifdef ENABLE_XML_RPC
-# define XML_RPC_ENABLED true
+    return "XML-RPC";
 #else // !ENABLE_XML_RPC
-# define XML_RPC_ENABLED false
+    return 0;
 #endif // !ENABLE_XML_RPC
+    break;
 
-#ifdef HAVE_ZLIB
-# define GZIP_ENABLED true
-#else // !HAVE_ZLIB
-# define GZIP_ENABLED false
-#endif // !HAVE_ZLIB
-
-#ifdef HAVE_SQLITE3
-# define FIREFOX3_COOKIE_ENABLED true
-#else // !HAVE_SQLITE3
-# define FIREFOX3_COOKIE_ENABLED false
-#endif // !HAVE_SQLITE3
-
-FeatureConfig::FeatureConfig() {
-  defaultPorts_.insert(PortMap::value_type(Request::PROTO_HTTP, 80));
-  defaultPorts_.insert(PortMap::value_type(Request::PROTO_HTTPS, 443));
-  defaultPorts_.insert(PortMap::value_type(Request::PROTO_FTP, 21));
-
-  FeatureMap::value_type featureArray[] = {
-    FeatureMap::value_type(FEATURE_HTTPS, HTTPS_ENABLED),
-    FeatureMap::value_type(FEATURE_BITTORRENT, BITTORRENT_ENABLED),
-    FeatureMap::value_type(FEATURE_METALINK, METALINK_ENABLED),
-    FeatureMap::value_type(FEATURE_MESSAGE_DIGEST, MESSAGE_DIGEST_ENABLED),
-    FeatureMap::value_type(FEATURE_ASYNC_DNS, ASYNC_DNS_ENABLED),
-    FeatureMap::value_type(FEATURE_XML_RPC, XML_RPC_ENABLED),
-    FeatureMap::value_type(FEATURE_GZIP, GZIP_ENABLED),
-    FeatureMap::value_type(FEATURE_FIREFOX3_COOKIE, FIREFOX3_COOKIE_ENABLED),
-  };
-
-  features_.insert(vbegin(featureArray), vend(featureArray));
-}
-
-FeatureConfig::~FeatureConfig() {}
-
-const SharedHandle<FeatureConfig>& FeatureConfig::getInstance()
-{
-  if(!featureConfig_) {
-    featureConfig_.reset(new FeatureConfig());
-  }
-  return featureConfig_;
-}
-
-uint16_t FeatureConfig::getDefaultPort(const std::string& protocol) const
-{
-  PortMap::const_iterator itr = defaultPorts_.find(protocol);
-  if(itr == defaultPorts_.end()) {
+  default:
     return 0;
-  } else {
-    return itr->second;
-  }
-}
-
-bool FeatureConfig::isSupported(const std::string& feature) const
-{
-  FeatureMap::const_iterator itr = features_.find(feature);
-  if(itr == features_.end()) {
-    return false;
-  } else {
-    return itr->second;
-  }
-}
-
-std::string FeatureConfig::featureSummary() const
-{
-  std::string s;
-  for(FeatureMap::const_iterator i = features_.begin(), eoi = features_.end();
-      i != eoi; ++i) {
-    if((*i).second) {
-      s += (*i).first;
-      s += ", ";
-    }
   }
-  return util::strip(s, ", ");
 }
 
 } // namespace aria2

src/FeatureConfig.h

@@ -2,7 +2,7 @@
 /*
  * aria2 - The high speed download utility
  *
- * Copyright (C) 2006 Tatsuhiro Tsujikawa
+ * Copyright (C) 2012 Tatsuhiro Tsujikawa
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -37,49 +37,31 @@
 
 #include "common.h"
 
-#include <map>
 #include <string>
 
-#include "SharedHandle.h"
-
 namespace aria2 {
 
-typedef std::map<std::string, uint16_t> PortMap;
-typedef std::map<std::string, bool> FeatureMap;
-
-class FeatureConfig {
-private:
-  static SharedHandle<FeatureConfig> featureConfig_;
-
-  PortMap defaultPorts_;
-  FeatureMap features_;
-
-  FeatureConfig();
-public:
-  ~FeatureConfig();
-
-  static const SharedHandle<FeatureConfig>& getInstance();
-
-  uint16_t getDefaultPort(const std::string& protocol) const;
-
-  bool isSupported(const std::string& feature) const;
-
-  std::string featureSummary() const;
+// Returns default port for the given |protocol|.
+uint16_t getDefaultPort(const std::string& protocol);
+
+enum FeatureType {
+  FEATURE_ASYNC_DNS,
+  FEATURE_BITTORRENT,
+  FEATURE_FF3_COOKIE,
+  FEATURE_GZIP,
+  FEATURE_HTTPS,
+  FEATURE_MESSAGE_DIGEST,
+  FEATURE_METALINK,
+  FEATURE_XML_RPC,
+  MAX_FEATURE
+};
 
-  const FeatureMap& getFeatures() const
-  {
-    return features_;
-  }
+// Returns summary string of the available features.
+std::string featureSummary();
 
-  static const std::string FEATURE_HTTPS;
-  static const std::string FEATURE_BITTORRENT;
-  static const std::string FEATURE_METALINK;
-  static const std::string FEATURE_MESSAGE_DIGEST;
-  static const std::string FEATURE_ASYNC_DNS;
-  static const std::string FEATURE_XML_RPC;
-  static const std::string FEATURE_GZIP;
-  static const std::string FEATURE_FIREFOX3_COOKIE;
-};
+// Returns the string representation of the given |feature| if it is
+// available in the build. If it is not available, returns NULL.
+const char* strSupportedFeature(int feature);
 
 } // namespace aria2
 

src/RpcMethodImpl.cc

@@ -1228,11 +1228,10 @@ SharedHandle<ValueBase> GetVersionRpcMethod::process
   SharedHandle<Dict> result = Dict::g();
   result->put(KEY_VERSION, PACKAGE_VERSION);
   SharedHandle<List> featureList = List::g();
-  const FeatureMap& features = FeatureConfig::getInstance()->getFeatures();
-  for(FeatureMap::const_iterator i = features.begin(), eoi = features.end();
-      i != eoi;++i){
-    if((*i).second) {
-      featureList->append((*i).first);
+  for(int feat = 0; feat < MAX_FEATURE; ++feat) {
+    const char* name = strSupportedFeature(feat);
+    if(name) {
+      featureList->append(name);
     }
   }
   result->put(KEY_ENABLED_FEATURES, featureList);

src/uri.cc

@@ -131,8 +131,7 @@ bool parse(UriStruct& result, const std::string& uri)
   if(protocolOffset == std::string::npos) return false;
   result.protocol.assign(uri.begin(), uri.begin()+protocolOffset);
   uint16_t defPort;
-  if((defPort = FeatureConfig::getInstance()->
-      getDefaultPort(result.protocol)) == 0) {
+  if((defPort = getDefaultPort(result.protocol)) == 0) {
     return false;
   }
   // find authority
@@ -268,8 +267,7 @@ std::string construct(const UriStruct& us)
   } else {
     res += us.host;
   }
-  uint16_t defPort= FeatureConfig::getInstance()->
-    getDefaultPort(us.protocol);
+  uint16_t defPort= getDefaultPort(us.protocol);
   if(us.port != 0 && defPort != us.port) {
     res += fmt(":%u", us.port);
   }

src/version_usage.cc

@@ -70,7 +70,7 @@ void showVersion() {
             << "\n"
             << _("** Configuration **") << "\n"
             << _("Enabled Features") << ": "
-            << FeatureConfig::getInstance()->featureSummary() << "\n"
+            << featureSummary() << "\n"
 #ifdef ENABLE_MESSAGE_DIGEST
             << _("Hash Algorithms") << ": "
             << MessageDigest::getSupportedHashTypeString() << "\n"

test/FeatureConfigTest.cc

@@ -14,13 +14,12 @@ class FeatureConfigTest:public CppUnit::TestFixture {
 
   CPPUNIT_TEST_SUITE(FeatureConfigTest);
   CPPUNIT_TEST(testGetDefaultPort);
-  CPPUNIT_TEST(testIsSupported);
+  CPPUNIT_TEST(testStrSupportedFeature);
   CPPUNIT_TEST(testFeatureSummary);
   CPPUNIT_TEST_SUITE_END();
-  
 public:
   void testGetDefaultPort();
-  void testIsSupported();
+  void testStrSupportedFeature();
   void testFeatureSummary();
 };
 
@@ -28,26 +27,19 @@ public:
 CPPUNIT_TEST_SUITE_REGISTRATION(FeatureConfigTest);
 
 void FeatureConfigTest::testGetDefaultPort() {
-  CPPUNIT_ASSERT_EQUAL((uint16_t)80,
-                       FeatureConfig::getInstance()->getDefaultPort("http"));
-  CPPUNIT_ASSERT_EQUAL((uint16_t)443,
-                       FeatureConfig::getInstance()->getDefaultPort("https"));
-  CPPUNIT_ASSERT_EQUAL((uint16_t)21,
-                       FeatureConfig::getInstance()->getDefaultPort("ftp"));
+  CPPUNIT_ASSERT_EQUAL((uint16_t)80, getDefaultPort("http"));
+  CPPUNIT_ASSERT_EQUAL((uint16_t)443, getDefaultPort("https"));
+  CPPUNIT_ASSERT_EQUAL((uint16_t)21, getDefaultPort("ftp"));
 }
 
-void FeatureConfigTest::testIsSupported() {
+void FeatureConfigTest::testStrSupportedFeature() {
+  const char* https = strSupportedFeature(FEATURE_HTTPS);
 #ifdef ENABLE_SSL
-  CPPUNIT_ASSERT_EQUAL(true,
-                       FeatureConfig::getInstance()->isSupported
-                       (FeatureConfig::FEATURE_HTTPS));
+  CPPUNIT_ASSERT(https);
 #else
-  CPPUNIT_ASSERT_EQUAL(false,
-                       FeatureConfig::getInstance()->isSupported
-                       (FeatureConfig::FEATURE_HTTPS));
+  CPPUNIT_ASSERT(!https);
 #endif // ENABLE_SSL
-  CPPUNIT_ASSERT_EQUAL(false,
-                       FeatureConfig::getInstance()->isSupported("FTPS"));
+  CPPUNIT_ASSERT(!strSupportedFeature(MAX_FEATURE));
 }
 
 void FeatureConfigTest::testFeatureSummary() {
@@ -92,9 +84,8 @@ void FeatureConfigTest::testFeatureSummary() {
   std::for_each(vbegin(features), vend(features),
                 StringAppend(featuresString, delim));
   featuresString = util::strip(featuresString, delim);
-  
-  CPPUNIT_ASSERT_EQUAL(featuresString,
-                       FeatureConfig::getInstance()->featureSummary());
+
+  CPPUNIT_ASSERT_EQUAL(featuresString, featureSummary());
 }
 
 } // namespace aria2

test/RpcMethodTest.cc

@@ -741,9 +741,7 @@ void RpcMethodTest::testGetVersion()
     features += s->s();
     features += ", ";
   }
-  
-  CPPUNIT_ASSERT_EQUAL(FeatureConfig::getInstance()->featureSummary()+", ",
-                       features);
+  CPPUNIT_ASSERT_EQUAL(featureSummary()+", ", features);
 }
 
 void RpcMethodTest::testGatherStoppedDownload()