vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: google/protobuf/timestamp.proto
   3
   4 /*
   5 Package timestamp is a generated protocol buffer package.
   6
   7 It is generated from these files:
   8         google/protobuf/timestamp.proto
   9
  10 It has these top-level messages:
  11         Timestamp
  12 */
  13 package timestamp
  14
  15 import proto "github.com/golang/protobuf/proto"
  16 import fmt "fmt"
  17 import math "math"
  18
  19 // Reference imports to suppress errors if they are not otherwise used.
  20 var _ = proto.Marshal
  21 var _ = fmt.Errorf
  22 var _ = math.Inf
  23
  24 // This is a compile-time assertion to ensure that this generated file
  25 // is compatible with the proto package it is being compiled against.
  26 // A compilation error at this line likely means your copy of the
  27 // proto package needs to be updated.
  28 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
  29
  30 // A Timestamp represents a point in time independent of any time zone
  31 // or calendar, represented as seconds and fractions of seconds at
  32 // nanosecond resolution in UTC Epoch time. It is encoded using the
  33 // Proleptic Gregorian Calendar which extends the Gregorian calendar
  34 // backwards to year one. It is encoded assuming all minutes are 60
  35 // seconds long, i.e. leap seconds are "smeared" so that no leap second
  36 // table is needed for interpretation. Range is from
  37 // 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
  38 // By restricting to that range, we ensure that we can convert to
  39 // and from  RFC 3339 date strings.
  40 // See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
  41 //
  42 // # Examples
  43 //
  44 // Example 1: Compute Timestamp from POSIX `time()`.
  45 //
  46 //     Timestamp timestamp;
  47 //     timestamp.set_seconds(time(NULL));
  48 //     timestamp.set_nanos(0);
  49 //
  50 // Example 2: Compute Timestamp from POSIX `gettimeofday()`.
  51 //
  52 //     struct timeval tv;
  53 //     gettimeofday(&tv, NULL);
  54 //
  55 //     Timestamp timestamp;
  56 //     timestamp.set_seconds(tv.tv_sec);
  57 //     timestamp.set_nanos(tv.tv_usec * 1000);
  58 //
  59 // Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
  60 //
  61 //     FILETIME ft;
  62 //     GetSystemTimeAsFileTime(&ft);
  63 //     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
  64 //
  65 //     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
  66 //     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
  67 //     Timestamp timestamp;
  68 //     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
  69 //     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
  70 //
  71 // Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
  72 //
  73 //     long millis = System.currentTimeMillis();
  74 //
  75 //     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
  76 //         .setNanos((int) ((millis % 1000) * 1000000)).build();
  77 //
  78 //
  79 // Example 5: Compute Timestamp from current time in Python.
  80 //
  81 //     timestamp = Timestamp()
  82 //     timestamp.GetCurrentTime()
  83 //
  84 // # JSON Mapping
  85 //
  86 // In JSON format, the Timestamp type is encoded as a string in the
  87 // [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
  88 // format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
  89 // where {year} is always expressed using four digits while {month}, {day},
  90 // {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
  91 // seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
  92 // are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
  93 // is required, though only UTC (as indicated by "Z") is presently supported.
  94 //
  95 // For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
  96 // 01:30 UTC on January 15, 2017.
  97 //
  98 // In JavaScript, one can convert a Date object to this format using the
  99 // standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString]
 100 // method. In Python, a standard `datetime.datetime` object can be converted
 101 // to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime)
 102 // with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one
 103 // can use the Joda Time's [`ISODateTimeFormat.dateTime()`](
 104 // http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime())
 105 // to obtain a formatter capable of generating timestamps in this format.
 106 //
 107 //
 108 type Timestamp struct {
 109         // Represents seconds of UTC time since Unix epoch
 110         // 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
 111         // 9999-12-31T23:59:59Z inclusive.
 112         Seconds int64 `protobuf:"varint,1,opt,name=seconds" json:"seconds,omitempty"`
 113         // Non-negative fractions of a second at nanosecond resolution. Negative
 114         // second values with fractions must still have non-negative nanos values
 115         // that count forward in time. Must be from 0 to 999,999,999
 116         // inclusive.
 117         Nanos int32 `protobuf:"varint,2,opt,name=nanos" json:"nanos,omitempty"`
 118 }
 119
 120 func (m *Timestamp) Reset()                    { *m = Timestamp{} }
 121 func (m *Timestamp) String() string            { return proto.CompactTextString(m) }
 122 func (*Timestamp) ProtoMessage()               {}
 123 func (*Timestamp) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 124 func (*Timestamp) XXX_WellKnownType() string   { return "Timestamp" }
 125
 126 func (m *Timestamp) GetSeconds() int64 {
 127         if m != nil {
 128                 return m.Seconds
 129         }
 130         return 0
 131 }
 132
 133 func (m *Timestamp) GetNanos() int32 {
 134         if m != nil {
 135                 return m.Nanos
 136         }
 137         return 0
 138 }
 139
 140 func init() {
 141         proto.RegisterType((*Timestamp)(nil), "google.protobuf.Timestamp")
 142 }
 143
 144 func init() { proto.RegisterFile("google/protobuf/timestamp.proto", fileDescriptor0) }
 145
 146 var fileDescriptor0 = []byte{
 147         // 191 bytes of a gzipped FileDescriptorProto
 148         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4f, 0xcf, 0xcf, 0x4f,
 149         0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0xc9, 0xcc, 0x4d,
 150         0x2d, 0x2e, 0x49, 0xcc, 0x2d, 0xd0, 0x03, 0x0b, 0x09, 0xf1, 0x43, 0x14, 0xe8, 0xc1, 0x14, 0x28,
 151         0x59, 0x73, 0x71, 0x86, 0xc0, 0xd4, 0x08, 0x49, 0x70, 0xb1, 0x17, 0xa7, 0x26, 0xe7, 0xe7, 0xa5,
 152         0x14, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0x30, 0x07, 0xc1, 0xb8, 0x42, 0x22, 0x5c, 0xac, 0x79, 0x89,
 153         0x79, 0xf9, 0xc5, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0xac, 0x41, 0x10, 0x8e, 0x53, 0x1d, 0x97, 0x70,
 154         0x72, 0x7e, 0xae, 0x1e, 0x9a, 0x99, 0x4e, 0x7c, 0x70, 0x13, 0x03, 0x40, 0x42, 0x01, 0x8c, 0x51,
 155         0xda, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0xe9, 0xf9, 0x39, 0x89,
 156         0x79, 0xe9, 0x08, 0x27, 0x16, 0x94, 0x54, 0x16, 0xa4, 0x16, 0x23, 0x5c, 0xfa, 0x83, 0x91, 0x71,
 157         0x11, 0x13, 0xb3, 0x7b, 0x80, 0xd3, 0x2a, 0x26, 0x39, 0x77, 0x88, 0xc9, 0x01, 0x50, 0xb5, 0x7a,
 158         0xe1, 0xa9, 0x39, 0x39, 0xde, 0x79, 0xf9, 0xe5, 0x79, 0x21, 0x20, 0x3d, 0x49, 0x6c, 0x60, 0x43,
 159         0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x77, 0x4a, 0x07, 0xf7, 0x00, 0x00, 0x00,
 160 }