Merge branch 'master' into fix_alter_drop

vesoft-inc · Oct 15, 2021 · 379440a · 379440a
2 parents d715940 + fb3be74
commit 379440a
Show file tree

Hide file tree

Showing 11 changed files with 65 additions and 64 deletions.
diff --git a/.clang-format b/.clang-format
@@ -166,7 +166,7 @@ SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
 SpaceBeforeSquareBrackets: false
-Standard:        Auto
+Standard:        c++17
 StatementMacros:
   - Q_UNUSED
   - QT_REQUIRE_VERSION

diff --git a/src/common/base/EitherOr.h b/src/common/base/EitherOr.h
@@ -159,7 +159,7 @@ class EitherOr {
   template <typename U,
             typename V,
             typename = std::enable_if_t<std::is_constructible<LEFT, U>::value &&
-                                        std::is_constructible<RIGHT, V>::value> >
+                                        std::is_constructible<RIGHT, V>::value>>
   EitherOr(const EitherOr<U, V>& rhs) noexcept {
     switch (rhs.state_) {
       case State::VOID:
@@ -178,7 +178,7 @@ class EitherOr {
   template <typename U,
             typename V,
             typename = std::enable_if_t<std::is_constructible<LEFT, U>::value &&
-                                        std::is_constructible<RIGHT, V>::value> >
+                                        std::is_constructible<RIGHT, V>::value>>
   EitherOr(EitherOr<U, V>&& rhs) noexcept {
     switch (rhs.state_) {
       case State::VOID:
@@ -218,7 +218,7 @@ class EitherOr {
   // LEFT or RIGHT, not both
   template <class... Args,
             typename = std::enable_if_t<std::is_constructible<LEFT, Args...>::value ||
-                                        std::is_constructible<RIGHT, Args...>::value> >
+                                        std::is_constructible<RIGHT, Args...>::value>>
   EitherOr(Args&&... v) noexcept {  // NOLINT
     new (&val_) Variant(convert_to_t<Args...>, std::forward<Args>(v)...);
     state_ = convert_to_s<Args...>;
@@ -228,7 +228,7 @@ class EitherOr {
   // So we use a type tag to force selecting LEFT
   template <typename U,
             typename = std::enable_if_t<std::is_constructible<LEFT, U>::value &&
-                                        std::is_constructible<RIGHT, U>::value> >
+                                        std::is_constructible<RIGHT, U>::value>>
   EitherOr(const LeftType*, U&& v) noexcept {
     new (&val_) Variant(kConstructLeft, std::forward<U>(v));
     state_ = State::LEFT_TYPE;
@@ -238,7 +238,7 @@ class EitherOr {
   // So we use a type tag to force selecting RIGHT
   template <typename U,
             typename = std::enable_if_t<std::is_constructible<LEFT, U>::value &&
-                                        std::is_constructible<RIGHT, U>::value> >
+                                        std::is_constructible<RIGHT, U>::value>>
   EitherOr(const RightType*, U&& v) noexcept {
     new (&val_) Variant(kConstructRight, std::forward<U>(v));
     state_ = State::RIGHT_TYPE;

diff --git a/src/common/base/ErrorOr.h b/src/common/base/ErrorOr.h
@@ -30,7 +30,7 @@ namespace nebula {
 template <typename ErrorCode,
           typename ResultType,
           typename = std::enable_if_t<std::is_integral<ErrorCode>::value ||
-                                      std::is_enum<ErrorCode>::value> >
+                                      std::is_enum<ErrorCode>::value>>
 using ErrorOr = EitherOr<ErrorCode, ResultType>;
 
 /***********************************************

diff --git a/src/common/datatypes/DataSetOps-inl.h b/src/common/datatypes/DataSetOps-inl.h
@@ -53,12 +53,12 @@ uint32_t Cpp2Ops<nebula::DataSet>::write(Protocol* proto, nebula::DataSet const*
 
   xfer += proto->writeFieldBegin("column_names", protocol::T_LIST, 1);
   xfer += detail::pm::protocol_methods<type_class::list<type_class::binary>,
-                                       std::vector<std::string> >::write(*proto, obj->colNames);
+                                       std::vector<std::string>>::write(*proto, obj->colNames);
   xfer += proto->writeFieldEnd();
 
   xfer += proto->writeFieldBegin("rows", apache::thrift::protocol::T_LIST, 2);
   xfer += detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                       std::vector<nebula::Row> >::write(*proto, obj->rows);
+                                       std::vector<nebula::Row>>::write(*proto, obj->rows);
   xfer += proto->writeFieldEnd();
 
   xfer += proto->writeFieldStop();
@@ -81,7 +81,7 @@ void Cpp2Ops<nebula::DataSet>::read(Protocol* proto, nebula::DataSet* obj) {
 _readField_column_names : {
   obj->colNames = std::vector<std::string>();
   detail::pm::protocol_methods<type_class::list<type_class::binary>,
-                               std::vector<std::string> >::read(*proto, obj->colNames);
+                               std::vector<std::string>>::read(*proto, obj->colNames);
 }
 
   if (UNLIKELY(!readState.advanceToNextField(proto, 1, 2, protocol::T_LIST))) {
@@ -91,7 +91,7 @@ _readField_column_names : {
 _readField_rows : {
   obj->rows = std::vector<nebula::Row>();
   detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                               std::vector<nebula::Row> >::read(*proto, obj->rows);
+                               std::vector<nebula::Row>>::read(*proto, obj->rows);
 }
 
   if (UNLIKELY(!readState.advanceToNextField(proto, 2, 0, protocol::T_STOP))) {
@@ -147,13 +147,13 @@ uint32_t Cpp2Ops<nebula::DataSet>::serializedSize(Protocol const* proto,
   xfer += proto->serializedFieldSize("column_names", protocol::T_LIST, 1);
   xfer +=
       detail::pm::protocol_methods<type_class::list<type_class::binary>,
-                                   std::vector<std::string> >::serializedSize<false>(*proto,
-                                                                                     obj->colNames);
+                                   std::vector<std::string>>::serializedSize<false>(*proto,
+                                                                                    obj->colNames);
 
   xfer += proto->serializedFieldSize("rows", apache::thrift::protocol::T_LIST, 2);
   xfer += detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                       std::vector<nebula::Row> >::serializedSize<false>(*proto,
-                                                                                         obj->rows);
+                                       std::vector<nebula::Row>>::serializedSize<false>(*proto,
+                                                                                        obj->rows);
 
   xfer += proto->serializedSizeStop();
   return xfer;
@@ -168,13 +168,13 @@ uint32_t Cpp2Ops<nebula::DataSet>::serializedSizeZC(Protocol const* proto,
   xfer += proto->serializedFieldSize("column_names", protocol::T_LIST, 1);
   xfer +=
       detail::pm::protocol_methods<type_class::list<type_class::binary>,
-                                   std::vector<std::string> >::serializedSize<false>(*proto,
-                                                                                     obj->colNames);
+                                   std::vector<std::string>>::serializedSize<false>(*proto,
+                                                                                    obj->colNames);
 
   xfer += proto->serializedFieldSize("rows", protocol::T_LIST, 2);
   xfer += detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                       std::vector<nebula::Row> >::serializedSize<false>(*proto,
-                                                                                         obj->rows);
+                                       std::vector<nebula::Row>>::serializedSize<false>(*proto,
+                                                                                        obj->rows);
 
   xfer += proto->serializedSizeStop();
   return xfer;

diff --git a/src/common/datatypes/EdgeOps-inl.h b/src/common/datatypes/EdgeOps-inl.h
@@ -88,7 +88,7 @@ uint32_t Cpp2Ops<nebula::Edge>::write(Protocol* proto, nebula::Edge const* obj)
   xfer += proto->writeFieldBegin("props", apache::thrift::protocol::T_MAP, 6);
   xfer += detail::pm::protocol_methods<
       type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::write(*proto, obj->props);
+      std::unordered_map<std::string, nebula::Value>>::write(*proto, obj->props);
   xfer += proto->writeFieldEnd();
 
   xfer += proto->writeFieldStop();
@@ -145,8 +145,8 @@ _readField_ranking : {
 _readField_props : {
   obj->props = std::unordered_map<std::string, nebula::Value>();
   detail::pm::protocol_methods<type_class::map<type_class::binary, type_class::structure>,
-                               std::unordered_map<std::string, nebula::Value> >::read(*proto,
-                                                                                      obj->props);
+                               std::unordered_map<std::string, nebula::Value>>::read(*proto,
+                                                                                     obj->props);
 }
 
   if (UNLIKELY(!readState.advanceToNextField(proto, 6, 0, protocol::T_STOP))) {
@@ -248,7 +248,7 @@ uint32_t Cpp2Ops<nebula::Edge>::serializedSize(Protocol const* proto, nebula::Ed
   xfer += proto->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 6);
   xfer += detail::pm::protocol_methods<
       type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::serializedSize<false>(*proto, obj->props);
+      std::unordered_map<std::string, nebula::Value>>::serializedSize<false>(*proto, obj->props);
 
   xfer += proto->serializedSizeStop();
   return xfer;
@@ -281,7 +281,7 @@ uint32_t Cpp2Ops<nebula::Edge>::serializedSizeZC(Protocol const* proto, nebula::
   xfer += proto->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 6);
   xfer += detail::pm::protocol_methods<
       type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::serializedSize<false>(*proto, obj->props);
+      std::unordered_map<std::string, nebula::Value>>::serializedSize<false>(*proto, obj->props);
 
   xfer += proto->serializedSizeStop();
   return xfer;

diff --git a/src/common/datatypes/ListOps-inl.h b/src/common/datatypes/ListOps-inl.h
@@ -45,7 +45,7 @@ uint32_t Cpp2Ops<nebula::List>::write(Protocol* proto, nebula::List const* obj)
 
   xfer += proto->writeFieldBegin("values", apache::thrift::protocol::T_LIST, 1);
   xfer += detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                       std::vector<nebula::Value> >::write(*proto, obj->values);
+                                       std::vector<nebula::Value>>::write(*proto, obj->values);
   xfer += proto->writeFieldEnd();
 
   xfer += proto->writeFieldStop();
@@ -68,7 +68,7 @@ void Cpp2Ops<nebula::List>::read(Protocol* proto, nebula::List* obj) {
 _readField_values : {
   obj->values = std::vector<nebula::Value>();
   detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                               std::vector<nebula::Value> >::read(*proto, obj->values);
+                               std::vector<nebula::Value>>::read(*proto, obj->values);
 }
 
   if (UNLIKELY(!readState.advanceToNextField(proto, 1, 0, protocol::T_STOP))) {
@@ -116,8 +116,8 @@ uint32_t Cpp2Ops<nebula::List>::serializedSize(Protocol const* proto, nebula::Li
   xfer += proto->serializedFieldSize("values", apache::thrift::protocol::T_LIST, 1);
   xfer +=
       detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                   std::vector<nebula::Value> >::serializedSize<false>(*proto,
-                                                                                       obj->values);
+                                   std::vector<nebula::Value>>::serializedSize<false>(*proto,
+                                                                                      obj->values);
   xfer += proto->serializedSizeStop();
   return xfer;
 }
@@ -130,8 +130,8 @@ uint32_t Cpp2Ops<nebula::List>::serializedSizeZC(Protocol const* proto, nebula::
   xfer += proto->serializedFieldSize("values", apache::thrift::protocol::T_LIST, 1);
   xfer +=
       detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                   std::vector<nebula::Value> >::serializedSize<false>(*proto,
-                                                                                       obj->values);
+                                   std::vector<nebula::Value>>::serializedSize<false>(*proto,
+                                                                                      obj->values);
   xfer += proto->serializedSizeStop();
   return xfer;
 }

diff --git a/src/common/datatypes/MapOps-inl.h b/src/common/datatypes/MapOps-inl.h
@@ -44,9 +44,10 @@ uint32_t Cpp2Ops<nebula::Map>::write(Protocol* proto, nebula::Map const* obj) {
   xfer += proto->writeStructBegin("NMap");
 
   xfer += proto->writeFieldBegin("kvs", apache::thrift::protocol::T_MAP, 1);
-  xfer += detail::pm::protocol_methods<
-      type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::write(*proto, obj->kvs);
+  xfer +=
+      detail::pm::protocol_methods<type_class::map<type_class::binary, type_class::structure>,
+                                   std::unordered_map<std::string, nebula::Value>>::write(*proto,
+                                                                                          obj->kvs);
   xfer += proto->writeFieldEnd();
 
   xfer += proto->writeFieldStop();
@@ -69,8 +70,8 @@ void Cpp2Ops<nebula::Map>::read(Protocol* proto, nebula::Map* obj) {
 _readField_kvs : {
   obj->kvs = std::unordered_map<std::string, nebula::Value>();
   detail::pm::protocol_methods<type_class::map<type_class::binary, type_class::structure>,
-                               std::unordered_map<std::string, nebula::Value> >::read(*proto,
-                                                                                      obj->kvs);
+                               std::unordered_map<std::string, nebula::Value>>::read(*proto,
+                                                                                     obj->kvs);
 }
 
   if (UNLIKELY(!readState.advanceToNextField(proto, 1, 0, protocol::T_STOP))) {
@@ -118,7 +119,7 @@ uint32_t Cpp2Ops<nebula::Map>::serializedSize(Protocol const* proto, nebula::Map
   xfer += proto->serializedFieldSize("kvs", apache::thrift::protocol::T_MAP, 1);
   xfer += detail::pm::protocol_methods<
       type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::serializedSize<false>(*proto, obj->kvs);
+      std::unordered_map<std::string, nebula::Value>>::serializedSize<false>(*proto, obj->kvs);
   xfer += proto->serializedSizeStop();
   return xfer;
 }
@@ -131,7 +132,7 @@ uint32_t Cpp2Ops<nebula::Map>::serializedSizeZC(Protocol const* proto, nebula::M
   xfer += proto->serializedFieldSize("kvs", apache::thrift::protocol::T_MAP, 1);
   xfer += detail::pm::protocol_methods<
       type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::serializedSize<false>(*proto, obj->kvs);
+      std::unordered_map<std::string, nebula::Value>>::serializedSize<false>(*proto, obj->kvs);
   xfer += proto->serializedSizeStop();
   return xfer;
 }

diff --git a/src/common/datatypes/PathOps-inl.h b/src/common/datatypes/PathOps-inl.h
@@ -86,7 +86,7 @@ uint32_t Cpp2Ops<nebula::Step>::write(Protocol* proto, nebula::Step const* obj)
   xfer += proto->writeFieldBegin("props", apache::thrift::protocol::T_MAP, 5);
   xfer += detail::pm::protocol_methods<
       type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::write(*proto, obj->props);
+      std::unordered_map<std::string, nebula::Value>>::write(*proto, obj->props);
   xfer += proto->writeFieldEnd();
 
   xfer += proto->writeFieldStop();
@@ -138,8 +138,8 @@ _readField_ranking : {
 _readField_props : {
   obj->props = std::unordered_map<std::string, nebula::Value>();
   detail::pm::protocol_methods<type_class::map<type_class::binary, type_class::structure>,
-                               std::unordered_map<std::string, nebula::Value> >::read(*proto,
-                                                                                      obj->props);
+                               std::unordered_map<std::string, nebula::Value>>::read(*proto,
+                                                                                     obj->props);
 }
 
   if (UNLIKELY(!readState.advanceToNextField(proto, 5, 0, protocol::T_STOP))) {
@@ -231,7 +231,7 @@ uint32_t Cpp2Ops<nebula::Step>::serializedSize(Protocol const* proto, nebula::St
   xfer += proto->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 5);
   xfer += detail::pm::protocol_methods<
       type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::serializedSize<false>(*proto, obj->props);
+      std::unordered_map<std::string, nebula::Value>>::serializedSize<false>(*proto, obj->props);
 
   xfer += proto->serializedSizeStop();
   return xfer;
@@ -261,7 +261,7 @@ uint32_t Cpp2Ops<nebula::Step>::serializedSizeZC(Protocol const* proto, nebula::
   xfer += proto->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 5);
   xfer += detail::pm::protocol_methods<
       type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::serializedSize<false>(*proto, obj->props);
+      std::unordered_map<std::string, nebula::Value>>::serializedSize<false>(*proto, obj->props);
 
   xfer += proto->serializedSizeStop();
   return xfer;
@@ -306,7 +306,7 @@ uint32_t Cpp2Ops<nebula::Path>::write(Protocol* proto, nebula::Path const* obj)
 
   xfer += proto->writeFieldBegin("steps", apache::thrift::protocol::T_LIST, 2);
   xfer += detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                       std::vector<nebula::Step> >::write(*proto, obj->steps);
+                                       std::vector<nebula::Step>>::write(*proto, obj->steps);
   xfer += proto->writeFieldEnd();
 
   xfer += proto->writeFieldStop();
@@ -335,7 +335,7 @@ _readField_src : { Cpp2Ops<nebula::Vertex>::read(proto, &obj->src); }
 _readField_steps : {
   obj->steps = std::vector<nebula::Step>();
   detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                               std::vector<nebula::Step> >::read(*proto, obj->steps);
+                               std::vector<nebula::Step>>::read(*proto, obj->steps);
 }
 
   if (UNLIKELY(!readState.advanceToNextField(proto, 2, 0, protocol::T_STOP))) {
@@ -393,8 +393,8 @@ uint32_t Cpp2Ops<nebula::Path>::serializedSize(Protocol const* proto, nebula::Pa
   xfer += proto->serializedFieldSize("steps", apache::thrift::protocol::T_LIST, 2);
   xfer +=
       detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                   std::vector<nebula::Step> >::serializedSize<false>(*proto,
-                                                                                      obj->steps);
+                                   std::vector<nebula::Step>>::serializedSize<false>(*proto,
+                                                                                     obj->steps);
 
   xfer += proto->serializedSizeStop();
   return xfer;
@@ -411,8 +411,8 @@ uint32_t Cpp2Ops<nebula::Path>::serializedSizeZC(Protocol const* proto, nebula::
   xfer += proto->serializedFieldSize("steps", apache::thrift::protocol::T_LIST, 2);
   xfer +=
       detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                   std::vector<nebula::Step> >::serializedSize<false>(*proto,
-                                                                                      obj->steps);
+                                   std::vector<nebula::Step>>::serializedSize<false>(*proto,
+                                                                                     obj->steps);
 
   xfer += proto->serializedSizeStop();
   return xfer;