package durationpb

Import Path
	google.golang.org/protobuf/types/known/durationpb (on go.dev)

Dependency Relation
	imports 6 packages, and imported by 2 packages


Involved Source Files

	
		Package durationpb contains generated types for google/protobuf/duration.proto.

		The Duration message represents a signed span of time.

		Conversion to a Go Duration

		The AsDuration method can be used to convert a Duration message to a
		standard Go time.Duration value:

			d := dur.AsDuration()
			... // make use of d as a time.Duration

		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:

			if err := dur.CheckValid(); err != nil {
				... // handle error
			}

		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).

		Conversion from a Go Duration

		The durationpb.New function can be used to construct a Duration message
		from a standard Go time.Duration value:

			dur := durationpb.New(d)
			... // make use of d as a *durationpb.Duration


Package-Level Type Names (only one, which is exported)


	/* sort exporteds by:  |  */
	
		A Duration represents a signed, fixed-length span of time represented
		as a count of seconds and fractions of seconds at nanosecond
		resolution. It is independent of any calendar and concepts like "day"
		or "month". It is related to Timestamp in that the difference between
		two Timestamp values is a Duration and it can be added or subtracted
		from a Timestamp. Range is approximately +-10,000 years.

		# Examples

		Example 1: Compute Duration from two Timestamps in pseudo code.

		    Timestamp start = ...;
		    Timestamp end = ...;
		    Duration duration = ...;

		    duration.seconds = end.seconds - start.seconds;
		    duration.nanos = end.nanos - start.nanos;

		    if (duration.seconds < 0 && duration.nanos > 0) {
		      duration.seconds += 1;
		      duration.nanos -= 1000000000;
		    } else if (duration.seconds > 0 && duration.nanos < 0) {
		      duration.seconds -= 1;
		      duration.nanos += 1000000000;
		    }

		Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.

		    Timestamp start = ...;
		    Duration duration = ...;
		    Timestamp end = ...;

		    end.seconds = start.seconds + duration.seconds;
		    end.nanos = start.nanos + duration.nanos;

		    if (end.nanos < 0) {
		      end.seconds -= 1;
		      end.nanos += 1000000000;
		    } else if (end.nanos >= 1000000000) {
		      end.seconds += 1;
		      end.nanos -= 1000000000;
		    }

		Example 3: Compute Duration from datetime.timedelta in Python.

		    td = datetime.timedelta(days=3, minutes=10)
		    duration = Duration()
		    duration.FromTimedelta(td)

		# JSON Mapping

		In JSON format, the Duration type is encoded as a string rather than an
		object, where the string ends in the suffix "s" (indicating seconds) and
		is preceded by the number of seconds, with nanoseconds expressed as
		fractional seconds. For example, 3 seconds with 0 nanoseconds should be
		encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
		be expressed in JSON format as "3.000000001s", and 3 seconds and 1
		microsecond should be expressed in JSON format as "3.000001s".

		
			
				Signed fractions of a second at nanosecond resolution of the span
				of time. Durations less than one second are represented with a 0
				`seconds` field and a positive or negative `nanos` field. For durations
				of one second or more, a non-zero value for the `nanos` field must be
				of the same sign as the `seconds` field. Must be from -999,999,999
				to +999,999,999 inclusive.

			
				Signed seconds of the span of time. Must be from -315,576,000,000
				to +315,576,000,000 inclusive. Note: these bounds are computed from:
				60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years

			
		
			
				AsDuration converts x to a time.Duration,
				returning the closest duration value in the event of overflow.

			
				CheckValid returns an error if the duration is invalid.
				In particular, it checks whether the value is within the range of
				-10000 years to +10000 years inclusive.
				An error is reported for a nil Duration.

			
				Deprecated: Use Duration.ProtoReflect.Descriptor instead.

			(*T) GetNanos() int32
			(*T) GetSeconds() int64
			
				IsValid reports whether the duration is valid.
				It is equivalent to CheckValid == nil.

			(*T) ProtoMessage()
			(*T) ProtoReflect() protoreflect.Message
			(*T) Reset()
			(*T) String() string
			
		
			*T : google.golang.org/protobuf/reflect/protoreflect.ProtoMessage
			*T : google.golang.org/protobuf/runtime/protoiface.MessageV1
			*T : fmt.Stringer
			
		
			func New(d time.Duration) *Duration
			func google.golang.org/genproto/googleapis/logging/type.(*HttpRequest).GetLatency() *Duration
			func github.com/golang/protobuf/ptypes.DurationProto(d time.Duration) *durationpb.Duration
		
			func github.com/golang/protobuf/ptypes.Duration(dur *durationpb.Duration) (time.Duration, error)
			




Package-Level Functions (total 4, in which 1 are exported)


	
		New constructs a new Duration from the provided time.Duration.


	



Package-Level Constants (total 5, none are exported)