Merge pull request 'fix/reinit' (#3) from fix/reinit into master

Reviewed-on: #3

.gitea/workflows/android.yml

@@ -17,7 +17,7 @@ on:
       - "third_party/**"
   
 concurrency:
-  group: android-${{github.ref}}
+  group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
 jobs:

.gitea/workflows/linux-aarch64-gcc.yml

@@ -24,7 +24,7 @@ on:
       - "CMakeLists.txt"
       - "cmake/**"
 concurrency:
-  group: linux-aarch64-cpu-gcc-${{ github.ref }}
+  group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 permissions:
   contents: read

.gitea/workflows/linux-arm-gcc.yml

@@ -26,7 +26,7 @@ on:
       - CMakeLists.txt
       - cmake/**
 concurrency:
-  group: linux-arm-gcc-${{ github.ref }}
+  group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 jobs:
   linux-gcc-arm:

.gitea/workflows/linux-mips-gcc.yml

@@ -22,9 +22,9 @@ on:
       - CMakeLists.txt
       - cmake/**
 concurrency:
-  group: linux-mips-gcc-${{ github.ref }}
+  group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
-permissions: read-all
+
 jobs:
   linux-gcc-mipsel:
     runs-on: ubuntu-20.04

.gitea/workflows/linux-mips64-gcc.yml

@@ -23,9 +23,9 @@ on:
       - CMakeLists.txt
       - cmake/**
 concurrency:
-  group: linux-mips64-gcc-${{ github.ref }}
+  group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
-permissions: read-all
+
 jobs:
   linux-gcc-mips64el:
     runs-on: ubuntu-20.04

.gitea/workflows/linux-riscv64-gcc.yml

@@ -24,9 +24,9 @@ on:
       - CMakeLists.txt
       - cmake/**
 concurrency:
-  group: linux-riscv64-gcc-${{ github.ref }}
+  group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
-permissions: read-all
+
 jobs:
   linux-gcc-riscv64:
     runs-on: ubuntu-20.04

.gitea/workflows/linux-x64-clang.yml

@@ -16,7 +16,7 @@ on:
       - "CMakeLists.txt"
 
 concurrency:
-  group: linux-x64-clang-${{ github.ref }}
+  group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
 jobs:

.gitea/workflows/linux-x64-gcc.yml

@@ -20,7 +20,7 @@ on:
       - "CMakeLists.txt"
 
 concurrency:
-  group: linux-x64-gcc-${{ github.ref }}
+  group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
 jobs:

.gitea/workflows/linux-x86-gcc.yml

@@ -22,7 +22,7 @@ on:
       - "CMakeLists.txt"
 
 concurrency:
-  group: linux-x86-gcc-${{ github.ref }}
+  group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
 jobs:

CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.5)
 
 set(tile_VERSION_MAJOR 0)
 set(tile_VERSION_MINOR 1)
-set(tile_VERSION_PATCH 1)
+set(tile_VERSION_PATCH 2)
 set(tile_VERSION_BUILD $ENV{CI_STEP_NUMBER})
 if(NOT tile_VERSION_BUILD)
   set(tile_VERSION_BUILD "0")
@@ -38,31 +38,6 @@ if(NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE "Release")
 endif()
 
-# if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang") # set(CMAKE_CXX_FLAGS
-# "${CMAKE_CXX_FLAGS} -gz") # set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -gz") #
-# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static") set(CMAKE_C_FLAGS #
-# "${CMAKE_CXX_FLAGS} -static") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} #
-# -fsanitize=address ") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address #
-# ")
-#
-# set(WHOLE_ARCHIVE_PREFIX "-Wl,-force_load") # set(NO_WHOLE_ARCHIVE_PREFIX "")
-# elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang") # set(CMAKE_CXX_FLAGS
-# "${CMAKE_CXX_FLAGS} -gz") # set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -gz") #
-# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static") set(CMAKE_C_FLAGS #
-# "${CMAKE_CXX_FLAGS} -static")
-#
-# set(WHOLE_ARCHIVE_PREFIX "-Wl,-force_load,") # set(NO_WHOLE_ARCHIVE_PREFIX "")
-# elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") set(CMAKE_CXX_FLAGS
-# "${CMAKE_CXX_FLAGS} -gz") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -gz") #
-# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libgcc -static-libstdc++") #
-# set(CMAKE_C_FLAGS "${CMAKE_CXX_FLAGS} -static-libgcc -static-libstdc++")
-#
-# set(STATIC_BINARY_FLAGS "-static-libgcc -static-libstdc++")
-# set(WHOLE_ARCHIVE_PREFIX "-Wl,--whole-archive") set(WHOLE_ARCHIVE_SUFFIX
-# "-Wl,--no-whole-archive") endif()
-
-# extern int getifaddrs(struct ifaddrs **ifap); extern void freeifaddrs(struct
-# ifaddrs *ifa);
 include(CheckSymbolExists)
 include(cmake/BuildInfo.cmake)
 
@@ -76,6 +51,7 @@ check_symbol_exists("freeifaddrs" "ifaddrs.h" TILE_HAVE_FREEIFADDRS)
 
 set(THIRD_PARTY_INCLUDE_DIRS # "third_party/json" "third_party/inja"
     "third_party/sigslot"
+    "third_party/result"
     "${CMAKE_CURRENT_BINARY_DIR}/third_party/gflags/include")
 include_directories(${THIRD_PARTY_INCLUDE_DIRS})
 add_subdirectory("third_party/zlib")
@@ -88,7 +64,6 @@ add_subdirectory("third_party/googletest")
 add_subdirectory("third_party/gflags")
 set(GFLAGS_USE_TARGET_NAMESPACE ON)
 set(gflags_DIR "${CMAKE_CURRENT_BINARY_DIR}/third_party/gflags")
-# add_subdirectory("third_party/context")
 
 set(CURL_DISABLE_TESTS ON)
 set(CURL_CA_PATH "none" CACHE STRING "" FORCE)
@@ -210,6 +185,7 @@ target_precompile_headers(
   tile
   PUBLIC
   "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_CURRENT_SOURCE_DIR}/third_party/header_only/toml.hpp>"
+  # "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_CURRENT_SOURCE_DIR}/third_party/result/result.hpp>"
   # ${CMAKE_CURRENT_SOURCE_DIR}/third_party/json/nlohann/json.hpp
   # ${CMAKE_CURRENT_SOURCE_DIR}/third_party/inja/inja/string_view.h
   # ${CMAKE_CURRENT_SOURCE_DIR}/third_party/inja/inja/inja.h

README.md

@@ -1,3 +1,8 @@
 ## TILE
 一个`C++11`工具库，集成常见的编码工具
+## TODO
+  - [ ] 支持`EventLoop`的模式的网络库
+    - [ ] 支持UDP
+    - [ ] 支持TCP
+
 

tile/base/internal/time_keeper_test.cc

@@ -14,6 +14,7 @@ namespace internal {
 constexpr auto kTestDuration = std::chrono::seconds(5);
 constexpr auto kInterval     = std::chrono::milliseconds(100);
 constexpr auto kTimerNum     = 100;
+constexpr auto kExpFactor    = 0.5;
 
 TEST(TimeKeeper, OneFastTimer)
 {
@@ -22,7 +23,7 @@ TEST(TimeKeeper, OneFastTimer)
     std::this_thread::sleep_for(kTestDuration);
     TimeKeeper::Instance()->KillTimer(timer_id);
     constexpr auto expires_count = kTestDuration / kInterval;
-    constexpr auto eps           = expires_count / 10;
+    constexpr auto eps           = expires_count * kExpFactor;
     ASSERT_NEAR(x, expires_count, eps);
 }
 
@@ -39,7 +40,7 @@ TEST(TimeKeeper, SlowTimer)
     for (auto &&e : timers) { TimeKeeper::Instance()->KillTimer(e); }
 
     const auto expires_count = kTimerNum * (2 * kTestDuration / kInterval);
-    const auto eps           = expires_count / 10;
+    const auto eps           = expires_count * kExpFactor;
     ASSERT_NEAR(x, expires_count, eps);
 }
 
@@ -56,7 +57,7 @@ TEST(TimeKeeper, FastTimer)
     for (auto &&e : timers) { TimeKeeper::Instance()->KillTimer(e); }
 
     const auto expires_count = kTimerNum * (2 * kTestDuration / kInterval);
-    const auto eps           = expires_count / 10;
+    const auto eps           = expires_count * kExpFactor;
     ASSERT_NEAR(x, expires_count, eps);
 }
 

tile/base/slice.h

@@ -225,6 +225,28 @@ operator+(const Slice &lhs, const Slice &rhs)
     return lhs.ToString() + rhs.ToString();
 }
 
+static_assert(std::is_constructible<Slice, char>::value, "Can't Build Sliece");
+static_assert(std::is_constructible<Slice, char &>::value, "Can't Build Sliece");
+static_assert(std::is_constructible<Slice, const char>::value, "Can't Build Sliece");
+static_assert(std::is_constructible<Slice, const char &>::value, "Can't Build Sliece");
+
+static_assert(std::is_constructible<Slice, char[]>::value, "Can't Build Sliece");
+static_assert(std::is_constructible<Slice, const char[]>::value, "Can't Build Sliece");
+
+static_assert(std::is_constructible<Slice, char[2]>::value, "Can't Build Sliece");
+static_assert(std::is_constructible<Slice, const char[2]>::value, "Can't Build Sliece");
+
+static_assert(std::is_constructible<Slice, char *>::value, "Can't Build Sliece");
+static_assert(std::is_constructible<Slice, const char *>::value, "Can't Build Sliece");
+
+static_assert(std::is_constructible<Slice, void *, int>::value, "Can't Build Sliece");
+static_assert(std::is_constructible<Slice, const void *, int>::value, "Can't Build Sliece");
+
+static_assert(std::is_constructible<Slice, std::string>::value, "Can't Build Sliece");
+static_assert(std::is_constructible<Slice, std::string &>::value, "Can't Build Sliece");
+static_assert(std::is_constructible<Slice, const std::string>::value, "Can't Build Sliece");
+static_assert(std::is_constructible<Slice, const std::string &>::value, "Can't Build Sliece");
+
 }// namespace tile
 
 namespace std {

tile/base/string.cc

@@ -121,24 +121,6 @@ Split(Slice s, Slice delim, bool keep_empty, std::size_t max_split_parts)
     return splited;
 }
 
-Slice
-TrimLeft(Slice s, Slice cutset)
-{
-    return TrimLeft(s, [&cutset](char c) { return cutset.find(Slice(&c, 1)) != Slice::npos; });
-}
-
-Slice
-TrimRight(Slice s, Slice cutset)
-{
-    return TrimRight(s, [&cutset](char c) { return cutset.find(Slice(&c, 1)) != Slice::npos; });
-}
-
-Slice
-Trim(Slice s, Slice cutset)
-{
-    return Trim(s, [&cutset](char c) { return cutset.find(Slice(&c, 1)) != Slice::npos; });
-}
-
 template<typename T>
 void
 JoinImpl(const T &parts, Slice delim, std::string *result)

tile/base/string.h

@@ -39,12 +39,8 @@ bool EndsWithIgnoreCase(Slice s, Slice prefix);
 void Replace(Slice from, Slice to, std::string *str, std::size_t count = std::numeric_limits<std::size_t>::max());
 std::string Replace(Slice str, Slice from, Slice to, std::size_t count = std::numeric_limits<std::size_t>::max());
 
-Slice TrimLeft(Slice s, Slice cutset);
-Slice TrimRight(Slice s, Slice cutset);
-Slice Trim(Slice s, Slice cutset);
-
 template<typename Pred = int(int)>
-Slice
+enable_if_t<!std::is_constructible<Slice, Pred>::value, Slice>
 TrimLeft(Slice s, Pred pred = isspace)
 {
     while (!s.empty() && pred(s[0])) { s.RemovePrefix(1); }
@@ -52,7 +48,7 @@ TrimLeft(Slice s, Pred pred = isspace)
 }
 
 template<typename Pred = int(int)>
-Slice
+enable_if_t<!std::is_constructible<Slice, Pred>::value, Slice>
 TrimRight(Slice s, Pred pred = isspace)
 {
     while (!s.empty() && pred(s[s.size() - 1])) { s.RemoveSuffix(1); }
@@ -60,12 +56,36 @@ TrimRight(Slice s, Pred pred = isspace)
 }
 
 template<typename Pred = int(int)>
-Slice
+enable_if_t<!std::is_constructible<Slice, Pred>::value, Slice>
 Trim(Slice s, Pred pred = isspace)
 {
     return TrimRight(TrimLeft(s, pred), pred);
 }
 
+template<typename T>
+enable_if_t<std::is_constructible<Slice, T>::value, Slice>
+TrimLeft(Slice s, T slice_like)
+{
+    Slice cutset(slice_like);
+    return TrimLeft(s, [&cutset](char c) { return cutset.find(c) != Slice::npos; });
+}
+
+template<typename T>
+enable_if_t<std::is_constructible<Slice, T>::value, Slice>
+TrimRight(Slice s, T slice_like)
+{
+    Slice cutset(slice_like);
+    return TrimRight(s, [&cutset](char c) { return cutset.find(c) != Slice::npos; });
+}
+
+template<typename T>
+enable_if_t<std::is_constructible<Slice, T>::value, Slice>
+Trim(Slice s, T slice_like)
+{
+    Slice cutset(slice_like);
+    return Trim(s, [&cutset](char c) { return cutset.find(c) != Slice::npos; });
+}
+
 std::vector<Slice> Split(Slice s,
                          char delim,
                          bool keep_empty             = false,

tile/base/string_test.cc

@@ -184,6 +184,17 @@ TEST(String, Trim)
     ASSERT_EQ("a a", Trim("  a a  "));
 }
 
+TEST(String, TrimByCustset)
+{
+    static_assert(std::is_constructible<Slice, decltype("d")>::value, "");
+    static_assert(!std::is_constructible<Slice, int(int)>::value, "");
+    ASSERT_EQ(" ", Trim("abcd abcd", "abcd"));
+    ASSERT_EQ("abcd abc", Trim("abcd abcd", "d"));
+    ASSERT_EQ("abcd abcd ", Trim("abcd abcd ", "d"));
+    ASSERT_EQ(" abcd abcd ", Trim(" abcd abcd ", "ad"));
+    ASSERT_EQ("bcd abc", Trim(" abcd abcd ", "ad "));
+}
+
 TEST(String, Split1)
 {
     auto splited = Split("/a/b/c/d/e/f///g", '/');

tile/init.cc

@@ -17,6 +17,7 @@
 // #include "glog/logging.h"
 // #include "glog/raw_logging.h"
 
+#include <condition_variable>
 #include <functional>
 #include <mutex>
 #include <sys/signal.h>
@@ -130,4 +131,44 @@ TerminateBasicRuntime()
     detail::chrono::CoarseClockInitializer::Instance()->Join();
 }
 
+std::mutex init_lock;
+std::condition_variable init_cv;
+std::thread *lib_thread;
+const char *my_argv[1] = {"unknown"};
+
+void
+Init(int argc, char **argv, std::function<int(int, char **)> cb)
+{
+    std::unique_lock<std::mutex> _(init_lock);
+    assert(!lib_thread && "ReInitialize!!!");
+
+    if (!argv) {
+        argc = 1;
+        argv = (char **) my_argv;
+    }
+
+    if (!cb) {
+        cb = [](int argc, char **) {
+            std::unique_lock<std::mutex> _(init_lock);
+            init_cv.wait(_);
+            return 0;
+        };
+    }
+
+    lib_thread = new std::thread([=] { ::tile::Start(argc, argv, cb); });
+}
+
+void
+Uninit()
+{
+    std::thread *work_thread = nullptr;
+    {
+        std::unique_lock<std::mutex> _(init_lock);
+        assert(!lib_thread && "Please Initialize it!!!");
+        init_cv.notify_all();
+        std::swap(work_thread, lib_thread);
+    }
+    work_thread->join();
+}
+
 }// namespace tile

tile/init.h

@@ -18,9 +18,14 @@ bool CheckForQuitSignal();
 void InitializeBasicRuntime();
 void TerminateBasicRuntime();
 
+void Init(int argc = 0, char **argv = nullptr, std::function<int(int, char **)> cb = nullptr);
+void Uninit();
 }// namespace tile
 
 #define TILE_MAIN(func)                                                                                                \
     int main(int argc, char *argv[]) { return ::tile::Start(argc, argv, func); }
 
+#define TILE_LIB_INIT(...) ::tile::Init(__VA_ARGS__);
+#define TILE_LIB_UNINIT() ::tile::Uninit();
+
 #endif// TILE_INIT_H

tile/tile.h

@@ -17,6 +17,7 @@
 #include "tile/base/encoding.h"
 #include "tile/base/enum.h"
 #include "tile/base/erased_ptr.h"
+#include "tile/base/expected.h"
 #include "tile/base/exposed_var.h"
 #include "tile/base/future.h"
 #include "tile/base/handle.h"