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

Last update: Jan 3, 2023

Overview

EA Standard Template Library

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/3.15.00@

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

Frostbite - Electronic Arts - [https://www.ea.com/frostbite]

License

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

Comments

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

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

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
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
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

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
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

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
(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:

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.)

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
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

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

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
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:

open VS2019 x64 tools command

git clone https://github.com/electronicarts/EASTL F:\gitP\electronicarts\EASTL

cd F:\gitP\electronicarts\EASTL

mkdir build_amd64 & cd build_amd64

set CL= /std:c++latest

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 ..

set CL=%CL% /Zc:static_assert- /Zc:char8_t-

msbuild /m /p:Platform=x64 /p:Configuration=Release EASTL.sln /t:Rebuild

Detailed log: build.log
opened by Zhaojun-Liu 0
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)" (??_U@YAPEAX_KPEBDHI1H@Z) 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)" (??_U@YAPEAX_K00PEBDHI1H@Z)

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

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

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)

128-bit integral feature define fix (#393)
Source code(tar.gz)
Source code(zip)
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)

Fixed issue with SSO String unit tests.
Source code(tar.gz)
Source code(zip)