Documentation

Overview

    Package civil implements types for civil time, a time-zone-independent representation of time that follows the rules of the proleptic Gregorian calendar with exactly 24-hour days, 60-minute hours, and 60-second minutes.

    Because they lack location information, these types do not represent unique moments or intervals of time. Use time.Time for that purpose.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type Date

    type Date struct {
    	Year  int        // Year (e.g., 2014).
    	Month time.Month // Month of the year (January = 1, ...).
    	Day   int        // Day of the month, starting at 1.
    }

      A Date represents a date (year, month, day).

      This type does not include location information, and therefore does not describe a unique 24-hour timespan.

      func DateOf

      func DateOf(t time.Time) Date

        DateOf returns the Date in which a time occurs in that time's location.

        func ParseDate

        func ParseDate(s string) (Date, error)

          ParseDate parses a string in RFC3339 full-date format and returns the date value it represents.

          func (Date) AddDays

          func (d Date) AddDays(n int) Date

            AddDays returns the date that is n days in the future. n can also be negative to go into the past.

            func (Date) After

            func (d1 Date) After(d2 Date) bool

              After reports whether d1 occurs after d2.

              func (Date) Before

              func (d1 Date) Before(d2 Date) bool

                Before reports whether d1 occurs before d2.

                func (Date) DaysSince

                func (d Date) DaysSince(s Date) (days int)

                  DaysSince returns the signed number of days between the date and s, not including the end day. This is the inverse operation to AddDays.

                  func (Date) In

                  func (d Date) In(loc *time.Location) time.Time

                    In returns the time corresponding to time 00:00:00 of the date in the location.

                    In is always consistent with time.Date, even when time.Date returns a time on a different day. For example, if loc is America/Indiana/Vincennes, then both

                    time.Date(1955, time.May, 1, 0, 0, 0, 0, loc)
                    

                    and

                    civil.Date{Year: 1955, Month: time.May, Day: 1}.In(loc)
                    

                    return 23:00:00 on April 30, 1955.

                    In panics if loc is nil.

                    func (Date) IsValid

                    func (d Date) IsValid() bool

                      IsValid reports whether the date is valid.

                      func (Date) MarshalText

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

                        MarshalText implements the encoding.TextMarshaler interface. The output is the result of d.String().

                        func (Date) String

                        func (d Date) String() string

                          String returns the date in RFC3339 full-date format.

                          func (*Date) UnmarshalText

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

                            UnmarshalText implements the encoding.TextUnmarshaler interface. The date is expected to be a string in a format accepted by ParseDate.

                            type DateTime

                            type DateTime struct {
                            	Date Date
                            	Time Time
                            }

                              A DateTime represents a date and time.

                              This type does not include location information, and therefore does not describe a unique moment in time.

                              func DateTimeOf

                              func DateTimeOf(t time.Time) DateTime

                                DateTimeOf returns the DateTime in which a time occurs in that time's location.

                                func ParseDateTime

                                func ParseDateTime(s string) (DateTime, error)

                                  ParseDateTime parses a string and returns the DateTime it represents. ParseDateTime accepts a variant of the RFC3339 date-time format that omits the time offset but includes an optional fractional time, as described in ParseTime. Informally, the accepted format is

                                  YYYY-MM-DDTHH:MM:SS[.FFFFFFFFF]
                                  

                                  where the 'T' may be a lower-case 't'.

                                  func (DateTime) After

                                  func (dt1 DateTime) After(dt2 DateTime) bool

                                    After reports whether dt1 occurs after dt2.

                                    func (DateTime) Before

                                    func (dt1 DateTime) Before(dt2 DateTime) bool

                                      Before reports whether dt1 occurs before dt2.

                                      func (DateTime) In

                                      func (dt DateTime) In(loc *time.Location) time.Time

                                        In returns the time corresponding to the DateTime in the given location.

                                        If the time is missing or ambigous at the location, In returns the same result as time.Date. For example, if loc is America/Indiana/Vincennes, then both

                                        time.Date(1955, time.May, 1, 0, 30, 0, 0, loc)
                                        

                                        and

                                        civil.DateTime{
                                            civil.Date{Year: 1955, Month: time.May, Day: 1}},
                                            civil.Time{Minute: 30}}.In(loc)
                                        

                                        return 23:30:00 on April 30, 1955.

                                        In panics if loc is nil.

                                        func (DateTime) IsValid

                                        func (dt DateTime) IsValid() bool

                                          IsValid reports whether the datetime is valid.

                                          func (DateTime) MarshalText

                                          func (dt DateTime) MarshalText() ([]byte, error)

                                            MarshalText implements the encoding.TextMarshaler interface. The output is the result of dt.String().

                                            func (DateTime) String

                                            func (dt DateTime) String() string

                                              String returns the date in the format described in ParseDate.

                                              func (*DateTime) UnmarshalText

                                              func (dt *DateTime) UnmarshalText(data []byte) error

                                                UnmarshalText implements the encoding.TextUnmarshaler interface. The datetime is expected to be a string in a format accepted by ParseDateTime

                                                type Time

                                                type Time struct {
                                                	Hour       int // The hour of the day in 24-hour format; range [0-23]
                                                	Minute     int // The minute of the hour; range [0-59]
                                                	Second     int // The second of the minute; range [0-59]
                                                	Nanosecond int // The nanosecond of the second; range [0-999999999]
                                                }

                                                  A Time represents a time with nanosecond precision.

                                                  This type does not include location information, and therefore does not describe a unique moment in time.

                                                  This type exists to represent the TIME type in storage-based APIs like BigQuery. Most operations on Times are unlikely to be meaningful. Prefer the DateTime type.

                                                  func ParseTime

                                                  func ParseTime(s string) (Time, error)

                                                    ParseTime parses a string and returns the time value it represents. ParseTime accepts an extended form of the RFC3339 partial-time format. After the HH:MM:SS part of the string, an optional fractional part may appear, consisting of a decimal point followed by one to nine decimal digits. (RFC3339 admits only one digit after the decimal point).

                                                    func TimeOf

                                                    func TimeOf(t time.Time) Time

                                                      TimeOf returns the Time representing the time of day in which a time occurs in that time's location. It ignores the date.

                                                      func (Time) IsValid

                                                      func (t Time) IsValid() bool

                                                        IsValid reports whether the time is valid.

                                                        func (Time) MarshalText

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

                                                          MarshalText implements the encoding.TextMarshaler interface. The output is the result of t.String().

                                                          func (Time) String

                                                          func (t Time) String() string

                                                            String returns the date in the format described in ParseTime. If Nanoseconds is zero, no fractional part will be generated. Otherwise, the result will end with a fractional part consisting of a decimal point and nine digits.

                                                            func (*Time) UnmarshalText

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

                                                              UnmarshalText implements the encoding.TextUnmarshaler interface. The time is expected to be a string in a format accepted by ParseTime.

                                                              Source Files