nodejieba-plus 3.5.8

package/submodules/cppjieba/deps/limonp/CHANGELOG.md

@@ -0,0 +1,160 @@
+# CHANGELOG
+
+## v1.0.0
+
++ rm thread pool demo
++ deleted:    include/limonp/BlockingQueue.hpp
++ deleted:    include/limonp/BoundedBlockingQueue.hpp
++ deleted:    include/limonp/BoundedQueue.hpp
++ deleted:    include/limonp/MutexLock.hpp
++ deleted:    include/limonp/Thread.hpp
++ deleted:    include/limonp/ThreadPool.hpp
++ deleted:    test/unittest/TBlockingQueue.cpp
++ deleted:    test/unittest/TBoundedQueue.cpp
++ deleted:    test/unittest/TMutexLock.cpp
++ deleted:    test/unittest/TThread.cpp
++ deleted:    test/unittest/TThreadPool.cpp
++ rm FileLock
++ rm Md5.hpp
+
+## v0.9.0
+
++ [c++20] compatibility
++ [c++17] compatibility
+
+## v0.8.1
+
++ [CI] fix windows gtest thread link error
++ [submodule] rm test/googletest
++ [CMake] FetchContent googletest
++ [CMake] required 3.5 -> 3.14
+
+## v0.8.0
+
++ [StringUtil] Fix windows assert typo
++ [CMake] find_package(Threads REQUIRED); target_link_libraries(... Threads::Threads)
++ [CMAKE][CI] windows: 2019,2022
++ [CMAKE][CI] matrix.build_type[Release, Debug]
++ [unittest] disable #TMd5.cpp
++ [unittest] disable #TFileLock.cpp
++ [unittest] disable #TBoundedQueue.cpp 
++ [unittest] disable #TMutexLock.cpp 
++ [unittest] disable #TBlockingQueue.cpp 
++ [unittest] disable #TThread.cpp 
++ [unittest] disable #TThreadPool.cpp
+
+## v0.7.2
+
++ [CI] ubuntu version from 20 to 22, macos version from 12 to 14
++ [test/unittes] uint->size_t
++ [googletest] v1.6.0->v1.10.0
++ [CMake] version required 3.0 -> 3.5
+
+## v0.7.1
+
++ [CMake] fix CMAKE_CXX_STANDARD passed from github/actions and [c++11, c++14] only
+
+## v0.7.0
+
++ [CI] Added os.macos and cpp_version=[c++98, c++03, c++11, c++14, c++17, c++20]
++ [git submodule] Added googletest-release-v1.6.0
+
+## v0.6.7
+
++ Merged [pr35](https://github.com/yanyiwu/limonp/pull/35)
++ Merged [pr33](https://github.com/yanyiwu/limonp/pull/33)
++ Merged [pr32](https://github.com/yanyiwu/limonp/pull/32)
+
+## v0.6.6
+
++ Merged [pr-31 To be compatible with cpp17 and later, use lambda instead of std::not1 & std::bind2nd #31](https://github.com/yanyiwu/limonp/pull/31)
+
+## v0.6.5
+
++ Merged [pr-25 Update cmake.yml](https://github.com/yanyiwu/limonp/pull/25)
++ Merged [pr-26 fix license for end of line sequence and remove useless signature](https://github.com/yanyiwu/limonp/pull/26)
++ Merged [pr-27 Update cmake.yml](https://github.com/yanyiwu/limonp/pull/27)
++ Merged [pr-28 add a target to be ready to support installation](https://github.com/yanyiwu/limonp/pull/28)
++ Merged [pr-29 Installable by cmake](https://github.com/yanyiwu/limonp/pull/29)
++ Merged [pr-30 Replace localtime with localtime_s on Windows and localtime_r on Linux](https://github.com/yanyiwu/limonp/pull/30)
+
+## v0.6.4
+
++ merge [fixup gcc8 warnings](https://github.com/yanyiwu/gojieba/pull/70)
+
+## v0.6.3
+
++ remove compiler conplained macro
+
+## v0.6.2
+
++ merge [pr-18](https://github.com/yanyiwu/limonp/pull/18/files)
+
+## v0.6.1
+
+add Specialized template for vector<string>
+
+when it is `vector<string>`, print like this: ["hello", "world"]; (special case)
+when it is `vector<int>`, print like this: [1, 10, 1000]; (common cases)
+
+## v0.6.0
+
++ remove Trim out of Split.
+
+## v0.5.6
+
++ fix hidden trouble.
+
+## v0.5.5
+
++ macro name LOG and CHECK in Logging.hpp is so easy to confict with other lib, so I have to rename them to XLOG and XCHECK for avoiding those macro name conflicts.
+
+## v0.5.4
+
++ add ForcePublic.hpp
++ Add Utf8ToUnicode32 and Unicode32ToUtf8 in StringUtil.hpp
+
+## v0.5.3
+
++ Fix incompatibility problem about 'time.h' in Windows.
+
+## v0.5.2
+
++ Fix incompatibility problem about `enum {INFO ...}` name conflicts in Windows .
++ So from this version begin: the compile flags: `-DLOGGING_LEVEL=WARNING` must be changed to `-DLOGGING_LEVEL=LL_WARNING`
+
+## v0.5.1
+
++ add `ThreadPool::Stop()` to wait util all the threads finished. 
+If Stop() has not been called, it will be called when the ThreadPool destructing.
+
+## v0.5.0
+
++ Reorganized directories: include/ -> include/limonp/ ... and so on.
++ Add `NewClosure` in Closure.hpp, 0~3 arguments have been supported.
++ Update ThreadPool, use `NewClosure` instead of `CreateTask`
+
+## v0.4.1
+
++ `CHECK(exp) << "log message"` supported;
+
+## v0.4.0
+
++ add test/demo.cc as example.
++ move `print` macro to StdExtension.hpp
++ BigChange: rewrite `log` module, use `LOG(INFO) << "xxx" ` instead `LogInfo` .
++ remove HandyMacro.hpp, add CHECK in Logging.hpp instead.
+
+## v0.3.0
+
++ remove 'MysqlClient.hpp', 'InitOnOff.hpp', 'CastFloat.hpp'
++ add 'Closure.hpp'
++ uniform code style
+
+## v0.2.0
+
++ `namespace limonp`, not `Limonp` .
+
+## v0.1.0
+
++ Basic functions

package/submodules/cppjieba/deps/limonp/CMakeLists.txt

@@ -0,0 +1,61 @@
+cmake_minimum_required(VERSION 3.14)
+
+PROJECT(limonp
+        LANGUAGES CXX)
+
+################
+# cmake config #
+################
+
+if(NOT DEFINED CMAKE_CXX_STANDARD)
+    set(CMAKE_CXX_STANDARD 11)
+endif()
+message(STATUS "CMAKE_CXX_STANDARD is ${CMAKE_CXX_STANDARD}")
+
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+
+##############
+# dependency #
+##############
+include(GNUInstallDirs)
+
+##########
+# target #
+##########
+
+add_library(${PROJECT_NAME} INTERFACE)
+add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
+
+target_include_directories(${PROJECT_NAME}
+                           INTERFACE
+                               $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+                               $<INSTALL_INTERFACE:${CMAKE_INSTALL_FULL_INCLUDEDIR}>)
+
+########
+# test #
+########
+
+ENABLE_TESTING()
+
+ADD_SUBDIRECTORY(test)
+ADD_TEST(NAME ./test/demo COMMAND ./test/demo)
+ADD_TEST(NAME ./test/test.run COMMAND ./test/test.run)
+
+###########
+# install #
+###########
+
+include(GNUInstallDirs)
+
+install(TARGETS ${PROJECT_NAME}
+        EXPORT ${PROJECT_NAME})
+
+install(EXPORT ${PROJECT_NAME}
+        DESTINATION ${CMAKE_INSTALL_DATADIR}/${PROJECT_NAME}/cmake/
+        NAMESPACE ${PROJECT_NAME}::
+        FILE ${PROJECT_NAME}-config.cmake)
+
+install(DIRECTORY include/
+        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})

package/submodules/cppjieba/deps/limonp/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/submodules/cppjieba/deps/limonp/README.md

@@ -0,0 +1,38 @@
+# limonp 
+
+[![CMake](https://github.com/yanyiwu/limonp/actions/workflows/cmake.yml/badge.svg)](https://github.com/yanyiwu/limonp/actions/workflows/cmake.yml)
+[![Author](https://img.shields.io/badge/author-@yanyiwu-blue.svg?style=flat)](http://yanyiwu.com/) 
+[![Platform](https://img.shields.io/badge/platform-Linux,macOS,Windows-green.svg?style=flat)](https://github.com/yanyiwu/limonp)
+[![Tag](https://img.shields.io/github/v/tag/yanyiwu/limonp.svg)](https://github.com/yanyiwu/limonp/releases)
+[![License](https://img.shields.io/badge/license-MIT-yellow.svg?style=flat)](http://yanyiwu.mit-license.org)
+
+## Introduction
+
+`C++` headers(hpp) with Python style. 
+
+## Feature
+
++ linking is a annoying thing, so I write these source code in headers file(`*.hpp`), you can use them only with `#include "xx.hpp"`, without linking *.a or *.so .
+
+**`no linking , no hurts`** 
+
+## Example
+
+See Details in `test/demo.cpp`
+
+## Cases
+
+1. [CppJieba]
+
+## Reference
+
+1.  `md5.hpp` is copied from network, you can find original author in source code(in comments).
+2.  `MutexLock.hpp`, `BlockingQueue.hpp`, `Condition.hpp` reference from [muduo].
+
+## Contact
+
++ i@yanyiwu.com
+
+[CppJieba]:https://github.com/yanyiwu/cppjieba.git
+[muduo]:https://github.com/chenshuo/muduo.git
+

package/submodules/cppjieba/deps/limonp/include/limonp/ArgvContext.hpp

@@ -0,0 +1,70 @@
+/************************************
+ * file enc : ascii
+ * author   : wuyanyi09@gmail.com
+ ************************************/
+
+#ifndef LIMONP_ARGV_FUNCTS_H
+#define LIMONP_ARGV_FUNCTS_H
+
+#include <set>
+#include <sstream>
+#include "StringUtil.hpp"
+
+namespace limonp {
+
+using namespace std;
+
+class ArgvContext {
+ public :
+  ArgvContext(int argc, const char* const * argv) {
+    for(int i = 0; i < argc; i++) {
+      if(StartsWith(argv[i], "-")) {
+        if(i + 1 < argc && !StartsWith(argv[i + 1], "-")) {
+          mpss_[argv[i]] = argv[i+1];
+          i++;
+        } else {
+          sset_.insert(argv[i]);
+        }
+      } else {
+        args_.push_back(argv[i]);
+      }
+    }
+  }
+  ~ArgvContext() {
+  }
+
+  friend ostream& operator << (ostream& os, const ArgvContext& args);
+  string operator [](size_t i) const {
+    if(i < args_.size()) {
+      return args_[i];
+    }
+    return "";
+  }
+  string operator [](const string& key) const {
+    map<string, string>::const_iterator it = mpss_.find(key);
+    if(it != mpss_.end()) {
+      return it->second;
+    }
+    return "";
+  }
+
+  bool HasKey(const string& key) const {
+    if(mpss_.find(key) != mpss_.end() || sset_.find(key) != sset_.end()) {
+      return true;
+    }
+    return false;
+  }
+
+ private:
+  vector<string> args_;
+  map<string, string> mpss_;
+  set<string> sset_;
+}; // class ArgvContext
+
+inline ostream& operator << (ostream& os, const ArgvContext& args) {
+  return os<<args.args_<<args.mpss_<<args.sset_;
+}
+
+} // namespace limonp
+
+#endif

package/submodules/cppjieba/deps/limonp/include/limonp/Closure.hpp

@@ -0,0 +1,206 @@
+#ifndef LIMONP_CLOSURE_HPP
+#define LIMONP_CLOSURE_HPP
+
+namespace limonp {
+
+class ClosureInterface {
+ public:
+  virtual ~ClosureInterface() {
+  }
+  virtual void Run() = 0;
+};
+
+template <class Funct>
+class Closure0: public ClosureInterface {
+ public:
+  Closure0(Funct fun) {
+    fun_ = fun;
+  }
+  virtual ~Closure0() {
+  }
+  virtual void Run() {
+    (*fun_)();
+  }
+ private:
+  Funct fun_;
+}; 
+
+template <class Funct, class Arg1>
+class Closure1: public ClosureInterface {
+ public:
+  Closure1(Funct fun, Arg1 arg1) {
+    fun_ = fun;
+    arg1_ = arg1;
+  }
+  virtual ~Closure1() {
+  }
+  virtual void Run() {
+    (*fun_)(arg1_);
+  }
+ private:
+  Funct fun_;
+  Arg1 arg1_;
+}; 
+
+template <class Funct, class Arg1, class Arg2>
+class Closure2: public ClosureInterface {
+ public:
+  Closure2(Funct fun, Arg1 arg1, Arg2 arg2) {
+    fun_ = fun;
+    arg1_ = arg1;
+    arg2_ = arg2;
+  }
+  virtual ~Closure2() {
+  }
+  virtual void Run() {
+    (*fun_)(arg1_, arg2_);
+  }
+ private:
+  Funct fun_;
+  Arg1 arg1_;
+  Arg2 arg2_;
+}; 
+
+template <class Funct, class Arg1, class Arg2, class Arg3>
+class Closure3: public ClosureInterface {
+ public:
+  Closure3(Funct fun, Arg1 arg1, Arg2 arg2, Arg3 arg3) {
+    fun_ = fun;
+    arg1_ = arg1;
+    arg2_ = arg2;
+    arg3_ = arg3;
+  }
+  virtual ~Closure3() {
+  }
+  virtual void Run() {
+    (*fun_)(arg1_, arg2_, arg3_);
+  }
+ private:
+  Funct fun_;
+  Arg1 arg1_;
+  Arg2 arg2_;
+  Arg3 arg3_;
+}; 
+
+template <class Obj, class Funct> 
+class ObjClosure0: public ClosureInterface {
+ public:
+  ObjClosure0(Obj* p, Funct fun) {
+   p_ = p;
+   fun_ = fun;
+  }
+  virtual ~ObjClosure0() {
+  }
+  virtual void Run() {
+    (p_->*fun_)();
+  }
+ private:
+  Obj* p_;
+  Funct fun_;
+}; 
+
+template <class Obj, class Funct, class Arg1> 
+class ObjClosure1: public ClosureInterface {
+ public:
+  ObjClosure1(Obj* p, Funct fun, Arg1 arg1) {
+   p_ = p;
+   fun_ = fun;
+   arg1_ = arg1;
+  }
+  virtual ~ObjClosure1() {
+  }
+  virtual void Run() {
+    (p_->*fun_)(arg1_);
+  }
+ private:
+  Obj* p_;
+  Funct fun_;
+  Arg1 arg1_;
+}; 
+
+template <class Obj, class Funct, class Arg1, class Arg2> 
+class ObjClosure2: public ClosureInterface {
+ public:
+  ObjClosure2(Obj* p, Funct fun, Arg1 arg1, Arg2 arg2) {
+   p_ = p;
+   fun_ = fun;
+   arg1_ = arg1;
+   arg2_ = arg2;
+  }
+  virtual ~ObjClosure2() {
+  }
+  virtual void Run() {
+    (p_->*fun_)(arg1_, arg2_);
+  }
+ private:
+  Obj* p_;
+  Funct fun_;
+  Arg1 arg1_;
+  Arg2 arg2_;
+}; 
+template <class Obj, class Funct, class Arg1, class Arg2, class Arg3> 
+class ObjClosure3: public ClosureInterface {
+ public:
+  ObjClosure3(Obj* p, Funct fun, Arg1 arg1, Arg2 arg2, Arg3 arg3) {
+   p_ = p;
+   fun_ = fun;
+   arg1_ = arg1;
+   arg2_ = arg2;
+   arg3_ = arg3;
+  }
+  virtual ~ObjClosure3() {
+  }
+  virtual void Run() {
+    (p_->*fun_)(arg1_, arg2_, arg3_);
+  }
+ private:
+  Obj* p_;
+  Funct fun_;
+  Arg1 arg1_;
+  Arg2 arg2_;
+  Arg3 arg3_;
+}; 
+
+template<class R>
+ClosureInterface* NewClosure(R (*fun)()) {
+  return new Closure0<R (*)()>(fun);
+}
+
+template<class R, class Arg1>
+ClosureInterface* NewClosure(R (*fun)(Arg1), Arg1 arg1) {
+  return new Closure1<R (*)(Arg1), Arg1>(fun, arg1);
+}
+
+template<class R, class Arg1, class Arg2>
+ClosureInterface* NewClosure(R (*fun)(Arg1, Arg2), Arg1 arg1, Arg2 arg2) {
+  return new Closure2<R (*)(Arg1, Arg2), Arg1, Arg2>(fun, arg1, arg2);
+}
+
+template<class R, class Arg1, class Arg2, class Arg3>
+ClosureInterface* NewClosure(R (*fun)(Arg1, Arg2, Arg3), Arg1 arg1, Arg2 arg2, Arg3 arg3) {
+  return new Closure3<R (*)(Arg1, Arg2, Arg3), Arg1, Arg2, Arg3>(fun, arg1, arg2, arg3);
+}
+
+template<class R, class Obj>
+ClosureInterface* NewClosure(Obj* obj, R (Obj::* fun)()) {
+  return new ObjClosure0<Obj, R (Obj::* )()>(obj, fun);
+}
+
+template<class R, class Obj, class Arg1>
+ClosureInterface* NewClosure(Obj* obj, R (Obj::* fun)(Arg1), Arg1 arg1) {
+  return new ObjClosure1<Obj, R (Obj::* )(Arg1), Arg1>(obj, fun, arg1);
+}
+
+template<class R, class Obj, class Arg1, class Arg2>
+ClosureInterface* NewClosure(Obj* obj, R (Obj::* fun)(Arg1, Arg2), Arg1 arg1, Arg2 arg2) {
+  return new ObjClosure2<Obj, R (Obj::*)(Arg1, Arg2), Arg1, Arg2>(obj, fun, arg1, arg2);
+}
+
+template<class R, class Obj, class Arg1, class Arg2, class Arg3>
+ClosureInterface* NewClosure(Obj* obj, R (Obj::* fun)(Arg1, Arg2, Arg3), Arg1 arg1, Arg2 arg2, Arg3 arg3) {
+  return new ObjClosure3<Obj, R (Obj::*)(Arg1, Arg2, Arg3), Arg1, Arg2, Arg3>(obj, fun, arg1, arg2, arg3);
+}
+
+} // namespace limonp
+
+#endif // LIMONP_CLOSURE_HPP

package/submodules/cppjieba/deps/limonp/include/limonp/Colors.hpp

@@ -0,0 +1,31 @@
+#ifndef LIMONP_COLOR_PRINT_HPP
+#define LIMONP_COLOR_PRINT_HPP
+
+#include <string>
+#include <stdarg.h>
+
+namespace limonp {
+
+using std::string;
+
+enum Color {
+  BLACK = 30,
+  RED,
+  GREEN,
+  YELLOW,
+  BLUE,
+  PURPLE
+}; // enum Color
+
+static void ColorPrintln(enum Color color, const char * fmt, ...) {
+  va_list ap;
+  printf("\033[0;%dm", color);
+  va_start(ap, fmt);
+  vprintf(fmt, ap);
+  va_end(ap);
+  printf("\033[0m\n"); // if not \n , in some situation , the next lines will be set the same color unexpectedly
+}
+
+} // namespace limonp
+
+#endif // LIMONP_COLOR_PRINT_HPP

package/submodules/cppjieba/deps/limonp/include/limonp/Condition.hpp

@@ -0,0 +1,38 @@
+#ifndef LIMONP_CONDITION_HPP
+#define LIMONP_CONDITION_HPP
+
+#include "MutexLock.hpp"
+
+namespace limonp {
+
+class Condition : NonCopyable {
+ public:
+  explicit Condition(MutexLock& mutex)
+    : mutex_(mutex) {
+    XCHECK(!pthread_cond_init(&pcond_, NULL));
+  }
+
+  ~Condition() {
+    XCHECK(!pthread_cond_destroy(&pcond_));
+  }
+
+  void Wait() {
+    XCHECK(!pthread_cond_wait(&pcond_, mutex_.GetPthreadMutex()));
+  }
+
+  void Notify() {
+    XCHECK(!pthread_cond_signal(&pcond_));
+  }
+
+  void NotifyAll() {
+    XCHECK(!pthread_cond_broadcast(&pcond_));
+  }
+
+ private:
+  MutexLock& mutex_;
+  pthread_cond_t pcond_;
+}; // class Condition
+
+} // namespace limonp
+
+#endif // LIMONP_CONDITION_HPP