Stop using ScopeGuardImpl in DynamicParser

[folly.git] / folly / experimental / DynamicParser-inl.h

diff --git a/folly/experimental/DynamicParser-inl.h b/folly/experimental/DynamicParser-inl.h
index 7620f7214eb063b572493951123439f3e93afcdb..f3459223c9fa242783876163b4ed5148aa0fcc22 100644 (file)
--- a/folly/experimental/DynamicParser-inl.h
+++ b/folly/experimental/DynamicParser-inl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 Facebook, Inc.
+ * Copyright 2016-present Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,7 +24,6 @@
  */
 #pragma once
 
-#include <folly/Conv.h>
 #include <boost/function_types/is_member_pointer.hpp>
 #include <boost/function_types/parameter_types.hpp>
 #include <boost/mpl/equal.hpp>
@@ -32,17 +31,20 @@
 #include <boost/mpl/transform.hpp>
 #include <boost/mpl/vector.hpp>
 
+#include <folly/Conv.h>
+
 namespace folly {
 
 // Auto-conversion of key/value based on callback signature, documented in
 // DynamicParser.h.
 namespace detail {
 class IdentifyCallable {
-public:
+ public:
   enum class Kind { Function, MemberFunction };
   template <typename Fn>
   constexpr static Kind getKind() { return test<Fn>(nullptr); }
-private:
+
+ private:
   template <typename Fn>
   using IsMemFn = typename boost::function_types::template is_member_pointer<
     decltype(&Fn::operator())
@@ -77,22 +79,18 @@ using ArgumentTypes =
 // extended.  The comparison deliberately strips cv-qualifieers and
 // reference, leaving that choice up to the caller.
 template <typename Fn, typename... Args>
-constexpr bool hasArgumentTypes() {
-  using HasArgumentTypes = typename boost::mpl::template equal<
-    typename boost::mpl::template transform<
-      typename boost::mpl::template transform<
-        ArgumentTypes<Fn>,
-        typename std::template remove_reference<boost::mpl::_1>
-      >::type,
-      typename std::template remove_cv<boost::mpl::_1>
-    >::type,
-    boost::mpl::vector<Args...>
-  >::type;
-  return HasArgumentTypes::value;
-}
+struct HasArgumentTypes
+    : boost::mpl::template equal<
+          typename boost::mpl::template transform<
+              typename boost::mpl::template transform<
+                  ArgumentTypes<Fn>,
+                  typename std::template remove_reference<boost::mpl::_1>>::
+                  type,
+              typename std::template remove_cv<boost::mpl::_1>>::type,
+          boost::mpl::vector<Args...>>::type {};
 template <typename... Args>
 using EnableForArgTypes =
-  typename std::enable_if<hasArgumentTypes<Args...>(), void>::type;
+    typename std::enable_if<HasArgumentTypes<Args...>::value, void>::type;
 
 // No arguments
 template <typename Fn> EnableForArgTypes<Fn>
@@ -125,7 +123,7 @@ invokeForKeyValue(Fn fn, const folly::dynamic&, const folly::dynamic& v) {
 // std::string
 template <typename Fn> EnableForArgTypes<Fn, std::string>
 invokeForKeyValue(Fn fn, const folly::dynamic&, const folly::dynamic& v) {
-  fn(v.asString().toStdString());
+  fn(v.asString());
 }
 
 //
@@ -157,7 +155,7 @@ invokeForKeyValue(Fn fn, const folly::dynamic& k, const folly::dynamic& v) {
 // folly::dynamic, std::string
 template <typename Fn> EnableForArgTypes<Fn, folly::dynamic, std::string>
 invokeForKeyValue(Fn fn, const folly::dynamic& k, const folly::dynamic& v) {
-  fn(k, v.asString().toStdString());
+  fn(k, v.asString());
 }
 
 // Convert the key to std::string.
@@ -165,27 +163,27 @@ invokeForKeyValue(Fn fn, const folly::dynamic& k, const folly::dynamic& v) {
 // std::string, folly::dynamic (no conversion of value)
 template <typename Fn> EnableForArgTypes<Fn, std::string, folly::dynamic>
 invokeForKeyValue(Fn fn, const folly::dynamic& k, const folly::dynamic& v) {
-  fn(k.asString().toStdString(), v);
+  fn(k.asString(), v);
 }
 // std::string, int64_t
 template <typename Fn> EnableForArgTypes<Fn, std::string, int64_t>
 invokeForKeyValue(Fn fn, const folly::dynamic& k, const folly::dynamic& v) {
-  fn(k.asString().toStdString(), v.asInt());
+  fn(k.asString(), v.asInt());
 }
 // std::string, bool
 template <typename Fn> EnableForArgTypes<Fn, std::string, bool>
 invokeForKeyValue(Fn fn, const folly::dynamic& k, const folly::dynamic& v) {
-  fn(k.asString().toStdString(), v.asBool());
+  fn(k.asString(), v.asBool());
 }
 // std::string, double
 template <typename Fn> EnableForArgTypes<Fn, std::string, double>
 invokeForKeyValue(Fn fn, const folly::dynamic& k, const folly::dynamic& v) {
-  fn(k.asString().toStdString(), v.asDouble());
+  fn(k.asString(), v.asDouble());
 }
 // std::string, std::string
 template <typename Fn> EnableForArgTypes<Fn, std::string, std::string>
 invokeForKeyValue(Fn fn, const folly::dynamic& k, const folly::dynamic& v) {
-  fn(k.asString().toStdString(), v.asString().toStdString());
+  fn(k.asString(), v.asString());
 }
 
 // Convert the key to int64_t (good for arrays).
@@ -213,9 +211,9 @@ invokeForKeyValue(Fn fn, const folly::dynamic& k, const folly::dynamic& v) {
 // int64_t, std::string
 template <typename Fn> EnableForArgTypes<Fn, int64_t, std::string>
 invokeForKeyValue(Fn fn, const folly::dynamic& k, const folly::dynamic& v) {
-  fn(k.asInt(), v.asString().toStdString());
+  fn(k.asInt(), v.asString());
 }
-}  // namespace detail
+} // namespace detail
 
 template <typename Fn>
 void DynamicParser::optional(const folly::dynamic& key, Fn fn) {
@@ -267,11 +265,11 @@ template <typename Fn>
 void DynamicParser::wrapError(const folly::dynamic* lookup_k, Fn fn) {
   try {
     fn();
-  } catch (DynamicParserLogicError& ex) {
+  } catch (DynamicParserLogicError&) {
     // When the parser is misused, we throw all the way up to the user,
     // instead of reporting it as if the input is invalid.
     throw;
-  } catch (DynamicParserParseError& ex) {
+  } catch (DynamicParserParseError&) {
     // We are just bubbling up a parse error for OnError::THROW.
     throw;
   } catch (const std::exception& ex) {
@@ -302,4 +300,4 @@ inline const folly::dynamic& DynamicParser::ParserStack::value() const{
   return *value_;
 }
 
-}  // namespace folly
+} // namespace folly