Abseil Common Libraries (C++)

Overview

Abseil - C++ Common Libraries

The repository contains the Abseil C++ library code. Abseil is an open-source collection of C++ code (compliant to C++11) designed to augment the C++ standard library.

Table of Contents

About Abseil

Abseil is an open-source collection of C++ library code designed to augment the C++ standard library. The Abseil library code is collected from Google's own C++ code base, has been extensively tested and used in production, and is the same code we depend on in our daily coding lives.

In some cases, Abseil provides pieces missing from the C++ standard; in others, Abseil provides alternatives to the standard for special needs we've found through usage in the Google code base. We denote those cases clearly within the library code we provide you.

Abseil is not meant to be a competitor to the standard library; we've just found that many of these utilities serve a purpose within our code base, and we now want to provide those resources to the C++ community as a whole.

Quickstart

If you want to just get started, make sure you at least run through the Abseil Quickstart. The Quickstart contains information about setting up your development environment, downloading the Abseil code, running tests, and getting a simple binary working.

Building Abseil

Bazel and CMake are the official build systems for Abseil.

See the quickstart for more information on building Abseil using the Bazel build system.

If you require CMake support, please check the CMake build instructions and CMake Quickstart.

Support

Abseil is officially supported on many platforms. See the Abseil platform support guide for details on supported operating systems, compilers, CPUs, etc.

Codemap

Abseil contains the following C++ library components:

  • base Abseil Fundamentals
    The base library contains initialization code and other code which all other Abseil code depends on. Code within base may not depend on any other code (other than the C++ standard library).
  • algorithm
    The algorithm library contains additions to the C++ <algorithm> library and container-based versions of such algorithms.
  • cleanup
    The cleanup library contains the control-flow-construct-like type absl::Cleanup which is used for executing a callback on scope exit.
  • container
    The container library contains additional STL-style containers, including Abseil's unordered "Swiss table" containers.
  • debugging
    The debugging library contains code useful for enabling leak checks, and stacktrace and symbolization utilities.
  • hash
    The hash library contains the hashing framework and default hash functor implementations for hashable types in Abseil.
  • memory
    The memory library contains C++11-compatible versions of std::make_unique() and related memory management facilities.
  • meta
    The meta library contains C++11-compatible versions of type checks available within C++14 and C++17 versions of the C++ <type_traits> library.
  • numeric
    The numeric library contains C++11-compatible 128-bit integers.
  • status
    The status contains abstractions for error handling, specifically absl::Status and absl::StatusOr<T>.
  • strings
    The strings library contains a variety of strings routines and utilities, including a C++11-compatible version of the C++17 std::string_view type.
  • synchronization
    The synchronization library contains concurrency primitives (Abseil's absl::Mutex class, an alternative to std::mutex) and a variety of synchronization abstractions.
  • time
    The time library contains abstractions for computing with absolute points in time, durations of time, and formatting and parsing time within time zones.
  • types
    The types library contains non-container utility types, like a C++11-compatible version of the C++17 std::optional type.
  • utility
    The utility library contains utility and helper code.

Releases

Abseil recommends users "live-at-head" (update to the latest commit from the master branch as often as possible). However, we realize this philosophy doesn't work for every project, so we also provide Long Term Support Releases to which we backport fixes for severe bugs. See our release management document for more details.

License

The Abseil C++ library is licensed under the terms of the Apache license. See LICENSE for more information.

Links

For more information about Abseil:

Issues
  • Add CMake support

    Add CMake support

    Initial partial CMake support for abseil, created after the discussion of this afternoon.

    Do not merge yet, this is still incomplete.

    I created the pull request for tracking and avoid duplicated effort.

    Adev

    cla: yes 
    opened by adevress 88
  • to be or not to be: CMake install()

    to be or not to be: CMake install()

    Issue following the discussions on #8 : should we support install() in the cmake build:

    Pro:

    • required by people who do not use cmake in their project.
    • make the usage of package manager possible

    Cons:

    • make easy for to rely on ABI and have problems
    enhancement discussion cmake 
    opened by adevress 58
  • Add a version number to the library + git tag

    Add a version number to the library + git tag

    Hello,

    I can't see any version number / scheme in the library. Does it exist? It would be nice to have such version numbers reflected via git tags (and probably the cmake file) in order to:

    • clone the repository on a specific tag in order to ensure repeatable builds & environment setup
    • know if a new version has been released and compare what's new regarding the version we are currently using

    That would probably imply to maintain a changelog file as well. It's a bit of more work but it's very useful for consumers like me.

    Aurelien

    opened by aurelienrb 37
  • Don't #include <windows.h>

    Don't #include

    Currently it appears to be impossible to compile Abseil using VS 2017 without errors.

    Adding something like this resolve this problem with windows.h includes.

    # ifndef WIN32_LEAN_AND_MEAN
    #   define WIN32_LEAN_AND_MEAN
    # endif
    # ifndef VC_EXTRALEAN
    #   define VC_EXTRALEAN
    # endif
    # ifndef NOMINMAX
    #   define NOMINMAX
    # endif
    #include <windows.h>
    
    opened by Remotion 33
  • Implement the Parallel Hashmap in Abseil

    Implement the Parallel Hashmap in Abseil

    see https://greg7mdp.github.io/parallel-hashmap/ for writeup.

    The new absl::parallel_flat_hash_map and absl::parallel_flat_hash_set have the same tests as the base maps and all tests pass on Windows (vs2017) and linux (g++ 5.4 and clang 3.8)

    cla: yes 
    opened by greg7mdp 30
  • Cmake links all abseil components and results in a link time error

    Cmake links all abseil components and results in a link time error

    No matter what I try, cmake builds the whole abseil and then links everything into my shared library. I could reproduce this with a minimal cmake example:

    cmake_minimum_required(VERSION 2.8.12)
    project(my_project)
    set(CMAKE_CXX_FLAGS "-std=c++11 -fvisibility=hidden ${CMAKE_CXX_FLAGS}")
    add_subdirectory(abseil-cpp)
    add_library(my_lib SHARED main.cpp)
    include_directories(SYSTEM abseil-cpp)
    target_link_libraries(my_lib absl::hash absl::container)
    

    main.cpp contains only the following:

    #include <absl/container/flat_hash_map.h>
    int foo(void) {
    	absl::flat_hash_map<int,int> m;
    	return 0;
    }
    

    For an actual project where I'm trying to use abseil, I get a linker error in debug mode that says the following:

    /usr/sbin/ld: ../absail/absl/container/libabsl_container.a(raw_hash_set.cc.o): relocation R_X86_64_TPOFF32 against hidden symbol `_ZZN4absl18container_internal10RandomSeedEvE7counter' can not be used when making a shared object
    

    The project in question is here. Top level CmakeLists.txt Shared object defining CMakeLists.txt Abseil, at commit a06c4a1, is a submodule of my project. The build instructions are:

    • Clone bstaletic/ycmd and checkout aseil branch
    • git submodule update --init --recursive
    • mkdir build && cd build
    • cmake ../cpp -DCMAKE_BUILD_TYPE=Debug

    Other build time dependencies are python headers. For python3 -DUSE_PYTHON2=OFF is needed.

    cmake 
    opened by bstaletic 30
  • [Benchmark] flat_hash_map considerably slower than std::unordered_map

    [Benchmark] flat_hash_map considerably slower than std::unordered_map

    This is not a bug report, more of an interesting data point. In the past week I've been trying out absl::flat_hash_map and google::dense_hash_map (and sets) and comparing performance to STL counterparts.

    The following gist contains benchmarks for STL (Master), abseil and dense_hash_map: https://gist.github.com/bstaletic/7d3e31db7fc8d40a12787fab09ff092f

    The project whose benchmark results you're looking at is https://github.com/Valloric/ycmd The benchmarks test two separate algorithms, FilterAndSortCandidates and IdentifierCompleter.

    FilterAndSortCandidates benchmark

    This is benchmarking the function of the same name. This one actually has the best timings with abseil.

    IdentifierCompleter benchmark

    This is benchmarking this piece of code. Surprisingly, abseil is the slowest of the three.

    If there's interest to investigate my benchmark results further, I will gladly provide any information needed.

    opened by bstaletic 20
  • Support using Abseil via CMake find_package

    Support using Abseil via CMake find_package

    Hello,

    I have a bit of trouble using a local Abseil installation, as I dont want to depend on external packages with some fixes URL nor some fixed filesystem paths. Cmake already HAS the necessary infrastructure to allow building dependend modules.

    For using Abseil in your Project, just this would be necessary:

    # cctz pulls in some gtest and benchmark suites otherwise
    set (BUILD_TESTING OFF)
    find_package(Abseil REQUIRED
    )
    

    And, given the worst-case that abseil and cctz are in no directory that can be found automatically, configuration would add the respective paths: cmake -DAbseil_DIR=<local path> -DCctz_DIR=<local path> ...

    Basic support would be added by this patch (note that cctz would need to be fixed in a similar fashion):

    diff --git a/AbseilConfig.cmake b/AbseilConfig.cmake
    new file mode 100644
    index 0000000..4476b98
    --- /dev/null
    +++ b/AbseilConfig.cmake
    @@ -0,0 +1,2 @@
    +# Macros
    +include(${CMAKE_CURRENT_LIST_DIR}/CMake/AbseilMacros.cmake)
    diff --git a/CMake/AbseilMacros.cmake b/CMake/AbseilMacros.cmake
    new file mode 100644
    index 0000000..94c6886
    --- /dev/null
    +++ b/CMake/AbseilMacros.cmake
    @@ -0,0 +1,8 @@
    +# TODO: this should be another find_package(Cctz)
    +add_subdirectory(${Cctz_DIR} _libcctz
    +	EXCLUDE_FROM_ALL
    +)
    +
    +add_subdirectory("${CMAKE_CURRENT_LIST_DIR}/.." _libabseil
    +	EXCLUDE_FROM_ALL
    +)
    
    cmake 
    opened by nolange 20
  • Fix Randen and PCG on Big Endian platforms

    Fix Randen and PCG on Big Endian platforms

    Randen expects seed and state buffers to be in LE ordering even on BE machines, and PCG is not, but they both use a shared seed implementation which is currently favouring Randen.

    This patch fixes randen_slow to behave the same as RandenHwAes and reverse the byte order when necessary and changes seed generator to be in native byte order.

    cla: yes 
    opened by miladfarca 19
  • Use the implicitly defaulted constructor

    Use the implicitly defaulted constructor

    Defining an empty default constructor is worse than using the compiler generated constructor.

    Note that the compiler generated constructor requires that constexpr as well as exception specifiers are correctly considered. See Chapter 15.1 [class.ctor] paragraph 7

    cla: yes kokoro:run 
    opened by miscco 17
  • StrReadUntil(string_view&, string_view sep)

    StrReadUntil(string_view&, string_view sep)

    Request for a function like string_view StrReadUntil(string_view&, string_view sep)

    Returns the part until (not including) the separator and removes that part (including separator) from the input (in-place). Returns the entire input and clears it if separator isn't found.

    Examples: StrReadUntil(is, "\n"); // reads next line StrReadUntil(is, ";"); reads next value from 1;2;3

    It's a bit like getline() for string_views.

    opened by OlafvdSpek 17
  • StrSplit return as std::set/absl::flat_hash_set triggers warning

    StrSplit return as std::set/absl::flat_hash_set triggers warning

    I'm currently using Abseil-app from the master branch. My code:

    std::set<std::string> controllers = absl::StrSplit(*content, ' ');  // content: absl::StatusOr<std::string>
    

    Would trigger:

    In file included from /home/parallels/weiran-dev/rouster/third_party/abseil-cpp/absl/strings/str_split.h:48,
                     from /home/parallels/weiran-dev/rouster/src/main.cpp:11:
    /home/parallels/weiran-dev/rouster/third_party/abseil-cpp/absl/strings/internal/str_split_internal.h: In instantiation of ‘absl::strings_internal::SplitIterator<Splitter>& absl::strings_internal::SplitIterator<Splitter>::operator++() [with Splitter = absl::strings_internal::Splitter<absl::ByChar, absl::AllowEmpty, std::basic_string_view<char> >]’:
    /home/parallels/weiran-dev/rouster/third_party/abseil-cpp/absl/strings/internal/str_split_internal.h:321:7:   required from ‘Container absl::strings_internal::Splitter<Delimiter, Predicate, StringType>::ConvertToContainer<Container, ValueType, is_map>::operator()(const absl::strings_internal::Splitter<Delimiter, Predicate, StringType>&) const [with Container = std::set<std::__cxx11::basic_string<char> >; ValueType = std::__cxx11::basic_string<char>; bool is_map = false; Delimiter = absl::ByChar; Predicate = absl::AllowEmpty; StringType = std::basic_string_view<char>]’
    /home/parallels/weiran-dev/rouster/third_party/abseil-cpp/absl/strings/internal/str_split_internal.h:288:65:   required from ‘absl::strings_internal::Splitter<Delimiter, Predicate, StringType>::operator Container() const [with Container = std::set<std::__cxx11::basic_string<char> >; <template-parameter-2-2> = void; Delimiter = absl::ByChar; Predicate = absl::AllowEmpty; StringType = std::basic_string_view<char>]’
    /home/parallels/weiran-dev/rouster/src/main.cpp:54:71:   required from here
    /home/parallels/weiran-dev/rouster/third_party/abseil-cpp/absl/strings/internal/str_split_internal.h:135:42: warning: conversion to ‘std::basic_string_view<char>::size_type’ {aka ‘long unsigned int’} from ‘long int’ may change the sign of the result [-Wsign-conversion]
      135 |       curr_ = text.substr(pos_, d.data() - (text.data() + pos_));
          |                                 ~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~
    

    And absl::flat_hash_set will trigger additional warnings (besides the above warning):

    In file included from /home/parallels/weiran-dev/rouster/third_party/abseil-cpp/absl/container/internal/compressed_tuple.h:40,
                     from /home/parallels/weiran-dev/rouster/third_party/abseil-cpp/absl/container/internal/inlined_vector.h:30,
                     from /home/parallels/weiran-dev/rouster/third_party/abseil-cpp/absl/container/inlined_vector.h:53,
                     from /home/parallels/weiran-dev/rouster/third_party/abseil-cpp/absl/status/status.h:57,
                     from /home/parallels/weiran-dev/rouster/src/linux/sys.h:1,
                     from /home/parallels/weiran-dev/rouster/src/container.hpp:12,
                     from /home/parallels/weiran-dev/rouster/src/main.cpp:6:
    /home/parallels/weiran-dev/rouster/third_party/abseil-cpp/absl/utility/utility.h: In instantiation of ‘T absl::exchange(T&, U&&) [with T = long unsigned int; U = int]’:
    /home/parallels/weiran-dev/rouster/third_party/abseil-cpp/absl/container/internal/raw_hash_set.h:1275:29:   required from ‘absl::container_internal::raw_hash_set<Policy, Hash, Eq, Alloc>::raw_hash_set(absl::container_internal::raw_hash_set<Policy, Hash, Eq, Alloc>&&) [with Policy = absl::container_internal::FlatHashSetPolicy<std::basic_string_view<char> >; Hash = absl::container_internal::StringHash; Eq = absl::container_internal::StringEq; Alloc = std::allocator<std::basic_string_view<char> >]’
    /home/parallels/weiran-dev/rouster/third_party/abseil-cpp/absl/container/flat_hash_set.h:105:7:   required from ‘Container absl::strings_internal::Splitter<Delimiter, Predicate, StringType>::ConvertToContainer<Container, ValueType, is_map>::operator()(const absl::strings_internal::Splitter<Delimiter, Predicate, StringType>&) const [with Container = absl::flat_hash_set<std::basic_string_view<char> >; ValueType = std::basic_string_view<char>; bool is_map = false; Delimiter = absl::ByChar; Predicate = absl::AllowEmpty; StringType = std::basic_string_view<char>]’
    /home/parallels/weiran-dev/rouster/third_party/abseil-cpp/absl/strings/internal/str_split_internal.h:288:65:   required from ‘absl::strings_internal::Splitter<Delimiter, Predicate, StringType>::operator Container() const [with Container = absl::flat_hash_set<std::basic_string_view<char> >; <template-parameter-2-2> = void; Delimiter = absl::ByChar; Predicate = absl::AllowEmpty; StringType = std::basic_string_view<char>]’
    /home/parallels/weiran-dev/rouster/src/main.cpp:54:87:   required from here
    /home/parallels/weiran-dev/rouster/third_party/abseil-cpp/absl/utility/utility.h:316:7: warning: conversion to ‘long unsigned int’ from ‘int’ may change the sign of the result [-Wsign-conversion]
      316 |   obj = absl::forward<U>(new_value);
          |   ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    

    Seems like there exist some implicit conversions. Though these are not errors, can we have a fix for them?

    question 
    opened by EtoDemerzel0427 0
  • Make StrCat effective for single rvalue string

    Make StrCat effective for single rvalue string

    Main motivation for me is patter like:

    void SomeCall(Args&&...);
    
    auto msg = StrCat(...);
    LOG(unique_id, msg);
    SomeCall(std::move(msg)); // internally have absl::StrCat for case when argument more than one or some of them not is string
    
    opened by MBkkt 1
  • Build on 10.6.8 Rosetta uses ABSL_RANDOM_HWAES_X64_FLAGS despite OSX_ARCHITECTURES = ppc

    Build on 10.6.8 Rosetta uses ABSL_RANDOM_HWAES_X64_FLAGS despite OSX_ARCHITECTURES = ppc

    Describe the bug

    I am building abseil on 10.6.8 Rosetta for ppc (well, in fact I has built it, but with an ugly solution of just editing away Intel flags). Despite Cmake correctly recognizing OSX_ARCHITECTURES="ppc", it still pulls out Intel HWAES flags, which obviously cause a failure. I tried specifying CMAKE_SYSTEM_PROCESSOR=ppc and tried a couple of patches to the source code, but nothing helped. Removing away flags in question from abseil-abseil-cpp-273292d/absl/copts/GENERATED_AbseilCopts.cmake solved the issue, at least on the surface, but it is clearly a bad solution.

    What is required is to ensure ppc is used all through, with no x86 setting pulled over.

    This chunk of code causes the problem:

    list(APPEND ABSL_RANDOM_HWAES_X64_FLAGS
        "-maes"
        "-msse4.1"
    )
    

    What version of Abseil are you using?

    10:~ svacchanda$ port -v installed abseil
    The following ports are currently installed:
      abseil @20220623.0_0 (active) requested_variants='' platform='darwin 10' archs='ppc' date='2022-07-22T21:38:20+0400'
    

    What operating system and version are you using

    10.6.8 Rosetta (build for ppc32), Xcode 3.2.6

    What compiler and version are you using?

    10:~ svacchanda$ /opt/local/bin/gcc-mp-12 -v
    Using built-in specs.
    COLLECT_GCC=/opt/local/bin/gcc-mp-12
    COLLECT_LTO_WRAPPER=/opt/local/libexec/gcc/ppc-apple-darwin10/12.1.0/lto-wrapper
    Target: ppc-apple-darwin10
    Configured with: /opt/local/var/macports/build/_opt_PPCRosettaPorts_lang_gcc12/gcc12/work/gcc-12.1.0/configure --prefix=/opt/local --build=ppc-apple-darwin10 --enable-languages=c,c++,objc,obj-c++,lto,fortran,jit --libdir=/opt/local/lib/gcc12 --includedir=/opt/local/include/gcc12 --infodir=/opt/local/share/info --mandir=/opt/local/share/man --datarootdir=/opt/local/share/gcc-12 --with-local-prefix=/opt/local --with-system-zlib --disable-nls --program-suffix=-mp-12 --with-gxx-include-dir=/opt/local/include/gcc12/c++/ --with-gmp=/opt/local --with-mpfr=/opt/local --with-mpc=/opt/local --with-isl=/opt/local --with-zstd=/opt/local --enable-checking=release --disable-multilib --enable-lto --enable-libstdcxx-time --without-build-config --with-as=/opt/local/bin/as --with-ld=/opt/local/bin/ld --with-ar=/opt/local/bin/ar --with-bugurl=https://trac.macports.org/newticket --enable-host-shared --with-darwin-extra-rpath=/opt/local/lib/libgcc --with-libiconv-prefix=/opt/local --with-tune-cpu=G4 --disable-tls --with-pkgversion='MacPorts gcc12 12.1.0_3'
    Thread model: posix
    Supported LTO compression algorithms: zlib zstd
    gcc version 12.1.0 (MacPorts gcc12 12.1.0_3)
    

    What build system are you using?

    I use Macports and cmake-devel 3.24.0-rc4.

    bug 
    opened by barracuda156 1
  • UTF-8/Unicode Library

    UTF-8/Unicode Library

    Given the importance of i18n in software and the lack any good Unicode support in C++, would you consider adding a Unicode library to Abseil?

    Copies of the Google utf8 library has already shown up in various open source projects, such as the TensorFlow Syntaxnet model, and a number of other repos, and I think it would be great to make that a standard part of Abseil.

    question 
    opened by davidzchen 0
  • Requirement of bit_cast

    Requirement of bit_cast

    https://github.com/abseil/abseil-cpp/blob/56f5477f15ab63f77a3f34487304d6c7e0965238/absl/base/casts.h#L158

    Did you intend to write "std::is_trivially_default_constructible"? Thanks.

    opened by www1800 0
  • Remove workaround for llvm.23435?

    Remove workaround for llvm.23435?

    There is a workaround in attributes.h: https://github.com/abseil/abseil-cpp/blob/9eff97861b88999428d1254f95c83d94a2e95944/absl/base/attributes.h

    // A function-like feature checking macro that accepts C++11 style attributes.
    // It's a wrapper around `__has_cpp_attribute`, defined by ISO C++ SD-6
    // (https://en.cppreference.com/w/cpp/experimental/feature_test). If we don't
    // find `__has_cpp_attribute`, will evaluate to 0.
    #if defined(__cplusplus) && defined(__has_cpp_attribute)
    // NOTE: requiring __cplusplus above should not be necessary, but
    // works around https://bugs.llvm.org/show_bug.cgi?id=23435.
    #define ABSL_HAVE_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
    #else
    #define ABSL_HAVE_CPP_ATTRIBUTE(x) 0
    #endif
    

    This bug is marked as fixed: https://bugs.llvm.org/show_bug.cgi?id=23435 So, shall this workaround be removed?

    bug 
    opened by Chandlerooo 0
Releases(20220623.0)
  • 20220623.0(Jun 23, 2022)

    Abseil LTS 20220623

    What's New:

    Breaking Changes:

    Other:

    • This will be the last release to support C++11. Future releases will require at least C++14.

    Baseline: 273292d1cfc0a94a65082ee350509af1d113344d

    Source code(tar.gz)
    Source code(zip)
  • 20211102.0(Nov 3, 2021)

    Abseil LTS 20211102

    What's New:

    • absl::Cord is now implemented as a b-tree. The new implementation offers improved performance in most workloads.
    • absl::SimpleHexAtoi() has been added to strings library for parsing hexadecimal strings.

    Breaking Changes:

    Baseline: 215105818dfde3174fe799600bb0f3cae233d0bf

    Source code(tar.gz)
    Source code(zip)
  • 20210324.2(Jun 1, 2021)

    Abseil LTS 20210324.2

    What's New:

    • The cleanup library has been released. This library contains the control-flow-construct-like type absl::Cleanup which is used for executing a callback on scope exit.
    • The numeric library now includes bits.h, a polyfill header containing implementations of C++20's bitwise math functions.
    • Abseil now installs pkg-config files to make it easier to use Abseil with some other build systems.
    • Abseil now respects the default CMake installation paths. Standard CMake variables like CMAKE_INSTALL_PREFIX can be used to change the installation path.

    Breaking Changes:

    • The empty absl::container target has been removed from the CMake build. This target had no effect and references to this target in user code can safely be removed.

    Baseline: 997aaf3a28308eba1b9156aa35ab7bca9688e9f6 Cherry pick: e1d388e7e74803050423d035e4374131b9b57919 (Patch 1) Cherry pick: 278e0a071885a22dcd2fd1b5576cc44757299343 (Patch 2)

    Source code(tar.gz)
    Source code(zip)
  • 20210324.1(Apr 20, 2021)

    Abseil LTS 20210324.1

    What's New:

    • The cleanup library has been released. This library contains the control-flow-construct-like type absl::Cleanup which is used for executing a callback on scope exit.
    • The numeric library now includes bits.h, a polyfill header containing implementations of C++20's bitwise math functions.
    • Abseil now installs pkg-config files to make it easier to use Abseil with some other build systems.
    • Abseil now respects the default CMake installation paths. Standard CMake variables like CMAKE_INSTALL_PREFIX can be used to change the installation path.

    Breaking Changes:

    • The empty absl::container target has been removed from the CMake build. This target had no effect and references to this target in user code can safely be removed.

    Baseline: 997aaf3a28308eba1b9156aa35ab7bca9688e9f6 Cherry pick: e1d388e7e74803050423d035e4374131b9b57919 (Patch 1)

    Source code(tar.gz)
    Source code(zip)
  • 20210324.0(Mar 25, 2021)

    Abseil LTS 20210324.0

    What's New:

    • The cleanup library has been released. This library contains the control-flow-construct-like type absl::Cleanup which is used for executing a callback on scope exit.
    • The numeric library now includes bits.h, a polyfill header containing implementations of C++20's bitwise math functions.
    • Abseil now installs pkg-config files to make it easier to use Abseil with some other build systems.
    • Abseil now respects the default CMake installation paths. Standard CMake variables like CMAKE_INSTALL_PREFIX can be used to change the installation path.

    Breaking Changes:

    • The empty absl::container target has been removed from the CMake build. This target had no effect and references to this target in user code can safely be removed.

    Baseline: 997aaf3a28308eba1b9156aa35ab7bca9688e9f6

    Source code(tar.gz)
    Source code(zip)
  • 20200923.3(Jan 19, 2021)

    Abseil LTS 20200923, Patch 3

    What's New:

    • absl::StatusOr<T> has been released. See our blog post for more information.
    • Abseil Flags reflection interfaces have been released.
    • Abseil Flags memory usage has been significantly optimized.
    • Abseil now supports a "hardened" build mode. This build mode enables runtime checks that guard against programming errors that may lead to security vulnerabilities.

    Notable Fixes:

    • Sanitizer dynamic annotations like AnnotateRWLockCreate that are also defined by the compiler sanitizer implementation are no longer also defined by Abseil.
    • Sanitizer macros are now prefixed with ABSL_ to avoid naming collisions.
    • Sanitizer usage is now automatically detected and no longer requires macros like ADDRESS_SANITIZER to be defined on the command line.

    Breaking Changes:

    • Abseil no longer contains a dynamic_annotations library. Users using a supported build system (Bazel or CMake) are unaffected by this, but users manually specifying link libraries may get an error about a missing linker input.

    Baseline: 7680a5f8efe32de4753baadbd63e74e59d95bac1 Cherry pick: bd0de71e754eb3280094e89c7ac35a14dac6d61c (Patch 1) Cherry pick: 0f3bb466b868b523cf1dc9b2aaaed65c77b28862 (Patch 2) Cherry pick: 6f9d96a1f41439ac172ee2ef7ccd8edf0e5d068c (Patch 3)

    Source code(tar.gz)
    Source code(zip)
  • 20200923.2(Oct 21, 2020)

    Abseil LTS 20200923, Patch 2

    What's New:

    • absl::StatusOr<T> has been released. See our blog post for more information.
    • Abseil Flags reflection interfaces have been released.
    • Abseil Flags memory usage has been significantly optimized.
    • Abseil now supports a "hardened" build mode. This build mode enables runtime checks that guard against programming errors that may lead to security vulnerabilities.

    Notable Fixes:

    • Sanitizer dynamic annotations like AnnotateRWLockCreate that are also defined by the compiler sanitizer implementation are no longer also defined by Abseil.
    • Sanitizer macros are now prefixed with ABSL_ to avoid naming collisions.
    • Sanitizer usage is now automatically detected and no longer requires macros like ADDRESS_SANITIZER to be defined on the command line.

    Breaking Changes:

    • Abseil no longer contains a dynamic_annotations library. Users using a supported build system (Bazel or CMake) are unaffected by this, but users manually specifying link libraries may get an error about a missing linker input.

    Baseline: 7680a5f8efe32de4753baadbd63e74e59d95bac1 Cherry pick: bd0de71e754eb3280094e89c7ac35a14dac6d61c (Patch 1) Cherry pick: 0f3bb466b868b523cf1dc9b2aaaed65c77b28862 (Patch 2)

    Source code(tar.gz)
    Source code(zip)
  • 20200923.1(Oct 9, 2020)

    Abseil LTS 20200923, Patch 1

    What's New:

    • absl::StatusOr<T> has been released. See our blog post for more information.
    • Abseil Flags reflection interfaces have been released.
    • Abseil Flags memory usage has been significantly optimized.
    • Abseil now supports a "hardened" build mode. This build mode enables runtime checks that guard against programming errors that may lead to security vulnerabilities.

    Notable Fixes:

    • Sanitizer dynamic annotations like AnnotateRWLockCreate that are also defined by the compiler sanitizer implementation are no longer also defined by Abseil.
    • Sanitizer macros are now prefixed with ABSL_ to avoid naming collisions.
    • Sanitizer usage is now automatically detected and no longer requires macros like ADDRESS_SANITIZER to be defined on the command line.

    Breaking Changes:

    • Abseil no longer contains a dynamic_annotations library. Users using a supported build system (Bazel or CMake) are unaffected by this, but users manually specifying link libraries may get an error about a missing linker input.

    Baseline: 7680a5f8efe32de4753baadbd63e74e59d95bac1 Cherry picks: bd0de71e754eb3280094e89c7ac35a14dac6d61c (Patch 1)

    Source code(tar.gz)
    Source code(zip)
  • 20200225.3(Oct 9, 2020)

  • 20190808.1(Oct 9, 2020)

  • 20181200.1(Oct 9, 2020)

  • 20200923(Sep 24, 2020)

    Abseil LTS 20200923

    What's New:

    • absl::StatusOr<T> has been released. See our blog post for more information.
    • Abseil Flags reflection interfaces have been released.
    • Abseil Flags memory usage has been significantly optimized.
    • Abseil now supports a "hardened" build mode. This build mode enables runtime checks that guard against programming errors that may lead to security vulnerabilities.

    Notable Fixes:

    • Sanitizer dynamic annotations like AnnotateRWLockCreate that are also defined by the compiler sanitizer implementation are no longer also defined by Abseil.
    • Sanitizer macros are now prefixed with ABSL_ to avoid naming collisions.
    • Sanitizer usage is now automatically detected and no longer requires macros like ADDRESS_SANITIZER to be defined on the command line.

    Breaking Changes:

    • Abseil no longer contains a dynamic_annotations library. Users using a supported build system (Bazel or CMake) are unaffected by this, but users manually specifying link libraries may get an error about a missing linker input.

    Baseline: 7680a5f8efe32de4753baadbd63e74e59d95bac1 Cherry picks: None

    Source code(tar.gz)
    Source code(zip)
  • 20200225.2(Apr 22, 2020)

  • 20200225.1(Mar 4, 2020)

  • 20200225(Feb 26, 2020)

C++14 evented IO libraries for high performance networking and media based applications

LibSourcey C++ Networking Evolved LibSourcey is a collection of cross platform C++14 modules and classes that provide developers with an arsenal for r

Sourcey 1.2k Aug 1, 2022
stb single-file public domain libraries for C/C++

stb single-file public domain (or MIT licensed) libraries for C/C++ Noteworthy: image loader: stb_image.h image writer: stb_image_write.h image resize

Sean Barrett 19.4k Jul 30, 2022
A collection of single-file C libraries. (generic containers, random number generation, argument parsing and other functionalities)

cauldron A collection of single-file C libraries and tools with the goal to be portable and modifiable. Libraries library description arena-allocator.

Camel Coder 32 Jul 18, 2022
Abseil Common Libraries (C++)

The repository contains the Abseil C++ library code. Abseil is an open-source collection of C++ code (compliant to C++11) designed to augment the C++ standard library.

Abseil 10.7k Aug 5, 2022
Single-header C11 port of abseil.io's Swiss Table

cwisstable.h cwisstable is a single-header C11 port of the Abseil project's Swiss Tables. This project is intended to bring the proven performance and

Google 21 Jul 24, 2022
A library with common code used by libraries and tools around the libimobiledevice project

libimobiledevice-glue Library with common code used by the libraries and tools around the libimobiledevice project. Features The main functionality pr

libimobiledevice 36 Aug 3, 2022
POCO C++ Libraries are powerful cross-platform C++ libraries for building network

The POCO C++ Libraries are powerful cross-platform C++ libraries for building network- and internet-based applications that run on desktop, server, mobile, IoT, and embedded systems.

POCO C++ Libraries 6.2k Aug 2, 2022
Bolt is a C++ template library optimized for GPUs. Bolt provides high-performance library implementations for common algorithms such as scan, reduce, transform, and sort.

Bolt is a C++ template library optimized for heterogeneous computing. Bolt is designed to provide high-performance library implementations for common

null 355 Jun 27, 2022
C++ (with python bindings) library for easily reading/writing/manipulating common animation particle formats such as PDB, BGEO, PTC. See the discussion group @ http://groups.google.com/group/partio-discuss

Partio - A library for particle IO and manipulation This is the initial source code release of partio a tool we used for particle reading/writing. It

Walt Disney Animation Studios 402 Jul 17, 2022
Wangle is a framework providing a set of common client/server abstractions for building services in a consistent, modular, and composable way.

Wangle C++ networking library Wangle is a library that makes it easy to build protocols, application clients, and application servers. It's like Netty

Facebook 2.9k Jul 26, 2022
🔗 Common Data Structures and Algorithms

?? Data Structures and Algorithms This library provides common data structures. It will also provide some data structures which needed in render or ga

Recep Aslantas 41 Aug 3, 2022
The libxo library allows an application to generate text, XML, JSON, and HTML output using a common set of function calls. The application decides at run time which output style should be produced.

libxo libxo - A Library for Generating Text, XML, JSON, and HTML Output The libxo library allows an application to generate text, XML, JSON, and HTML

Juniper Networks 242 Jul 19, 2022
Utilities and common code for use with raylib

Utilities and shared components for use with raylib

Jeffery Myers 76 Jul 27, 2022
A library of common data structures and algorithms written in C.

C Algorithms The C programming language includes a very limited standard library in comparison to other modern programming languages. This is a coll

Simon Howard 2.8k Jul 30, 2022
Common Lisp and CXX interoperation with JIT

CL-CXX-JIT - Common Lisp C++ JIT for exposing C++ functions This library provides an interface to C++ from lisp. It compiles C++ code, then loads it i

Islam Omar 36 Jul 28, 2022
Common Sensor API for the BMA2 family of sensors

BMA2 Sensor API Sensor overview The BMA2 is a triaxial, low-g acceleration sensor with digital output. An ASIC in the sensor converts the output of a

Bosch Sensortec 9 Sep 12, 2021
Common utilities useful for embedded systems that are often not included in an RTOS or the standard C library.

Welcome to Fitterbap, the Firmware toolkit to enable reliable best architecture practices! Fitterbap provides common utilities useful for embedded systems that are often not included in an RTOS or the standard C library.

Jetperch 21 Apr 2, 2022
A fast Python Common substrings of multiple strings library with C++ implementation

A fast Python Common substrings of multiple strings library with C++ implementation Having a bunch of strings, can I print some substrings which appea

Đào Nguyên Dương 6 Sep 14, 2021
Common Device Source For Xiaomi Redmi Note 5 Pro (whyred)

The Redmi Note 5 Pro (codenamed "whyred") are high-end mid-range smartphones from Xiaomi announced and released in February 2018. Device specification

Yash Biyani 0 Dec 22, 2021
Isaac ROS common utilities and scripts for use in conjunction with the Isaac ROS suite of packages.

Isaac ROS Common Isaac ROS common utilities and scripts for use in conjunction with the Isaac ROS suite of packages. Docker Scripts run_dev.sh creates

NVIDIA Isaac ROS 45 Jul 25, 2022
A static analysis tool that helps security researchers scan a list of Windows kernel drivers for common vulnerability patterns in drivers (CVE makers!)

Driver Analyzer A static analysis tool that helps security researchers scan a list of Windows kernel drivers for common vulnerability patterns in driv

BehroozAbbassi 43 Jul 31, 2022
Clio is an embryonic experiment in UI for Common Lisp programs.

Clio Clio is an embryonic experiment in UI for Common Lisp programs. Building and running Clio Make sure you have the prerequisites: Visual Studio 201

mikel evins 0 Feb 26, 2022
A repository that includes common helper functions for writing applications in the DPDK. I will be using this for my future projects in the DPDK.

The DPDK Common (WIP) Description This project includes helpful functions and global variables for developing applications using the DPDK. I am using

Christian Deacon 11 May 31, 2022
Common files for Packet Batch. Read this for configuration guidance and more!

Packet Batch (Common) Description This is a repository for Packet Batch that includes common files for all versions of Packet Batch to use (standard,

Packet Batch 3 Feb 24, 2022
A multiplatform C++ library for common and basic system functionalities.

axl.cm A multiplatform C++ library for common and basic system functionalities. Platforms Linux Windows C++ standard minimum: C++98 target: C++11 maxi

Axel 2 Apr 4, 2022
This package contains the common algorithms in robotic arm, and I have developed it based on universal robot. It will be continuously updateing.

Robotic_Arm_Algorithms It contains the common algorithms in robotic arm, and will be recording the development as soon as I have completed the any one

Mingshan-Beal 54 Jul 29, 2022
Common Lisp editor/IDE with high expansibility

Lem is the editor/IDE well-tuned for Common Lisp. After installing lem, you can start developing in Common Lisp at once. You can skip over writing tid

null 1.2k Jul 26, 2022
Google's common Java, C++ and JavaScript library for parsing, formatting, and validating international phone numbers.

What is it? Google's common Java, C++ and JavaScript library for parsing, formatting, and validating international phone numbers. The Java version is

Google 14k Aug 6, 2022
NVRHI (NVIDIA Rendering Hardware Interface) is a library that implements a common abstraction layer over multiple graphics APIs

NVRHI Introduction NVRHI (NVIDIA Rendering Hardware Interface) is a library that implements a common abstraction layer over multiple graphics APIs (GA

NVIDIA GameWorks 389 Jul 31, 2022