Boost.org signals2 module

Overview

Signals2, part of collection of the Boost C++ Libraries, is an implementation of a managed signals and slots system.

License

Distributed under the Boost Software License, Version 1.0.

Properties

  • C++03
  • Header-Only

Build Status

Branch Travis Appveyor Coverity Scan codecov.io Deps Docs Tests
master Build Status Build status Coverity Scan Build Status codecov Deps Documentation Enter the Matrix
develop Build Status Build status Coverity Scan Build Status codecov Deps Documentation Enter the Matrix

Directories

Name Purpose
ci continuous integration scripts
doc documentation
example examples
include headers
test unit tests

More information

  • Ask questions
  • Report bugs: Be sure to mention Boost version, platform and compiler you're using. A small compilable code sample to reproduce the problem is always good as well.
  • Submit your patches as pull requests against develop branch. Note that by submitting patches you agree to license your modifications under the Boost Software License, Version 1.0.
  • Discussions about the library are held on the Boost developers mailing list. Be sure to read the discussion policy before posting and add the [signals2] tag at the beginning of the subject line.
Issues
  • Fails to compile on NVCC CUDA 11.0

    Fails to compile on NVCC CUDA 11.0

    The following code snippet will not compile in Nvidia's compiler.

      #include <boost/signals2/signal.hpp>
      
      // TODO: This is an example of a library function
      void fnBoostPreprocessorHeader()
      {
      }
    
    

    The compiler chokes somewhere inside of the include statement without any additional code except the snippet above. The following error is returned:

    C1012 unmatched parenthesis: missing ')' BoostPreprocessorHeader in C:\vcpkg\installed\x64-windows-static\include\boost\preprocessor\slot\detail\shared.hpp on line 27

    I have spoken to the nvidia compiler group and they responded with the following:

    We checked the issue and confirmed that it is a Boost issue .The error is emitted by Microsoft cl.exe compiler. Something in the    Boost headers is checking for one of the CUDA macros (__CUDACC__ / __NVCC__) and enabling code that is not accepted by the Microsoft compiler used for preprocessing.
    We suggest you track a ticket to Boost with this reproducer . Thank you.
    
    Nvidia
    
    opened by dahubley 24
  • Test function type template parameter support

    Test function type template parameter support

    <boost/signals2/variadic_signal.hpp>

    • Add boost::signals2::detail::variadic_extended_signature template specializations for boost::function and std::function (when available).

    <boost/signals2/signal_type.hpp>

    • Leverage Boost.Parameter support for function type template parameters.

    "test/signal_type_test.cpp"

    • Remove BOOST_SIGNALS2_NAMED_SIGNATURE_PARAMETER preprocessor guard.

    "test/Jamfile.v2"

    • Define BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY=0 where applicable to prevent ICE failures.
    opened by CromwellEnage 12
  • Release numbering and tag stability policy

    Release numbering and tag stability policy

    Hullo!

    Guix provides a boost-signals2 package. We noticed that the boost-1.77.0 tag moved significantly between 2019 and 2021.

    Looking back, this was (long) before boost 1.77.0 was actually released. If so, using that tag so early was premature on our part!

    Could you confirm my suspicion

    • that you develop for upcoming Boost releases using a movable tag,
    • but that this tag is not touched once that Boost has been officially released — even to fix bugs found later?

    From a brief glance at the repository this seems to be the case, but it would be great if that were a deliberate policy.

    Thanks in advance!

    opened by nckx 6
  • clang-tidy is reporting

    clang-tidy is reporting "Use of memory after it is freed"

    Hi, do you think it is misreporting? If it is I would like to suppress the warning

    #include <boost/signals2.hpp>
    
    int main()
    {
      boost::signals2::signal<void ()> sig;
      sig.connect([]{});
      sig();
    }
    

    The output of clang-tidy

    ❯ clang-tidy-14 --checks='clang-diag*' ../a.cpp
    1 warning generated.
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/smart_ptr/detail/shared_count.hpp:586:22: warning: Use of memory after it is freed [clang-analyzer-cplusplus.NewDelete]
            if(pi_ != 0) pi_->weak_release();
                         ^
    /tmp/foo/a.cpp:10:3: note: Calling 'signal::connect'
      sig.connect([]{});
      ^~~~~~~~~~~~~~~~~
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/signals2/detail/signal_template.hpp:691:16: note: Calling 'signal_impl::connect'
            return (*_pimpl).connect(slot, position);
                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/signals2/detail/signal_template.hpp:164:18: note: Calling 'signal_impl::nolock_connect'
              return nolock_connect(lock, slot, position);
                     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/signals2/detail/signal_template.hpp:552:14: note: 'position' is equal to at_back
              if(position == at_back)
                 ^~~~~~~~
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/signals2/detail/signal_template.hpp:552:11: note: Taking true branch
              if(position == at_back)
              ^
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/signals2/detail/signal_template.hpp:562:29: note: Calling implicit destructor for 'weak_ptr<boost::signals2::detail::connection_body_base>'
              return connection(newConnectionBody);
                                ^
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/signals2/detail/signal_template.hpp:562:29: note: Calling '~weak_count'
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/smart_ptr/detail/shared_count.hpp:586:12: note: Field 'pi_' is not equal to null
            if(pi_ != 0) pi_->weak_release();
               ^
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/smart_ptr/detail/shared_count.hpp:586:9: note: Taking true branch
            if(pi_ != 0) pi_->weak_release();
            ^
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/smart_ptr/detail/shared_count.hpp:586:22: note: Calling 'sp_counted_base::weak_release'
            if(pi_ != 0) pi_->weak_release();
                         ^~~~~~~~~~~~~~~~~~~
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/smart_ptr/detail/sp_counted_base_gcc_atomic.hpp:132:13: note: Assuming the condition is true
            if( atomic_decrement( &weak_count_ ) == 1 )
                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/smart_ptr/detail/sp_counted_base_gcc_atomic.hpp:132:9: note: Taking true branch
            if( atomic_decrement( &weak_count_ ) == 1 )
            ^
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/smart_ptr/detail/sp_counted_base_gcc_atomic.hpp:134:13: note: Calling 'sp_counted_base::destroy'
                destroy();
                ^~~~~~~~~
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/smart_ptr/detail/sp_counted_base_gcc_atomic.hpp:99:9: note: Memory is released
            delete this;
            ^~~~~~~~~~~
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/smart_ptr/detail/sp_counted_base_gcc_atomic.hpp:134:13: note: Returning; memory was released
                destroy();
                ^~~~~~~~~
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/smart_ptr/detail/shared_count.hpp:586:22: note: Returning; memory was released
            if(pi_ != 0) pi_->weak_release();
                         ^~~~~~~~~~~~~~~~~~~
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/signals2/detail/signal_template.hpp:562:29: note: Returning from '~weak_count'
              return connection(newConnectionBody);
                                ^
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/signals2/detail/signal_template.hpp:562:29: note: Returning from destructor for 'weak_ptr<boost::signals2::detail::connection_body_base>'
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/signals2/detail/signal_template.hpp:164:18: note: Returning; memory was released
              return nolock_connect(lock, slot, position);
                     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/signals2/detail/signal_template.hpp:691:16: note: Returning; memory was released
            return (*_pimpl).connect(slot, position);
                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    /tmp/foo/a.cpp:10:3: note: Returning; memory was released
      sig.connect([]{});
      ^~~~~~~~~~~~~~~~~
    /tmp/foo/a.cpp:10:19: note: Calling '~connection'
      sig.connect([]{});
                      ^
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/signals2/connection.hpp:265:22: note: Calling implicit destructor for 'weak_ptr<boost::signals2::detail::connection_body_base>'
          ~connection() {}
                         ^
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/signals2/connection.hpp:265:22: note: Calling '~weak_count'
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/smart_ptr/detail/shared_count.hpp:586:12: note: Field 'pi_' is not equal to null
            if(pi_ != 0) pi_->weak_release();
               ^
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/smart_ptr/detail/shared_count.hpp:586:9: note: Taking true branch
            if(pi_ != 0) pi_->weak_release();
            ^
    /home/hg/.conan/data/boost/1.78.0/_/_/package/cfef62e446e1bb07894de4523f2649afdfa94524/include/boost/smart_ptr/detail/shared_count.hpp:586:22: note: Use of memory after it is freed
            if(pi_ != 0) pi_->weak_release();
    
    opened by hg-zt 5
  • Safe disconnection

    Safe disconnection

    As the documentation states: when I disconnect a slot, then there is a chance that an emission is running from another thread. This makes me some trouble with my application, because after disconnection I cannot be sure that my callback object is really not used any more.

    I did not find (or overlooked) any solution in signals2. So I came up with a special scoped_connection, where I inject/capture a RAII tracker object into the slot (see the template constructor PostEmissionSafeConnection), so that in the connection I know when all slot copies are gone. The RAII tracker object (here: HandlerTrace) manipulates an atomic reference counter (TraceCounter) to keep track of the slot copies. By the way it was interesting to see how many copies of the slot object is created during registration (via the slot counter) - maybe that can be optimized too?

    I wonder if there is a better solution to that or this implementation sketch can evolve into the signals2 library. I used here C++20, but it can be relaxed.

    What do you think about this idea?

    #include <latch>
    #include <future>
    #include <thread>
    #include <chrono>
    #include <cassert>
    
    class PostEmissionSafeConnection : public boost::signals2::scoped_connection
    {
    public:
        template <typename TSignal, typename THandler>
        PostEmissionSafeConnection(TSignal &signal, const THandler &handler)
            : counter_(std::make_unique<TraceCounter>())
        {
            auto trackedHandler = [handlerTrace = HandlerTrace(*(counter_.get())), handler] { handler(); };
            boost::signals2::scoped_connection::operator=(signal.connect(std::move(trackedHandler)));
        }
    
        PostEmissionSafeConnection(const PostEmissionSafeConnection &) = delete;
        PostEmissionSafeConnection &operator=(const PostEmissionSafeConnection &) = delete;
    
        PostEmissionSafeConnection(PostEmissionSafeConnection &&other)
            : boost::signals2::scoped_connection::scoped_connection(std::move(other))
            , counter_(std::move(other.counter_))
        { }
    
        PostEmissionSafeConnection &operator=(PostEmissionSafeConnection &&other)
        {
            Release();
    
            boost::signals2::scoped_connection::operator=(std::move(other));
            counter_ = std::move(other.counter_);
    
            return *this;
        }
    
        ~PostEmissionSafeConnection() { Release(); }
    
        // The base class methods can be used
        // disconnect(), connected(), blocked() etc.
        // The only thing is: this class blocks at the destructor until all handlers are released
    
    private:
        // A shared counter, which tracks the living Trace instances
        // NOTE: This object is on the heap. This pins down its address, so the Trace-es can refer to it via
        // a C++ reference. The Connection can be moved, because that also refers to this fixed address counter.
        struct TraceCounter
        {
            void RegisterCreation()
            {
                auto currentTraceCount = traceCount_.load();
                assert(traceCount_ == 0);
                for (;;)
                {
                    auto incrementedTraceCount = currentTraceCount + 1;
    
                    const bool exchanged = traceCount_.compare_exchange_strong(
                        currentTraceCount, incrementedTraceCount, std::memory_order_release, std::memory_order_relaxed);
    
                    if (exchanged)
                        break;
                }
            }
    
            void RegisterCopy()
            {
                auto currentTraceCount = traceCount_.load();
                assert(currentTraceCount > 0);
                for (;;)
                {
                    auto incrementedTraceCount = currentTraceCount + 1;
    
                    const bool exchanged = traceCount_.compare_exchange_strong(
                        currentTraceCount, incrementedTraceCount, std::memory_order_release, std::memory_order_relaxed);
    
                    if (exchanged)
                        break;
                }
            }
    
            void UnRegister()
            {
                auto currentTraceCount = traceCount_.load();
                assert(currentTraceCount > 0);
                for (;;)
                {
                    auto decrementedTraceCount = currentTraceCount - 1;
    
                    const bool exchanged = traceCount_.compare_exchange_strong(
                        currentTraceCount, decrementedTraceCount, std::memory_order_release, std::memory_order_relaxed);
    
                    if (exchanged)
                        break;
                }
            }
    
            void WaitForLastHandlerTrace()
            {
                for (;;)
                {
                    auto currentTraceCount = traceCount_.load();
    
                    if (currentTraceCount == 0)
                        break;
    
                    using namespace std::literals;
                    std::this_thread::sleep_for(1ms);
                }
            }
    
            std::atomic<std::size_t> traceCount_ = 0;
        };
    
        // RAII object captured in the handler, so that we can keep track of the living handlers
        struct HandlerTrace
        {
            HandlerTrace() = delete;
    
            HandlerTrace(TraceCounter &counter)
                : counter_(&counter)
            {
                counter_->RegisterCreation();
            }
    
            HandlerTrace(const HandlerTrace &other)
                : counter_(other.counter_)
            {
                counter_->RegisterCopy();
            }
    
            HandlerTrace &operator=(const HandlerTrace &other)
            {
                counter_ = other.counter_;
                counter_->RegisterCopy();
                return *this;
            }
    
            HandlerTrace(HandlerTrace &&other)
                : counter_(other.counter_)
            {
                other.counter_ = nullptr;
            }
    
            HandlerTrace &operator=(HandlerTrace &&other)
            {
                counter_ = other.counter_;
                other.counter_ = nullptr;
                return *this;
            }
    
            ~HandlerTrace()
            {
                if (counter_)
                    counter_->UnRegister();
            }
    
            TraceCounter *counter_ = nullptr;
        };
    
        void Release()
        {
            if (!counter_)
                return;
    
            disconnect();
            counter_->WaitForLastHandlerTrace();
            counter_.reset();
        }
    
        std::unique_ptr<TraceCounter> counter_;
    };
    
    TEST(SignalTest, PostUnsubscriptionEmission)
    {
        // The handler must outlive all traces
        boost::signals2::signal<void()> signal;
    
        std::latch latch(2);
        PostEmissionSafeConnection connection(signal, [&latch] {
            latch.count_down();
            using namespace std::literals;
            std::this_thread::sleep_for(2s);
            std::this_thread::sleep_for(2s);
        });
    
        std::thread signalSenderThread([&signal] { signal(); });
        signalSenderThread.detach();
    
        latch.arrive_and_wait();
        connection.disconnect();
    
        // the connection blocks its destruction until all handler instances are destroyed.
    }
    
    
    opened by ruszkait 5
  • update readme and ci scripts to use new pull methods

    update readme and ci scripts to use new pull methods

    The ci files are now pulled from https://www.github.com/jeking3/boost-ci during the build process. This allows them to be updated "en masse".

    This PR updates the readme badges and I have enabled both Appveyor and Travis CI build jobs, so they should kick in normally on the PR.

    opened by jeking3 5
  • Fix compilation issue with -fno-exceptions

    Fix compilation issue with -fno-exceptions

    Double-posting from the mailing list:

    Trying to compile any program that includes boost/signals2 with -fno-exceptions fails as of 1.64:

    #include <boost/signals2.hpp> // boost/signals2/slot.hpp will also reproduce the error

    int main() { }

    g++ prog.cc -I<path to Boost 1.64.0 headers> -std=c++11 -fno-exceptions

    View it on Wandbox: https://wandbox.org/permlink/vZVpF5bb8E9K7sDz

    I was also able to reproduce this locally on the develop branch.

    I'm not sure if avoiding the lock functions when exceptions are turned off is a good idea or not, since I'm not intimately familiar with the inner workings of Signals2. Feedback welcome. I was also unable to figure out how to build the test suite for this library because I'm not familiar with Boost.Build.

    opened by jacquelinekay 4
  • signal_template.hpp uses 'new' to create shared_ptr when it should use make_shared

    signal_template.hpp uses 'new' to create shared_ptr when it should use make_shared

    boost_1_78_0\boost\signals2\detail\signal_template.hpp lines 156, 309, 478, 500, and 513 use 'new' when make_shared would be more efficient. ( There's probably even more places in the code base that could use make_shared, but lines 156, and 513 were the ones flagged by the profiler, and are unnecessary bottlenecks).

    Calling new to create a shared pointer forces an additional allocation for the shared count (new sp_counted_impl_p). Using make_shared, on the other hand, combines the allocations into one, thereby cutting the total number of allocations/deallocations in half.

    opened by BrianWeed 3
  • boost::signals2 deadlock with pthread

    boost::signals2 deadlock with pthread

    Hello,

    This issue seems to be back on version 1.65 https://svn.boost.org/trac10/ticket/10721

    If the code is compiled with pthread then this will block on the first assert, if it is not build with pthread it will not block, g++ deadlock-boost-signals2.cpp -pthread -o output g++ deadlock-boost-signals2.cpp -o output2

    deadlock-boost-signals2.zip

    Thank you, Adrian Radu

    opened by AdrianRK 2
  • Two tests from boost libraries failed to run after boost submodule signals2 updated from 0c51b5 to 19bf28

    Two tests from boost libraries failed to run after boost submodule signals2 updated from 0c51b5 to 19bf28

    Environment: VS 2017 + Windows Server 2016

    Issue description: We build and run test for boost and we found two tests failed to run after boost submodule signals2 updated from 0c51b5 (master) to 19bf28 boostorg/[email protected] Could you please take a look?

    Reproduce steps:

    1. git clone -c core.autocrlf=true --recursive ​https://github.com/boostorg/boost.git D:\Boost\src
    2. open a VS 2017 x86 command prompt and browse to D:\Boost\src
    3. .\bootstrap
    4. .\b2 headers variant=release --build-dir=..\out\Release --address-model=32
    5. .\b2 variant=release --build-dir=..\out\Release --address-model=32
    6. .\b2 -j4 variant=release --build-dir=..\out\x86rel libs\signals2\test
    7. .\b2 -j4 variant=release --build-dir=..\out\x86rel libs\phoenix\test

    ErrorMessage: .\boost/signals2/signal_type.hpp(26): fatal error C1083: Cannot open include file: 'boost/parameter/template_keyword.hpp': No such file or directory

    log_x86_test_96.log log_x86_test_74.log

    opened by spacelg 2
  • refactor: use core/checked_delete.hpp over checked_delete.hpp

    refactor: use core/checked_delete.hpp over checked_delete.hpp

    The later is deprecated.

    #ifndef BOOST_CHECKED_DELETE_HPP
    #define BOOST_CHECKED_DELETE_HPP
    
    // The header file at this path is deprecated;
    // use boost/core/checked_delete.hpp instead.
    
    #include <boost/core/checked_delete.hpp>
    
    #endif
    
    opened by fanquake 1
  • Mark move ctors/assignment and swap noexcept

    Mark move ctors/assignment and swap noexcept

    In connection and signal classes, move constructors/assignment and swap are not marked noexcept, which prevents the user's types that have objects of these types as members to have noexcept constructors/assignment. It also prevents optimizations in standard library containers.

    opened by Lastique 4
  • Documentation connect to another signal

    Documentation connect to another signal

    Boost.Signals2 can connect to boost::signals2::signal object, I found test: https://github.com/boostorg/signals2/blob/e814fe03d98f30a6468bc28bcbec52302f5f32cf/test/signal_test.cpp#L143-L163

    If the connected signal object is deleted, auto disconnected.

    This feature is very useful but does not found documented.

    Adding documentation for this feature will help users.

    opened by tt4g 2
  • Api reference with description api

    Api reference with description api

    How about api reference with normal description class and methods, as for example in the stl When navigate on table of contents in part reference, it is not obvious that class names are references. Can I add a list of classes separately in the table of contents?

    opened by SmileGobo 3
Owner
Boost.org
Boost provides free peer-reviewed portable C++ source libraries.
Boost.org
Boost.GIL - Generic Image Library | Requires C++11 since Boost 1.68

Documentation GitHub Actions AppVeyor Azure Pipelines CircleCI Regression Codecov Boost.GIL Introduction Documentation Requirements Branches Community

Boost.org 146 Jul 11, 2022
HTTP and WebSocket built on Boost.Asio in C++11

HTTP and WebSocket built on Boost.Asio in C++11 Branch Linux/OSX Windows Coverage Documentation Matrix master develop Contents Introduction Appearance

Boost.org 3.5k Jul 31, 2022
C++ peer to peer library, built on the top of boost

Breep What is Breep? Breep is a c++ bridged peer to peer library. What does that mean? It means that even though the network is constructed as a peer

Lucas Lazare 112 Jul 15, 2022
Asynchronous gRPC with Boost.Asio executors

asio-grpc This library provides an implementation of boost::asio::execution_context that dispatches work to a grpc::CompletionQueue. Making it possibl

Dennis 138 Aug 8, 2022
requests-like networking library using boost for C++

cq == C++ Requests cq == C++ Requests is a "Python Requests"-like C++ header-only library for sending HTTP requests. The library is inspired a lot by

null 11 Dec 15, 2021
Ole Christian Eidheim 737 Aug 6, 2022
Lightweight, header-only, Boost-based socket pool library

Stream-client This is a lightweight, header-only, Boost-based library providing client-side network primitives to easily organize and implement data t

Tinkoff.ru 12 Aug 5, 2022
Boost headers

About This repository contains a set of header files from Boost. Can be useful when using header only libraries. How to use You can easily include the

null 2 Oct 16, 2021
Packio - An asynchronous msgpack-RPC and JSON-RPC library built on top of Boost.Asio.

Header-only | JSON-RPC | msgpack-RPC | asio | coroutines This library requires C++17 and is designed as an extension to boost.asio. It will let you bu

Quentin Chateau 47 Jul 21, 2022
Boost::ASIO low-level redis client (connector)

bredis Boost::ASIO low-level redis client (connector), github gitee Features header only zero-copy (currently only for received replies from Redis) lo

Ivan Baidakou 142 Jul 21, 2022
A very simple, fast, multithreaded, platform independent HTTP and HTTPS server and client library implemented using C++11 and Boost.Asio.

A very simple, fast, multithreaded, platform independent HTTP and HTTPS server and client library implemented using C++11 and Boost.Asio. Created to be an easy way to make REST resources available from C++ applications.

Ole Christian Eidheim 2.3k Aug 2, 2022
Super-project for modularized Boost

Boost C++ Libraries The Boost project provides free peer-reviewed portable C++ source libraries. We emphasize libraries that work well with the C++ St

Boost.org 5k Aug 3, 2022
Minimalistic socket library inspired by Asio/Boost Asio, implemented in 1 single header file

cz-spas czspas (Small Portable Asynchronous Sockets) is minimalistic socket library inspired by Asio/Boost Asio, implemented in 1 single header file.

Rui Figueira 25 Jun 12, 2022
Level up your Beat Saber experience on Quest! AnyTweaks provides various tweaks to help boost your experience on Quest, such as Bloom, FPS Counter and more.

Need help/support? Ask in one of BSMG's support channels for Quest, or join my Discord server! AnyTweaks Level up your Beat Saber experience on Quest!

kaitlyn~ 14 Jul 28, 2022
canonical libwebsockets.org networking library

Libwebsockets Libwebsockets is a simple-to-use, MIT-license, pure C library providing client and server for http/1, http/2, websockets, MQTT and other

lws-team 3.6k Aug 6, 2022
Socket and Networking Library using msgpack.org[C++11]

netLink C++ 11 KISS principle networking library. Features: C++ 11 IPv4, IPv6 Protocols: TCP, UDP Enable/Disable blocking mode Join/Leave UDP-Multicas

Alexander Meißner 207 Aug 6, 2022
libsinsp, libscap, the kernel module driver, and the eBPF driver sources

falcosecurity/libs As per the OSS Libraries Contribution Plan, this repository has been chosen to be the new home for libsinsp, libscap, the kernel mo

Falco 108 Aug 5, 2022
This is a kernel module for FreeBSD to support WireGuard

WireGuard for FreeBSD This is a kernel module for FreeBSD to support WireGuard. It is being developed here before its eventual submission to FreeBSD 1

WireGuard 30 Jul 28, 2022
A Nginx module which tries to implement proxy wasm ABI in Nginx.

Status This library is under construction. Description A Nginx module which tries to implement proxy wasm ABI in Nginx. Install dependencies Download

API7 77 Jul 23, 2022