stringToEnum

Returns the variant of an enum type, T, which is named str, or null if no such variant exists.

Function parameters

Parameters

T:type
str:[]const u8

Functions in this namespace

Functions

TrailerFlags
stringToEnum: Returns the variant of an enum type, `T`, which is named `str`, or `null` if no such variant exists.
alignment: Returns the alignment of type T.
Child: Given a parameterized type (array, vector, pointer, optional), returns the "child type".
Elem: Given a "memory span" type (array, slice, vector, or pointer to such), returns the "element type".
sentinel: Given a type which can have a sentinel e.g.
Sentinel: Given a "memory span" type, returns the same type except with the given sentinel value.
containerLayout
declarations: Instead of this function, prefer to use e.g.
declarationInfo
fields
fieldInfo
fieldNames
tags: Given an enum or error set type, returns a pointer to an array containing all tags for that
FieldEnum: Returns an enum with a variant named after each field of `T`.
DeclEnum
Tag
activeTag: Returns the active tag of a tagged union
TagPayloadByName: Deprecated: Use @FieldType(U, tag_name)
TagPayload: Deprecated: Use @FieldType(U, @tagName(tag))
eql: Compares two of any type for equality.
intToEnum: Deprecated: use `std.enums.fromInt` instead and handle null instead of an error.
fieldIndex: Given a type and a name, return the field index according to source order.
declList: Returns a slice of pointers to public declarations of a namespace.
Int
Float
ArgsTuple: For a given function type, returns a tuple type which fields will
Tuple: For a given anonymous list of types, returns a new tuple type
isError: Returns whether `error_union` contains an error.
hasFn: Returns true if a type has a namespace and the namespace contains `name`;
hasMethod: Returns true if a type has a `name` method; `false` otherwise.
hasUniqueRepresentation: True if every value of the type `T` has a unique bit pattern representing it.

Error sets in this namespace

Error Sets

IntToEnumError: Deprecated: use `std.enums.fromInt` instead and handle null.

Source

Implementation

pub fn stringToEnum(comptime T: type, str: []const u8) ?T {
    // Using StaticStringMap here is more performant, but it will start to take too
    // long to compile if the enum is large enough, due to the current limits of comptime
    // performance when doing things like constructing lookup maps at comptime.
    // TODO The '100' here is arbitrary and should be increased when possible:
    // - https://github.com/ziglang/zig/issues/4055
    // - https://github.com/ziglang/zig/issues/3863
    if (@typeInfo(T).@"enum".fields.len <= 100) {
        const kvs = comptime build_kvs: {
            const EnumKV = struct { []const u8, T };
            var kvs_array: [@typeInfo(T).@"enum".fields.len]EnumKV = undefined;
            for (@typeInfo(T).@"enum".fields, 0..) |enumField, i| {
                kvs_array[i] = .{ enumField.name, @field(T, enumField.name) };
            }
            break :build_kvs kvs_array[0..];
        };
        const map = std.StaticStringMap(T).initComptime(kvs);
        return map.get(str);
    } else {
        inline for (@typeInfo(T).@"enum".fields) |enumField| {
            if (mem.eql(u8, str, enumField.name)) {
                return @field(T, enumField.name);
            }
        }
        return null;
    }
}