Documentation

Overview

    Package date provides time.Time derivatives that conform to the Swagger.io (https://swagger.io/) defined date formats: Date and DateTime. Both types may, in most cases, be used in lieu of time.Time types. And both convert to time.Time through a ToTime method.

    Index

    Examples

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func ParseTime

    func ParseTime(format string, t string) (d time.Time, err error)

      ParseTime to parse Time string to specified format.

      Example

      Code:

      d, _ := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
      fmt.Println(d)
      
      2001-02-03 04:05:06 +0000 UTC
      

      func UnixEpoch

      func UnixEpoch() time.Time

        UnixEpoch retreives the moment considered the Unix Epoch. I.e. The time represented by '0'

        Types

        type Date

        type Date struct {
        	time.Time
        }

          Date defines a type similar to time.Time but assumes a layout of RFC3339 full-date (i.e., 2006-01-02).

          Example

          Code:

          d, err := ParseDate("2001-02-03")
          if err != nil {
          	fmt.Println(err)
          }
          
          t, err := time.Parse(time.RFC3339, "2001-02-04T00:00:00Z")
          if err != nil {
          	fmt.Println(err)
          }
          
          // Date acts as time.Time when the receiver
          if d.Before(t) {
          	fmt.Printf("Before ")
          } else {
          	fmt.Printf("After ")
          }
          
          // Convert Date when needing a time.Time
          if t.After(d.ToTime()) {
          	fmt.Printf("After")
          } else {
          	fmt.Printf("Before")
          }
          
          Before After
          

          func ParseDate

          func ParseDate(date string) (d Date, err error)

            ParseDate create a new Date from the passed string.

            Example

            Code:

            d, err := ParseDate("2001-02-03")
            if err != nil {
            	fmt.Println(err)
            }
            fmt.Println(d)
            
            2001-02-03
            

            func (Date) MarshalBinary

            func (d Date) MarshalBinary() ([]byte, error)

              MarshalBinary preserves the Date as a byte array conforming to RFC3339 full-date (i.e., 2006-01-02).

              Example

              Code:

              d, err := ParseDate("2001-02-03")
              if err != nil {
              	fmt.Println(err)
              }
              t, err := d.MarshalBinary()
              if err != nil {
              	fmt.Println(err)
              }
              fmt.Println(string(t))
              
              2001-02-03
              

              func (Date) MarshalJSON

              func (d Date) MarshalJSON() (json []byte, err error)

                MarshalJSON preserves the Date as a JSON string conforming to RFC3339 full-date (i.e., 2006-01-02).

                Example

                Code:

                d, err := ParseDate("2001-02-03")
                if err != nil {
                	fmt.Println(err)
                }
                j, err := json.Marshal(d)
                if err != nil {
                	fmt.Println(err)
                }
                fmt.Println(string(j))
                
                "2001-02-03"
                

                func (Date) MarshalText

                func (d Date) MarshalText() (text []byte, err error)

                  MarshalText preserves the Date as a byte array conforming to RFC3339 full-date (i.e., 2006-01-02).

                  Example

                  Code:

                  d, err := ParseDate("2001-02-03")
                  if err != nil {
                  	fmt.Println(err)
                  }
                  t, err := d.MarshalText()
                  if err != nil {
                  	fmt.Println(err)
                  }
                  fmt.Println(string(t))
                  
                  2001-02-03
                  

                  func (Date) String

                  func (d Date) String() string

                    String returns the Date formatted as an RFC3339 full-date string (i.e., 2006-01-02).

                    func (Date) ToTime

                    func (d Date) ToTime() time.Time

                      ToTime returns a Date as a time.Time

                      func (*Date) UnmarshalBinary

                      func (d *Date) UnmarshalBinary(data []byte) error

                        UnmarshalBinary reconstitutes a Date saved as a byte array conforming to RFC3339 full-date (i.e., 2006-01-02).

                        Example

                        Code:

                        d := Date{}
                        t := "2001-02-03"
                        
                        if err := d.UnmarshalBinary([]byte(t)); err != nil {
                        	fmt.Println(err)
                        }
                        fmt.Println(d)
                        
                        2001-02-03
                        

                        func (*Date) UnmarshalJSON

                        func (d *Date) UnmarshalJSON(data []byte) (err error)

                          UnmarshalJSON reconstitutes the Date from a JSON string conforming to RFC3339 full-date (i.e., 2006-01-02).

                          Example

                          Code:

                          var d struct {
                          	Date Date `json:"date"`
                          }
                          j := `{"date" : "2001-02-03"}`
                          
                          if err := json.Unmarshal([]byte(j), &d); err != nil {
                          	fmt.Println(err)
                          }
                          fmt.Println(d.Date)
                          
                          2001-02-03
                          

                          func (*Date) UnmarshalText

                          func (d *Date) UnmarshalText(data []byte) (err error)

                            UnmarshalText reconstitutes a Date saved as a byte array conforming to RFC3339 full-date (i.e., 2006-01-02).

                            Example

                            Code:

                            d := Date{}
                            t := "2001-02-03"
                            
                            if err := d.UnmarshalText([]byte(t)); err != nil {
                            	fmt.Println(err)
                            }
                            fmt.Println(d)
                            
                            2001-02-03
                            

                            type Time

                            type Time struct {
                            	time.Time
                            }

                              Time defines a type similar to time.Time but assumes a layout of RFC3339 date-time (i.e., 2006-01-02T15:04:05Z).

                              func (Time) MarshalBinary

                              func (t Time) MarshalBinary() ([]byte, error)

                                MarshalBinary preserves the Time as a byte array conforming to RFC3339 date-time (i.e., 2006-01-02T15:04:05Z).

                                Example

                                Code:

                                ti, err := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
                                if err != nil {
                                	fmt.Println(err)
                                }
                                d := Time{ti}
                                t, err := d.MarshalBinary()
                                if err != nil {
                                	fmt.Println(err)
                                }
                                fmt.Println(string(t))
                                
                                2001-02-03T04:05:06Z
                                

                                func (Time) MarshalJSON

                                func (t Time) MarshalJSON() (json []byte, err error)

                                  MarshalJSON preserves the Time as a JSON string conforming to RFC3339 date-time (i.e., 2006-01-02T15:04:05Z).

                                  Example

                                  Code:

                                  d, err := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
                                  if err != nil {
                                  	fmt.Println(err)
                                  }
                                  j, err := json.Marshal(d)
                                  if err != nil {
                                  	fmt.Println(err)
                                  }
                                  fmt.Println(string(j))
                                  
                                  "2001-02-03T04:05:06Z"
                                  

                                  func (Time) MarshalText

                                  func (t Time) MarshalText() (text []byte, err error)

                                    MarshalText preserves the Time as a byte array conforming to RFC3339 date-time (i.e., 2006-01-02T15:04:05Z).

                                    Example

                                    Code:

                                    d, err := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
                                    if err != nil {
                                    	fmt.Println(err)
                                    }
                                    t, err := d.MarshalText()
                                    if err != nil {
                                    	fmt.Println(err)
                                    }
                                    fmt.Println(string(t))
                                    
                                    2001-02-03T04:05:06Z
                                    

                                    func (Time) String

                                    func (t Time) String() string

                                      String returns the Time formatted as an RFC3339 date-time string (i.e., 2006-01-02T15:04:05Z).

                                      func (Time) ToTime

                                      func (t Time) ToTime() time.Time

                                        ToTime returns a Time as a time.Time

                                        func (*Time) UnmarshalBinary

                                        func (t *Time) UnmarshalBinary(data []byte) error

                                          UnmarshalBinary reconstitutes a Time saved as a byte array conforming to RFC3339 date-time (i.e., 2006-01-02T15:04:05Z).

                                          Example

                                          Code:

                                          d := Time{}
                                          t := "2001-02-03T04:05:06Z"
                                          
                                          if err := d.UnmarshalBinary([]byte(t)); err != nil {
                                          	fmt.Println(err)
                                          }
                                          fmt.Println(d)
                                          
                                          2001-02-03T04:05:06Z
                                          

                                          func (*Time) UnmarshalJSON

                                          func (t *Time) UnmarshalJSON(data []byte) (err error)

                                            UnmarshalJSON reconstitutes the Time from a JSON string conforming to RFC3339 date-time (i.e., 2006-01-02T15:04:05Z).

                                            Example

                                            Code:

                                            var d struct {
                                            	Time Time `json:"datetime"`
                                            }
                                            j := `{"datetime" : "2001-02-03T04:05:06Z"}`
                                            
                                            if err := json.Unmarshal([]byte(j), &d); err != nil {
                                            	fmt.Println(err)
                                            }
                                            fmt.Println(d.Time)
                                            
                                            2001-02-03T04:05:06Z
                                            

                                            func (*Time) UnmarshalText

                                            func (t *Time) UnmarshalText(data []byte) (err error)

                                              UnmarshalText reconstitutes a Time saved as a byte array conforming to RFC3339 date-time (i.e., 2006-01-02T15:04:05Z).

                                              Example

                                              Code:

                                              d := Time{}
                                              t := "2001-02-03T04:05:06Z"
                                              
                                              if err := d.UnmarshalText([]byte(t)); err != nil {
                                              	fmt.Println(err)
                                              }
                                              fmt.Println(d)
                                              
                                              2001-02-03T04:05:06Z
                                              

                                              type TimeRFC1123

                                              type TimeRFC1123 struct {
                                              	time.Time
                                              }

                                                TimeRFC1123 defines a type similar to time.Time but assumes a layout of RFC1123 date-time (i.e., Mon, 02 Jan 2006 15:04:05 MST).

                                                Example

                                                Code:

                                                d, err := ParseTime(rfc1123, "Mon, 02 Jan 2006 15:04:05 MST")
                                                if err != nil {
                                                	fmt.Println(err)
                                                }
                                                fmt.Println(d)
                                                
                                                2006-01-02 15:04:05 +0000 MST
                                                

                                                func (TimeRFC1123) MarshalBinary

                                                func (t TimeRFC1123) MarshalBinary() ([]byte, error)

                                                  MarshalBinary preserves the Time as a byte array conforming to RFC1123 date-time (i.e., Mon, 02 Jan 2006 15:04:05 MST).

                                                  Example

                                                  Code:

                                                  ti, err := ParseTime(rfc1123, "Mon, 02 Jan 2006 15:04:05 MST")
                                                  if err != nil {
                                                  	fmt.Println(err)
                                                  }
                                                  d := TimeRFC1123{ti}
                                                  b, err := d.MarshalBinary()
                                                  if err != nil {
                                                  	fmt.Println(err)
                                                  }
                                                  fmt.Println(string(b))
                                                  
                                                  Mon, 02 Jan 2006 15:04:05 MST
                                                  

                                                  func (TimeRFC1123) MarshalJSON

                                                  func (t TimeRFC1123) MarshalJSON() ([]byte, error)

                                                    MarshalJSON preserves the Time as a JSON string conforming to RFC1123 date-time (i.e., Mon, 02 Jan 2006 15:04:05 MST).

                                                    Example

                                                    Code:

                                                    ti, err := ParseTime(rfc1123, "Mon, 02 Jan 2006 15:04:05 MST")
                                                    if err != nil {
                                                    	fmt.Println(err)
                                                    }
                                                    d := TimeRFC1123{ti}
                                                    j, err := json.Marshal(d)
                                                    if err != nil {
                                                    	fmt.Println(err)
                                                    }
                                                    fmt.Println(string(j))
                                                    
                                                    "Mon, 02 Jan 2006 15:04:05 MST"
                                                    

                                                    func (TimeRFC1123) MarshalText

                                                    func (t TimeRFC1123) MarshalText() ([]byte, error)

                                                      MarshalText preserves the Time as a byte array conforming to RFC1123 date-time (i.e., Mon, 02 Jan 2006 15:04:05 MST).

                                                      Example

                                                      Code:

                                                      ti, err := ParseTime(rfc3339, "2001-02-03T04:05:06Z")
                                                      if err != nil {
                                                      	fmt.Println(err)
                                                      }
                                                      d := TimeRFC1123{ti}
                                                      t, err := d.MarshalText()
                                                      if err != nil {
                                                      	fmt.Println(err)
                                                      }
                                                      fmt.Println(string(t))
                                                      
                                                      Sat, 03 Feb 2001 04:05:06 UTC
                                                      

                                                      func (TimeRFC1123) String

                                                      func (t TimeRFC1123) String() string

                                                        String returns the Time formatted as an RFC1123 date-time string (i.e., Mon, 02 Jan 2006 15:04:05 MST).

                                                        func (TimeRFC1123) ToTime

                                                        func (t TimeRFC1123) ToTime() time.Time

                                                          ToTime returns a Time as a time.Time

                                                          func (*TimeRFC1123) UnmarshalBinary

                                                          func (t *TimeRFC1123) UnmarshalBinary(data []byte) error

                                                            UnmarshalBinary reconstitutes a Time saved as a byte array conforming to RFC1123 date-time (i.e., Mon, 02 Jan 2006 15:04:05 MST).

                                                            Example

                                                            Code:

                                                            d := TimeRFC1123{}
                                                            t := "Mon, 02 Jan 2006 15:04:05 MST"
                                                            if err := d.UnmarshalBinary([]byte(t)); err != nil {
                                                            	fmt.Println(err)
                                                            }
                                                            fmt.Println(d)
                                                            
                                                            Mon, 02 Jan 2006 15:04:05 MST
                                                            

                                                            func (*TimeRFC1123) UnmarshalJSON

                                                            func (t *TimeRFC1123) UnmarshalJSON(data []byte) (err error)

                                                              UnmarshalJSON reconstitutes the Time from a JSON string conforming to RFC1123 date-time (i.e., Mon, 02 Jan 2006 15:04:05 MST).

                                                              Example

                                                              Code:

                                                              var d struct {
                                                              	Time TimeRFC1123 `json:"datetime"`
                                                              }
                                                              j := `{"datetime" : "Mon, 02 Jan 2006 15:04:05 MST"}`
                                                              
                                                              if err := json.Unmarshal([]byte(j), &d); err != nil {
                                                              	fmt.Println(err)
                                                              }
                                                              fmt.Println(d.Time)
                                                              
                                                              Mon, 02 Jan 2006 15:04:05 MST
                                                              

                                                              func (*TimeRFC1123) UnmarshalText

                                                              func (t *TimeRFC1123) UnmarshalText(data []byte) (err error)

                                                                UnmarshalText reconstitutes a Time saved as a byte array conforming to RFC1123 date-time (i.e., Mon, 02 Jan 2006 15:04:05 MST).

                                                                Example

                                                                Code:

                                                                d := TimeRFC1123{}
                                                                t := "Sat, 03 Feb 2001 04:05:06 UTC"
                                                                
                                                                if err := d.UnmarshalText([]byte(t)); err != nil {
                                                                	fmt.Println(err)
                                                                }
                                                                fmt.Println(d)
                                                                
                                                                Sat, 03 Feb 2001 04:05:06 UTC
                                                                

                                                                type UnixTime

                                                                type UnixTime time.Time

                                                                  UnixTime marshals and unmarshals a time that is represented as the number of seconds (ignoring skip-seconds) since the Unix Epoch.

                                                                  func NewUnixTimeFromDuration

                                                                  func NewUnixTimeFromDuration(dur time.Duration) UnixTime

                                                                    NewUnixTimeFromDuration creates a UnixTime as a duration of time since the UnixEpoch.

                                                                    func NewUnixTimeFromNanoseconds

                                                                    func NewUnixTimeFromNanoseconds(nanoseconds int64) UnixTime

                                                                      NewUnixTimeFromNanoseconds creates a UnixTime as a number of nanoseconds from the UnixEpoch.

                                                                      func NewUnixTimeFromSeconds

                                                                      func NewUnixTimeFromSeconds(seconds float64) UnixTime

                                                                        NewUnixTimeFromSeconds creates a UnixTime as a number of seconds from the UnixEpoch.

                                                                        func (UnixTime) Duration

                                                                        func (t UnixTime) Duration() time.Duration

                                                                          Duration returns the time as a Duration since the UnixEpoch.

                                                                          func (UnixTime) MarshalBinary

                                                                          func (t UnixTime) MarshalBinary() ([]byte, error)

                                                                            MarshalBinary converts a UnixTime into a binary.LittleEndian float64 of nanoseconds since the epoch.

                                                                            func (UnixTime) MarshalJSON

                                                                            func (t UnixTime) MarshalJSON() ([]byte, error)

                                                                              MarshalJSON preserves the UnixTime as a JSON number conforming to Unix Timestamp requirements. (i.e. the number of seconds since midnight January 1st, 1970 not considering leap seconds.)

                                                                              Example

                                                                              Code:

                                                                              epoch := UnixTime(UnixEpoch())
                                                                              text, _ := json.Marshal(epoch)
                                                                              fmt.Print(string(text))
                                                                              
                                                                              0
                                                                              

                                                                              func (UnixTime) MarshalText

                                                                              func (t UnixTime) MarshalText() ([]byte, error)

                                                                                MarshalText stores the number of seconds since the Unix Epoch as a textual floating point number.

                                                                                func (*UnixTime) UnmarshalBinary

                                                                                func (t *UnixTime) UnmarshalBinary(raw []byte) error

                                                                                  UnmarshalBinary converts a from a binary.LittleEndian float64 of nanoseconds since the epoch into a UnixTime.

                                                                                  func (*UnixTime) UnmarshalJSON

                                                                                  func (t *UnixTime) UnmarshalJSON(text []byte) error

                                                                                    UnmarshalJSON reconstitures a UnixTime saved as a JSON number of the number of seconds since midnight January 1st, 1970.

                                                                                    Example

                                                                                    Code:

                                                                                    var myTime UnixTime
                                                                                    json.Unmarshal([]byte("1.3e2"), &myTime)
                                                                                    fmt.Printf("%v", time.Time(myTime))
                                                                                    
                                                                                    1970-01-01 00:02:10 +0000 UTC
                                                                                    

                                                                                    func (*UnixTime) UnmarshalText

                                                                                    func (t *UnixTime) UnmarshalText(raw []byte) error

                                                                                      UnmarshalText populates a UnixTime with a value stored textually as a floating point number of seconds since the Unix Epoch.