Ecosyste.ms: Funds

An open API service for providing issue and pull request metadata for open source projects.

https://github.com/protocolbuffers/protobuf-go

go golang protobufs protocol-buffers

Last synced: about 4 hours ago

Repository metadata:

Go support for Google's protocol buffers

Owner metadata:

Committers metadata

Last synced: about 7 hours ago

Total Commits: 1,149
Total Committers: 54
Avg Commits per committer: 21.278
Development Distribution Score (DDS): 0.533

Commits in past year: 123
Committers in past year: 17
Avg Commits per committer in past year: 7.235
Development Distribution Score (DDS) in past year: 0.61

Name Email Commits
Joe Tsai j****i@d****t 537
Damien Neil d****l@g****m 324
Herbie Ong h****e@g****m 86
Lasse Folger l****r@g****m 60
Michael Stapelberg s****g@g****g 54
Josh Humphries j****s@b****d 11
Kir Kolyshkin k****n@g****m 8
Koichi Shiraishi z****o@g****m 5
Michael Stapelberg s****g@g****m 4
Mike Kruskal m****l@g****m 4
Nicolas Hillegeer a****u@g****m 4
John Wright j****w@g****m 3
David Chase d****e@g****m 2
Dmitri Shuralyov d****r@g****g 2
Edward McFarlane e****0@g****m 2
Julie Qiu j****e@g****g 2
Oleksandr Redko o****b@g****m 2
Vanja Pejovic v****a@g****m 2
Justin SB j****b@g****m 2
Abhilash Pallerlamudi s****i@g****m 1
Aliaksandr Mianzhynski a****y@g****m 1
Andrew Bonventre a****s@g****g 1
Andrew Gerrand a****g@g****g 1
Benny Siegert b****t@g****m 1
Christian Höppner h****i@g****m 1
Clement Jean C****3@g****m 1
Cody Schroeder s****c@g****m 1
Doug Fawley d****y@g****m 1
Emmanuel T Odeke e****l@o****m 1
Jeff Hodges j****f@s****m 1
and 24 more...

Issue and Pull Request metadata

Last synced: 1 day ago

Package metadata

go: github.com/protocolbuffers/protobuf-go

  • Homepage:
  • Documentation: https://pkg.go.dev/github.com/protocolbuffers/protobuf-go#section-documentation
  • Licenses: bsd-3-clause
  • Latest release: v1.34.1 (published 6 months ago)
  • Last Synced: 2024-11-09T00:09:41.912Z (1 day ago)
  • Versions: 24
  • Dependent Packages: 0
  • Dependent Repositories: 2
  • Rankings:
    • Stargazers count: 1.416%
    • Forks count: 1.618%
    • Dependent repos count: 3.578%
    • Average: 3.766%
    • Dependent packages count: 8.453%
go: google.golang.org/protobuf/types/known/fieldmaskpb

Package fieldmaskpb contains generated types for google/protobuf/field_mask.proto. The FieldMask message represents a set of symbolic field paths. The paths are specific to some target message type, which is not stored within the FieldMask message itself. The New function is used construct a FieldMask: The "field.name" and "field.number" paths are valid paths according to the google.protobuf.DescriptorProto message. Use of a path that does not correlate to valid fields reachable from DescriptorProto would result in an error. Once a FieldMask message has been constructed, the Append method can be used to insert additional paths to the path set: In order to verify that a FieldMask represents a set of fields that are reachable from some target message type, use the IsValid method: IsValid needs to be passed the target message type as an input since the FieldMask message itself does not store the message type that the set of paths are for.

  • Homepage: https://github.com/protocolbuffers/protobuf-go
  • Documentation: https://pkg.go.dev/google.golang.org/protobuf/types/known/fieldmaskpb#section-documentation
  • Licenses: BSD-3-Clause
  • Latest release:
  • Last Synced: 2024-11-09T00:09:19.979Z (1 day ago)
  • Versions: 0
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Docker Downloads: 9
  • Rankings:
    • Stargazers count: 1.214%
    • Forks count: 1.379%
    • Average: 3.827%
    • Dependent packages count: 6.151%
    • Dependent repos count: 6.563%
go: google.golang.org/protobuf/internal/encoding/defval

Package defval marshals and unmarshals textual forms of default values. This package handles both the form historically used in Go struct field tags and also the form used by google.protobuf.FieldDescriptorProto.default_value since they differ in superficial ways.

go: google.golang.org/protobuf/encoding/protojson

Package protojson marshals and unmarshals protocol buffer messages as JSON format. It follows the guide at https://protobuf.dev/programming-guides/proto3#json. This package produces a different output than the standard encoding/json package, which does not operate correctly on protocol buffer messages.

go: google.golang.org/protobuf/internal/descfmt

Package descfmt provides functionality to format descriptors.

go: google.golang.org/protobuf/types/known/durationpb

Package durationpb contains generated types for google/protobuf/duration.proto. The Duration message represents a signed span of time. The AsDuration method can be used to convert a Duration message to a standard Go time.Duration value: Converting to a time.Duration is a common operation so that the extensive set of time-based operations provided by the time package can be leveraged. See https://golang.org/pkg/time for more information. The AsDuration method performs the conversion on a best-effort basis. Durations with denormal values (e.g., nanoseconds beyond -99999999 and +99999999, inclusive; or seconds and nanoseconds with opposite signs) are normalized during the conversion to a time.Duration. To manually check for invalid Duration per the documented limitations in duration.proto, additionally call the CheckValid method: Note that the documented limitations in duration.proto does not protect a Duration from overflowing the representable range of a time.Duration in Go. The AsDuration method uses saturation arithmetic such that an overflow clamps the resulting value to the closest representable value (e.g., math.MaxInt64 for positive overflow and math.MinInt64 for negative overflow). The durationpb.New function can be used to construct a Duration message from a standard Go time.Duration value:

go: google.golang.org/protobuf/internal/order

Package order provides ordered access to messages and maps.

go: google.golang.org/protobuf/internal/version

Package version records versioning information about this module.

go: google.golang.org/protobuf/types/known/timestamppb

Package timestamppb contains generated types for google/protobuf/timestamp.proto. The Timestamp message represents a timestamp, an instant in time since the Unix epoch (January 1st, 1970). The AsTime method can be used to convert a Timestamp message to a standard Go time.Time value in UTC: Converting to a time.Time is a common operation so that the extensive set of time-based operations provided by the time package can be leveraged. See https://golang.org/pkg/time for more information. The AsTime method performs the conversion on a best-effort basis. Timestamps with denormal values (e.g., nanoseconds beyond 0 and 99999999, inclusive) are normalized during the conversion to a time.Time. To manually check for invalid Timestamps per the documented limitations in timestamp.proto, additionally call the CheckValid method: The timestamppb.New function can be used to construct a Timestamp message from a standard Go time.Time value: In order to construct a Timestamp representing the current time, use Now:

go: google.golang.org/protobuf/internal/set

Package set provides simple set data structures for uint64s.

  • Homepage: https://github.com/protocolbuffers/protobuf-go
  • Documentation: https://pkg.go.dev/google.golang.org/protobuf/internal/set#section-documentation
  • Licenses: BSD-3-Clause
  • Latest release:
  • Last Synced: 2024-11-09T00:10:33.428Z (1 day ago)
  • Versions: 0
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Docker Downloads: 9
  • Rankings:
    • Dependent packages count: 6.151%
    • Average: 6.357%
    • Dependent repos count: 6.563%
go: google.golang.org/protobuf/internal/descopts

Package descopts contains the nil pointers to concrete descriptor options. This package exists as a form of reverse dependency injection so that certain packages (e.g., internal/filedesc and internal/filetype can avoid a direct dependency on the descriptor proto package).

go: google.golang.org/protobuf/types/known/anypb

Package anypb contains generated types for google/protobuf/any.proto. The Any message is a dynamic representation of any other message value. It is functionally a tuple of the full name of the remote message type and the serialized bytes of the remote message value. An Any message containing another message value is constructed using New: With a populated Any message, the underlying message can be serialized into a remote concrete message value in a few ways. If the exact concrete type is known, then a new (or pre-existing) instance of that message can be passed to the UnmarshalTo method: If the exact concrete type is not known, then the UnmarshalNew method can be used to unmarshal the contents into a new instance of the remote message type: UnmarshalNew uses the global type registry to resolve the message type and construct a new instance of that message to unmarshal into. In order for a message type to appear in the global registry, the Go type representing that protobuf message type must be linked into the Go binary. For messages generated by protoc-gen-go, this is achieved through an import of the generated Go package representing a .proto file. A common pattern with UnmarshalNew is to use a type switch with the resulting proto.Message value: This pattern ensures that the generated packages containing the message types listed in the case clauses are linked into the Go binary and therefore also registered in the global registry. In order to type check whether an Any message represents some other message, then use the MessageIs method: The MessageIs method can also be used with an allocated instance of the target message type if the intention is to unmarshal into it if the type matches:

go: google.golang.org/protobuf/types/descriptorpb

go: google.golang.org/protobuf/internal/strs

Package strs provides string manipulation functionality specific to protobuf.

go: google.golang.org/protobuf/encoding/prototext

Package prototext marshals and unmarshals protocol buffer messages as the textproto format.

go: google.golang.org/protobuf/internal/encoding/messageset

Package messageset encodes and decodes the obsolete MessageSet wire format.

go: google.golang.org/protobuf/internal/editionssupport

Package editionssupport defines constants for editions that are supported.

go: google.golang.org/protobuf/internal/detrand

Package detrand provides deterministically random functionality. The pseudo-randomness of these functions is seeded by the program binary itself and guarantees that the output does not change within a program, while ensuring that the output is unstable across different builds.

go: google.golang.org/protobuf/internal/errors

Package errors implements functions to manipulate errors.

go: google.golang.org/protobuf/runtime/protoimpl

Package protoimpl contains the default implementation for messages generated by protoc-gen-go. WARNING: This package should only ever be imported by generated messages. The compatibility agreement covers nothing except for functionality needed to keep existing generated messages operational. Breakages that occur due to unauthorized usages of this package are not the author's responsibility.

go: google.golang.org/protobuf/encoding/protowire

Package protowire parses and formats the raw wire encoding. See https://protobuf.dev/programming-guides/encoding. For marshaling and unmarshaling entire protobuf messages, use the google.golang.org/protobuf/proto package instead.

go: google.golang.org/protobuf/reflect/protodesc

Package protodesc provides functionality for converting FileDescriptorProto messages to/from protoreflect.FileDescriptor values. The google.protobuf.FileDescriptorProto is a protobuf message that describes the type information for a .proto file in a form that is easily serializable. The protoreflect.FileDescriptor is a more structured representation of the FileDescriptorProto message where references and remote dependencies can be directly followed.

go: google.golang.org/protobuf/reflect/protoreflect

Package protoreflect provides interfaces to dynamically manipulate messages. This package includes type descriptors which describe the structure of types defined in proto source files and value interfaces which provide the ability to examine and manipulate the contents of messages. Protobuf descriptors (e.g., EnumDescriptor or MessageDescriptor) are immutable objects that represent protobuf type information. They are wrappers around the messages declared in descriptor.proto. Protobuf descriptors alone lack any information regarding Go types. Enums and messages generated by this module implement Enum and ProtoMessage, where the Descriptor and ProtoReflect.Descriptor accessors respectively return the protobuf descriptor for the values. The protobuf descriptor interfaces are not meant to be implemented by user code since they might need to be extended in the future to support additions to the protobuf language. The google.golang.org/protobuf/reflect/protodesc package converts between google.protobuf.DescriptorProto messages and protobuf descriptors. A type descriptor (e.g., EnumType or MessageType) is a constructor for a concrete Go type that represents the associated protobuf descriptor. There is commonly a one-to-one relationship between protobuf descriptors and Go type descriptors, but it can potentially be a one-to-many relationship. Enums and messages generated by this module implement Enum and ProtoMessage, where the Type and ProtoReflect.Type accessors respectively return the protobuf descriptor for the values. The google.golang.org/protobuf/types/dynamicpb package can be used to create Go type descriptors from protobuf descriptors. The Enum and Message interfaces provide a reflective view over an enum or message instance. For enums, it provides the ability to retrieve the enum value number for any concrete enum type. For messages, it provides the ability to access or manipulate fields of the message. To convert a google.golang.org/protobuf/proto.Message to a protoreflect.Message, use the former's ProtoReflect method. Since the ProtoReflect method is new to the v2 message interface, it may not be present on older message implementations. The github.com/golang/protobuf/proto.MessageReflect function can be used to obtain a reflective view on older messages. The following diagrams demonstrate the relationships between various types declared in this package. • An EnumType describes a concrete Go enum type. It has an EnumDescriptor and can construct an Enum instance. • An EnumDescriptor describes an abstract protobuf enum type. • An Enum is a concrete enum instance. Generated enums implement Enum. • A MessageType describes a concrete Go message type. It has a MessageDescriptor and can construct a Message instance. Just as how Go's reflect.Type is a reflective description of a Go type, a MessageType is a reflective description of a Go type for a protobuf message. • A MessageDescriptor describes an abstract protobuf message type. It has no understanding of Go types. In order to construct a MessageType from just a MessageDescriptor, you can consider looking up the message type in the global registry using the FindMessageByName method on google.golang.org/protobuf/reflect/protoregistry.GlobalTypes or constructing a dynamic MessageType using google.golang.org/protobuf/types/dynamicpb.NewMessageType. • A Message is a reflective view over a concrete message instance. Generated messages implement ProtoMessage, which can convert to a Message. Just as how Go's reflect.Value is a reflective view over a Go value, a Message is a reflective view over a concrete protobuf message instance. Using Go reflection as an analogy, the [ProtoMessage.ProtoReflect] method is similar to calling reflect.ValueOf, and the [Message.Interface] method is similar to calling reflect.Value.Interface. • An ExtensionType describes a concrete Go implementation of an extension. It has an ExtensionTypeDescriptor and can convert to/from an abstract Value and a Go value. • An ExtensionTypeDescriptor is an ExtensionDescriptor which also has an ExtensionType. • An ExtensionDescriptor describes an abstract protobuf extension field and may not always be an ExtensionTypeDescriptor.

go: google.golang.org/protobuf/types/known/emptypb

go: google.golang.org/protobuf/reflect/protoregistry

Package protoregistry provides data structures to register and lookup protobuf descriptor types. The Files registry contains file descriptors and provides the ability to iterate over the files or lookup a specific descriptor within the files. Files only contains protobuf descriptors and has no understanding of Go type information that may be associated with each descriptor. The Types registry contains descriptor types for which there is a known Go type associated with that descriptor. It provides the ability to iterate over the registered types or lookup a type by name.

go: google.golang.org/protobuf/internal/pragma

Package pragma provides types that can be embedded into a struct to statically enforce or prevent certain language properties.

go: google.golang.org/protobuf/internal/encoding/text

Package text implements the text format for protocol buffers. This package has no semantic understanding for protocol buffers and is only a parser and composer for the format. There is no formal specification for the protobuf text format, as such the C++ implementation (see google::protobuf::TextFormat) is the reference implementation of the text format. This package is neither a superset nor a subset of the C++ implementation. This implementation permits a more liberal grammar in some cases to be backwards compatible with the historical Go implementation. Future parsings unique to Go should not be added. Some grammars allowed by the C++ implementation are deliberately not implemented here because they are considered a bug by the protobuf team and should not be replicated. The Go implementation should implement a sufficient amount of the C++ grammar such that the default text serialization by C++ can be parsed by Go. However, just because the C++ parser accepts some input does not mean that the Go implementation should as well. The text format is almost a superset of JSON except:

go: google.golang.org/protobuf/internal/editiondefaults

Package editiondefaults contains the binary representation of the editions defaults.

go: google.golang.org/protobuf/protoadapt

Package protoadapt bridges the original and new proto APIs.

go: google.golang.org/protobuf/internal/filetype

Package filetype provides functionality for wrapping descriptors with Go type information.

go: google.golang.org/protobuf/runtime/protoiface

Package protoiface contains types referenced or implemented by messages. WARNING: This package should only be imported by message implementations. The functionality found in this package should be accessed through higher-level abstractions provided by the proto package.

go: google.golang.org/protobuf/internal/filedesc

Package filedesc provides functionality for constructing descriptors. The types in this package implement interfaces in the protoreflect package related to protobuf descripriptors.

go: google.golang.org/protobuf/types/known/structpb

Package structpb contains generated types for google/protobuf/struct.proto. The messages (i.e., Value, Struct, and ListValue) defined in struct.proto are used to represent arbitrary JSON. The Value message represents a JSON value, the Struct message represents a JSON object, and the ListValue message represents a JSON array. See https://json.org for more information. The Value, Struct, and ListValue types have generated MarshalJSON and UnmarshalJSON methods such that they serialize JSON equivalent to what the messages themselves represent. Use of these types with the "google.golang.org/protobuf/encoding/protojson" package ensures that they will be serialized as their JSON equivalent. The standard Go "encoding/json" package has functionality to serialize arbitrary types to a large degree. The Value.AsInterface, Struct.AsMap, and ListValue.AsSlice methods can convert the protobuf message representation into a form represented by any, map[string]any, and []any. This form can be used with other packages that operate on such data structures and also directly with the standard json package. In order to convert the any, map[string]any, and []any forms back as Value, Struct, and ListValue messages, use the NewStruct, NewList, and NewValue constructor functions. Consider the following example JSON object: To construct a Value message representing the above JSON object:

go: google.golang.org/protobuf/encoding/protodelim

Package protodelim marshals and unmarshals varint size-delimited messages.

go: google.golang.org/protobuf/internal/flags

Package flags provides a set of flags controlled by build tags.

go: google.golang.org/protobuf/internal/encoding/tag

Package tag marshals and unmarshals the legacy struct tags as generated by historical versions of protoc-gen-go.

go: google.golang.org/protobuf/internal/genid

Package genid contains constants for declarations in descriptor.proto and the well-known types.

go: google.golang.org/protobuf/types/gofeaturespb

go: google.golang.org/protobuf/internal/encoding/json

go: google.golang.org/protobuf/internal/impl

  • Homepage: https://github.com/protocolbuffers/protobuf-go
  • Documentation: https://pkg.go.dev/google.golang.org/protobuf/internal/impl#section-documentation
  • Licenses: BSD-3-Clause
  • Latest release:
  • Last Synced: 2024-10-30T19:34:34.407Z (10 days ago)
  • Versions: 0
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Docker Downloads: 9
  • Rankings:
    • Dependent packages count: 6.151%
    • Average: 6.357%
    • Dependent repos count: 6.563%
alpine: protoc-gen-go

Protocol Buffers Go generator

  • Homepage: https://github.com/protocolbuffers/protobuf-go
  • Licenses: BSD-3-Clause
  • Latest release: 1.34.0-r0 (published 6 months ago)
  • Last Synced: 2024-10-29T12:56:48.961Z (12 days ago)
  • Versions: 14
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Stargazers count: 5.536%
    • Forks count: 6.126%
    • Average: 6.384%
    • Dependent packages count: 13.873%
  • Maintainers (1)
go: google.golang.org/protobuf/types/known/wrapperspb

go: google.golang.org/protobuf/proto

Package proto provides functions operating on protocol buffer messages. For documentation on protocol buffers in general, see: https://protobuf.dev. For a tutorial on using protocol buffers with Go, see: https://protobuf.dev/getting-started/gotutorial. For a guide to generated Go protocol buffer code, see: https://protobuf.dev/reference/go/go-generated. This package contains functions to convert to and from the wire format, an efficient binary serialization of protocol buffers. Size reports the size of a message in the wire format. Marshal converts a message to the wire format. The MarshalOptions type provides more control over wire marshaling. Unmarshal converts a message from the wire format. The UnmarshalOptions type provides more control over wire unmarshaling. Clone makes a deep copy of a message. Merge merges the content of a message into another. Equal compares two messages. For more control over comparisons and detailed reporting of differences, see package google.golang.org/protobuf/testing/protocmp. Reset clears the content of a message. CheckInitialized reports whether all required fields in a message are set. The API for some generated messages represents optional scalar fields as pointers to a value. For example, an optional string field has the Go type *string. Generated enum types usually have an Enum method which performs the same operation. Optional scalar fields are only supported in proto2. Extension fields are only supported in proto2. Package google.golang.org/protobuf/encoding/protojson converts messages to and from JSON. Package google.golang.org/protobuf/encoding/prototext converts messages to and from the text format. Package google.golang.org/protobuf/reflect/protoreflect provides a reflection interface for protocol buffer data types. Package google.golang.org/protobuf/testing/protocmp provides features to compare protocol buffer messages with the github.com/google/go-cmp/cmp package. Package google.golang.org/protobuf/types/dynamicpb provides a dynamic message type, suitable for working with messages where the protocol buffer type is only known at runtime. This module contains additional packages for more specialized use cases. Consult the individual package documentation for details.

  • Homepage: https://github.com/protocolbuffers/protobuf-go
  • Documentation: https://pkg.go.dev/google.golang.org/protobuf/proto#section-documentation
  • Licenses: BSD-3-Clause
  • Latest release:
  • Last Synced: 2024-10-30T19:34:35.907Z (10 days ago)
  • Versions: 0
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Docker Downloads: 9
  • Rankings:
    • Dependent packages count: 6.548%
    • Average: 6.768%
    • Dependent repos count: 6.988%
homebrew: protoc-gen-go

Go support for Google's protocol buffers

  • Homepage: https://github.com/protocolbuffers/protobuf-go
  • Licenses: BSD-3-Clause
  • Latest release: 1.34.0 (published 6 months ago)
  • Last Synced: 2024-11-09T00:09:08.250Z (1 day ago)
  • Versions: 12
  • Dependent Packages: 0
  • Dependent Repositories: 8
  • Downloads: 1,136 Last month
  • Rankings:
    • Forks count: 7.494%
    • Stargazers count: 10.143%
    • Average: 13.096%
    • Dependent repos count: 14.615%
    • Downloads: 14.785%
    • Dependent packages count: 18.441%

Dependencies

.github/workflows/test.yml actions
  • actions/cache v3 composite
  • actions/checkout v3 composite
  • actions/setup-go v4 composite
go.mod go
  • github.com/golang/protobuf v1.5.0
  • github.com/google/go-cmp v0.5.5
  • golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543
go.sum go
  • github.com/golang/protobuf v1.5.0
  • github.com/google/go-cmp v0.5.5
  • golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543
  • google.golang.org/protobuf v1.26.0-rc.1