chrono_types Namespace Reference

Description

Namespace for custom make_shared implementation.

Classes
class	class_has_custom_new_operator
	Check if a class has a custom new operator. More...

Functions
template<typename T , typename... Args, typename std::enable_if< class_has_custom_new_operator< T >::value, int >::type = 0>
std::shared_ptr< T >	make_shared (Args &&... args)
	Replacement for make_shared guaranteed to use operator new rather than placement new in order to avoid memory alignment issues (classes with members that are fixed-sized Eigen matrices have overriden operator new). More...
template<typename T , typename... Args>
std::unique_ptr< T >	make_unique (Args &&... args)
	Replacement for make_unique guaranteed to use operator new rather than placement new in order to avoid memory alignment issues (classes with members that are fixed-sized Eigen matrices have overriden operator new). More...

Function Documentation

make_shared()

template<typename T , typename... Args, typename std::enable_if< class_has_custom_new_operator< T >::value, int >::type = 0>

std::shared_ptr< T > chrono_types::make_shared ( Args &&...  args )

inline

Replacement for make_shared guaranteed to use operator new rather than placement new in order to avoid memory alignment issues (classes with members that are fixed-sized Eigen matrices have overriden operator new).

For classes without members that are fixed-sized Eigen matrices (and hence do not have an overriden operator new), it is safe to default to using std::make_shared (no alignment issues).

Dynamic objects of classes with fixed-size vectorizable Eigen object members

• Many of the Chrono classes now have members that are fixed-size vectorizable Eigen types. These classes overload their operator new to generate 16-byte-aligned pointers (using an Eigen - provided macro).
• This requirement for aligned memory allocation has implications on creation of shared pointers. Indeed, std::make_shared uses placement new instead of operator new. To address this issue and preserve encapsulation (as much as possible), Chrono provides this for make_shared. This function will automatically infer if it can safely fallback on std::make_shared or else create a shared pointer with a mechanism that ensures use of aligned memory. As such, user code should always use chrono_types::make_shared as in

    auto my_body = chrono_types::make_shared<ChBody>();
    

make_unique()

template<typename T , typename... Args>

std::unique_ptr<T> chrono_types::make_unique ( Args &&...  args )

inline

Replacement for make_unique guaranteed to use operator new rather than placement new in order to avoid memory alignment issues (classes with members that are fixed-sized Eigen matrices have overriden operator new).

Note: Since std::make_unique was only introduced in C++14, the default C++11 implementation of chrono_types::make_unique