EASTL stands for Electronic Arts Standard C++ Template Library

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.

Comments
  • 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
  • Add EASTL.natvis to EASTL when using MSVC and install to doc directory

    Add EASTL.natvis to EASTL when using MSVC and install to doc directory

    This adds EASTL.natvis to the EASTL target when using MSVC and installs the file to the doc directory, enabling users to use the file without needing to reference the Git repository or manually copy the file.

    opened by SamVanheer 0
  • Re-add install commands

    Re-add install commands

    This adds back the install commands that were removed in an earlier commit.

    This is the same as #423 but does not include any other changes and is based on the current head commit.

    opened by SamVanheer 0
  • Incorrect behaviour of vector (and other) with switched off exceptions

    Incorrect behaviour of vector (and other) with switched off exceptions

    struct Foo
    {
      Foo();
      ~Foo();
      Foo(const Foo& a);
    };
    vector<Foo> foo;
    foo.resize(1);
    foo.resize(200);//this line will call operator = on never constructed Foo, instead of copy constructor
    In the end, operator = destructor will be called from never constructed elements.
    
    this happens, because uninitialized_move_ptr uses is_trivially_copy_assignable (which is true), rather than is_trivially_copyable, I guess.
    opened by AntonYudintsev 1
  • Outdated/incorrect documentation for use of containers with fixed allocators

    Outdated/incorrect documentation for use of containers with fixed allocators

    When using a standard non-fixed container (e.g. list, map, etc...) with a fixed allocator like eastl::fixed_pool or eastl::fixed_node_allocator, the default container constructor (/the default parameter for the allocator) attempts to construct the allocator using the container name string as the first parameter.

    e.g. for map:

    // Constructor
    map(const allocator_type& allocator = EASTL_MAP_DEFAULT_ALLOCATOR);
    // i.e. 
    map(const allocator_type& allocator = allocator_type("EASTL map"));
    

    The fixed allocator constructors are declared as:

    explicit fixed_pool(void* pMemory = NULL);
    fixed_node_allocator(void* pNodeBuffer);
    

    This breaks and fails to compile when a fixed allocator is used for a default constructed container since the fixed allocators do not use the name as the first constructor parameter. (Actually it attempts to use the const char* string as the void* memory buffer argument and the only reason it fails to compile is because it expects a non-const pointer, otherwise it would silently accept it which might be even worse.)

    The example that's given in the documentation does not actually work due to this issue. https://eastl.docsforge.com/master/faq/#cont10-how-do-i-use-a-memory-pool-with-a-container

    char buffer[256];
    
    list<Widget, fixed_pool> myList;
    myList.get_allocator().init(buffer, 256);
    
    opened by Woazboat 1
  • Cannot build EASTL_ITC_NS::contiguous_iterator_tag with EASTL_STD_ITERATOR_CATEGORY_ENABLED on C++17 compiler

    Cannot build EASTL_ITC_NS::contiguous_iterator_tag with EASTL_STD_ITERATOR_CATEGORY_ENABLED on C++17 compiler

    Pretty much title. After commit #477 I cannot build with C++17 compiler and EASTL_STD_ITERATOR_CATEGORY_ENABLED, because EASTL_ITC_NS::contiguous_iterator_tag is resolved as std::contiguous_iterator_tag which is obviously undefined. I would make a PR but I am not sure how the fix should look like.

    opened by eugeneko 1
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
FSD-Template - A template UE4.25 project for BP modding.

FSD-Template Project generated by Archengius' UE4 Template Generator. Reflected C++ classes generated by CheatingMuppet & Archengius' UE4SS UHT Genera

null 12 Aug 3, 2022
Libft is an individual project at 42 that requires us to re-create some standard C library functions including some additional ones that can be used later to build a library of useful functions for the rest of the program.

?? Index What is Libft? List of Functions Technologies ✨ What is Libft? Libft is an individual project at 42 that requires us to re-create some standa

Paulo Rafael Ramalho 7 Jan 17, 2022
Thrust is a C++ parallel programming library which resembles the C++ Standard Library.

Thrust: Code at the speed of light Thrust is a C++ parallel programming library which resembles the C++ Standard Library. Thrust's high-level interfac

NVIDIA Corporation 4.2k Sep 17, 2022
jkds is a modern header-only C++20 library that complements the standard library.

jkds is a modern header-only C++20 library that complements the standard library. It provides generic atypical data structures, ergonomic functional programming abstractions, and then some.

Alberto Schiabel 5 May 24, 2022
Bionic BSD-3-ClauseBionic - Google's standard library, developed for Android. BSD-3-Clause

bionic bionic is Android's C library, math library, and dynamic linker. Using bionic as an app developer See the user documentation. Working on bionic

Android Open Source Project 553 Sep 12, 2022
CloudABI's standard C library

NOTE: This project is unmaintained CloudABI is no longer being maintained. It was an awesome experiment, but it never got enough traction to be sustai

Nuxi 272 Sep 15, 2022
libcu++: The C++ Standard Library for Your Entire System

libcu++, the NVIDIA C++ Standard Library, is the C++ Standard Library for your entire system. It provides a heterogeneous implementation of the C++ Standard Library that can be used in and between CPU and GPU code.

NVIDIA Corporation 2k Sep 19, 2022
An open source standard C library that includes useful functions && (Reimplementation of libc functions + own functions).

?? LIBFT-42 : Artistic view of LIBC: ?? HOW DOES IT FEEL HAVING YOUR OWN LIB: SUBJECT : ENGLISH PDF ℹ️ What is LIBFT : This project aims to code a C l

Abdessamad Laamimi 11 Sep 21, 2022
Your standard library for metaprogramming

Boost.Hana Your standard library for metaprogramming Overview #include <boost/hana.hpp> #include <cassert> #include <string> namespace hana = boost::h

Boost.org 1.4k Sep 22, 2022
Reimplementation of some of the Standard C Library functions.

42-libft Reimplementation of some of the Standard C Library functions. This repository contains some of the standard library C functions. List of avai

Lavrenova Maria 5 Jan 26, 2022
MSVC's implementation of the C++ Standard Library.

Microsoft's C++ Standard Library This is the official repository for Microsoft's implementation of the C++ Standard Library (also known as the STL), w

Microsoft 8.1k Sep 22, 2022
mlibc is a C standard library

mlibc is a C standard library Official Discord server: https://discord.gg/7WB6Ur3 Design of the library Directory Purpose options/ (More or less) OS-i

The Managarm Project 521 Sep 16, 2022
A standard conforming C++20 implementation of std::optional.

A standard conforming C++20 implementation of std::optional.

null 31 Aug 24, 2022
RTL - Reactive Template Library for C++

RTL - Reactive Template Library It solves all my C++ animation problems -- me Using RTL Lazy, caching, reactive variables

Lorents Odin Gravås 3 Dec 22, 2021
Modern C++ generic header-only template library.

nytl A lightweight and generic header-only template library for C++17. Includes various utility of all kind that i needed across multiple projects: Ex

Jan 94 Sep 15, 2022
A template C project using CMAKE, logging library and basic memory handling.

C Project template Aim of this Repository is to create a template repository for C executable projects with following properties: Cmake project Loggin

Aditya Singh Rathore 6 May 23, 2022
this lib with 26 template container and 10 kinds of algorithm, it is a good lib for study and usage

simple stl this lib simplify the achievement detail of common container, but add the container variety, the whole code partily follow Google Style. Em

wujiazheng 7 Mar 10, 2022
This is the template for peripheral projects using nRF5 SDK

NRF5_SDK template project About This is the template for peripheral projects using nRF5 SDK Getting Started To get a local copy up and running follow

Tai Nguyen 1 Nov 27, 2021
Code::Blocks template for custom launcher executable.

Launcher Code::Blocks template for custom launcher executables. This is a basic Code::Blocks project for creating authentic Windows executables. Inclu

Federico Cappelletti 1 Feb 5, 2022