This is an automated email from the ASF dual-hosted git repository.

dataroaring pushed a commit to branch branch-3.0
in repository https://gitbox.apache.org/repos/asf/doris.git


The following commit(s) were added to refs/heads/branch-3.0 by this push:
     new 3030321e001 branch-3.0: [fix](build) Fix Mac compilation error caused 
by namespace conflict in find_symbols.h #43004 (#49078)
3030321e001 is described below

commit 3030321e001cdc3a6de23298a3f5ec7c0ba8a7b9
Author: github-actions[bot] 
<41898282+github-actions[bot]@users.noreply.github.com>
AuthorDate: Thu Mar 20 14:56:02 2025 +0800

    branch-3.0: [fix](build) Fix Mac compilation error caused by namespace 
conflict in find_symbols.h #43004 (#49078)
    
    Cherry-picked from #43004
    
    Co-authored-by: zy-kkk <zhongy...@gmail.com>
    Co-authored-by: camby <camby...@tencent.com>
---
 be/src/vec/functions/url/find_symbols.h | 56 +++++++++++++++++----------------
 1 file changed, 29 insertions(+), 27 deletions(-)

diff --git a/be/src/vec/functions/url/find_symbols.h 
b/be/src/vec/functions/url/find_symbols.h
index 0fa0588e656..4eafea893f8 100644
--- a/be/src/vec/functions/url/find_symbols.h
+++ b/be/src/vec/functions/url/find_symbols.h
@@ -362,8 +362,8 @@ inline const char* find_first_symbols_dispatch(const 
std::string_view haystack,
 
 template <char... symbols>
 inline const char* find_first_symbols(const char* begin, const char* end) {
-    return detail::find_first_symbols_dispatch<true, detail::ReturnMode::End, 
symbols...>(begin,
-                                                                               
           end);
+    return ::detail::find_first_symbols_dispatch<true, 
::detail::ReturnMode::End, symbols...>(begin,
+                                                                               
               end);
 }
 
 /// Returning non const result for non const arguments.
@@ -371,93 +371,95 @@ inline const char* find_first_symbols(const char* begin, 
const char* end) {
 template <char... symbols>
 inline char* find_first_symbols(char* begin, char* end) {
     return const_cast<char*>(
-            detail::find_first_symbols_dispatch<true, detail::ReturnMode::End, 
symbols...>(begin,
-                                                                               
            end));
+            ::detail::find_first_symbols_dispatch<true, 
::detail::ReturnMode::End, symbols...>(
+                    begin, end));
 }
 
 inline const char* find_first_symbols(std::string_view haystack, const 
SearchSymbols& symbols) {
-    return detail::find_first_symbols_dispatch<true, 
detail::ReturnMode::End>(haystack, symbols);
+    return ::detail::find_first_symbols_dispatch<true, 
::detail::ReturnMode::End>(haystack,
+                                                                               
   symbols);
 }
 
 template <char... symbols>
 inline const char* find_first_not_symbols(const char* begin, const char* end) {
-    return detail::find_first_symbols_dispatch<false, detail::ReturnMode::End, 
symbols...>(begin,
-                                                                               
            end);
+    return ::detail::find_first_symbols_dispatch<false, 
::detail::ReturnMode::End, symbols...>(
+            begin, end);
 }
 
 template <char... symbols>
 inline char* find_first_not_symbols(char* begin, char* end) {
     return const_cast<char*>(
-            detail::find_first_symbols_dispatch<false, 
detail::ReturnMode::End, symbols...>(begin,
-                                                                               
             end));
+            ::detail::find_first_symbols_dispatch<false, 
::detail::ReturnMode::End, symbols...>(
+                    begin, end));
 }
 
 inline const char* find_first_not_symbols(std::string_view haystack, const 
SearchSymbols& symbols) {
-    return detail::find_first_symbols_dispatch<false, 
detail::ReturnMode::End>(haystack, symbols);
+    return ::detail::find_first_symbols_dispatch<false, 
::detail::ReturnMode::End>(haystack,
+                                                                               
    symbols);
 }
 
 template <char... symbols>
 inline const char* find_first_symbols_or_null(const char* begin, const char* 
end) {
-    return detail::find_first_symbols_dispatch<true, 
detail::ReturnMode::Nullptr, symbols...>(begin,
-                                                                               
               end);
+    return ::detail::find_first_symbols_dispatch<true, 
::detail::ReturnMode::Nullptr, symbols...>(
+            begin, end);
 }
 
 template <char... symbols>
 inline char* find_first_symbols_or_null(char* begin, char* end) {
     return const_cast<char*>(
-            detail::find_first_symbols_dispatch<true, 
detail::ReturnMode::Nullptr, symbols...>(
+            ::detail::find_first_symbols_dispatch<true, 
::detail::ReturnMode::Nullptr, symbols...>(
                     begin, end));
 }
 
 inline const char* find_first_symbols_or_null(std::string_view haystack,
                                               const SearchSymbols& symbols) {
-    return detail::find_first_symbols_dispatch<true, 
detail::ReturnMode::Nullptr>(haystack,
-                                                                               
   symbols);
+    return ::detail::find_first_symbols_dispatch<true, 
::detail::ReturnMode::Nullptr>(haystack,
+                                                                               
       symbols);
 }
 
 template <char... symbols>
 inline const char* find_first_not_symbols_or_null(const char* begin, const 
char* end) {
-    return detail::find_first_symbols_dispatch<false, 
detail::ReturnMode::Nullptr, symbols...>(
+    return ::detail::find_first_symbols_dispatch<false, 
::detail::ReturnMode::Nullptr, symbols...>(
             begin, end);
 }
 
 template <char... symbols>
 inline char* find_first_not_symbols_or_null(char* begin, char* end) {
     return const_cast<char*>(
-            detail::find_first_symbols_dispatch<false, 
detail::ReturnMode::Nullptr, symbols...>(
+            ::detail::find_first_symbols_dispatch<false, 
::detail::ReturnMode::Nullptr, symbols...>(
                     begin, end));
 }
 
 inline const char* find_first_not_symbols_or_null(std::string_view haystack,
                                                   const SearchSymbols& 
symbols) {
-    return detail::find_first_symbols_dispatch<false, 
detail::ReturnMode::Nullptr>(haystack,
-                                                                               
    symbols);
+    return ::detail::find_first_symbols_dispatch<false, 
::detail::ReturnMode::Nullptr>(haystack,
+                                                                               
        symbols);
 }
 
 template <char... symbols>
 inline const char* find_last_symbols_or_null(const char* begin, const char* 
end) {
-    return detail::find_last_symbols_sse2<true, detail::ReturnMode::Nullptr, 
symbols...>(begin,
-                                                                               
          end);
+    return ::detail::find_last_symbols_sse2<true, 
::detail::ReturnMode::Nullptr, symbols...>(begin,
+                                                                               
              end);
 }
 
 template <char... symbols>
 inline char* find_last_symbols_or_null(char* begin, char* end) {
     return const_cast<char*>(
-            detail::find_last_symbols_sse2<true, detail::ReturnMode::Nullptr, 
symbols...>(begin,
-                                                                               
           end));
+            ::detail::find_last_symbols_sse2<true, 
::detail::ReturnMode::Nullptr, symbols...>(begin,
+                                                                               
               end));
 }
 
 template <char... symbols>
 inline const char* find_last_not_symbols_or_null(const char* begin, const 
char* end) {
-    return detail::find_last_symbols_sse2<false, detail::ReturnMode::Nullptr, 
symbols...>(begin,
-                                                                               
           end);
+    return ::detail::find_last_symbols_sse2<false, 
::detail::ReturnMode::Nullptr, symbols...>(begin,
+                                                                               
               end);
 }
 
 template <char... symbols>
 inline char* find_last_not_symbols_or_null(char* begin, char* end) {
     return const_cast<char*>(
-            detail::find_last_symbols_sse2<false, detail::ReturnMode::Nullptr, 
symbols...>(begin,
-                                                                               
            end));
+            ::detail::find_last_symbols_sse2<false, 
::detail::ReturnMode::Nullptr, symbols...>(
+                    begin, end));
 }
 
 /// Slightly resembles boost::split. The drawback of boost::split is that it 
fires a false positive in clang static analyzer.


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscr...@doris.apache.org
For additional commands, e-mail: commits-h...@doris.apache.org

Reply via email to