Nit enhance 25 03 05

src/brpc/adaptive_max_concurrency.cpp

@@ -24,15 +24,18 @@
 
 namespace brpc {
 
+const std::string AdaptiveMaxConcurrency::UNLIMITED = "unlimited";
+const std::string AdaptiveMaxConcurrency::CONSTANT = "constant";
+
 AdaptiveMaxConcurrency::AdaptiveMaxConcurrency()
-    : _value(UNLIMITED())
+    : _value(UNLIMITED)
     , _max_concurrency(0) {
 }
 
 AdaptiveMaxConcurrency::AdaptiveMaxConcurrency(int max_concurrency)
     : _max_concurrency(0) {
     if (max_concurrency <= 0) {
-        _value = UNLIMITED();
+        _value = UNLIMITED;
         _max_concurrency = 0;
     } else {
         _value = butil::string_printf("%d", max_concurrency);
@@ -76,7 +79,7 @@ void AdaptiveMaxConcurrency::operator=(const butil::StringPiece& value) {
 
 void AdaptiveMaxConcurrency::operator=(int max_concurrency) {
     if (max_concurrency <= 0) {
-        _value = UNLIMITED();
+        _value = UNLIMITED;
         _max_concurrency = 0;
     } else {
         _value = butil::string_printf("%d", max_concurrency);
@@ -92,24 +95,14 @@ void AdaptiveMaxConcurrency::operator=(const TimeoutConcurrencyConf& value) {
 
 const std::string& AdaptiveMaxConcurrency::type() const {
     if (_max_concurrency > 0) {
-        return CONSTANT();
+        return CONSTANT;
     } else if (_max_concurrency == 0) {
-        return UNLIMITED();
+        return UNLIMITED;
     } else {
         return _value;
     }
 }
 
-const std::string& AdaptiveMaxConcurrency::UNLIMITED() {
-    static std::string* s = new std::string("unlimited");
-    return *s;
-}
-
-const std::string& AdaptiveMaxConcurrency::CONSTANT() {
-    static std::string* s = new std::string("constant");
-    return *s;
-}
-
 bool operator==(const AdaptiveMaxConcurrency& adaptive_concurrency,
                 const butil::StringPiece& concurrency) {
     return CompareStringPieceWithoutCase(concurrency, 

src/brpc/adaptive_max_concurrency.h

@@ -65,8 +65,8 @@ class AdaptiveMaxConcurrency{
     const std::string& type() const;
 
     // Get strings filled with "unlimited" and "constant"
-    static const std::string& UNLIMITED();
-    static const std::string& CONSTANT();
+    static const std::string UNLIMITED;// = "unlimited";
+    static const std::string CONSTANT;// = "constant";
 
 private:
     std::string _value;

src/brpc/policy/constant_concurrency_limiter.cpp

@@ -37,7 +37,7 @@ int ConstantConcurrencyLimiter::MaxConcurrency() {
 
 ConstantConcurrencyLimiter*
 ConstantConcurrencyLimiter::New(const AdaptiveMaxConcurrency& amc) const {
-    CHECK_EQ(amc.type(), AdaptiveMaxConcurrency::CONSTANT());
+    CHECK_EQ(amc.type(), AdaptiveMaxConcurrency::CONSTANT);
     return new ConstantConcurrencyLimiter(static_cast<int>(amc));
 }
 

src/brpc/server.cpp

@@ -738,7 +738,7 @@ static int get_port_from_fd(int fd) {
 
 bool Server::CreateConcurrencyLimiter(const AdaptiveMaxConcurrency& amc,
                                       ConcurrencyLimiter** out) {
-    if (amc.type() == AdaptiveMaxConcurrency::UNLIMITED()) {
+    if (amc.type() == AdaptiveMaxConcurrency::UNLIMITED) {
         *out = NULL;
         return true;
     }
@@ -1086,7 +1086,7 @@ int Server::StartInternal(const butil::EndPoint& endpoint,
             it->second.status->SetConcurrencyLimiter(NULL);
         } else {
             const AdaptiveMaxConcurrency* amc = &it->second.max_concurrency;
-            if (amc->type() == AdaptiveMaxConcurrency::UNLIMITED()) {
+            if (amc->type() == AdaptiveMaxConcurrency::UNLIMITED) {
                 amc = &_options.method_max_concurrency;
             }
             ConcurrencyLimiter* cl = NULL;

src/brpc/server.h

@@ -716,7 +716,7 @@ friend class Controller;
     int SetServiceMaxConcurrency(T* service) {
         if (NULL != service) {
             const AdaptiveMaxConcurrency* amc = &service->_max_concurrency;
-            if (amc->type() == AdaptiveMaxConcurrency::UNLIMITED()) {
+            if (amc->type() == AdaptiveMaxConcurrency::UNLIMITED) {
                 amc = &_options.method_max_concurrency;
             }
             ConcurrencyLimiter* cl = NULL;

test/brpc_adaptive_class_unittest.cpp

@@ -31,13 +31,13 @@ const std::string kPooled = "PoOled";
 TEST(AdaptiveMaxConcurrencyTest, ShouldConvertCorrectly) {
     brpc::AdaptiveMaxConcurrency amc(0);
 
-    EXPECT_EQ(brpc::AdaptiveMaxConcurrency::UNLIMITED(), amc.type());
-    EXPECT_EQ(brpc::AdaptiveMaxConcurrency::UNLIMITED(), amc.value());
+    EXPECT_EQ(brpc::AdaptiveMaxConcurrency::UNLIMITED, amc.type());
+    EXPECT_EQ(brpc::AdaptiveMaxConcurrency::UNLIMITED, amc.value());
     EXPECT_EQ(0, int(amc));
-    EXPECT_TRUE(amc == brpc::AdaptiveMaxConcurrency::UNLIMITED());
+    EXPECT_TRUE(amc == brpc::AdaptiveMaxConcurrency::UNLIMITED);
 
     amc = 10;
-    EXPECT_EQ(brpc::AdaptiveMaxConcurrency::CONSTANT(), amc.type());
+    EXPECT_EQ(brpc::AdaptiveMaxConcurrency::CONSTANT, amc.type());
     EXPECT_EQ("10", amc.value());
     EXPECT_EQ(10, int(amc));
     EXPECT_EQ(amc, "10");