cxxaux.hh File Reference

Classes
struct	Id32
class	Persistent< Class >
struct	VirtualBase

Namespaces
namespace	Ase

Macros
#define	ASE_ABS(a)
#define	ASE_ALIGN(size, base)
#define	ASE_ALIGNED16(pointer)
#define	ASE_ALIGNMENT16(pointer)
#define	ASE_ARRAY_SIZE(array)
#define	ASE_ASSERT(expr)
#define	ASE_ASSERT_PARANOID(expr)
#define	ASE_ASSERT_RETURN(expr, ...)
#define	ASE_ASSERT_RETURN_UNREACHED(...)
#define	ASE_ASSERT_UNREACHED(...)
#define	ASE_ASSERT_WARN(expr)
#define	ASE_CLAMP(v, mi, ma)
#define	ASE_CLASS_NON_COPYABLE(ClassName)
#define	ASE_COLD
#define	ASE_CONSTRUCTOR
#define	ASE_CPP_PASTE2(a, b)
#define	ASE_CPP_PASTE2_(a, b)
#define	ASE_CPP_STRINGIFY(s)
#define	ASE_CPP_STRINGIFY_(s)
#define	ASE_DEFINE_FLAGS_ARITHMETIC(Enum)
#define	ASE_DEFINE_MAKE_SHARED(CLASS)
#define	ASE_DEPRECATED
#define	ASE_FORMAT(fx)
#define	ASE_HOT
#define	ASE_ISLIKELY(expr)
#define	ASE_MALLOC
#define	ASE_MAX(a, b)
#define	ASE_MAY_ALIAS
#define	ASE_MIN(a, b)
#define	ASE_NO_INSTRUMENT
#define	ASE_NOINLINE
#define	ASE_NORETURN
#define	ASE_PRINTF(fx, ax)
#define	ASE_PURE
#define	ASE_RETURN_UNLESS(cond, ...)
#define	ASE_SCANF(fx, ax)
#define	ASE_SENTINEL
#define	ASE_UNLIKELY(expr)
#define	ASE_UNUSED
#define	ASE_USE_RESULT
#define	ASE_USED
#define	ASE_WEAK

Typedefs
typedef int16_t	int16
typedef int32_t	int32
typedef int64_t	int64
typedef int8_t	int8
template<bool value>
using	REQUIRES = typename ::std::enable_if< value, bool >::type
template<bool value>
using	REQUIRESv = typename ::std::enable_if< value, void >::type
using	String = std::string
using	StringPair = std::pair< std::string, std::string >
using	StringS = std::vector< String >
typedef uint32_t	uint
typedef uint16_t	uint16
typedef uint32_t	uint32
typedef uint64_t	uint64
typedef uint8_t	uint8
typedef uint32_t	unichar
using	VirtualBaseP = std::shared_ptr< VirtualBase >
using	VoidF = std::function< void()>

Functions
void	assertion_failed (const char *msg, const char *file, int line, const char *func) noexcept
void	assertion_fatal (const char *msg, const char *file, int line, const char *func) noexcept
std::string	backtrace_command ()
template<class T >
void	call_delete (T *o)
constexpr bool	constexpr_equals (const char *a, const char *b, size_t n)
template<class Target , class Source >
const std::shared_ptr< typename std::remove_pointer< Target >::type >	shared_ptr_cast (const Source *object)
template<class Target , class Source >
const std::shared_ptr< typename std::remove_pointer< Target >::type >	shared_ptr_cast (const std::shared_ptr< Source > &sptr)
template<class Target , class Source >
std::shared_ptr< typename std::remove_pointer< Target >::type >	shared_ptr_cast (Source *object)
template<class Target , class Source >
std::shared_ptr< typename std::remove_pointer< Target >::type >	shared_ptr_cast (std::shared_ptr< Source > &sptr)
template<class Source >
std::shared_ptr< typename std::remove_pointer< Source >::type >	shared_ptr_from (Source *object)
const char *	string_demangle_cxx (const char *mangled_identifier) noexcept
template<class C >
std::shared_ptr< C >	weak_ptr_fetch_or_create (std::weak_ptr< C > &wptr, const std::function< std::shared_ptr< C >()> &ctor)

Variables
Ts &&	args

Macro Definition Documentation

ASE_CPP_STRINGIFY

#define ASE_CPP_STRINGIFY

(

s

)

Convert macro argument into a C const char*.

ASE_CPP_STRINGIFY_

#define ASE_CPP_STRINGIFY_

(

s

)

ASE_CPP_PASTE2_

#define ASE_CPP_PASTE2_	(		a,
			b
	)

ASE_CPP_PASTE2

#define ASE_CPP_PASTE2	(		a,
			b
	)

Paste two macro arguments into one C symbol name.

ASE_ISLIKELY

#define ASE_ISLIKELY

(

expr

)

Compiler hint to optimize for expr evaluating to true.

ASE_UNLIKELY

#define ASE_UNLIKELY

(

expr

)

Compiler hint to optimize for expr evaluating to false.

ASE_ABS

#define ASE_ABS

(

a

)

Yield the absolute value of a.

ASE_MIN

#define ASE_MIN	(		a,
			b
	)

Yield the smaller value of a and b.

ASE_MAX

#define ASE_MAX	(		a,
			b
	)

Yield the greater value of a and b.

ASE_CLAMP

#define ASE_CLAMP	(		v,
			mi,
			ma
	)

Yield v clamped to [ mi .. ma ].

ASE_ARRAY_SIZE

#define ASE_ARRAY_SIZE

(

array

)

Yield the number of C array elements.

ASE_ALIGN

#define ASE_ALIGN	(		size,
			base
	)

Round up size to multiples of base.

ASE_ALIGNMENT16

#define ASE_ALIGNMENT16

(

pointer

)

ASE_ALIGNED16

#define ASE_ALIGNED16

(

pointer

)

ASE_COLD

#define ASE_COLD

ASE_CONSTRUCTOR

#define ASE_CONSTRUCTOR

ASE_DEPRECATED

#define ASE_DEPRECATED

ASE_FORMAT

#define ASE_FORMAT

(

fx

)

ASE_HOT

#define ASE_HOT

ASE_MALLOC

#define ASE_MALLOC

ASE_MAY_ALIAS

#define ASE_MAY_ALIAS

ASE_NOINLINE

#define ASE_NOINLINE

ASE_NORETURN

#define ASE_NORETURN

ASE_NO_INSTRUMENT

#define ASE_NO_INSTRUMENT

ASE_PRINTF

#define ASE_PRINTF	(		fx,
			ax
	)

ASE_PURE

#define ASE_PURE

ASE_SCANF

#define ASE_SCANF	(		fx,
			ax
	)

ASE_SENTINEL

#define ASE_SENTINEL

ASE_UNUSED

#define ASE_UNUSED

ASE_USE_RESULT

#define ASE_USE_RESULT

ASE_USED

#define ASE_USED

ASE_WEAK

#define ASE_WEAK

ASE_RETURN_UNLESS

#define ASE_RETURN_UNLESS	(		cond,
			...
	)

Return silently if cond does not evaluate to true, with return value ...

ASE_ASSERT_RETURN

#define ASE_ASSERT_RETURN	(		expr,
			...
	)

Return from the current function if `expr` evaluates to false and issue an assertion warning.

ASE_ASSERT_RETURN_UNREACHED

#define ASE_ASSERT_RETURN_UNREACHED

(

...

)

Return from the current function and issue an assertion warning.

ASE_ASSERT_UNREACHED

#define ASE_ASSERT_UNREACHED

(

...

)

Abort and issue an assertion error.

ASE_ASSERT

#define ASE_ASSERT

(

expr

)

Issue an assertion warning if `expr` evaluates to false.

ASE_ASSERT_WARN

#define ASE_ASSERT_WARN

(

expr

)

Issue an assertion warning if `expr` evaluates to false.

ASE_ASSERT_PARANOID

#define ASE_ASSERT_PARANOID

(

expr

)

Like ASE_ASSERT_WARN(), enabled if expensive `expr` are allowed.

ASE_CLASS_NON_COPYABLE

#define ASE_CLASS_NON_COPYABLE

(

ClassName

)

Delete copy ctor and assignment operator.

ASE_DEFINE_FLAGS_ARITHMETIC

#define ASE_DEFINE_FLAGS_ARITHMETIC

(

Enum

)

ASE_DEFINE_MAKE_SHARED

#define ASE_DEFINE_MAKE_SHARED

(

CLASS

)

Define a member function `static shared_ptr<CLASS> make_shared(ctorargs...);`. As member function, access to a private dtor and ctors is granted, so no std::allocator friend declaration is needed to define `make_shared()` for its own class.