protoenum

package module
v0.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 10, 2026 License: MIT Imports: 5 Imported by: 0

README

GitHub Workflow Status (branch) GoDoc Coverage Status Supported Go Versions GitHub Release Go Report Card

protoenum

protoenum provides utilities to manage Protobuf enum metadata in Go. It bridges Protobuf enums with Go native enums (type StatusType string) via the Basic() method, and offers enum collections with simple code, name, and basic-value lookups.

CHINESE README

中文说明

Core Features

🎯 Smart Enum Management: Wrap Protobuf enums with Go native enums and custom metadata 🔗 Go Native Enum Bridge: Seamless conversion via Basic() method to Go native enum types ⚡ Multi-Lookup Support: Fast code, name, and basic-value lookups 🔄 Type-Safe Operations: Triple generics maintain strict type checks across protobuf, Go native enums, and metadata 🛡️ Strict Design: Single usage pattern prevents misuse with required defaults 🌍 Production Grade: Battle-tested enum handling in enterprise applications

Installation

go get github.com/yylego/protoenum

Quick Start

Define Proto Enum

The project includes example proto files:

  • protoenumstatus.proto - Basic status enum
  • protoenumresult.proto - Test result enum
Basic Collection Usage
package main

import (
	"github.com/yylego/protoenum"
	"github.com/yylego/protoenum/protos/protoenumstatus"
	"github.com/yylego/zaplog"
	"go.uber.org/zap"
)

// StatusType represents a Go native enum of status
// StatusType 代表状态的 Go 原生枚举
type StatusType string

const (
	StatusTypeUnknown StatusType = "unknown"
	StatusTypeSuccess StatusType = "success"
	StatusTypeFailure StatusType = "failure"
)

// Build status enum collection
// 构建状态枚举集合
var enums = protoenum.NewEnums(
	protoenum.NewEnum(protoenumstatus.StatusEnum_UNKNOWN, StatusTypeUnknown),
	protoenum.NewEnum(protoenumstatus.StatusEnum_SUCCESS, StatusTypeSuccess),
	protoenum.NewEnum(protoenumstatus.StatusEnum_FAILURE, StatusTypeFailure),
)

func main() {
	// Get Go native enum from protobuf enum (returns default when not found)
	// 从 protobuf 枚举获取 Go 原生枚举（找不到时返回默认值）
	item := enums.GetByCode(int32(protoenumstatus.StatusEnum_SUCCESS))
	zaplog.LOG.Debug("basic", zap.String("msg", string(item.Basic())))

	// Convert between protoenum and native enum (safe with default fallback)
	// 在 protoenum 和原生枚举之间转换（安全且有默认值回退）
	enum := enums.GetByName("SUCCESS")
	base := protoenumstatus.StatusEnum(enum.Code())
	zaplog.LOG.Debug("base", zap.String("msg", base.String()))

	// Use in business logic
	// 在业务逻辑中使用
	if base == protoenumstatus.StatusEnum_SUCCESS {
		zaplog.LOG.Debug("done")
	}

	// Get default basic enum value (first item becomes default)
	// 获取默认 basic 枚举值（第一个元素成为默认值）
	defaultBasic := enums.GetDefaultBasic()
	zaplog.LOG.Debug("default", zap.String("msg", string(defaultBasic)))
}

⬆️ Source: Source

Advanced Lookup Methods
package main

import (
	"github.com/yylego/protoenum"
	"github.com/yylego/protoenum/protos/protoenumresult"
	"github.com/yylego/zaplog"
	"go.uber.org/zap"
)

// ResultType represents a Go native enum of result
// ResultType 代表结果的 Go 原生枚举
type ResultType string

const (
	ResultTypeUnknown ResultType = "unknown"
	ResultTypePass    ResultType = "pass"
	ResultTypeMiss    ResultType = "miss"
	ResultTypeSkip    ResultType = "skip"
)

// Build enum collection with description
// 构建带描述的枚举集合
var enums = protoenum.NewEnums(
	protoenum.NewEnumWithDesc(protoenumresult.ResultEnum_UNKNOWN, ResultTypeUnknown, "其它"),
	protoenum.NewEnumWithDesc(protoenumresult.ResultEnum_PASS, ResultTypePass, "通过"),
	protoenum.NewEnumWithDesc(protoenumresult.ResultEnum_MISS, ResultTypeMiss, "出错"),
	protoenum.NewEnumWithDesc(protoenumresult.ResultEnum_SKIP, ResultTypeSkip, "跳过"),
)

func main() {
	// Lookup using enum code (returns default when not found)
	// 按枚举代码查找（找不到时返回默认值）
	skip := enums.GetByCode(int32(protoenumresult.ResultEnum_SKIP))
	zaplog.LOG.Debug("basic", zap.String("msg", string(skip.Basic())))
	zaplog.LOG.Debug("desc", zap.String("msg", skip.Meta().Desc()))

	// Lookup using Go native enum value (type-safe)
	// 按 Go 原生枚举值查找（类型安全查找）
	pass := enums.GetByBasic(ResultTypePass)
	base := protoenumresult.ResultEnum(pass.Code())
	zaplog.LOG.Debug("base", zap.String("msg", base.String()))

	// Business logic with native enum
	// 使用原生枚举的业务逻辑
	if base == protoenumresult.ResultEnum_PASS {
		zaplog.LOG.Debug("pass")
	}

	// Lookup using enum name (safe with default fallback)
	// 按枚举名称查找（安全且有默认值回退）
	miss := enums.GetByName("MISS")
	zaplog.LOG.Debug("basic", zap.String("msg", string(miss.Basic())))
	zaplog.LOG.Debug("desc", zap.String("msg", miss.Meta().Desc()))

	// List each basic enum value in defined sequence
	// 按定义次序列出各 basic 枚举值
	basics := enums.ListBasics()
	for _, basic := range basics {
		zaplog.LOG.Debug("list", zap.String("basic", string(basic)))
	}
}

⬆️ Source: Source

API Reference

Single Enum Operations
Method Description Returns
NewEnum(protoEnum, basicEnum) Create enum instance without metadata *Enum[P, B, *MetaNone]
NewEnumWithDesc(protoEnum, basicEnum, desc) Create enum instance with description *Enum[P, B, *MetaDesc]
NewEnumWithMeta(protoEnum, basicEnum, meta) Create enum instance with custom metadata *Enum[P, B, M]
enum.Proto() Get underlying protobuf enum P
enum.Code() Get numeric code int32
enum.Name() Get enum name string
enum.Basic() Get Go native enum value B
enum.Meta() Get custom metadata M
Collection Creation
Method Description Returns
NewEnums(items...) Create collection with strict validation (first item becomes default) *Enums[P, B, M]
Existence Check (Lookup)
Method Description Returns
enums.LookupByProto(proto) Lookup by protobuf enum, check existence (*Enum[P, B, M], bool)
enums.LookupByCode(code) Lookup by code, check existence (*Enum[P, B, M], bool)
enums.LookupByName(name) Lookup by name, check existence (*Enum[P, B, M], bool)
enums.LookupByBasic(basic) Lookup by Go native enum, check existence (*Enum[P, B, M], bool)
Safe Access (Get)
Method Description Returns
enums.GetByProto(proto) Get by protobuf enum (returns default if not found, panics if no default) *Enum[P, B, M]
enums.GetByCode(code) Get by code (returns default if not found, panics if no default) *Enum[P, B, M]
enums.GetByName(name) Get by name (returns default if not found, panics if no default) *Enum[P, B, M]
enums.GetByBasic(basic) Get by Go native enum (returns default if not found, panics if no default) *Enum[P, B, M]
Strict Access (MustGet)
Method Description Returns
enums.MustGetByProto(proto) Strict get by protobuf enum (panics if not found) *Enum[P, B, M]
enums.MustGetByCode(code) Strict get by code (panics if not found) *Enum[P, B, M]
enums.MustGetByName(name) Strict get by name (panics if not found) *Enum[P, B, M]
enums.MustGetByBasic(basic) Strict get by Go native enum (panics if not found) *Enum[P, B, M]
Enumeration (List)
Method Description Returns
enums.ListProtos() Returns a slice of each protoEnum value []P
enums.ListBasics() Returns a slice of each basicEnum value []B
enums.ListValidProtos() Returns protoEnum values excluding default []P
enums.ListValidBasics() Returns basicEnum values excluding default []B
Default Value Management
Method Description Returns
enums.GetDefault() Get current default value (panics if unset) *Enum[P, B, M]
enums.GetDefaultProto() Get default protoEnum value (panics if unset) P
enums.GetDefaultBasic() Get default basicEnum value (panics if unset) B
enums.SetDefault(enum) Set default (requires no existing default) void
enums.UnsetDefault() Remove default (requires existing default) void
enums.WithDefault(enum) Chain: set default by enum instance *Enums[P, B, M]
enums.WithDefaultCode(code) Chain: set default by code (panics if not found) *Enums[P, B, M]
enums.WithDefaultName(name) Chain: set default by name (panics if not found) *Enums[P, B, M]
enums.WithUnsetDefault() Chain: remove default value *Enums[P, B, M]

Examples

Working with Single Enums

Creating enhanced enum instance:

type StatusType string
const StatusTypeSuccess StatusType = "success"

statusEnum := protoenum.NewEnumWithDesc(protoenumstatus.StatusEnum_SUCCESS, StatusTypeSuccess, "操作成功")
fmt.Printf("Code: %d, Name: %s, Basic: %s, Description: %s\n",
    statusEnum.Code(), statusEnum.Name(), statusEnum.Basic(), statusEnum.Meta().Desc())

Accessing underlying protobuf enum:

originalEnum := statusEnum.Proto()
if originalEnum == protoenumstatus.StatusEnum_SUCCESS {
    fmt.Println("Success status detected")
}
Collection Operations

Building enum collections:

type StatusType string
const (
    StatusTypeUnknown StatusType = "unknown"
    StatusTypeSuccess StatusType = "success"
    StatusTypeFailure StatusType = "failure"
)

statusEnums := protoenum.NewEnums(
    protoenum.NewEnumWithDesc(protoenumstatus.StatusEnum_UNKNOWN, StatusTypeUnknown, "未知状态"),
    protoenum.NewEnumWithDesc(protoenumstatus.StatusEnum_SUCCESS, StatusTypeSuccess, "成功"),
    protoenum.NewEnumWithDesc(protoenumstatus.StatusEnum_FAILURE, StatusTypeFailure, "失败"),
)

Multiple lookup methods:

// Using numeric code - returns valid enum (default if not found)
enum := statusEnums.GetByCode(1)
fmt.Printf("Found: %s\n", enum.Meta().Desc())

// Using enum name - guaranteed non-nil
enum = statusEnums.GetByName("SUCCESS")
fmt.Printf("Status: %s\n", enum.Meta().Desc())

// Using Go native enum value - type-safe lookup
enum = statusEnums.GetByBasic(StatusTypeSuccess)
fmt.Printf("Basic: %s\n", enum.Basic())

// Strict lookup - panics if not found (no default fallback)
enum = statusEnums.MustGetByCode(1)
fmt.Printf("Strict: %s\n", enum.Meta().Desc())

Listing values:

// Get a slice of each registered proto enum
protoEnums := statusEnums.ListProtos()
// > [UNKNOWN, SUCCESS, FAILURE]

// Get a slice of each registered basic Go enum
basicEnums := statusEnums.ListBasics()
// > ["unknown", "success", "failure"]

// Get valid values (excluding default)
validProtos := statusEnums.ListValidProtos()
// > [SUCCESS, FAILURE] (UNKNOWN is default, excluded)

validBasics := statusEnums.ListValidBasics()
// > ["success", "failure"]
Advanced Usage

Go native enum bridge via Basic():

type StatusType string
const (
    StatusTypeUnknown StatusType = "unknown"
    StatusTypeSuccess StatusType = "success"
)

// Bridge protobuf enum to Go native enum
enum := enums.GetByCode(1)
basicValue := enum.Basic()  // Returns StatusType("success")

// Use in business logic with Go native enum
switch basicValue {
case StatusTypeSuccess:
    fmt.Println("Operation succeeded")
case StatusTypeUnknown:
    fmt.Println("Unknown status")
}

// Lookup using Go native enum value
found := enums.GetByBasic(StatusTypeSuccess)
fmt.Printf("Code: %d, Name: %s\n", found.Code(), found.Name())

Type conversion patterns:

// Convert from enum instance to native protobuf enum
// Always returns valid enum (with default fallback)
statusEnum := enums.GetByName("SUCCESS")
native := protoenumstatus.StatusEnum(statusEnum.Code())
// Use native enum in protobuf operations with safe access

Strict validation patterns:

// Use MustGetByXxx with strict validation (panics if not found)
result := enums.MustGetByCode(1)  // Panics if code not in collection
fmt.Printf("Found: %s\n", result.Name())

// GetByXxx returns default on unknown values
result = enums.GetByCode(999)  // Returns default (UNKNOWN)
fmt.Printf("Fallback: %s\n", result.Name())
Default Values and Chain Configuration

Automatic default value (first item):

type StatusType string
const (
    StatusTypeUnknown StatusType = "unknown"
    StatusTypeSuccess StatusType = "success"
)

enums := protoenum.NewEnums(
    protoenum.NewEnumWithDesc(protoenumstatus.StatusEnum_UNKNOWN, StatusTypeUnknown, "未知"),
    protoenum.NewEnumWithDesc(protoenumstatus.StatusEnum_SUCCESS, StatusTypeSuccess, "成功"),
)
// First item (UNKNOWN) becomes default on creation
defaultEnum := enums.GetDefault()

Strict default management:

type StatusType string
const (
    StatusTypeUnknown StatusType = "unknown"
    StatusTypeSuccess StatusType = "success"
)

// Collections MUST have a default value
// NewEnums sets first item as default on init
enums := protoenum.NewEnums(
    protoenum.NewEnumWithDesc(protoenumstatus.StatusEnum_UNKNOWN, StatusTypeUnknown, "未知"),
    protoenum.NewEnumWithDesc(protoenumstatus.StatusEnum_SUCCESS, StatusTypeSuccess, "成功"),
)

// Lookup failures return default (not nil)
notFound := enums.GetByCode(999)  // Returns UNKNOWN (default)
fmt.Printf("Fallback: %s\n", notFound.Meta().Desc())  // Safe without nil check

// Change default using strict pattern
enums.UnsetDefault()  // Must unset first
enums.SetDefault(enums.MustGetByCode(1))  // Then set new default

// Once UnsetDefault called, lookups panic if not found
// This enforces single usage pattern: collections must have defaults

📄 License

MIT License - see LICENSE.

💬 Contact & Feedback

Contributions are welcome! Report bugs, suggest features, and contribute code:

  • 🐛 Mistake reports? Open an issue on GitHub with reproduction steps
  • 💡 Fresh ideas? Create an issue to discuss
  • 📖 Documentation confusing? Report it so we can improve
  • 🚀 Need new features? Share the use cases to help us understand requirements
  • ⚡ Performance issue? Help us optimize through reporting slow operations
  • 🔧 Configuration problem? Ask questions about complex setups
  • 📢 Follow project progress? Watch the repo to get new releases and features
  • 🌟 Success stories? Share how this package improved the workflow
  • 💬 Feedback? We welcome suggestions and comments

🔧 Development

New code contributions, follow this process:

  1. Fork: Fork the repo on GitHub (using the webpage UI).
  2. Clone: Clone the forked project (git clone https://github.com/yourname/repo-name.git).
  3. Navigate: Navigate to the cloned project (cd repo-name)
  4. Branch: Create a feature branch (git checkout -b feature/xxx).
  5. Code: Implement the changes with comprehensive tests
  6. Testing: (Golang project) Ensure tests pass (go test ./...) and follow Go code style conventions
  7. Documentation: Update documentation to support client-facing changes
  8. Stage: Stage changes (git add .)
  9. Commit: Commit changes (git commit -m "Add feature xxx") ensuring backward compatible code
  10. Push: Push to the branch (git push origin feature/xxx).
  11. PR: Open a merge request on GitHub (on the GitHub webpage) with detailed description.

Please ensure tests pass and include relevant documentation updates.

🌟 Support

Welcome to contribute to this project via submitting merge requests and reporting issues.

Project Support:

  • ⭐ Give GitHub stars if this project helps you
  • 🤝 Share with teammates and (golang) programming friends
  • 📝 Write tech blogs about development tools and workflows - we provide content writing support
  • 🌟 Join the ecosystem - committed to supporting open source and the (golang) development scene

Have Fun Coding with this package! 🎉🎉🎉

GitHub Stars

Stargazers

Documentation

Overview

Package protoenum: Utilities to handle Protocol Buffer enum metadata management Provides type-safe enum descriptors with Go native enum binding and custom metadata Supports triple generic wrapping: protoEnum, basic, and metaType Enables seamless conversion between protobuf enums and Go native enum types

protoenum: Protocol Buffer 枚举元数据管理包装工具 提供带有 Go 原生枚举绑定和自定义元数据的类型安全枚举描述符 支持三泛型包装：protoEnum、basic 和 metaType 实现 protobuf 枚举与 Go 原生枚举类型之间的无缝转换

Package protoenum: Collection management to handle Protocol Buffer enum metadata Provides indexed collections of enum descriptors with multiple lookup methods Enables fast lookup using code, name, and basic value with efficient enum handling

protoenum: Protocol Buffer 枚举元数据集合管理 提供带有多种查找方法的枚举描述符索引集合 支持按代码、名称或 basic 枚举值快速检索，实现高效枚举处理

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Enum 

type Enum[protoEnum ProtoEnum, basicEnum comparable, metaType any] struct {
	// contains filtered or unexported fields
}

Enum wraps a Protocol Buffer enum with Go native enum and custom metadata Bridges protobuf enum (protoEnum) with Go native enum (basic) via Basic() method Associates custom metadata with the enum value via Meta() method Uses triple generics to maintain type checking across protobuf, Go native enum, and metadata

Enum 使用 Go 原生枚举和自定义元数据包装 Protocol Buffer 枚举 通过 Basic() 方法桥接 protobuf 枚举 (protoEnum) 和 Go 原生枚举 (basic) 通过 Meta() 方法关联枚举值与自定义元数据 使用三泛型在 protobuf、Go 原生枚举和元数据类型间保持类型安全

func NewEnum 

func NewEnum[protoEnum ProtoEnum, basicEnum comparable](proto protoEnum, basic basicEnum) *Enum[protoEnum, basicEnum, *MetaNone]

NewEnum creates a new Enum instance binding protobuf enum with Go native enum Use this when you just need enum mapping without description The basic param accepts Go native enum type (e.g. type StatusType string) Returns a reference to the created Enum instance, supporting chained invocation

创建新的 Enum 实例，绑定 protobuf 枚举与 Go 原生枚举 当只需要枚举映射而不需要描述时使用此函数 basic 参数接受 Go 原生枚举类型（如 type StatusType string） 返回创建的 Enum 实例指针以便链式调用

func NewEnumWithDesc 

func NewEnumWithDesc[protoEnum ProtoEnum, basicEnum comparable](proto protoEnum, basic basicEnum, description string) *Enum[protoEnum, basicEnum, *MetaDesc]

NewEnumWithDesc creates a new Enum instance with protobuf enum, Go native enum, and description Use this when you need both enum mapping and human-readable description The basic param accepts Go native enum type (e.g. type StatusType string) The description param provides custom description used in docs and UI rendering

创建带有 protobuf 枚举、Go 原生枚举和描述的新 Enum 实例 当需要枚举映射和人类可读描述时使用此函数 basic 参数接受 Go 原生枚举类型（如 type StatusType string） description 参数提供用于文档和显示的自定义描述

func NewEnumWithMeta 

func NewEnumWithMeta[protoEnum ProtoEnum, basicEnum comparable, metaType any](proto protoEnum, basic basicEnum, meta metaType) *Enum[protoEnum, basicEnum, metaType]

NewEnumWithMeta creates a new Enum instance with protobuf enum, Go native enum, and custom metadata Use this when you need customized metadata types beyond simple string description The basic param accepts Go native enum type (e.g. type StatusType string) The meta param accepts custom metadata types (e.g. i18n descriptions with multiple languages)

创建带有 protobuf 枚举、Go 原生枚举和自定义元数据的新 Enum 实例 当需要超越简单字符串描述的灵活元数据类型时使用此函数 basic 参数接受 Go 原生枚举类型（如 type StatusType string） meta 参数接受任意自定义元数据类型（如双语描述）

func (*Enum[protoEnum, basicEnum, metaType]) Basic 

func (c *Enum[protoEnum, basicEnum, metaType]) Basic() basicEnum

Basic returns the Go native enum value associated with this enum Enables type-safe conversion from protobuf enum to Go native enum (e.g. type StatusType string) Use this to get the basic enum value when working with Go native enum patterns Bridges protobuf enums with existing Go enum-based business logic with ease

返回与此枚举关联的 Go 原生枚举值 实现从 protobuf 枚举到 Go 原生枚举的类型安全转换（如 type StatusType string） 在使用 Go 原生枚举模式时使用此方法获取 basic 枚举值 无缝桥接 protobuf 枚举与现有基于 Go 枚举的业务逻辑

func (*Enum[protoEnum, basicEnum, metaType]) Code 

func (c *Enum[protoEnum, basicEnum, metaType]) Code() int32

Code returns the numeric code of the enum as int32 Converts the Protocol Buffer enum value to a standard int32 type

返回枚举的数字代码作 int32 将 Protocol Buffer 枚举数字转换成标准 int32 类型

func (*Enum[protoEnum, basicEnum, metaType]) Meta 

func (c *Enum[protoEnum, basicEnum, metaType]) Meta() metaType

Meta returns the metadata associated with this enum Provides access to custom metadata like description via MetaDesc Use this when you need to access extended enum metadata

返回与此枚举关联的元数据 提供对自定义元数据（如通过 MetaDesc 获取描述）的访问 在需要访问额外的枚举元数据时使用此方法

func (*Enum[protoEnum, basicEnum, metaType]) Name 

func (c *Enum[protoEnum, basicEnum, metaType]) Name() string

Name returns the string name of the enum value Gets the Protocol Buffer enum's string representation

返回枚举值的字符串名称 获取 Protocol Buffer 枚举的字符串表示

func (*Enum[protoEnum, basicEnum, metaType]) Proto 

func (c *Enum[protoEnum, basicEnum, metaType]) Proto() protoEnum

Proto returns the underlying Protocol Buffer enum value Provides access to the source enum enabling Protocol Buffer operations

返回底层的 Protocol Buffer 枚举值 提供对源枚举的访问以进行 Protocol Buffer 操作

type Enums 

type Enums[P ProtoEnum, B comparable, M any] struct {
	// contains filtered or unexported fields
}

Enums manages a collection of Enum instances with indexed lookups Maintains multiple maps enabling efficient lookup using different identifiers Provides O(1) lookup when searching proto, code, name, and basic value Includes a configurable default value returned when lookups miss

Enums 管理 Enum 实例集合并提供索引查找 维护四个映射表以通过不同标识符高效检索 为 proto、代码、名称和 basic 枚举值搜索提供 O(1) 查找性能 支持在查找失败时返回可选的默认值

func NewEnums 

func NewEnums[P ProtoEnum, B comparable, M any](params ...*Enum[P, B, M]) *Enums[P, B, M]

NewEnums creates a new Enums collection from the given Enum instances Builds indexed maps enabling efficient lookup using proto, code, name, and basic value The first item becomes the default value if provided Returns a reference to the created Enums collection, usable in lookup operations

从给定的 Enum 实例创建新的 Enums 集合 构建索引映射以通过 proto、代码、名称和 basic 枚举值高效查找 如果提供了参数，第一个项成为默认值 返回创建的 Enums 集合指针，可用于各种查找操作

func (*Enums[P, B, M]) GetByBasic 

func (c *Enums[P, B, M]) GetByBasic(basic B) *Enum[P, B, M]

GetByBasic finds an Enum using its Go native enum value Performs direct map lookup using the basic enum value Returns default value if no enum with the given basic enum exists Panics if no default value has been configured

通过 Go 原生枚举值检索 Enum 使用 basic 枚举值执行直接映射查找 如果不存在具有给定 basic 枚举的枚举则返回默认值 如果未配置默认值则会 panic

func (*Enums[P, B, M]) GetByCode 

func (c *Enums[P, B, M]) GetByCode(code int32) *Enum[P, B, M]

GetByCode finds an Enum using its numeric code Performs direct map lookup using the int32 code value Returns default value if no enum with the given code exists Panics if no default value has been configured

通过数字代码检索 Enum 使用 int32 代码值执行直接映射查找 如果不存在具有给定代码的枚举则返回默认值 如果未配置默认值则会 panic

func (*Enums[P, B, M]) GetByName 

func (c *Enums[P, B, M]) GetByName(name string) *Enum[P, B, M]

GetByName finds an Enum using its string name Performs direct map lookup using the enum name string Returns default value if no enum with the given name exists Panics if no default value has been configured

通过字符串名称检索 Enum 使用枚举名称字符串执行直接映射查找 如果不存在具有给定名称的枚举则返回默认值 如果未配置默认值则会 panic

func (*Enums[P, B, M]) GetByProto 

func (c *Enums[P, B, M]) GetByProto(proto P) *Enum[P, B, M]

GetByProto finds an Enum using its Protocol Buffer enum value Uses the enum's numeric code when searching in the collection Returns default value if the enum is not found in the collection Panics if no default value has been configured

通过 Protocol Buffer 枚举值检索 Enum 使用枚举的数字代码在集合中查找 如果在集合中找不到枚举则返回默认值 如果未配置默认值则会 panic

func (*Enums[P, B, M]) GetDefault 

func (c *Enums[P, B, M]) GetDefault() *Enum[P, B, M]

GetDefault returns the current default Enum value Panics if no default value has been configured

返回当前的默认 Enum 值 如果未配置默认值则会 panic

func (*Enums[P, B, M]) GetDefaultBasic 

func (c *Enums[P, B, M]) GetDefaultBasic() B

GetDefaultBasic returns the basicEnum value of the default Enum Panics if no default value has been configured

返回默认 Enum 的 basicEnum 值 如果未配置默认值则会 panic

func (*Enums[P, B, M]) GetDefaultProto 

func (c *Enums[P, B, M]) GetDefaultProto() P

GetDefaultProto returns the protoEnum value of the default Enum Panics if no default value has been configured

返回默认 Enum 的 protoEnum 值 如果未配置默认值则会 panic

func (*Enums[P, B, M]) ListBasics 

func (c *Enums[P, B, M]) ListBasics() []B

ListBasics returns a slice containing each basicEnum value in the defined sequence Maintains the same sequence as enum values were registered

返回一个包含各 basicEnum 值的切片，次序与定义时一致 保持枚举值注册时的顺序

func (*Enums[P, B, M]) ListProtos 

func (c *Enums[P, B, M]) ListProtos() []P

ListProtos returns a slice containing each protoEnum value in the defined sequence Maintains the same sequence as enum values were registered

返回一个包含各 protoEnum 值的切片，次序与定义时一致 保持枚举值注册时的顺序

func (*Enums[P, B, M]) ListValidBasics 

func (c *Enums[P, B, M]) ListValidBasics() []B

ListValidBasics returns a slice excluding the default basicEnum value. If no default value is configured, returns each basicEnum value.

返回一个切片，排除默认 basicEnum 值，其余按定义次序排列。 如果未配置默认值，则返回所有 basicEnum 值。

func (*Enums[P, B, M]) ListValidProtos 

func (c *Enums[P, B, M]) ListValidProtos() []P

ListValidProtos returns a slice excluding the default protoEnum value. If no default value is configured, returns each protoEnum value.

返回一个切片，排除默认 protoEnum 值，其余按定义次序排列。 如果未配置默认值，则返回所有 protoEnum 值。

func (*Enums[P, B, M]) LookupByBasic 

func (c *Enums[P, B, M]) LookupByBasic(basic B) (*Enum[P, B, M], bool)

LookupByBasic finds an Enum using its Go native enum value Returns the Enum and true if found, nil and false otherwise Use this when you need to check existence before accessing the value

通过 Go 原生枚举值查找 Enum 找到时返回 Enum 和 true，否则返回 nil 和 false 当需要在访问值之前检查是否存在时使用此方法

func (*Enums[P, B, M]) LookupByCode 

func (c *Enums[P, B, M]) LookupByCode(code int32) (*Enum[P, B, M], bool)

LookupByCode finds an Enum using its numeric code Returns the Enum and true if found, nil and false otherwise Use this when you need to check existence before accessing the value

通过数字代码查找 Enum 找到时返回 Enum 和 true，否则返回 nil 和 false 当需要在访问值之前检查是否存在时使用此方法

func (*Enums[P, B, M]) LookupByName 

func (c *Enums[P, B, M]) LookupByName(name string) (*Enum[P, B, M], bool)

LookupByName finds an Enum using its string name Returns the Enum and true if found, nil and false otherwise Use this when you need to check existence before accessing the value

通过字符串名称查找 Enum 找到时返回 Enum 和 true，否则返回 nil 和 false 当需要在访问值之前检查是否存在时使用此方法

func (*Enums[P, B, M]) LookupByProto 

func (c *Enums[P, B, M]) LookupByProto(proto P) (*Enum[P, B, M], bool)

LookupByProto finds an Enum using its Protocol Buffer enum value Returns the Enum and true if found, nil and false otherwise Use this when you need to check existence before accessing the value

通过 Protocol Buffer 枚举值查找 Enum 找到时返回 Enum 和 true，否则返回 nil 和 false 当需要在访问值之前检查是否存在时使用此方法

func (*Enums[P, B, M]) MustGetByBasic 

func (c *Enums[P, B, M]) MustGetByBasic(basic B) *Enum[P, B, M]

MustGetByBasic finds an Enum using its Go native enum value Panics if no enum with the given basic enum exists

通过 Go 原生枚举值检索 Enum 如果不存在具有给定 basic 枚举的枚举则会 panic

func (*Enums[P, B, M]) MustGetByCode 

func (c *Enums[P, B, M]) MustGetByCode(code int32) *Enum[P, B, M]

MustGetByCode finds an Enum using its numeric code Panics if no enum with the given code exists

通过数字代码检索 Enum 如果不存在具有给定代码的枚举则会 panic

func (*Enums[P, B, M]) MustGetByName 

func (c *Enums[P, B, M]) MustGetByName(name string) *Enum[P, B, M]

MustGetByName finds an Enum using its string name Panics if no enum with the given name exists

通过字符串名称检索 Enum 如果不存在具有给定名称的枚举则会 panic

func (*Enums[P, B, M]) MustGetByProto 

func (c *Enums[P, B, M]) MustGetByProto(proto P) *Enum[P, B, M]

MustGetByProto finds an Enum using its Protocol Buffer enum value Panics if the enum is not found in the collection

通过 Protocol Buffer 枚举值检索 Enum 如果在集合中找不到枚举则会 panic

func (*Enums[P, B, M]) SetDefault 

func (c *Enums[P, B, M]) SetDefault(enum *Enum[P, B, M])

SetDefault sets the default Enum value to return when lookups miss Allows dynamic configuration of the fallback value post creation Panics if defaultEnum is nil, use UnsetDefault to remove the default value

设置查找失败时返回的默认 Enum 值 允许在创建后动态配置回退值 如果 defaultEnum 为 nil 则会 panic，使用 UnsetDefault 清除默认值

func (*Enums[P, B, M]) SetDefaultBasic 

func (c *Enums[P, B, M]) SetDefaultBasic(basic B)

SetDefaultBasic sets the default using a Go native enum value Panics if the specified basic enum is not found in the collection

使用 Go 原生枚举值设置默认值 如果指定的 basic 枚举不存在则会 panic

func (*Enums[P, B, M]) SetDefaultProto 

func (c *Enums[P, B, M]) SetDefaultProto(proto P)

SetDefaultProto sets the default using a Protocol Buffer enum value Panics if the specified proto enum is not found in the collection

使用 Protocol Buffer 枚举值设置默认值 如果指定的 proto 枚举不存在则会 panic

func (*Enums[P, B, M]) SetDefaultValid 

func (c *Enums[P, B, M]) SetDefaultValid(valid bool)

SetDefaultValid marks the default value as active when true When active, ListValidProtos and ListValidBasics include the default Panics if no default value exists, panics if defaultValid has been set

标记默认值是否应被视为有效 当 valid 为 true 时，ListValidProtos 和 ListValidBasics 包含默认值 如果无默认值或 defaultValid 已设置则会 panic

func (*Enums[P, B, M]) UnsetDefault 

func (c *Enums[P, B, M]) UnsetDefault()

UnsetDefault unsets the default Enum value Once invoked, GetByXxx lookups panic if not found Panics if no default value exists at the moment

取消设置默认 Enum 值 调用此方法后，GetByXxx 查找失败时会 panic 如果当前无默认值则会 panic

func (*Enums[P, B, M]) WithDefault 

func (c *Enums[P, B, M]) WithDefault(enum *Enum[P, B, M]) *Enums[P, B, M]

WithDefault sets the default Enum value and returns the Enums instance Enables fluent chain-style configuration during initialization Convenient when setting defaults in package-scope variable declarations

设置默认 Enum 值并返回 Enums 实例 支持初始化时的流式链式配置 适用于在全局变量声明中设置默认值

func (*Enums[P, B, M]) WithDefaultBasic 

func (c *Enums[P, B, M]) WithDefaultBasic(basic B) *Enums[P, B, M]

WithDefaultBasic sets the default using a basic enum and returns the Enums instance Convenient chain method when you know the default Go native enum value Panics if the specified basic enum is not found in the collection

使用 basic 枚举设置默认值并返回 Enums 实例 当你知道默认 Go 原生枚举值时的便捷链式方法 如果指定的 basic 枚举不存在则会 panic

func (*Enums[P, B, M]) WithDefaultCode 

func (c *Enums[P, B, M]) WithDefaultCode(code int32) *Enums[P, B, M]

WithDefaultCode sets the default using a numeric code and returns the Enums instance Convenient chain method when you know the default enum code Panics if the specified code is not found in the collection

使用数字代码设置默认值并返回 Enums 实例 当你知道默认枚举代码时的便捷链式方法 如果指定的代码不存在则会 panic

func (*Enums[P, B, M]) WithDefaultName 

func (c *Enums[P, B, M]) WithDefaultName(name string) *Enums[P, B, M]

WithDefaultName sets the default using an enum name and returns the Enums instance Convenient chain method when you know the default enum name Panics if the specified name is not found in the collection

使用枚举名称设置默认值并返回 Enums 实例 当你知道默认枚举名称时的便捷链式方法 如果指定的名称不存在则会 panic

func (*Enums[P, B, M]) WithDefaultProto 

func (c *Enums[P, B, M]) WithDefaultProto(proto P) *Enums[P, B, M]

WithDefaultProto sets the default using a proto enum and returns the Enums instance Convenient chain method when you know the default Protocol Buffer enum value Panics if the specified proto enum is not found in the collection

使用 proto 枚举设置默认值并返回 Enums 实例 当你知道默认 Protocol Buffer 枚举值时的便捷链式方法 如果指定的 proto 枚举不存在则会 panic

func (*Enums[P, B, M]) WithDefaultValid 

func (c *Enums[P, B, M]) WithDefaultValid(valid bool) *Enums[P, B, M]

WithDefaultValid marks the default as active and returns the Enums instance When active, ListValidProtos and ListValidBasics include the default Convenient chain method to configure default active state at initialization

标记默认值为有效并返回 Enums 实例 当 valid 为 true 时，ListValidProtos 和 ListValidBasics 包含默认值 用于初始化时配置默认值有效性的便捷链式方法

func (*Enums[P, B, M]) WithUnsetDefault 

func (c *Enums[P, B, M]) WithUnsetDefault() *Enums[P, B, M]

WithUnsetDefault unsets the default Enum value and returns the Enums instance Enables fluent chain-style configuration to remove default value Once invoked, GetByXxx lookups panic if not found

取消设置默认 Enum 值并返回 Enums 实例 支持流式链式配置以移除默认值 之后 GetByXxx 查找失败时会 panic

type MetaDesc 

type MetaDesc struct {
	// contains filtered or unexported fields
}

MetaDesc represents metadata with string description attached to enums

MetaDesc 代表带字符串描述的枚举元数据

func (*MetaDesc) Desc 

func (c *MetaDesc) Desc() string

Desc returns the custom description of the enum Provides human-readable description with documentation purposes

返回枚举的自定义描述 提供人类可读的描述用于文档目的

type MetaNone 

type MetaNone struct{}

MetaNone represents blank metadata when enums have no description

MetaNone 代表无描述枚举的空元数据

type ProtoEnum 

type ProtoEnum interface {
	// String provides the standard name of the enum value as defined in protobuf schema
	// Important when performing serialization, debugging, and human-readable enum identification
	// String 提供 protobuf 模式中定义的枚举值规范名称标识符
	// 在进行序列化、调试和人类可读的枚举识别时至关重要
	String() string
	// Number exposes the underlying numeric wire-format encoding used in protobuf serialization
	// Enables efficient storage, transmission, and support with protobuf specifications
	// Number 暴露 protobuf 序列化中使用的底层数值线格式编码
	// 实现高效存储、传输以及与 protobuf 规范的兼容性
	Number() protoreflect.EnumNumber

	// comparable constraint matches protobuf enum patterns and enables map-index usage
	// protobuf enums can be compared, this constraint maintains type-safe operations
	// comparable 约束与 protobuf 枚举行为一致，并支持作为 map 键使用
	// Protocol Buffer 枚举本身可比较，此约束确保类型安全
	comparable
}

ProtoEnum establishes the core contract enabling Protocol Buffer enum integration Serves as the generic constraint enabling type-safe enum operations across each protobuf enum Bridges the native protobuf enum system with enhanced metadata management capabilities Important when maintaining compile-time type checking while adding runtime descriptive features

ProtoEnum 建立 Protocol Buffer 枚举集成的基础契约 作为泛型约束实现跨所有 protobuf 枚举的类型安全包装操作 在原生 protobuf 枚举系统与增强元数据管理能力之间建立桥梁 在添加运行时描述特性的同时保持编译时类型安全至关重要

Source Files

View all Source files

Directories

Path Synopsis
internal
demos/demo1x command
demos/demo2x command
demos/demo3x command
utils
Package utils: Private utilities handling pointers and zero values Provides generic functions to handle pointers and value extraction
 Package utils: Private utilities handling pointers and zero values Provides generic functions to handle pointers and value extraction
protos
protoenumresult
protoenumstatus

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.