EASTL stands for Electronic Arts Standard Template Library. It is an extensive and robust implementation that has an emphasis on high performance.

Overview

EA Standard Template Library

Build Status

EASTL stands for Electronic Arts Standard Template Library. It is a C++ template library of containers, algorithms, and iterators useful for runtime and tool development across multiple platforms. It is a fairly extensive and robust implementation of such a library and has an emphasis on high performance above all other considerations.

Usage

If you are familiar with the C++ STL or have worked with other templated container/algorithm libraries, you probably don't need to read this. If you have no familiarity with C++ templates at all, then you probably will need more than this document to get you up to speed. In this case, you need to understand that templates, when used properly, are powerful vehicles for the ease of creation of optimized C++ code. A description of C++ templates is outside the scope of this documentation, but there is plenty of such documentation on the Internet.

EASTL is suitable for any tools and shipping applications where the functionality of EASTL is useful. Modern compilers are capable of producing good code with templates and many people are using them in both current generation and future generation applications on multiple platforms from embedded systems to servers and mainframes.

Package Managers

You can download and install EASTL using the Conan package manager:

conan install eastl/[email protected]

The EASTL package in conan is kept up to date by Conan team members and community contributors. If the version is out-of-date, please create an issue or pull request on the Conan Center Index repository.

You can download and install EASTL using the vcpkg dependency manager:

git clone https://github.com/Microsoft/vcpkg.git
cd vcpkg
./bootstrap-vcpkg.sh
./vcpkg integrate install
vcpkg install eastl

The EASTL port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please create an issue or pull request on the vcpkg repository.

Documentation

Please see EASTL Introduction.

Compiling sources

Please see CONTRIBUTING.md for details on compiling and testing the source.

Credits And Maintainers

EASTL was created by Paul Pedriana and he maintained the project for roughly 10 years.

EASTL was subsequently maintained by Roberto Parolin for more than 8 years. He was the driver and proponent for getting EASTL opensourced. Rob was a mentor to all members of the team and taught us everything we ever wanted to know about C++ spookyness.

Max Winkler is the current EASTL owner and primary maintainer within EA and is responsible for the open source repository.

Significant EASTL contributions were made by (in alphabetical order):

  • Avery Lee
  • Colin Andrews
  • JP Flouret
  • Liam Mitchell
  • Matt Newport
  • Max Winkler
  • Paul Pedriana
  • Roberto Parolin
  • Simon Everett

Contributors

Projects And Products Using EASTL

License

Modified BSD License (3-Clause BSD license) see the file LICENSE in the project root.

Issues
  • Cannot move assign a eastl::vector<unique_ptr<int>>

    Cannot move assign a eastl::vector>

    #include <memory>
    #include <vector>
    #include <EASTL/vector.h>
    
    int main(int, char**) {
    
      // Works                                                                                                                         
      std::vector<std::unique_ptr<int>> stdv1;
      std::vector<std::unique_ptr<int>> stdv2;
      stdv2 = std::move(stdv1);
    
      // Doesn't work                                                                                                                  
      eastl::vector<std::unique_ptr<int>> v1;
      eastl::vector<std::unique_ptr<int>> v2;
      v2 = std::move(v1);
    
    }
    
    
    

    The output on os x clang 3.9:

    
    clang++ -std=c++14 eastl-vector-move.cpp 
    In file included from eastl-vector-move.cpp:3:
    In file included from /usr/local/include/EASTL/vector.h:42:
    /usr/local/include/EASTL/memory.h:605:34: error: call to implicitly-deleted copy constructor of 'value_type' (aka
          'std::__1::unique_ptr<int, std::__1::default_delete<int> >')
                                            ::new((void*)&*currentDest) value_type(*first);
                                                                        ^          ~~~~~~
    /usr/local/include/EASTL/memory.h:705:52: note: in instantiation of function template specialization
          'eastl::Internal::uninitialized_copy_impl<eastl::generic_iterator<std::__1::unique_ptr<int, std::__1::default_delete<int> >
          *, void>, eastl::generic_iterator<std::__1::unique_ptr<int, std::__1::default_delete<int> > *, void> >' requested here
                    const generic_iterator<Result, void> i(Internal::uninitialized_copy_impl(eastl::generic_iterator<First, voi...
                                                                     ^
    /usr/local/include/EASTL/vector.h:578:18: note: in instantiation of function template specialization
          'eastl::uninitialized_copy_ptr<std::__1::unique_ptr<int, std::__1::default_delete<int> > *, std::__1::unique_ptr<int,
          std::__1::default_delete<int> > *, std::__1::unique_ptr<int, std::__1::default_delete<int> > *>' requested here
                    mpEnd = eastl::uninitialized_copy_ptr(x.mpBegin, x.mpEnd, mpBegin);
                                   ^
    /usr/local/include/EASTL/vector.h:1733:13: note: in instantiation of member function 'eastl::vector<std::__1::unique_ptr<int,
          std::__1::default_delete<int> >, eastl::allocator>::vector' requested here
                    this_type temp(*this);  // This is the simplest way to accomplish this, 
                              ^
    /usr/local/include/EASTL/vector.h:685:5: note: in instantiation of member function 'eastl::vector<std::__1::unique_ptr<int,
          std::__1::default_delete<int> >, eastl::allocator>::DoClearCapacity' requested here
                                    DoClearCapacity(); // To consider: Are we really required to clear here? x is going away so...
                                    ^
    eastl-vector-move.cpp:8:6: note: in instantiation of member function 'eastl::vector<std::__1::unique_ptr<int,
          std::__1::default_delete<int> >, eastl::allocator>::operator=' requested here
      v2 = std::move(v1);
         ^
    /Library/Developer/CommandLineTools/usr/bin/../include/c++/v1/memory:2600:31: note: copy constructor is implicitly deleted because
          'unique_ptr<int, std::__1::default_delete<int> >' has a user-declared move constructor
        _LIBCPP_INLINE_VISIBILITY unique_ptr(unique_ptr&& __u) _NOEXCEPT
                                  ^
    In file included from eastl-vector-move.cpp:3:
    In file included from /usr/local/include/EASTL/vector.h:40:
    In file included from /usr/local/include/EASTL/algorithm.h:237:
    /usr/local/include/EASTL/internal/copy_help.h:73:13: error: object of type 'std::__1::unique_ptr<int, std::__1::default_delete<int>
          >' cannot be assigned because its copy assignment operator is implicitly deleted
                                    *result = *first;
                                            ^
    /usr/local/include/EASTL/internal/copy_help.h:135:67: note: in instantiation of function template specialization
          'eastl::move_and_copy_helper<eastl::random_access_iterator_tag, false, false>::move_or_copy<const std::__1::unique_ptr<int,
          std::__1::default_delete<int> > *, std::__1::unique_ptr<int, std::__1::default_delete<int> > *>' requested here
                    return eastl::move_and_copy_helper<IIC, isMove, canBeMemmoved>::move_or_copy(first, last, result); // Need ...
                                                                                    ^
    /usr/local/include/EASTL/internal/copy_help.h:143:32: note: in instantiation of function template specialization
          'eastl::move_and_copy_chooser<false, const std::__1::unique_ptr<int, std::__1::default_delete<int> > *,
          std::__1::unique_ptr<int, std::__1::default_delete<int> > *>' requested here
                    return OutputIterator(eastl::move_and_copy_chooser<isMove>(eastl::unwrap_iterator(first), eastl::unwrap_ite...
                                                 ^
    /usr/local/include/EASTL/internal/copy_help.h:193:17: note: in instantiation of function template specialization
          'eastl::move_and_copy_unwrapper<false, const std::__1::unique_ptr<int, std::__1::default_delete<int> > *,
          std::__1::unique_ptr<int, std::__1::default_delete<int> > *>' requested here
                    return eastl::move_and_copy_unwrapper<isMove>(eastl::unwrap_iterator(first), eastl::unwrap_iterator(last), result);
                                  ^
    /usr/local/include/EASTL/vector.h:1543:35: note: in instantiation of function template specialization 'eastl::copy<const
          std::__1::unique_ptr<int, std::__1::default_delete<int> > *, std::__1::unique_ptr<int, std::__1::default_delete<int> > *>'
          requested here
                            pointer const pNewEnd = eastl::copy(first, last, mpBegin); // Since we are copying to mpBegin, we d...
                                                           ^
    /usr/local/include/EASTL/vector.h:1480:3: note: in instantiation of function template specialization
          'eastl::vector<std::__1::unique_ptr<int, std::__1::default_delete<int> >, eastl::allocator>::DoAssignFromIterator<const
          std::__1::unique_ptr<int, std::__1::default_delete<int> > *, false>' requested here
                    DoAssignFromIterator<InputIterator, bMove>(first, last, IC());
                    ^
    /usr/local/include/EASTL/vector.h:660:4: note: in instantiation of function template specialization
          'eastl::vector<std::__1::unique_ptr<int, std::__1::default_delete<int> >, eastl::allocator>::DoAssign<const
          std::__1::unique_ptr<int, std::__1::default_delete<int> > *, false>' requested here
                            DoAssign<const_iterator, false>(x.begin(), x.end(), eastl::false_type());
                            ^
    /usr/local/include/EASTL/vector.h:1393:10: note: in instantiation of member function 'eastl::vector<std::__1::unique_ptr<int,
          std::__1::default_delete<int> >, eastl::allocator>::operator=' requested here
                            *this = x;                   // itself call this member swap function.
                                  ^
    /usr/local/include/EASTL/vector.h:686:5: note: in instantiation of member function 'eastl::vector<std::__1::unique_ptr<int,
          std::__1::default_delete<int> >, eastl::allocator>::swap' requested here
                                    swap(x);           // member swap handles the case that x has a different allocator than ou...
                                    ^
    eastl-vector-move.cpp:8:6: note: in instantiation of member function 'eastl::vector<std::__1::unique_ptr<int,
          std::__1::default_delete<int> >, eastl::allocator>::operator=' requested here
      v2 = std::move(v1);
         ^
    /Library/Developer/CommandLineTools/usr/bin/../include/c++/v1/memory:2600:31: note: copy assignment operator is implicitly deleted
          because 'unique_ptr<int, std::__1::default_delete<int> >' has a user-declared move constructor
        _LIBCPP_INLINE_VISIBILITY unique_ptr(unique_ptr&& __u) _NOEXCEPT
                                  ^
    In file included from eastl-vector-move.cpp:3:
    In file included from /usr/local/include/EASTL/vector.h:42:
    /usr/local/include/EASTL/memory.h:605:34: error: call to implicitly-deleted copy constructor of 'value_type' (aka
          'std::__1::unique_ptr<int, std::__1::default_delete<int> >')
                                            ::new((void*)&*currentDest) value_type(*first);
                                                                        ^          ~~~~~~
    /usr/local/include/EASTL/memory.h:705:52: note: in instantiation of function template specialization
          'eastl::Internal::uninitialized_copy_impl<eastl::generic_iterator<const std::__1::unique_ptr<int,
          std::__1::default_delete<int> > *, void>, eastl::generic_iterator<std::__1::unique_ptr<int, std::__1::default_delete<int> >
          *, void> >' requested here
                    const generic_iterator<Result, void> i(Internal::uninitialized_copy_impl(eastl::generic_iterator<First, voi...
                                                                     ^
    /usr/local/include/EASTL/vector.h:1551:19: note: in instantiation of function template specialization
          'eastl::uninitialized_copy_ptr<const std::__1::unique_ptr<int, std::__1::default_delete<int> > *, const
          std::__1::unique_ptr<int, std::__1::default_delete<int> > *, std::__1::unique_ptr<int, std::__1::default_delete<int> > *>'
          requested here
                            mpEnd = eastl::uninitialized_copy_ptr(position, last, mpEnd);
                                           ^
    /usr/local/include/EASTL/vector.h:1480:3: note: in instantiation of function template specialization
          'eastl::vector<std::__1::unique_ptr<int, std::__1::default_delete<int> >, eastl::allocator>::DoAssignFromIterator<const
          std::__1::unique_ptr<int, std::__1::default_delete<int> > *, false>' requested here
                    DoAssignFromIterator<InputIterator, bMove>(first, last, IC());
                    ^
    /usr/local/include/EASTL/vector.h:660:4: note: in instantiation of function template specialization
          'eastl::vector<std::__1::unique_ptr<int, std::__1::default_delete<int> >, eastl::allocator>::DoAssign<const
          std::__1::unique_ptr<int, std::__1::default_delete<int> > *, false>' requested here
                            DoAssign<const_iterator, false>(x.begin(), x.end(), eastl::false_type());
                            ^
    /usr/local/include/EASTL/vector.h:1393:10: note: in instantiation of member function 'eastl::vector<std::__1::unique_ptr<int,
          std::__1::default_delete<int> >, eastl::allocator>::operator=' requested here
                            *this = x;                   // itself call this member swap function.
                                  ^
    /usr/local/include/EASTL/vector.h:686:5: note: in instantiation of member function 'eastl::vector<std::__1::unique_ptr<int,
          std::__1::default_delete<int> >, eastl::allocator>::swap' requested here
                                    swap(x);           // member swap handles the case that x has a different allocator than ou...
                                    ^
    eastl-vector-move.cpp:8:6: note: in instantiation of member function 'eastl::vector<std::__1::unique_ptr<int,
          std::__1::default_delete<int> >, eastl::allocator>::operator=' requested here
      v2 = std::move(v1);
         ^
    /Library/Developer/CommandLineTools/usr/bin/../include/c++/v1/memory:2600:31: note: copy constructor is implicitly deleted because
          'unique_ptr<int, std::__1::default_delete<int> >' has a user-declared move constructor
        _LIBCPP_INLINE_VISIBILITY unique_ptr(unique_ptr&& __u) _NOEXCEPT
                                  ^
    3 errors generated.
    
    
    opened by xaxxon 45
  • Visual Studio project generation not including appropriate headers

    Visual Studio project generation not including appropriate headers

    After generating a Visual Studio solution using the following:

    cmake.exe -G "Visual Studio 14 2015 Win64"
    

    Visual studio fails in compilation with the following:

    1>------ Build started: Project: EASTL, Configuration: Debug x64 ------
    1>  allocator_eastl.cpp
    1>C:\Code\Research\EASTL\include\EASTL/internal/config.h(61): fatal error C1083: Cannot open include file: 'EABase/eabase.h': No such file or directory
    1>  assert.cpp
    1>C:\Code\Research\EASTL\include\EASTL/internal/config.h(61): fatal error C1083: Cannot open include file: 'EABase/eabase.h': No such file or directory
    1>  fixed_pool.cpp
    1>C:\Code\Research\EASTL\include\EASTL/internal/fixed_pool.h(22): fatal error C1083: Cannot open include file: 'EABase/eabase.h': No such file or directory
    1>  hashtable.cpp
    1>C:\Code\Research\EASTL\include\EASTL/internal/hashtable.h(30): fatal error C1083: Cannot open include file: 'EABase/eabase.h': No such file or directory
    1>  intrusive_list.cpp
    1>C:\Code\Research\EASTL\include\EASTL/internal/config.h(61): fatal error C1083: Cannot open include file: 'EABase/eabase.h': No such file or directory
    1>  numeric_limits.cpp
    1>C:\Code\Research\EASTL\include\EASTL/internal/config.h(61): fatal error C1083: Cannot open include file: 'EABase/eabase.h': No such file or directory
    1>  red_black_tree.cpp
    1>C:\Code\Research\EASTL\include\EASTL/internal/config.h(61): fatal error C1083: Cannot open include file: 'EABase/eabase.h': No such file or directory
    1>  string.cpp
    1>C:\Code\Research\EASTL\include\EASTL/internal/config.h(61): fatal error C1083: Cannot open include file: 'EABase/eabase.h': No such file or directory
    1>  thread_support.cpp
    1>C:\Code\Research\EASTL\include\EASTL/internal/config.h(61): fatal error C1083: Cannot open include file: 'EABase/eabase.h': No such file or directory
    1>  Generating Code...
    2>------ Skipped Build: Project: ALL_BUILD, Configuration: Debug x64 ------
    2>Project not selected to build for this solution configuration 
    
    opened by Nuclearfossil 18
  • Submodule hell - not the way they're meant to work

    Submodule hell - not the way they're meant to work

    Hi,

    I'm not sure who's idea it was to switch to submodules. That in itself is not a huge problem, a little annoying maybe, but ok, fair enough, its your project. But to make them interdependent so that --recursive is effectively broken? Its now very difficult (read: impractical) to keep up-to-date with the latest versions without hacking around, creating an independent folder and committing that to a local repository without the submodules. It just takes someone who already has other submodules in their project, such as protobuf for example, that has its own submodules so that they require the use of --recursive for a successful clone.

    Please reconsider this layout. I'm a long time user of EASTL and I'm glad its still being maintained and is as great as ever, but this change is going to be an ongoing issue to keep up-to-date.

    opened by IanMDay 17
  • Add MinGW-w64 (MSYS2) CI scripts

    Add MinGW-w64 (MSYS2) CI scripts

    This PR adds scripts for appveyor to automatically check mingw-w64 (MSYS2) compatibility. Some things I did:

    • Switch GCC to C++14, since it needs to run in C++14 mode for variadic template support.
    • Add C++14 deleters to the test allocators.
    • Turn off strict aliasing on GCC, without this the intrusive list test won't pass. (Probably needs some investigating to make sure this also works on compilers that do not have such an option.)
    • Clean up the CMakeLists a bit.

    The mingw-w64 appveyor build script is separate from the standard one, I've done this in an attempt to shorten the amount of time before you can see if integration failed. Another thing I did, I stopped clang from building in release mode in x86 configurations, since it ICEs on about 90% of the source code.

    opened by DragoonX6 16
  • Build issue | Xcode 7.2 Apple LLVM version 7.0.2 (clang-700.1.81) Target: x86_64-apple-darwin14.5.0

    Build issue | Xcode 7.2 Apple LLVM version 7.0.2 (clang-700.1.81) Target: x86_64-apple-darwin14.5.0

    CMake generates files properly, but none of the header files is detected at the very start of the of the config.h so i need to point out to the directory manually

    #ifndef EASTL_EABASE_DISABLED
        #include <EABase/eabase.h>
    #endif
        #include <EABase/eahave.h>
    
    opened by nyotis 16
  • eabase.h: error C2371: 'char16_t' : redefinition; different basic types

    eabase.h: error C2371: 'char16_t' : redefinition; different basic types

    Hi, I'm getting the compile error below.

    I added the following include paths: D:\programming\EASTL-master\test\packages\EABase\include\Common D:\programming\EASTL-master\include

    and this line:

    include < EASTL/sort.h >

    and got:

    1>D:\programming\EASTL-master\test\packages\EABase\include\Common\EABase/eabase.h(724): error C2371: 'char16_t' : redefinition; different basic types 1> C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\include\yvals.h(528) : see declaration of 'char16_t'

    Visual studio 2012, x64 build.

    opened by Ono-Sendai 15
  • macro defining char8_t to char breaks valid code

    macro defining char8_t to char breaks valid code

    The macro in eabase.h breaks valid code: https://github.com/electronicarts/EASTL/blob/master/test/packages/EABase/include/Common/EABase/eabase.h#L715

    // this code is fine without the #define
    #define char8_t char
    
    enum char8_t : unsigned char {};
    

    produces the error:

    
    <source>:4:6: error: expected identifier or '{'
    
    enum char8_t : unsigned char {};
    
         ^
    

    https://godbolt.org/z/GjgPra

    This example code comes from the popular c++ library {fmt}:

    https://github.com/fmtlib/fmt/blob/master/include/fmt/format.h#L404

    opened by xaxxon 14
  • When copying a vector_map to another vector_map, sends entire pair to key's constructor if it can accept it

    When copying a vector_map to another vector_map, sends entire pair to key's constructor if it can accept it

    https://github.com/electronicarts/EASTL/blob/master/include/EASTL/utility.h#L407

    If your key type has a templated constructor that can take a pair, this constructor is selected. For example a constructor like:

    template<class T>
    MyKeyType(T&&t);
    
    

    I don't see why (off the top of my head) you'd ever want this constructor to be called.

    
    /Users/xaxxon/apb/include/field_string.h:15:9: note: in instantiation of function template specialization 'AlignedString<16>::AlignedString<eastl::pair<FieldString, std::__1::function<bool (Thing &)> > >' requested here
            SUPER(std::forward<Strings>(strings)...)
            ^
    /usr/local/include/EASTL/utility.h:407:7: note: in instantiation of function template specialization 'FieldString::FieldString<eastl::pair<FieldString, std::__1::function<bool (Thing &)> > >' requested here
                                    : first(eastl::move(x)),
                                      ^
    /usr/local/include/EASTL/memory.h:605:34: note: in instantiation of function template specialization 'eastl::pair<FieldString, std::__1::function<bool (Thing &)> >::pair<eastl::pair<FieldString, std::__1::function<bool (Thing &)> > &, void>' requested here
                                            ::new((void*)&*currentDest) value_type(*first);
                                                                        ^
    /usr/local/include/EASTL/memory.h:705:52: note: in instantiation of function template specialization 'eastl::Internal::uninitialized_copy_impl<eastl::generic_iterator<eastl::pair<FieldString, std::__1::function<bool (Thing &)> > *, void>, eastl::generic_iterator<eastl::pair<FieldString, std::__1::function<bool (Thing &)> > *, void> >' requested here
                    const generic_iterator<Result, void> i(Internal::uninitialized_copy_impl(eastl::generic_iterator<First, void>(first), // generic_iterator makes a pointer act like an iterator.
                                                                     ^
    /usr/local/include/EASTL/vector.h:578:18: note: in instantiation of function template specialization 'eastl::uninitialized_copy_ptr<eastl::pair<FieldString, std::__1::function<bool (Thing &)> > *, eastl::pair<FieldString, std::__1::function<bool (Thing &)> > *, eastl::pair<FieldString, std::__1::function<bool (Thing &)> > *>' requested here
                    mpEnd = eastl::uninitialized_copy_ptr(x.mpBegin, x.mpEnd, mpBegin);
                                   ^
    /usr/local/include/EASTL/vector_map.h:326:5: note: in instantiation of member function 'eastl::vector<eastl::pair<FieldString, std::__1::function<bool (Thing &)> >, eastl::allocator>::vector' requested here
                    : base_type(x), mValueCompare(x.mValueCompare)
                      ^
    /Users/xaxxon/apb/src/game_data.cpp:30:9: note: in instantiation of member function 'eastl::vector_map<FieldString, std::__1::function<bool (Thing &)>, eastl::less<FieldString>, eastl::allocator, eastl::vector<eastl::pair<FieldString, std::__1::function<bool (Thing &)> >, eastl::allocator> >::vector_map' requested here
            insertion_filters(other.insertion_filters) {
    
    
    opened by xaxxon 14
  • Compile failures with char8_t

    Compile failures with char8_t

    (Disclaimer: I'm a Microsoft employee on the Visual C++ team.)

    We've stumbled across some build failures in EASTL after implementing support for char8_t under /std:c++latest in the development version of Visual C++. Specifically:

    1. Line 927 of include/EASTL/string.h calls eastl::CharStrlen with a const value_type*. When char8_t is the C++20 fundamental type and value_type is char, there is no overload of eastl::CharStrlen that accepts const char*. (There are four overloads defined in include/EASTL/internal/char_traits.h accepting pointer-to-const char8_t, char16_t, char32_t, and wchar_t, but no char.)

    2. Line 16 of test/packages/EAStdC/source/EASprintf.cpp wants to call vsnprintf with a char8_t*, but there's no such overload of vsnprintf.

    opened by CaseyCarter 12
  • Inconsistency between std::is_function and eastl::is_function

    Inconsistency between std::is_function and eastl::is_function

    While attempting to add an is_function_pointer type trait, I seem to have found an inconsistency between EASTL's is_function and the STL's is_function when a function pointer type has an MSVC calling convention such as __stdcall.

    In Visual Studio 2015 (with Update 3), the following code produces expected results with function pointer types:

    template <typename T>
    struct is_function_pointer
        : std::integral_constant<bool, std::is_pointer<T>::value &&
                                       std::is_function<typename std::remove_pointer<T>::type>::value>
    {
    };
    

    However, the equivalent code using EASTL's implementations does not work for function pointer types that have MSVC calling conventions, such as __stdcall, associated with them.

    For example, when working with OpenGL on Windows the function signature for glClearColor would be typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); where APIENTRYP evaluates to __stdcall * (note: this only seems to be the case with 32-bit builds, as I can compile 64-bit with no warnings/errors). is_function_pointer<PFNGLCLEARCOLORPROC>::value using the STL's functions evaluates to true, whereas the value is false using EASTL's implementations.

    opened by raselneck 11
  • EASTL doesn't detect non-apple clang on MacOS properly - thinks modern clang versions are pre-C++11

    EASTL doesn't detect non-apple clang on MacOS properly - thinks modern clang versions are pre-C++11

    on clang 3.9 (and probably others), I have to make sure to have

    #define EA_HAVE_CPP11_INITIALIZER_LIST

    before I include any eastl headers or I get redefinition of initializer_list. Is this normal?

    Searching the eastl source on github for that string, I don't see anywhere it would be set automatically...

    Thank you.

    bug help wanted 
    opened by xaxxon 11
  • variant: fix unused args warnings

    variant: fix unused args warnings

    Some of them are clang-specific (might even require /permissive-), other - msvc.

    Example of warning variant.h(133,24): error: unused parameter 'pThis' [-Werror,-Wunused-parameter]

    opened by virt00l 0
  • LNK2019 error

    LNK2019 error

    Hi, I have a project that is a static library and a main project that uses the static library project. I have used premake to include and link the library and include files to both project. I have used eastl::unique_ptr and eastl::shared_ptr with no problems at all. however, when I use eastl::string or eastl::vector I get 3 errors shown below, (these issues happen in both projects when I try using eastl string or easlt vector). What can I do to fix this? image

    opened by KielanT 2
  • View EASTL Containers Data in Qt Creator like Visual Studio.

    View EASTL Containers Data in Qt Creator like Visual Studio.

    I need to see eastl containers data in Qt Creator like Visual Studio Visualizer. Using Qt Creator on Windows with CDB debugger, Qt Creator is much faster but can't see symbol of eastl::map and eastl::vector.

    opened by xhimanshuz 0
  • Fixing issue with list ctor that differs from stl (wasn't documented)

    Fixing issue with list ctor that differs from stl (wasn't documented)

    (https://en.cppreference.com/w/cpp/container/list/list) constructor 4) dictates: "Constructs the container with count default-inserted instances of T. No copies are made." However, EASTL created a default constructed object which would then be copied into the nodes. No default object is constructed now and the parameter-less overload of DoCreateNode is now used to create the nodes.

    opened by RisingLiberty 1
  • Implement extract/insert node for node based containers (C++17 standard)

    Implement extract/insert node for node based containers (C++17 standard)

    It would be nice to have the extract/insert functions for node based containers to allow no-copy splicing of elements

    https://en.cppreference.com/w/cpp/container/node_handle https://en.cppreference.com/w/cpp/container/set/extract https://en.cppreference.com/w/cpp/container/set/insert (7-8)

    opened by Woazboat 0
Releases(3.18.00)
  • 3.18.00(Oct 20, 2021)

    Welcome to the 3.18.00 release of EASTL. Thank you to everyone who's contributed to this release.

    Feature additions and standard updates:

    • Implemented eastl::bit_cast.
    • Implemented eastl::is_nothrow_invocable.
    • Implemented eastl::to_underlying.
    • Implemented LWG defect 2106: move_iterator doesn't work with iterators which don't return a reference

    Bugfixes:

    • eastl::invoke fixes:

      • invoke now correctly deduces the function signature when invoking a member function or member data pointer on a reference_wrapper. Previously, this would fail if using arguments which were convertible to the correct type, but did not exactly match.
      • invoke now correctly forwards arguments when invoking a member data pointer.
      • invoke now correctly uses decay_t instead of remove_reference_t in a number of places.
      • invoke_result_t no longer uses decay_t on the type being invoked.
      • invoke is now constexpr.
    • eastl::variant fixes:

      • Fixed incorrect results from some relational operators when valueless_by_exception() is true.
      • Fixed incorrect index when an exception is thrown during emplace().
    • Removed assertions from some eastl::array functions in order to ensure usability in constexpr contexts.

    • eastl::make_signed and eastl::make_unsigned now work correctly for enum types and volatile-qualified types.

    • Containers which support find_as now support using it with keys of the same type as the container's key.

    • Disallowed use of smart pointer default deleter on incomplete types.

    • Fixed an issue where nodes for some data structures could be under-aligned.

    • Properly supported arrays in eastl::cbegin() and eastl::cend().

    • Fixed creation of zero-length spans and subspans.

    • eastl::is_reference now returns true for rvalue references.

    • Fixed a potential out-of-bounds memory access when sorting certain containers.

    Optimizations:

    • eastl::variant optimizations:
      • Avoided unnecessary double index checks in variant relational operators.
      • Avoided unnecessary work in valueless_by_exception() when exceptions are disabled.
      • Optimized visit() for the common case of visiting a single variant.
      • Removed unnecessary copies during visit().
    Source code(tar.gz)
    Source code(zip)
  • 3.17.06(Jan 26, 2021)

    Minor spelling and grammar corrections. (#396) Using of qualified eastl move() and forward() functions. (#405) Fixed warnings in function_detail.h on MSVC at warning level 4. (#400) Fix get(variant) when variant is a rvalue (#406) Using of qualified eastl functions. (#407) Removed extra parentheses on eastl::move's return statement (#409)

    [EASTL 3.17.06] (#412)

    Thanks to all committers for this EASTL release.

    Source code(tar.gz)
    Source code(zip)
  • 3.17.03(Nov 6, 2020)

    [EASTL 3.17.03] (#397)

    EASTL: lru_cache iteration tests and added support for initializer_lists

    eastl::atomic : fixed msvc compiler warning 4459

    Source code(tar.gz)
    Source code(zip)
  • 3.17.02(Nov 5, 2020)

    rbtree::emplace_hint() compilation fix for variadic arg use (#392)

    • Fix hint-versions of rbtree class variadic insertion methods: parameter pack and move semantics support.

    • Fix hashtable::insert() to satisfy new map tests.

    Fixed typo in Deque comments (#394)

    [EASTL 3.17.02] (#395)

    eastl::atomic

    • fix all the spelling mistakes in the doc
    • Added support for non-trivially default constructible types
    • Cleaned up comments and impl
    • improved 128-bit load code gen
    • fixed type pun to support non-trivially default constructible types
    • ensure msvc instrinics do not emit prefetch instructions

    EASTL: to_array implementation

    EASTL: fix for rbtree input iterator ctor moving elements from the source container

    Source code(tar.gz)
    Source code(zip)
  • 3.17.01(Oct 15, 2020)

  • 3.17.00(Oct 10, 2020)

    • Ensure the alignment of a node<value_type> is the alignment of the whole node allocation, not just the user type

    • Removing old compiler special case code for EA_CPP14_CONSTEXPR

    • Adding eastl::string hash tests and removing an addition overload in the helper template that contrains usage to enum types.

    • Fixing user reported regression when attempting to use fancy pointers in a tuple

    • Resolving uint128_t hashing compiler errors from properly limiting the generic template for enums

    • eastl::pair adding C++17 structured bindings unpacking support

    • eastl::atomic implementation - See EASTL/atomic.h for documentation

    • eastl::function - Optimized function call operator - see Invoker() in function_detail.h for explanation of the optimization

    • Consolidate Warnings by using EA_DISABLE_WARNING macros

    • Reverting the UDL warning suppression because of push/pop mismatch issues with the EABase warning suppression macros

    • eastl::variant - Fixed variant warnings due to not sfinae overloads that are not the same type but still comparable - improved code gen on msvc - added tests

    • Removed unndeded allocator_traits headers

    • Added comments on reverse_wrapper

    • Removed sparse_matrix.h as it was removed internally quite a while ago

    • Updated files that had slight differences to internal eastl

    • Update travis CI to use g++-9 && clang++-11

    • Updated README and CONTRIBUTING to allow contributors to submit their info under the contributors section

    • cleared mpPtrArray in base destructor #389

    • Add eastl::span<*> to EASTL.natvis #386

    • Fix typo in doc #384

    • Fix reverse adaptor when using on a rvalue range #382

    • Fix GCC 9 string SSO segfault #380

    • eastl::shared_ptr<>::reset(): function not thread safe #378

    • Enable compilation without building tests #359

    • Fix tuple vector assign #374

    • fixed unique_ptr<[]>::reset() instructions order. Internal pointer must be updated before deleting object #375

    Source code(tar.gz)
    Source code(zip)
  • 3.16.07(Jun 10, 2020)

    • fixing spelling mistake in eastl::basic_string

    • Fix for insertion_sort() doing a --(BiDirectionalIterator.begin()) which is an illegal operation and causes crashes on containers such as eastl::deque.

    • eastl::optional_storage - remove unneeded union and trivial type initialization since we use eastl::aligned_storage_t, remove unreferenced internal member function

    • resolving 32-bit eastl_size_t compiler error

    • EASTL_ALIGN_OF porting to C++11 alignof keyword.

    • EASTL_EMPTY_REFERENCE_ASSERT_ENABLED when enabled would not assert when taking a reference to an empty container. Example, eastl::vector[0] would not assert that a null reference was being taken if the vector was empty.

    • fixing shared_ptr compiler error when passing nullptr with a custom deleter lambda

    • fixed unique_ptr::reset() instructions order. Internal pointer must be updated before deleting object (#373)

    • fixed unique_ptr<[]>::reset() instructions order. Internal pointer must be updated before deleting object (#375)

    • fixed adl with exchange inside unique_ptr to be fully qualified

    • fix bitvector iterators (#358) use mContainer.begin() instead of &mContainer[0], since it causes out of bounds exception in non release build

    • Fix circular dependency in fixed_function.h (#350)

    Source code(tar.gz)
    Source code(zip)
  • 3.16.05(Feb 24, 2020)

    • Implemented C++17 eastl::shared_ptr::weak_from_this.
    • Implemented C++20 char8_t string/string_view support improvements.
    • Fixed unguarded eastl::allocator::set_name usage in eastl::vector_multimap.
    • Added bool autoDestruct template parameter to eastl::late_constructed to determine whether to destruct the containing object
    • eastl::finally fixes for missing type_traits headers.
    • eastl::span fixes for C++17 deduction guides, and completing subspan API.
    • eastl::array fixes for C++17 deduction guides.
    • C++20 iterator fixes.
    • atomic_exchange_explicit bug fix for a missing return statement in a member function.
    • string_view::find_first_of bug fix where incorrect string count member variable was used.
    • vector::DoRealloc tag dispatch bug fix for 'should_copy_tag' and 'should_move_tag' expression.
    • eastl::u8string updated to C++20 definition 'basic_string<char8_t>'
    Source code(tar.gz)
    Source code(zip)
  • 3.16.01(Dec 14, 2019)

    • Implemented C++20 uniform container erasure algorithms as defined by: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/n4806.html#container.erasure
    • removing eastl::sparse_matrix files as it was never implemented.
    • eastl::span conversion constructor fix for eastl::vector.
    Source code(tar.gz)
    Source code(zip)
  • 3.15.00(Nov 1, 2019)

    • eastl::span specification updated implemented which changes its extents type from ptrdiff_t (a signed type) to size_t (an unsigned type).
    Source code(tar.gz)
    Source code(zip)
  • 3.14.06(Oct 18, 2019)

    • eastl::string::ltrim/rtrim/trim can now be passed an array of characters to trim.
    • Implemented eastl::finally, an RAII type for guaranteed callback execution at scope-exit.
    • Updated fixed_list/list, fixed_map/map, fixed_set/set, fixed_slist/slist, and rb_tree to use empty-base-class optimization for their allocator.
    • Fixed bug in eastl::string::append_convert which incorrectly assumed the provided string object was a pointer.
    • Fixed bug in eastl::variant conversion ctor and assignment-operator which ignored cv-qualifiers.
    • eastl::optional::swap fixes for mismatched engaged values.
    Source code(tar.gz)
    Source code(zip)
  • 3.14.03(Sep 30, 2019)

    • Fixed bug in segmented_vector_iterator::operator++(int).
    • Adding a basic eastl::any natvis. Has a limitation of switching between inplace and heap views due to natvis scripting limitations.
    • Adding a EASTL_IF_NOT_DLL macro to add back in eastl::any non-RTTI type checking in static builds.
    • Fixed optional::swap with mismatched engaged values.
    Source code(tar.gz)
    Source code(zip)
  • 3.14.02(Sep 6, 2019)

    • Fixed memory leak in eastl::string_hash_map when inserting a duplicate key.
    • Added eastl::stable_partition algorithm implementation.
    • Fixed eastl::CoreDeleterAdapter so the object destructor is called before freeing the allocated memory.
    Source code(tar.gz)
    Source code(zip)
  • 3.14.01(Jul 26, 2019)

    • Adding non-const overload of eastl::basic_string::data.
    • eastl::stack::emplace_back / emplace fixes for C++17 support.
    • C++20 char8_t distinct type fixes due to assumptions char8_t aliased char type.
    • eastl::fixed_function fixes when attempting to copy to an eastl::fixed_function type with a larger SBO size.
    • eastl::pair single element ctor overload disabled by default.
    Source code(tar.gz)
    Source code(zip)
  • 3.14.00(Jul 10, 2019)

    • eastl::fixed_function conversion ctor fixes to allow conversion to greater than or equal sized fixed_function target types.
    • eastl::pair single element ctor fixes when the first-element via reference-collapsing rules produces a move-ctor and copy-ctor of the same signature.
    • eastl::vector_multiset and eastl::vector_multimap compliance fixes. Insert functions now use eastl::upper_bound as mandated by the ISO specification.
    • eastl::queue compliance fix by deprecating eastl::queue::emplace_back and replacing with eastl::queue::emplace.
    • eastl::vector_* containers removing push_back and emplace_back from the overload set. Users are required to use *_unsorted variants.
    Source code(tar.gz)
    Source code(zip)
  • 3.13.06(May 31, 2019)

    • eastl::any runtime crash fix when assigning two null eastl::any instances.
    • Fixed eastl::optional::emplace support for non-copyable, non-movable types.
    • Fixed eastl::optional::emplace to destroy previously engaged value.
    • Adding C++20 eastl::ssize implementation.
    • eastl::fixed_function conversion ctor fixes to allow conversion to greater than or equal sized fixed_function target types.
    • Converting HTML package documentation to Markdown.
    Source code(tar.gz)
    Source code(zip)
  • 3.13.05(Apr 29, 2019)

    • Updated chrono code to use EA_PLATFORM_SONY.
    • Added eastl::lru_cache an implementation of a "least recently used" cache contributed by Jose Caban.
    Source code(tar.gz)
    Source code(zip)
  • 3.13.04(Mar 17, 2019)

    • Removing some old type_traits fallback code for when C++11 language features were added.
    • Fixed a runtime crash when string_hash_map::insert_or_assign was used because the key strings weren't being copied into memory owned by the containers allocator.
    • Added all the type-trait '_v' aliases added in C++14.
    Source code(tar.gz)
    Source code(zip)
  • 3.13.03(Feb 25, 2019)

    • Fixed eastl::variant support of move-only types.
    • Fixed eastl::rbtree::swap to no longer require types with a copy-ctor.
    • Fixed eastl::is_move_constructible_v which was aliasing to an unrelated type-trait.
    • Added eastl::is_empty_v template variable for eastl::is_empty::value.
    • Fixed eastl::tuple_cat lvalue-reference support.
    • Removing some old type_traits fallback code for when C++11 language features were added.
    Source code(tar.gz)
    Source code(zip)
  • 3.13.02(Feb 8, 2019)

    • Adding explicit moves to eastl::string::operator+ due to NRVO rules.
    • Removing dependency on global new/delete in eastl::any and routing all memory requests to the default allocator.
    • Removing support for 'EASTL_STRING_OPT_CHAR_INIT'.
    Source code(tar.gz)
    Source code(zip)
  • 3.13.00(Jan 24, 2019)

    • Fixed eastl::deque selecting an optimized 'memmove' code path to move elements within a memory page. The implementation was incorrectly selecting code that utilized memmove for non-trivial objects.
    • Removing some fallback code for variadic template code paths in allocator_traits.h
    • Added more type_trait variable template for values.
    • Fixed issue in eastl::unique_ptr that would call deleter for unique_ptrs holding a nullptr.
    Source code(tar.gz)
    Source code(zip)
  • 3.12.08(Jan 4, 2019)

    • Resolved eastl::function memory leak when assigning to a non-null eastl::function with a closure containing non-trivial types.
    • Fixed all eastl::list::insert overloads to return the insertation position for C++11 standards conformance.
    • Fixed eastl::vector noexcept annotations to use EABase portability macros.
    • Resolved compilation errors when using eastl::scoped_ptr<void> and eastl::scoped_array<void>.
    • Port benchmarks to use std::unordered_map instead of std::hash_map.
    Source code(tar.gz)
    Source code(zip)
  • 3.12.07(Dec 6, 2018)

    • eastl::late_constructed added 'operator* / operator->' const overloads.
    • Adding portability macro EA_CONSTEXPR_IF.
    • Adding chrono, function, reference_wrapper types to eastl.natvis.
    • Improved reference_wrapper implementation.
    • Completed eastl::ref / east::cref implementations.
    • Updated eastl::unique_ptr to used "delete" keyword to prevent copying.
    • Added EA_CURRENT_FUNCTION macro provides a consistent way to get the current function name.
    Source code(tar.gz)
    Source code(zip)
  • 3.12.04(Nov 3, 2018)

    • vector_map fixes for that allow std::variant and other container types.
    • MSVC permissive- mode fixes for std::fill algorithms.
    • CMake scripts migrating to C++17 for Github builds.
    • eastl::array now supports compile-time use-cases added to the C++17 standard.
    • Resolving compiler error when using eastl::hash with an enum type.
    • Adding eastl::is_enum_v type_trait.
    • eastl::deque support for move-only types.
    • Resolving eastl::function self-assignment bugs.
    • eastl::tuple supports C++17 structured binding.
    • Fixed eastl::string_view::copy writing out a null-terminator.
    • Added natvis for eastl::optional.
    • Added eastl::is_trivially_assignable_v.
    • Resolved compiler error in eastl::ring_buffer when using eastl::fixed_vector as the underlying container type.
    • Migrated all platforms to use std::mutex by default for our shared_ptr atomic implementations.
    • Removed all EASTL_MOVE_SEMANTICS_ENABLED preprocessor branches.
    Source code(tar.gz)
    Source code(zip)
  • 3.12.01(Aug 9, 2018)

    • eastl::pair first element constructor required fix due to a Clang compiler bug when using is_default_constructible type trait on a class with NSDMI.
      • We have submitted a bug with LLVM: https://bugs.llvm.org/show_bug.cgi?id=38374
    • eastl::is_final type trait support added.
    • eastl::endian support for C++20 conformance.
    • eastl::fixed_pool improving swap performance by enabling move semantics.
    • eastl::optional bug fixes to properly destroy held objects when assigning another object.
    • eastl::string bug fixes for string_view substr ctor overload.
    • eastl::function improved C++17 standards conformance
      • Can now call functions where return type is implicity converitble to the return type specified in the function template
      • Implemented missing functions for operator=, such as operator=(Functor&&)
      • operator bool() is now explicit so function cannot be implicit convertible to bool in wierd unintended places (eg. vectoreastl::function).
      • SFINAE away the templated construct/operator= so it is not a candidate in the overload set
    • eastl::function && eastl::fixed_function now share a common implementation
    • eastl::invoke_result && eastl::is_invocable are now C++14 compliant
      • can be used in an unevaluated context
      • typename F is no longer required to be a Callable
    • Added EASTL_CPP17_INLINE_VARIABLE macro to declare a variable as inline
    • eastl::pair first element constructor overload can not be toggled to give users the opportunity to fix their code before the overloads are removed in a future release.
      • Look at the feature define: EASTL_ENABLE_PAIR_FIRST_ELEMENT_CONSTRUCTOR
    • eastl::string_map and eastl::string_hash_map optimizations to avoid implicit eastl::string conversions.
    • eastl::ring_buffer fixes when using an underlying container with a large stack memory requirement that it allocates the required heap allocation from the containers allocator -- not the default EASTL allocator instance.
    Source code(tar.gz)
    Source code(zip)
  • 3.10.00(Jul 6, 2018)

    • eastl::span implementation for C++20.
    • eastl::variant get_if bug fix for requesting the incorrect held type or when passing a nullptr.
    • eastl::string substr(), left(), right() return a copy of this->get_allocator()
    • eastl::string changed SSOSize variable name from mnSize to mnRemainingSize to better signify what type of data the variable holds
    • Added iterator vector::erase_first_unsorted(const T& val) and the reverse equivalent, iterator vector::erase_last_unsorted(const T& val). These allow for erasing the first found value matching element, as a convenience function. The container is considered unsorted after the operation.
    • Implemented for_each_n
      • http://en.cppreference.com/w/cpp/algorithm/for_each_n
    • Implemented string_view::starts_with, string_view_ends_with.
    • Implemented eastl::basic_string constructor and assignment operator overloads for eastl::basic_string_view.
    • Resolved a bug in the uint8_t specialization of radix_sort_impl that was detected by adding verification to a sorting test.
    • eastl::fixed_function fixes to ensure closure destructors run correctly.
    • eastl::optional copy-construction fixes for complex types.
    • eastl::optional move-only type fixes.
    Source code(tar.gz)
    Source code(zip)
  • 3.09.00(Apr 2, 2018)

    • eastl::any fix to correctly decay reference types.
    • eastl::fixed_hash_map/eastl::fixed_hash_multimap fixes when a user requests to clear the bucket array hashtable rehashing was disabled with a default bucket count of 1. The behaviour now for fixed_hash_map (and fixed_hash_multimap) is the clear buckets request resets the containter to use the SBO and the default bucket count.
    • Added 'eastl::is_literal_type_v' type trait.
    • Added 'eastl::is_convertible_v' type trait.
    • eastl::string SSO capacity is now optimal
      • HeapLayout now uses 1 pointer and 2 size_t instead of 3 pointers
      • SSO rework to now use the maximum number of bytes possible, 23 bytes of SSO on 64bit, was 14 bytes before
      • set_capacity() will now shrink to SSO if the new capacity is within SSO limits
      • shrink_to_fit() implemented
      • basic_string(const basic_string&, const Allocator&) constructor implemented
      • substr(), left(), right() now properly return a basic_string with a default constructed allocator when inserting yourself into yourself reduced allocations from 1 to 0 or 1.
      • is_sso() function implemented that returns true if the current string is an SSO string
      • natvis updated
    • eastl::fixed_substring && eastl::fixed_string updated due to eastl::string changes
    • eastl::vector::emplace_back() now returns a reference to the emplaced element
    • eastl::variant::operator=(T) conversion assignment operator fixed an issue due to a incorrect conjunction expression that caused the operator to be removed via SFINAE.
    • eastl::intrusive_ptr now supports move semantics.
    • eastl::is_trivially_copyable fixes to use the proper compiler intrinsics.
    • eastl::deque::shrink_to_fit() implemented.
    Source code(tar.gz)
    Source code(zip)
  • 3.08.00(Mar 19, 2018)

    • Fully qualifying call to move in algorithms "remove_copy_if".
    • Implemented the following new C++17 memory algorithms:
      • uninitialized_default_construct
      • uninitialized_default_construct_n
      • uninitialized_value_construct
      • uninitialized_value_construct_n
    • Implemented the eastl::remove_cvref type trait.
    • eastl::string_view hash fixes for both char and wchar types
    • eastl::optional compiler fixes when building with exceptions enabled
    • Implemented eastl::unordered_map/map/hash_map "try_emplace" and "insert_or_assign".
    • Removing deprecated "reset" member function from containers.
    • string_view string compare fixes.
    • eastl::optional storage now type aligned.
    • eastl::string_view no longer crashes when passed a nullptr via the 'const char*' conversion constructor.
    • Added static_asserts to eastl::variant visit function to improve diagonistic message when variant instances are not provided.
    • Added noexcept decorations to eastl::vector and eastl::string.
    • eastl::any::swap fixes to ensure destructors are being called correctly.
    • eastl::rbtree and eastl::hashtable insert and emplace optimizations to reduce the allocation overhead for object that act as a handle to a heap allocation (ie. eastl::string). Breaking change: rbtree/hashtable backed containers now correct forbid inserting pointers with that lose cv-qualifers.
    • Adding eastl::string_view visualizer to EASTL natvis.
    Source code(tar.gz)
    Source code(zip)
  • 3.07.02(Feb 28, 2018)

    • Implemented eastl::variant.
    • Implemented eastl::fixed_function.
    • Implemented eastl::apply for unpacking tuples into callable arguments.
    • Implemented eastl::piecewise_construct constructor overload for eastl::pair.
    • Implemented eastl::reference_wrapper.
    • Implemented eastl::invoke for pointer-to-member, pointer-to-member-function and eastl::reference_wrapper types.
    • Implemented vector::insert updates that return an iterator to the beginning of the inserted range.
    • Implemented eastl::tuple_size_v alias.
    • Removed non-variadic template code paths in eastl::function.
    • Implemented eastl::is_invocable.
    • Fixed eastl::common_type<void, void> and updated eastl::common_type to decay result type based on defect #2141
    Source code(tar.gz)
    Source code(zip)
  • 3.07.01(Feb 28, 2018)

Owner
Electronic Arts
Electronic Arts
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
Embedded Template Library

Embedded Template Library (ETL) Motivation C++ is a great language to use for embedded applications and templates are a powerful aspect. The standard

Embedded Template Library 1.3k Aug 8, 2022
KoanLogic 385 Aug 9, 2022
An open-source C++ library developed and used at Facebook.

Folly: Facebook Open-source Library What is folly? Folly (acronymed loosely after Facebook Open Source Library) is a library of C++14 components desig

Facebook 22.8k Aug 5, 2022
Functional Programming Library for C++. Write concise and readable C++ code.

FunctionalPlus helps you write concise and readable C++ code. Table of contents Introduction Usage examples Type deduction and useful error messages T

Tobias Hermann 1.7k Aug 9, 2022
? A glib-like multi-platform c library

A glib-like cross-platform C library Supporting the project Support this project by becoming a sponsor. Your logo will show up here with a link to you

TBOOX 4.1k Aug 12, 2022
NIH Utility Library

libnih is a light-weight "standard library" of C functions to ease the development of other libraries and applications. Its goals are: * despite it

Scott James Remnant 81 Aug 7, 2022
An open source library for C

Homo Deus - C Library Introduction The Homo Deus C Library (hdelibc) is an open source collection of tools for the C programming language. The project

Homo Deus 99 Aug 4, 2022
JUCE is an open-source cross-platform C++ application framework for desktop and mobile applications, including VST, VST3, AU, AUv3, RTAS and AAX audio plug-ins.

JUCE is an open-source cross-platform C++ application framework used for rapidly developing high quality desktop and mobile applications, including VS

JUCE 4.4k Aug 3, 2022
A toolkit for making real world machine learning and data analysis applications in C++

dlib C++ library Dlib is a modern C++ toolkit containing machine learning algorithms and tools for creating complex software in C++ to solve real worl

Davis E. King 11.3k Aug 6, 2022
Easy to use, header only, macro generated, generic and type-safe Data Structures in C

C Macro Collections Easy to use, header only, macro generated, generic and type-safe Data Structures in C. Table of Contents Installation Contributing

Leonardo Vencovsky 312 Aug 8, 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
C++ Parallel Computing and Asynchronous Networking Engine

As Sogou`s C++ server engine, Sogou C++ Workflow supports almost all back-end C++ online services of Sogou, including all search services, cloud input method,online advertisements, etc., handling more than 10 billion requests every day. This is an enterprise-level programming engine in light and elegant design which can satisfy most C++ back-end development requirements.

Sogou-inc 8.9k Aug 8, 2022
Idle is an asynchronous and hot-reloadable C++ dynamic component framework

Idle is an asynchronous, hot-reloadable, and highly reactive dynamic component framework similar to OSGI that is: ?? Modular: Your program logic is en

Denis Blank 165 Jul 28, 2022
EASTL stands for Electronic Arts Standard C++ Template Library

EASTL stands for Electronic Arts Standard Template Library. It is an extensive and robust implementation that has an emphasis on high performance.

Electronic Arts 6.6k Aug 8, 2022
High Performance 3D Game Engine, with a high emphasis on Rendering

Electro High Performance 3D Game Engine, with a high emphasis on Rendering MainFeatures Rendering PBR Renderer (Cook–Torrance GGX) IBL (Image Based Li

Surge 44 Jul 28, 2022
GWork is a skinnable, embeddable GUI library with an extensive control set

GWork is a skinnable, embeddable GUI library with an extensive control set. Control rendering is abstracted, and can be implemented by any application wishing to use the library. Gwork (pronounced "gw-orc") is a fork of the GUI library GWEN. It was forked to fix issues with GWEN and add new features.

Bill Quith 197 Aug 3, 2022
RRxIO - Robust Radar Visual/Thermal Inertial Odometry: Robust and accurate state estimation even in challenging visual conditions.

RRxIO - Robust Radar Visual/Thermal Inertial Odometry RRxIO offers robust and accurate state estimation even in challenging visual conditions. RRxIO c

Christopher Doer 56 Jul 26, 2022
HDRView is a simple research-oriented image viewer with an emphasis on examining and comparing high-dynamic range (HDR) images

HDRView is a simple research-oriented high-dynamic range image viewer with an emphasis on examining and comparing images, and including minimalistic tonemapping capabilities. HDRView currently supports reading EXR, PNG, TGA, BMP, HDR, JPG, GIF, PNM, PFM, and PSD images and writing EXR, HDR, PNG, TGA, PPM, PFM, and BMP images.

Wojciech Jarosz 116 Aug 6, 2022
R2LIVE is a robust, real-time tightly-coupled multi-sensor fusion framework, which fuses the measurement from the LiDAR, inertial sensor, visual camera to achieve robust, accurate state estimation.

R2LIVE is a robust, real-time tightly-coupled multi-sensor fusion framework, which fuses the measurement from the LiDAR, inertial sensor, visual camera to achieve robust, accurate state estimation.

HKU-Mars-Lab 572 Aug 2, 2022
High dynamic range (HDR) image comparison tool for graphics people. With an emphasis on OpenEXR images.

tev — The EXR Viewer A high dynamic range (HDR) image comparison tool for graphics people. tev allows viewing images through various tonemapping opera

Thomas Müller 664 Aug 4, 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
This is a simple UNITEST to test the implementation of the the various container types of the C++ standard template library

ft_container UNITest. This is a simple UNITEST to test the implementation of the the various container types of the C++ standard template library that

Mohamed AMOUSSAOUI 38 Aug 5, 2022
C++ Matrix -- High performance and accurate (e.g. edge cases) matrix math library with expression template arithmetic operators

Matrix This is a math and arithmetic matrix library. It has stood many years of performing in mission critical production for financial systems. It ha

Hossein Moein 68 Aug 6, 2022
Fast and robust template matching with majority neighbour similarity and annulus projection transformation

A-MNS_TemplateMatching This is the official code for the PatternRecognition2020 paper: Fast and robust template matching with majority neighbour simil

Layjuns 15 Jul 4, 2022
Cross-platform, efficient, customizable, and robust asynchronous HTTP/WebSocket server C++14 library with the right balance between performance and ease of use

What Is RESTinio? RESTinio is a header-only C++14 library that gives you an embedded HTTP/Websocket server. It is based on standalone version of ASIO

Stiffstream 871 Aug 9, 2022
OpenGL®-Starter is a template for your upcoming OpenGL Projects which has been compiled to run the most basic Hello World OpenGL Program from LearnOpenGL.com.

OpenGL®-Starter OpenGL®-Starter is a template for your upcoming OpenGL Projects which has been compiled to run the most basic Hello World OpenGL Progr

Kushagra 9 Jul 18, 2022
A template to build a 3DS firmware binary which just has an Arm9 section

minifirm A template to build a 3DS firmware binary which just has an Arm9 section. Install dependencies $ sudo apt install gcc-arm-none-eabi binutils-

HIDE 2 Mar 15, 2022