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.

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
  • intrusive_slist is not implemented

    intrusive_slist is not implemented

    Documentation and header files for intrusive_slist exist, but the implementation is missing. This isn't documented anywhere except in a comment in the (empty) test file for intrusive_slist. Should either be implemented or disabled to prevent it from being used.

    opened by Woazboat 0
  • [MSVC][std:c++latest] EASTL build failed due to error C2666: 'TestLruCacheInternal::Foo::operator ==': overloaded functions have similar conversions

    [MSVC][std:c++latest] EASTL build failed due to error C2666: 'TestLruCacheInternal::Foo::operator ==': overloaded functions have similar conversions

    Description: After the MSVC team implented P2468R2 The Equality Operator You Are Looking For, we got a compiler error with /std:c++latest like below, the error is due to the operator== https://github.com/electronicarts/EASTL/blob/master/test/source/TestLruCache.cpp#L25 here needs a 'const'. Could you please look this issue? Thanks.

    F:\gitP\electronicarts\EASTL\test\source\TestLruCache.cpp(157,3): error C2666: 'TestLruCacheInternal::Foo::operator ==': overloaded functions have similar conversions [F:\gitP\electronicarts\EASTL\build_amd64\test\EASTLTest.vcxproj]
             TestRandom.cpp
           F:\gitP\electronicarts\EASTL\test\source\TestLruCache.cpp(25,8): message : could be 'bool TestLruCacheInternal::Foo::operator ==(const TestLruCacheInternal::Foo &)' [F:\gitP\electronicarts\EASTL\build_amd64\test\EASTLTest.vcxproj]
    

    Note: this issue will be reproduced on next release version of VS(VS17.6 or later)

    Repro steps:

    1. open VS2019 x64 tools command
    2. git clone https://github.com/electronicarts/EASTL F:\gitP\electronicarts\EASTL
    3. cd F:\gitP\electronicarts\EASTL
    4. mkdir build_amd64 & cd build_amd64
    5. set CL= /std:c++latest
    6. cmake -G "Visual Studio 16 2019" -A x64 -DCMAKE_SYSTEM_VERSION=10.0.18362.0 -DEASTL_BUILD_TESTS:BOOL=ON -DEASTL_BUILD_BENCHMARK:BOOL=OFF ..
    7. set CL=%CL% /Zc:static_assert- /Zc:char8_t-
    8. msbuild /m /p:Platform=x64 /p:Configuration=Release EASTL.sln /t:Rebuild

    Detailed log: build.log

    opened by Zhaojun-Liu 0
  • Building EASTL

    Building EASTL

    I experienced problems trying to build/link using the build downloaded by vcpkg

    1>ConsoleApplication1.obj : error LNK2001: unresolved external symbol "void * __cdecl operator new[](unsigned __int64,char const *,int,unsigned int,char const *,int)" ([email protected][email protected])
    1>ConsoleApplication1.obj : error LNK2001: unresolved external symbol "void * __cdecl operator new[](unsigned __int64,unsigned __int64,unsigned __int64,char const *,int,unsigned int,char const *,int)" ([email protected][email protected])
    

    I was able to compile & run from the github repo using @spacelg's steps, and do some testing from within the Test Suite. (Alternatively to @spacelg's step 7, you can open & build in Visual Studio).

    Would it be a good idea to incorporate @spacelg's build steps into README.md?

    I think it may be worth mentioning in the documentation that starting with the test suite is a great way to learn & get comfortable with EASTL.

    opened by superwills 0
  • Add automatic conversion between std::string_view and eastl::string_view

    Add automatic conversion between std::string_view and eastl::string_view

    While eastl containers are interoperable with std algorithms thanks to iterators, strings are typically not handled through iterators. Converting an eastl string to an std string is problematic and string_views are a better tool for this.

    This commit adds automatic conversion between std::string_view and eastl::string_view.

    The feature (and corresponding unit test) is guarded by EASTL_STRING_VIEW_STD_CONVERSION_ENABLED. Let me know where to add EASTL_STRING_VIEW_STD_CONVERSION_ENABLED such that it is correctly picked up by testing facilities.

    opened by W4RH4WK 0
  • Fix fixed_string resize within SSO capacity

    Fix fixed_string resize within SSO capacity

    As pointed out in #454, when fixed_string gets resized but capacity stays within SSO capacity the null-terminator gets copied over as well. The corresponding code assumes heap capacity is always greater than SSO capacity. fixed_string's internal buffer is handled as heap inside the string class and may, in fact, be <= SSO capacity.

    This commit fixes the described issue and adds a unit test for this specific case.

    opened by W4RH4WK 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.3k Dec 21, 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.5k Dec 28, 2022
KoanLogic 400 Dec 25, 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 24k Jan 1, 2023
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 Dec 29, 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.2k Dec 29, 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 Dec 10, 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 115 Dec 11, 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.7k Jan 1, 2023
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.6k Jan 5, 2023
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 345 Jan 5, 2023
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 40 Dec 29, 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 9.7k Dec 26, 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 173 Dec 7, 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.9k Dec 27, 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 45 Dec 19, 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 198 Nov 24, 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 63 Dec 20, 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 177 Jan 5, 2023