Classes
struct	supported

struct	has_is_flags

struct	has_is_flags< T, std::void_t< decltype(customize::enum_range< T >::is_flags)> >

struct	range_min

struct	range_min< T, std::void_t< decltype(customize::enum_range< T >::min)> >

struct	range_max

struct	range_max< T, std::void_t< decltype(customize::enum_range< T >::max)> >

class	static_string

class	static_string< 0 >

class	case_insensitive

struct	enable_if_enum

struct	enable_if_enum< true, R >

struct	is_scoped_enum

struct	is_scoped_enum< T, true >

struct	is_unscoped_enum

struct	is_unscoped_enum< T, true >

struct	underlying_type

struct	underlying_type< T, true >

struct	default_result_type

struct	identity

struct	nonesuch

struct	invoke_result

struct	invoke_result< F, V, true >

Typedefs
template<auto V, typename E = std::decay_t<decltype(V)>, std::enable_if_t< std::is_enum_v< E >, int > = 0>
using	enum_constant = std::integral_constant< E, V >

template<typename E , typename D = std::decay_t<E>>
using	values_t = decltype((values_v< D >))

template<typename E , typename D = std::decay_t<E>>
using	names_t = decltype((names_v< D >))

template<typename E , typename D = std::decay_t<E>>
using	entries_t = decltype((entries_v< D >))

template<typename T , typename R , typename BinaryPredicate = std::equal_to<>, typename D = std::decay_t<T>>
using	enable_if_t = typename enable_if_enum< std::is_enum_v< D > &&std::is_invocable_r_v< bool, BinaryPredicate, char, char >, R >::type

template<typename T , typename R , value_type VT, typename BinaryPredicate = std::equal_to<>, typename D = std::decay_t<T>>
using	enable_if_default_t = typename enable_if_enum< std::is_enum_v< D > &&VT==value_type::default_value &&std::is_invocable_r_v< bool, BinaryPredicate, char, char >, R >::type

template<typename T , typename R , value_type VT, typename BinaryPredicate = std::equal_to<>, typename D = std::decay_t<T>>
using	enable_if_flags_t = typename enable_if_enum< std::is_enum_v< D > &&VT==value_type::flags_value &&std::is_invocable_r_v< bool, BinaryPredicate, char, char >, R >::type

template<typename T , std::enable_if_t< std::is_enum_v< std::decay_t< T >>, int > = 0>
using	enum_concept = T

template<typename F , typename V >
using	invoke_result_t = typename invoke_result< F, V >::type

template<typename T , typename Result , typename F , typename D = std::decay_t<T>, typename R = typename decltype(result_type<D, Result, F>())::type>
using	result_t = std::enable_if_t< std::is_enum_v< D > &&!std::is_same_v< R, nonesuch >, R >

Enumerations
enum class	value_type { default_value , flags_value }

Functions
constexpr string_view	pretty_name (string_view name) noexcept

constexpr std::size_t	find (string_view str, char c) noexcept

template<typename T , std::size_t N, std::size_t... I>
constexpr std::array< std::remove_cv_t< T >, N >	to_array (T(&a)[N], std::index_sequence< I... >) noexcept

template<typename BinaryPredicate >
constexpr bool	is_default_predicate () noexcept

template<typename BinaryPredicate >
constexpr bool	is_nothrow_invocable ()

template<typename BinaryPredicate >
constexpr bool	cmp_equal (string_view lhs, string_view rhs, [[maybe_unused]] BinaryPredicate &&p) noexcept(is_nothrow_invocable< BinaryPredicate >())

template<typename L , typename R >
constexpr bool	cmp_less (L lhs, R rhs) noexcept

template<typename I >
constexpr I	log2 (I value) noexcept

template<typename E >
constexpr auto	n () noexcept

template<typename E >
constexpr auto	type_name () noexcept

template<typename E , E V>
constexpr auto	n () noexcept

template<typename E , E V>
constexpr auto	enum_name () noexcept

template<typename E , auto V>
constexpr bool	is_valid () noexcept

template<typename E , int O, bool IsFlags, typename U = std::underlying_type_t<E>>
constexpr U	ualue (std::size_t i) noexcept

template<typename E , int O, bool IsFlags, typename U = std::underlying_type_t<E>>
constexpr E	value (std::size_t i) noexcept

template<typename E , bool IsFlags, typename U = std::underlying_type_t<E>>
constexpr int	reflected_min () noexcept

template<typename E , bool IsFlags, typename U = std::underlying_type_t<E>>
constexpr int	reflected_max () noexcept

template<std::size_t N>
constexpr std::size_t	values_count (const bool(&valid)[N]) noexcept

template<typename E , bool IsFlags, int Min, std::size_t... I>
constexpr auto	values (std::index_sequence< I... >) noexcept

template<typename E , bool IsFlags, typename U = std::underlying_type_t<E>>
constexpr auto	values () noexcept

template<typename E , typename U = std::underlying_type_t<E>>
constexpr bool	is_flags_enum () noexcept

template<typename E , std::size_t... I>
constexpr auto	names (std::index_sequence< I... >) noexcept

template<typename E , std::size_t... I>
constexpr auto	entries (std::index_sequence< I... >) noexcept

template<typename E , typename U = std::underlying_type_t<E>>
constexpr bool	is_sparse () noexcept

template<typename E , typename U = std::underlying_type_t<E>>
constexpr U	values_ors () noexcept

template<typename E , typename F , std::size_t... I>
constexpr auto	for_each (F &&f, std::index_sequence< I... >)

template<typename E , typename F , std::size_t... I>
constexpr bool	all_invocable (std::index_sequence< I... >)

template<typename E >
constexpr optional< std::uintmax_t >	fuse_one_enum (optional< std::uintmax_t > hash, E value) noexcept

template<typename E >
constexpr optional< std::uintmax_t >	fuse_enum (E value) noexcept

template<typename E , typename... Es>
constexpr optional< std::uintmax_t >	fuse_enum (E head, Es... tail) noexcept

template<typename... Es>
constexpr auto	typesafe_fuse_enum (Es... values) noexcept

template<typename E , typename F , std::size_t... I>
constexpr auto	common_invocable (std::index_sequence< I... >) noexcept

template<typename E , typename Result , typename F >
constexpr auto	result_type () noexcept

template<typename R , typename F , typename... Args>
constexpr R	invoke_r (F &&f, Args &&... args) noexcept(std::is_nothrow_invocable_r_v< R, F, Args... >)

template<std::size_t I, std::size_t End, typename R , typename E , typename F , typename Def >
constexpr decltype(auto)	constexpr_switch_impl (F &&f, E value, Def &&def)

template<typename R , typename E , typename F , typename Def >
constexpr decltype(auto)	constexpr_switch (F &&f, E value, Def &&def)

Variables
template<typename... T>
constexpr bool	always_false_v = false

template<typename T >
constexpr bool	is_enum_v = std::is_enum_v<T> && std::is_same_v<T, std::decay_t<T>>

template<typename E >
constexpr auto	type_name_v = type_name<E>()

template<typename E , E V>
constexpr auto	enum_name_v = enum_name<E, V>()

template<typename E , bool IsFlags>
constexpr auto	reflected_min_v = reflected_min<E, IsFlags>()

template<typename E , bool IsFlags>
constexpr auto	reflected_max_v = reflected_max<E, IsFlags>()

template<typename E >
constexpr bool	is_flags_v = is_flags_enum<E>()

template<typename E >
constexpr std::array	values_v = values<E, is_flags_v<E>>()

template<typename E >
constexpr auto	count_v = values_v<E>.size()

template<typename E , typename U = std::underlying_type_t<E>>
constexpr auto	min_v = (count_v<E> > 0) ? static_cast<U>(values_v<E>.front()) : U{0}

template<typename E , typename U = std::underlying_type_t<E>>
constexpr auto	max_v = (count_v<E> > 0) ? static_cast<U>(values_v<E>.back()) : U{0}

template<typename E >
constexpr std::array	names_v = names<E>(std::make_index_sequence<count_v<E>>{})

template<typename E >
constexpr std::array	entries_v = entries<E>(std::make_index_sequence<count_v<E>>{})

template<typename E >
constexpr bool	is_sparse_v = is_sparse<E>()

template<typename T >
constexpr bool	has_hash = false

template<typename T = void>
constexpr auto	default_result_type_lambda

template<>
constexpr auto	default_result_type_lambda< void >

Typedef Documentation

◆ enable_if_default_t

template<typename T , typename R , value_type VT, typename BinaryPredicate = std::equal_to<>, typename D = std::decay_t<T>>

using magic_enum::detail::enable_if_default_t = typedef typename enable_if_enum<std::is_enum_v<D> && VT == value_type::default_value && std::is_invocable_r_v<bool, BinaryPredicate, char, char>, R>::type

◆ enable_if_flags_t

template<typename T , typename R , value_type VT, typename BinaryPredicate = std::equal_to<>, typename D = std::decay_t<T>>

using magic_enum::detail::enable_if_flags_t = typedef typename enable_if_enum<std::is_enum_v<D> && VT == value_type::flags_value && std::is_invocable_r_v<bool, BinaryPredicate, char, char>, R>::type

◆ enable_if_t

template<typename T , typename R , typename BinaryPredicate = std::equal_to<>, typename D = std::decay_t<T>>

using magic_enum::detail::enable_if_t = typedef typename enable_if_enum<std::is_enum_v<D> && std::is_invocable_r_v<bool, BinaryPredicate, char, char>, R>::type

◆ entries_t

template<typename E , typename D = std::decay_t<E>>

using magic_enum::detail::entries_t = typedef decltype((entries_v<D>) )

◆ enum_concept

template<typename T , std::enable_if_t< std::is_enum_v< std::decay_t< T >>, int > = 0>

using magic_enum::detail::enum_concept = typedef T

◆ enum_constant

template<auto V, typename E = std::decay_t<decltype(V)>, std::enable_if_t< std::is_enum_v< E >, int > = 0>

using magic_enum::detail::enum_constant = typedef std::integral_constant<E, V>

◆ invoke_result_t

template<typename F , typename V >

using magic_enum::detail::invoke_result_t = typedef typename invoke_result<F, V>::type

◆ names_t

template<typename E , typename D = std::decay_t<E>>

using magic_enum::detail::names_t = typedef decltype((names_v<D>) )

◆ result_t

template<typename T , typename Result , typename F , typename D = std::decay_t<T>, typename R = typename decltype(result_type<D, Result, F>())::type>

using magic_enum::detail::result_t = typedef std::enable_if_t<std::is_enum_v<D> && !std::is_same_v<R, nonesuch>, R>

◆ values_t

template<typename E , typename D = std::decay_t<E>>

using magic_enum::detail::values_t = typedef decltype((values_v<D>) )

Enumeration Type Documentation

◆ value_type

enum magic_enum::detail::value_type

strong

Enumerator
default_value
flags_value

Function Documentation

◆ all_invocable()

template<typename E , typename F , std::size_t... I>

constexpr bool magic_enum::detail::all_invocable ( std::index_sequence< I... > )

constexpr

◆ cmp_equal()

template<typename BinaryPredicate >

constexpr bool magic_enum::detail::cmp_equal	(	string_view	lhs,
		string_view	rhs,
		[[maybe_unused] ] BinaryPredicate &&	p
	)

constexprnoexcept

References size().

Here is the call graph for this function:

◆ cmp_less()

template<typename L , typename R >

constexpr bool magic_enum::detail::cmp_less	(	L	lhs,
		R	rhs
	)

constexprnoexcept

Referenced by reflected_max(), and reflected_min().

Here is the caller graph for this function:

◆ common_invocable()

template<typename E , typename F , std::size_t... I>

constexpr auto magic_enum::detail::common_invocable ( std::index_sequence< I... > )

constexprnoexcept

◆ constexpr_switch()

template<typename R , typename E , typename F , typename Def >

constexpr decltype(auto) magic_enum::detail::constexpr_switch	(	F &&	f,
		E	value,
		Def &&	def
	)

constexpr

References value().

Here is the call graph for this function:

◆ constexpr_switch_impl()

template<std::size_t I, std::size_t End, typename R , typename E , typename F , typename Def >

constexpr decltype(auto) magic_enum::detail::constexpr_switch_impl	(	F &&	f,
		E	value,
		Def &&	def
	)

constexpr

References value().

Here is the call graph for this function:

◆ entries()

template<typename E , std::size_t... I>

constexpr auto magic_enum::detail::entries ( std::index_sequence< I... > )

constexprnoexcept

Referenced by NES::Runtime::BloomFilter::BloomFilter().

Here is the caller graph for this function:

◆ enum_name()

template<typename E , E V>

constexpr auto magic_enum::detail::enum_name ( )

constexprnoexcept

References magic_enum::customize::detail::custom_tag, magic_enum::customize::detail::default_tag, magic_enum::customize::detail::invalid_tag, and magic_enum::detail::static_string< N >::size().

Here is the call graph for this function:

◆ find()

constexpr std::size_t magic_enum::detail::find	(	string_view	str,
		char	c
	)

constexprnoexcept

Referenced by cuckoohash_map< Key, T, Hash, KeyEqual, Allocator, SLOT_PER_BUCKET >::locked_table::at(), cuckoohash_map< Key, T, Hash, KeyEqual, Allocator, SLOT_PER_BUCKET >::locked_table::equal_range(), NES::Schema::getQualifierNameForSystemGeneratedFields(), NES::Schema::getSourceNameQualifier(), main(), NES::Runtime::Execution::StreamJoinQuerySharedExecutionTest::miniShuffleHelper(), NES::Runtime::Execution::ExecutableQueryPlan::notifyPipelineCompletion(), NES::Runtime::Execution::ExecutableQueryPlan::notifySinkCompletion(), NES::Runtime::Execution::ExecutableQueryPlan::notifySourceCompletion(), cuckoohash_map< Key, T, Hash, KeyEqual, Allocator, SLOT_PER_BUCKET >::locked_table::operator!=(), cuckoohash_map< Key, T, Hash, KeyEqual, Allocator, SLOT_PER_BUCKET >::locked_table::operator==(), NES::Runtime::Execution::StreamJoinQuerySharedExecutionTest::printDifference(), NES::CoordinatorHealthCheckService::startHealthCheck(), NES::Spatial::TEST_F(), and NES::TEST_F().

Here is the caller graph for this function:

◆ for_each()

template<typename E , typename F , std::size_t... I>

constexpr auto magic_enum::detail::for_each	(	F &&	f,
		std::index_sequence< I... >
	)

constexpr

Referenced by cleanUpPlan().

Here is the caller graph for this function:

◆ fuse_enum() [1/2]

template<typename E , typename... Es>

constexpr optional<std::uintmax_t> magic_enum::detail::fuse_enum	(	E	head,
		Es...	tail
	)

constexprnoexcept

References fuse_enum(), and fuse_one_enum().

Here is the call graph for this function:

◆ fuse_enum() [2/2]

template<typename E >

constexpr optional<std::uintmax_t> magic_enum::detail::fuse_enum ( E value )

constexprnoexcept

References fuse_one_enum(), and value().

Referenced by fuse_enum(), and typesafe_fuse_enum().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fuse_one_enum()

template<typename E >

constexpr optional<std::uintmax_t> magic_enum::detail::fuse_one_enum	(	optional< std::uintmax_t >	hash,
		E	value
	)

constexprnoexcept

References magic_enum::enum_index(), index, log2(), and value().

Referenced by fuse_enum().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ invoke_r()

template<typename R , typename F , typename... Args>

constexpr R magic_enum::detail::invoke_r	(	F &&	f,
		Args &&...	args
	)

constexprnoexcept

◆ is_default_predicate()

template<typename BinaryPredicate >

constexpr bool magic_enum::detail::is_default_predicate ( )

constexprnoexcept

◆ is_flags_enum()

template<typename E , typename U = std::underlying_type_t<E>>

constexpr bool magic_enum::detail::is_flags_enum ( )

constexprnoexcept

◆ is_nothrow_invocable()

template<typename BinaryPredicate >

constexpr bool magic_enum::detail::is_nothrow_invocable ( )

constexpr

◆ is_sparse()

template<typename E , typename U = std::underlying_type_t<E>>

constexpr bool magic_enum::detail::is_sparse ( )

constexprnoexcept

References log2().

Here is the call graph for this function:

◆ is_valid()

template<typename E , auto V>

constexpr bool magic_enum::detail::is_valid ( )

constexprnoexcept

References magic_enum::customize::detail::custom_tag, and magic_enum::customize::detail::default_tag.

◆ log2()

template<typename I >

constexpr I magic_enum::detail::log2 ( I value )

constexprnoexcept

References value().

Referenced by magic_enum::enum_fuse(), magic_enum::enum_value(), fuse_one_enum(), and is_sparse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ n() [1/2]

template<typename E >

constexpr auto magic_enum::detail::n ( )

constexprnoexcept

References pretty_name().

Referenced by NES::ChunkCollector< NodeSize, Alignment >::collect(), jitify::parallel_for(), NES::Util::partition(), NES::Monitoring::CpuMetricsWrapper::readFromBuffer(), NES::Monitoring::NetworkMetricsWrapper::readFromBuffer(), cuckoohash_map< Key, T, Hash, KeyEqual, Allocator, SLOT_PER_BUCKET >::rehash(), cuckoohash_map< Key, T, Hash, KeyEqual, Allocator, SLOT_PER_BUCKET >::locked_table::rehash(), NES::Node::removeAndLevelUpChildren(), cuckoohash_map< Key, T, Hash, KeyEqual, Allocator, SLOT_PER_BUCKET >::reserve(), cuckoohash_map< Key, T, Hash, KeyEqual, Allocator, SLOT_PER_BUCKET >::locked_table::reserve(), and backward::StackTraceImplBase::skip_n_firsts().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ n() [2/2]

template<typename E , E V>

constexpr auto magic_enum::detail::n ( )

constexprnoexcept

References pretty_name().

Referenced by magic_enum::enum_name().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ names()

template<typename E , std::size_t... I>

constexpr auto magic_enum::detail::names ( std::index_sequence< I... > )

constexprnoexcept

◆ pretty_name()

constexpr string_view magic_enum::detail::pretty_name ( string_view name )

constexprnoexcept

Referenced by n().

Here is the caller graph for this function:

◆ reflected_max()

template<typename E , bool IsFlags, typename U = std::underlying_type_t<E>>

constexpr int magic_enum::detail::reflected_max ( )

constexprnoexcept

References cmp_less().

Here is the call graph for this function:

◆ reflected_min()

template<typename E , bool IsFlags, typename U = std::underlying_type_t<E>>

constexpr int magic_enum::detail::reflected_min ( )

constexprnoexcept

References cmp_less().

Here is the call graph for this function:

◆ result_type()

template<typename E , typename Result , typename F >

constexpr auto magic_enum::detail::result_type ( )

constexprnoexcept

References type.

◆ to_array()

template<typename T , std::size_t N, std::size_t... I>

constexpr std::array<std::remove_cv_t<T>, N> magic_enum::detail::to_array	(	T(&)	a[N],
		std::index_sequence< I... >
	)

constexprnoexcept

Referenced by values().

Here is the caller graph for this function:

◆ type_name()

template<typename E >

constexpr auto magic_enum::detail::type_name ( )

constexprnoexcept

References magic_enum::customize::detail::custom_tag, magic_enum::customize::detail::default_tag, magic_enum::customize::detail::invalid_tag, and magic_enum::detail::static_string< N >::size().

Here is the call graph for this function:

◆ typesafe_fuse_enum()

template<typename... Es>

constexpr auto magic_enum::detail::typesafe_fuse_enum ( Es... values )

constexprnoexcept

References fuse_enum().

Here is the call graph for this function:

◆ ualue()

template<typename E , int O, bool IsFlags, typename U = std::underlying_type_t<E>>

constexpr U magic_enum::detail::ualue ( std::size_t i )

constexprnoexcept

◆ value()

template<typename E , int O, bool IsFlags, typename U = std::underlying_type_t<E>>

constexpr E magic_enum::detail::value ( std::size_t i )

constexprnoexcept

Referenced by NES::QueryReconfigurationTest::addLogicalSourceAndCreatePhysicalSourceType(), NES::checkBinary(), NES::Runtime::JsonFormatTest::checkExpectedValue(), libcuckoo_bucket_container< Key, T, Allocator, Partial, SLOT_PER_BUCKET >::clear(), NES::TestUtils::configOption(), constexpr_switch(), constexpr_switch_impl(), NES::RequestProcessor::AddKeyDistributionEntryEvent::create(), NES::DataTypeFactory::createBasicValue(), NES::DistributedNemoJoinIntegrationTest::createTestHarness(), jitify::experimental::serialization::detail::deserialize(), NES::DataTypeSerializationUtil::deserializeDataValue(), NES::Sequencing::NonBlockingMonotonicSeqQueue< T, BlockSize >::emplace(), NES::NonBlockingMonotonicSeqQueueTest::emplaceInMockupQueue(), NES::REST::Controller::SourceCatalogController::ENDPOINT(), magic_enum::enum_cast(), magic_enum::enum_contains(), magic_enum::enum_flags_cast(), magic_enum::enum_flags_contains(), magic_enum::enum_flags_name(), magic_enum::enum_index(), magic_enum::enum_integer(), magic_enum::enum_name(), magic_enum::enum_switch(), magic_enum::enum_underlying(), NES::Network::ExchangeProtocol::ExchangeProtocol(), fuse_enum(), fuse_one_enum(), jitify::KernelInstantiation::get_global_value(), jitify::experimental::KernelInstantiation::get_global_value(), NES::Sequencing::NonBlockingMonotonicSeqQueue< T, BlockSize >::getCurrentValue(), NES::getLogLevel(), NES::getLogName(), NES::RequestProcessor::AddKeyDistributionEntryEvent::getValue(), NES::Monitoring::LinuxSystemResourcesReader::getWallTimeInNs(), jitify::reflection::instance_of(), NES::InvalidArgumentException::InvalidArgumentException(), NES::BasicValue::isEquals(), NES::Runtime::JsonFormatTest::isInJsonObject(), libcuckoo_bucket_container< Key, T, Allocator, Partial, SLOT_PER_BUCKET >::libcuckoo_bucket_container(), log2(), Yaml::Node::Node(), operator""_s16(), operator""_s32(), operator""_s64(), operator""_s8(), operator""_u16(), operator""_u32(), operator""_u64(), operator""_u8(), Yaml::Node::operator=(), magic_enum::istream_operators::operator>>(), NES::CircularBuffer< T, Allocator, >::push(), NES::TestHarness::pushElement(), NES::RequestHandlerService::queueAddKeyDistributionEntryRequest(), NES::DefaultSource::receiveData(), jitify::reflection::reflect(), NES::Runtime::MemoryLayouts::DynamicField::requires(), NES::TestHarness::runQuery(), NES::ReconfigurationMarkerSerializationUtil::serialize(), jitify::experimental::serialization::detail::serialize(), NES::DataTypeSerializationUtil::serializeDataValue(), jitify::KernelInstantiation::set_func_attribute(), jitify::experimental::KernelInstantiation::set_func_attribute(), jitify::KernelInstantiation::set_global_value(), jitify::experimental::KernelInstantiation::set_global_value(), NES::Runtime::TupleBuffer::setCreationTimestampInMS(), NES::Runtime::FormatIteratorTestUtil< ExpectedType >::setExpectedValue(), NES::Runtime::MemoryLayouts::TestTupleBuffer::setNumberOfTuples(), NES::DataSource::setSourceSharing(), NES::TestHarness::setupTopology(), NES::Runtime::TupleBuffer::setWatermark(), NES::TEST_F(), TEST_F(), NES::TEST_P(), NES::Network::TestSink::writeData(), NES::Parser::writeFieldValueToTupleBuffer(), NES::Runtime::MemoryLayouts::DynamicTuple::writeVarSized(), and NES::Runtime::MemoryLayouts::writeVarSizedData().

◆ values() [1/2]

template<typename E , bool IsFlags, typename U = std::underlying_type_t<E>>

constexpr auto magic_enum::detail::values ( )

constexprnoexcept

◆ values() [2/2]

template<typename E , bool IsFlags, int Min, std::size_t... I>

constexpr auto magic_enum::detail::values ( std::index_sequence< I... > )

constexprnoexcept

References to_array(), and values_count().

Referenced by NES::DataTypeFactory::createArrayValueFromContainerType(), NES::DataTypeFactory::createArrayValueWithContainedType(), NES::DataTypeFactory::createFixedCharValue(), jitify::experimental::serialization::deserialize(), NES::DataTypeSerializationUtil::deserializeDataValue(), magic_enum::enum_fuse(), NES::SchemaTest::getRandomFields(), NES::ArrayValue::isEquals(), NES::Util::numberOfUniqueValues(), NES::Runtime::FormatIteratorTestUtil< ExpectedType >::processTuple(), NES::Runtime::FormatIteratorTestUtil< ExpectedType >::processTuples(), NES::Runtime::FormatIteratorTestUtil< ExpectedType >::processTuplesWithString(), NES::Runtime::FormatIteratorTestUtil< ExpectedType >::processTupleWithString(), NES::CircularBuffer< T, Allocator, >::push(), jitify::experimental::serialization::serialize(), and NES::CSVParser::writeInputTupleToTupleBuffer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ values_count()

template<std::size_t N>

constexpr std::size_t magic_enum::detail::values_count ( const bool(&) valid[N] )

constexprnoexcept

Referenced by values().

Here is the caller graph for this function:

◆ values_ors()

template<typename E , typename U = std::underlying_type_t<E>>

constexpr U magic_enum::detail::values_ors ( )

constexprnoexcept

Variable Documentation

◆ always_false_v

template<typename... T>

constexpr bool magic_enum::detail::always_false_v = false

inlineconstexpr

◆ count_v

template<typename E >

constexpr auto magic_enum::detail::count_v = values_v<E>.size()

inlineconstexpr

◆ default_result_type_lambda

template<typename T = void>

constexpr auto magic_enum::detail::default_result_type_lambda

inlineconstexpr

Initial value:

= []() noexcept(std::is_nothrow_default_constructible_v<T>) {
    return T{};
}

Referenced by magic_enum::enum_cast().

◆ default_result_type_lambda< void >

template<>

constexpr auto magic_enum::detail::default_result_type_lambda< void >

inlineconstexpr

Initial value:

= []() noexcept {

}

◆ entries_v

template<typename E >

constexpr std::array magic_enum::detail::entries_v = entries<E>(std::make_index_sequence<count_v<E>>{})

inlineconstexpr

◆ enum_name_v

template<typename E , E V>

constexpr auto magic_enum::detail::enum_name_v = enum_name<E, V>()

inlineconstexpr

Referenced by magic_enum::enum_name().

◆ has_hash

template<typename T >

constexpr bool magic_enum::detail::has_hash = false

inlineconstexpr

◆ is_enum_v

template<typename T >

constexpr bool magic_enum::detail::is_enum_v = std::is_enum_v<T> && std::is_same_v<T, std::decay_t<T>>

inlineconstexpr

Referenced by magic_enum::enum_fuse().

◆ is_flags_v

template<typename E >

constexpr bool magic_enum::detail::is_flags_v = is_flags_enum<E>()

inlineconstexpr

◆ is_sparse_v

template<typename E >

constexpr bool magic_enum::detail::is_sparse_v = is_sparse<E>()

inlineconstexpr

◆ max_v

template<typename E , typename U = std::underlying_type_t<E>>

constexpr auto magic_enum::detail::max_v = (count_v<E> > 0) ? static_cast<U>(values_v<E>.back()) : U{0}

inlineconstexpr

◆ min_v

template<typename E , typename U = std::underlying_type_t<E>>

constexpr auto magic_enum::detail::min_v = (count_v<E> > 0) ? static_cast<U>(values_v<E>.front()) : U{0}

inlineconstexpr

◆ names_v

template<typename E >

constexpr std::array magic_enum::detail::names_v = names<E>(std::make_index_sequence<count_v<E>>{})

inlineconstexpr

◆ reflected_max_v

template<typename E , bool IsFlags>

constexpr auto magic_enum::detail::reflected_max_v = reflected_max<E, IsFlags>()

inlineconstexpr

◆ reflected_min_v

template<typename E , bool IsFlags>

constexpr auto magic_enum::detail::reflected_min_v = reflected_min<E, IsFlags>()

inlineconstexpr

◆ type_name_v

template<typename E >

constexpr auto magic_enum::detail::type_name_v = type_name<E>()

inlineconstexpr

◆ values_v

template<typename E >

constexpr std::array magic_enum::detail::values_v = values<E, is_flags_v<E>>()

inlineconstexpr

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ enable_if_default_t

◆ enable_if_flags_t

◆ enable_if_t

◆ entries_t

◆ enum_concept

◆ enum_constant

◆ invoke_result_t

◆ names_t

◆ result_t

◆ values_t

Enumeration Type Documentation

◆ value_type

Function Documentation

◆ all_invocable()

◆ cmp_equal()

◆ cmp_less()

◆ common_invocable()

◆ constexpr_switch()

◆ constexpr_switch_impl()

◆ entries()

◆ enum_name()

◆ find()

◆ for_each()

◆ fuse_enum() [1/2]

◆ fuse_enum() [2/2]

◆ fuse_one_enum()

◆ invoke_r()

◆ is_default_predicate()

◆ is_flags_enum()

◆ is_nothrow_invocable()

◆ is_sparse()

◆ is_valid()

◆ log2()

◆ n() [1/2]

◆ n() [2/2]

◆ names()

◆ pretty_name()

◆ reflected_max()

◆ reflected_min()

◆ result_type()

◆ to_array()

◆ type_name()

◆ typesafe_fuse_enum()

◆ ualue()

◆ value()

◆ values() [1/2]

◆ values() [2/2]

◆ values_count()

◆ values_ors()

Variable Documentation

◆ always_false_v

◆ count_v

◆ default_result_type_lambda

◆ default_result_type_lambda< void >

◆ entries_v

◆ enum_name_v

◆ has_hash

◆ is_enum_v

◆ is_flags_v

◆ is_sparse_v

◆ max_v

◆ min_v

◆ names_v

◆ reflected_max_v

◆ reflected_min_v

◆ type_name_v

◆ values_v