cipd: instance cache

common/proto/google/util.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package google
 
 import (
         "time"
 )
 
 const (
         nanosecondsInASecond = int64(time.Second / time.Nanosecond)
 )
 
 // NewTimestamp creates a new Timestamp protobuf from a time.Time type.
 func NewTimestamp(t time.Time) *Timestamp {
         if t.IsZero() {
                 return nil
         }
 
         return &Timestamp{
                 Seconds: t.Unix(),
                 Nanos:   int32(t.Nanosecond()),
         }
 }
 
+// FromTime sets t to the timestamp of the given time.Time value.
+func (t *Timestamp) FromTime(other time.Time) {

[Vadim Sh., 2016/04/11 16:52:03]

what if 'other' is Zero?

other.Unix() returns some nonsense in that case

I'd prefer NewTimestamp to be used always, since in proto fields we usually have
*Timestamp, and doing proto.timestamp = google.NewTimestamp(...) deals correctly
with zero time.

[nodir, 2016/04/11 22:16:16]

Done.

+        t.Seconds = other.Unix()
+        t.Nanos = int32(other.Nanosecond())
+}
+
 // Time returns the time.Time associated with a Timestamp protobuf.
 func (t *Timestamp) Time() time.Time {
         if t == nil {
                 return time.Time{}
         }
         return time.Unix(t.Seconds, int64(t.Nanos)).UTC()
 }
 
 // NewDuration creates a new Duration protobuf from a time.Duration.
 func NewDuration(d time.Duration) *Duration {
         if d == 0 {
                 return nil
         }
 
         nanos := d.Nanoseconds()
         return &Duration{
                 Seconds: nanos / nanosecondsInASecond,
                 Nanos:   int32(nanos % nanosecondsInASecond),
         }
 }
 
 // Duration returns the time.Duration associated with a Duration protobuf.
 func (d *Duration) Duration() time.Duration {
         if d == nil {
                 return 0
         }
         return (time.Duration(d.Seconds) * time.Second) + (time.Duration(d.Nanos) * time.Nanosecond)
 }