Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

chron

package module

Go to main page

Versions in this module

v1

v1.0.0

Feb 4, 2018

Changes in this version

+ const CCMonth

+ const DashDDMMMYY

+ const DashDDMMMYYYY

+ const DashMMDDYY

+ const DashMMDDYYYY

+ const DashMonth

+ const DashMonthShort

+ const DashNumMonth

+ const DashNumMonthShort

+ const ShortDateTime

+ const ShortDateTime24

+ const ShortSecond

+ const ShortSecond24

+ const SlashMMDDYY

+ const SlashMMDDYYYY

+ const YearFmt

+ var ParseFormats = []string

+ var ParseFunctions = []func(string) (time.Time, error)

+ func ErrJoin(errs []error, delim string) error

+ func Parse(s string) (time.Time, error)

+ func ParseUnixSeconds(secs string) (time.Time, error)

+ func ParseWithFormats(s string) (time.Time, error)

+ func ZeroTime() time.Time

+ type Chron struct

+ func (t *Chron) Scan(value interface{}) error

+ func (t Chron) AddDays(d int) Chron

+ func (t Chron) AddHours(h int) Chron

+ func (t Chron) AddMicros(m int) Chron

+ func (t Chron) AddMillis(m int) Chron

+ func (t Chron) AddMinutes(m int) Chron

+ func (t Chron) AddMonths(m int) Chron

+ func (t Chron) AddN(n int) Chron

+ func (t Chron) AddNanos(n int) Chron

+ func (t Chron) AddSeconds(s int) Chron

+ func (t Chron) AddYears(y int) Chron

+ func (t Chron) After(s Span) bool

+ func (t Chron) AsChron() Chron

+ func (t Chron) AsDay() Day

+ func (t Chron) AsHour() Hour

+ func (t Chron) AsMicro() Micro

+ func (t Chron) AsMilli() Milli

+ func (t Chron) AsMinute() Minute

+ func (t Chron) AsMonth() Month

+ func (t Chron) AsSecond() Second

+ func (t Chron) AsTime() time.Time

+ func (t Chron) AsYear() Year

+ func (t Chron) Before(s Span) bool

+ func (t Chron) Contains(s Span) bool

+ func (t Chron) Decrement(d dura.Time) Chron

+ func (t Chron) Duration() dura.Time

+ func (t Chron) End() Chron

+ func (t Chron) Increment(d dura.Time) Chron

+ func (t Chron) Start() Chron

+ func (t Chron) Value() (driver.Value, error)

+ type Comparer interface

+ After func(Span) bool

+ Before func(Span) bool

+ Contains func(Span) bool

type Day

+ func (d *Day) UnmarshalJSON(data []byte) error

+ func (d Day) AddMicros(m int) Micro

+ func (d Day) AddNanos(n int) Chron

+ func (d Day) AsChron() Chron

type Hour

+ func (h *Hour) UnmarshalJSON(data []byte) error

+ func (h Hour) AddMicros(m int) Micro

+ func (h Hour) AddNanos(n int) Chron

+ func (h Hour) AsChron() Chron

+ type Incrementer interface

+ Decrement func(dura.Time) Chron

+ Increment func(dura.Time) Chron

+ type Interval struct

+ func NewInterval(start Chron, d dura.Time) *Interval

+ func (s Interval) After(t Span) bool

+ func (s Interval) Before(t Span) bool

+ func (s Interval) Contains(t Span) bool

+ func (s Interval) Duration() dura.Time

+ func (s Interval) End() Chron

+ func (s Interval) Start() Chron

+ func (s Interval) String() string

type Micro

+ func (m *Micro) UnmarshalJSON(data []byte) error

+ func (m Micro) AddMicros(ms int) Micro

+ func (m Micro) AddNanos(n int) Chron

+ func (m Micro) AsChron() Chron

type Milli

+ func (m *Milli) UnmarshalJSON(data []byte) error

+ func (m Milli) AddMicros(ms int) Micro

+ func (m Milli) AddNanos(n int) Chron

+ func (m Milli) AsChron() Chron

type Minute

+ func (m *Minute) UnmarshalJSON(data []byte) error

+ func (m Minute) AddMicros(ms int) Micro

+ func (m Minute) AddNanos(n int) Chron

+ func (m Minute) AsChron() Chron

type Month

+ func (m *Month) UnmarshalJSON(data []byte) error

+ func (m Month) AddMicros(mi int) Micro

+ func (m Month) AddNanos(n int) Chron

+ func (m Month) AsChron() Chron

type Second

+ func (s *Second) UnmarshalJSON(data []byte) error

+ func (s Second) AddMicros(m int) Micro

+ func (s Second) AddNanos(n int) Chron

+ func (s Second) AsChron() Chron

type Time

+ AsChron func() Chron

type Year

+ func (y *Year) UnmarshalJSON(data []byte) error

+ func (y Year) AddMicros(m int) Micro

+ func (y Year) AddNanos(n int) Chron

+ func (y Year) AsChron() Chron

v0

v0.0.0

Jan 16, 2018

Changes in this version

+ type Comparable interface

+ After func(Span) bool

+ Before func(Span) bool

+ Contains func(Span) bool

+ type Day struct

+ func DayOf(time time.Time) Day

+ func NewDay(year int, month time.Month, day int) Day

+ func Today() Day

+ func (d *Day) Scan(value interface{}) error

+ func (d Day) AddDays(ds int) Day

+ func (d Day) AddHours(h int) Hour

+ func (d Day) AddMicro(m int) Micro

+ func (d Day) AddMillis(m int) Milli

+ func (d Day) AddMinutes(m int) Minute

+ func (d Day) AddMonths(m int) Day

+ func (d Day) AddN(n int) Day

+ func (d Day) AddNano(n int) TimeExact

+ func (d Day) AddSeconds(s int) Second

+ func (d Day) AddYears(y int) Day

+ func (d Day) After(t Span) bool

+ func (d Day) AsDay() Day

+ func (d Day) AsHour() Hour

+ func (d Day) AsMicro() Micro

+ func (d Day) AsMilli() Milli

+ func (d Day) AsMinute() Minute

+ func (d Day) AsMonth() Month

+ func (d Day) AsSecond() Second

+ func (d Day) AsTime() time.Time

+ func (d Day) AsTimeExact() TimeExact

+ func (d Day) AsYear() Year

+ func (d Day) Before(t Span) bool

+ func (d Day) Contains(t Span) bool

+ func (d Day) Decrement(t dura.Time) TimeExact

+ func (d Day) Duration() dura.Time

+ func (d Day) End() TimeExact

+ func (d Day) Increment(t dura.Time) TimeExact

+ func (d Day) Start() TimeExact

+ func (d Day) Value() (driver.Value, error)

+ type Filter struct

+ func NewFilter(fn FilterFunc, priority int, invert bool) *Filter

+ func (f Filter) Check(t Time) (filtered bool, span Span)

+ func (f Filter) Priority() int

+ type FilterFunc func(Time) (filtered bool, span Span)

+ type Hour struct

+ func HourOf(time time.Time) Hour

+ func NewHour(year int, month time.Month, day, hour int) Hour

+ func ThisHour() Hour

+ func (h *Hour) Scan(value interface{}) error

+ func (h Hour) AddDays(d int) Hour

+ func (h Hour) AddHours(hs int) Hour

+ func (h Hour) AddMicro(m int) Micro

+ func (h Hour) AddMillis(m int) Milli

+ func (h Hour) AddMinutes(m int) Minute

+ func (h Hour) AddMonths(m int) Hour

+ func (h Hour) AddN(n int) Hour

+ func (h Hour) AddNano(n int) TimeExact

+ func (h Hour) AddSeconds(s int) Second

+ func (h Hour) AddYears(y int) Hour

+ func (h Hour) After(t Span) bool

+ func (h Hour) AsDay() Day

+ func (h Hour) AsHour() Hour

+ func (h Hour) AsMicro() Micro

+ func (h Hour) AsMilli() Milli

+ func (h Hour) AsMinute() Minute

+ func (h Hour) AsMonth() Month

+ func (h Hour) AsSecond() Second

+ func (h Hour) AsTime() time.Time

+ func (h Hour) AsTimeExact() TimeExact

+ func (h Hour) AsYear() Year

+ func (h Hour) Before(t Span) bool

+ func (h Hour) Contains(t Span) bool

+ func (h Hour) Decrement(l dura.Time) TimeExact

+ func (h Hour) Duration() dura.Time

+ func (h Hour) End() TimeExact

+ func (h Hour) Increment(l dura.Time) TimeExact

+ func (h Hour) Start() TimeExact

+ func (h Hour) Value() (driver.Value, error)

+ type Incrementable interface

+ Decrement func(dura.Time) TimeExact

+ Increment func(dura.Time) TimeExact

+ type Micro struct

+ func MicroOf(t time.Time) Micro

+ func NewMicro(year int, month time.Month, day, hour, min, sec, micro int) Micro

+ func ThisMicro() Micro

+ func (m *Micro) Scan(value interface{}) error

+ func (m Micro) AddDays(d int) Micro

+ func (m Micro) AddHours(h int) Micro

+ func (m Micro) AddMicro(ms int) Micro

+ func (m Micro) AddMillis(ms int) Micro

+ func (m Micro) AddMinutes(ms int) Micro

+ func (m Micro) AddMonths(ms int) Micro

+ func (m Micro) AddN(n int) Micro

+ func (m Micro) AddNano(n int) TimeExact

+ func (m Micro) AddSeconds(s int) Micro

+ func (m Micro) AddYears(y int) Micro

+ func (m Micro) After(t Span) bool

+ func (m Micro) AsDay() Day

+ func (m Micro) AsHour() Hour

+ func (m Micro) AsMicro() Micro

+ func (m Micro) AsMilli() Milli

+ func (m Micro) AsMinute() Minute

+ func (m Micro) AsMonth() Month

+ func (m Micro) AsSecond() Second

+ func (m Micro) AsTime() time.Time

+ func (m Micro) AsTimeExact() TimeExact

+ func (m Micro) AsYear() Year

+ func (m Micro) Before(t Span) bool

+ func (m Micro) Contains(t Span) bool

+ func (m Micro) Decrement(l dura.Time) TimeExact

+ func (m Micro) Duration() dura.Time

+ func (m Micro) End() TimeExact

+ func (m Micro) Increment(l dura.Time) TimeExact

+ func (m Micro) Start() TimeExact

+ func (m Micro) Value() (driver.Value, error)

+ type Milli struct

+ func MilliOf(t time.Time) Milli

+ func NewMilli(year int, month time.Month, day, hour, min, sec, milli int) Milli

+ func ThisMilli() Milli

+ func (m *Milli) Scan(value interface{}) error

+ func (m Milli) AddDays(d int) Milli

+ func (m Milli) AddHours(h int) Milli

+ func (m Milli) AddMicro(ms int) Micro

+ func (m Milli) AddMillis(ms int) Milli

+ func (m Milli) AddMinutes(ms int) Milli

+ func (m Milli) AddMonths(ms int) Milli

+ func (m Milli) AddN(n int) Milli

+ func (m Milli) AddNano(n int) TimeExact

+ func (m Milli) AddSeconds(s int) Milli

+ func (m Milli) AddYears(y int) Milli

+ func (m Milli) After(t Span) bool

+ func (m Milli) AsDay() Day

+ func (m Milli) AsHour() Hour

+ func (m Milli) AsMicro() Micro

+ func (m Milli) AsMilli() Milli

+ func (m Milli) AsMinute() Minute

+ func (m Milli) AsMonth() Month

+ func (m Milli) AsSecond() Second

+ func (m Milli) AsTime() time.Time

+ func (m Milli) AsTimeExact() TimeExact

+ func (m Milli) AsYear() Year

+ func (m Milli) Before(t Span) bool

+ func (m Milli) Contains(t Span) bool

+ func (m Milli) Decrement(l dura.Time) TimeExact

+ func (m Milli) Duration() dura.Time

+ func (m Milli) End() TimeExact

+ func (m Milli) Increment(l dura.Time) TimeExact

+ func (m Milli) Start() TimeExact

+ func (m Milli) Value() (driver.Value, error)

+ type Minute struct

+ func MinuteOf(time time.Time) Minute

+ func NewMinute(year int, month time.Month, day, hour, min int) Minute

+ func ThisMinute() Minute

+ func (m *Minute) Scan(value interface{}) error

+ func (m Minute) AddDays(d int) Minute

+ func (m Minute) AddHours(h int) Minute

+ func (m Minute) AddMicro(ms int) Micro

+ func (m Minute) AddMillis(ms int) Milli

+ func (m Minute) AddMinutes(ms int) Minute

+ func (m Minute) AddMonths(ms int) Minute

+ func (m Minute) AddN(n int) Minute

+ func (m Minute) AddNano(n int) TimeExact

+ func (m Minute) AddSeconds(s int) Second

+ func (m Minute) AddYears(y int) Minute

+ func (m Minute) After(t Span) bool

+ func (m Minute) AsDay() Day

+ func (m Minute) AsHour() Hour

+ func (m Minute) AsMicro() Micro

+ func (m Minute) AsMilli() Milli

+ func (m Minute) AsMinute() Minute

+ func (m Minute) AsMonth() Month

+ func (m Minute) AsSecond() Second

+ func (m Minute) AsTime() time.Time

+ func (m Minute) AsTimeExact() TimeExact

+ func (m Minute) AsYear() Year

+ func (m Minute) Before(t Span) bool

+ func (m Minute) Contains(t Span) bool

+ func (m Minute) Decrement(l dura.Time) TimeExact

+ func (m Minute) Duration() dura.Time

+ func (m Minute) End() TimeExact

+ func (m Minute) Increment(l dura.Time) TimeExact

+ func (m Minute) Start() TimeExact

+ func (m Minute) Value() (driver.Value, error)

+ type Month struct

+ func MonthOf(time time.Time) Month

+ func NewMonth(year int, month time.Month) Month

+ func ThisMonth() Month

+ func (m *Month) Scan(value interface{}) error

+ func (m Month) AddDays(d int) Day

+ func (m Month) AddHours(h int) Hour

+ func (m Month) AddMicro(mi int) Micro

+ func (m Month) AddMillis(mi int) Milli

+ func (m Month) AddMinutes(mi int) Minute

+ func (m Month) AddMonths(ms int) Month

+ func (m Month) AddN(n int) Month

+ func (m Month) AddNano(n int) TimeExact

+ func (m Month) AddSeconds(s int) Second

+ func (m Month) AddYears(y int) Month

+ func (m Month) After(t Span) bool

+ func (m Month) AsDay() Day

+ func (m Month) AsHour() Hour

+ func (m Month) AsMicro() Micro

+ func (m Month) AsMilli() Milli

+ func (m Month) AsMinute() Minute

+ func (m Month) AsMonth() Month

+ func (m Month) AsSecond() Second

+ func (m Month) AsTime() time.Time

+ func (m Month) AsTimeExact() TimeExact

+ func (m Month) AsYear() Year

+ func (m Month) Before(t Span) bool

+ func (m Month) Contains(t Span) bool

+ func (m Month) Decrement(l dura.Time) TimeExact

+ func (m Month) Duration() dura.Time

+ func (m Month) End() TimeExact

+ func (m Month) Increment(l dura.Time) TimeExact

+ func (m Month) Start() TimeExact

+ func (m Month) Value() (driver.Value, error)

+ type Schedule struct

+ type Second struct

+ func NewSecond(year int, month time.Month, day, hour, min, sec int) Second

+ func SecondOf(t time.Time) Second

+ func ThisSecond() Second

+ func (s *Second) Scan(value interface{}) error

+ func (s Second) AddDays(d int) Second

+ func (s Second) AddHours(h int) Second

+ func (s Second) AddMicro(m int) Micro

+ func (s Second) AddMillis(m int) Milli

+ func (s Second) AddMinutes(m int) Second

+ func (s Second) AddMonths(m int) Second

+ func (s Second) AddN(n int) Second

+ func (s Second) AddNano(n int) TimeExact

+ func (s Second) AddSeconds(secs int) Second

+ func (s Second) AddYears(y int) Second

+ func (s Second) After(t Span) bool

+ func (s Second) AsDay() Day

+ func (s Second) AsHour() Hour

+ func (s Second) AsMicro() Micro

+ func (s Second) AsMilli() Milli

+ func (s Second) AsMinute() Minute

+ func (s Second) AsMonth() Month

+ func (s Second) AsSecond() Second

+ func (s Second) AsTime() time.Time

+ func (s Second) AsTimeExact() TimeExact

+ func (s Second) AsYear() Year

+ func (s Second) Before(t Span) bool

+ func (s Second) Contains(t Span) bool

+ func (s Second) Decrement(l dura.Time) TimeExact

+ func (s Second) Duration() dura.Time

+ func (s Second) End() TimeExact

+ func (s Second) Increment(l dura.Time) TimeExact

+ func (s Second) Start() TimeExact

+ func (s Second) Value() (driver.Value, error)

+ type SeqOption func(*Sequence) error

+ type Sequence struct

+ func NewSequence(begin Time, opts ...SeqOption) *Sequence

+ type Span interface

+ Duration func() dura.Time

+ End func() TimeExact

+ Start func() TimeExact

+ type Time interface

+ AsDay func() Day

+ AsHour func() Hour

+ AsMicro func() Micro

+ AsMilli func() Milli

+ AsMinute func() Minute

+ AsMonth func() Month

+ AsSecond func() Second

+ AsTime func() time.Time

+ AsTimeExact func() TimeExact

+ AsYear func() Year

+ type TimeExact struct

+ func MaxValue() TimeExact

+ func MinValue() TimeExact

+ func NewTime(year int, month time.Month, day, hour, min, sec, nano int) TimeExact

+ func Now() TimeExact

+ func TimeOf(t time.Time) TimeExact

+ func ZeroUnix() TimeExact

+ func ZeroValue() TimeExact

+ func ZeroYear() TimeExact

+ func (t *TimeExact) Scan(value interface{}) error

+ func (t TimeExact) AddDays(d int) TimeExact

+ func (t TimeExact) AddHours(h int) TimeExact

+ func (t TimeExact) AddMicro(m int) TimeExact

+ func (t TimeExact) AddMillis(m int) TimeExact

+ func (t TimeExact) AddMinutes(m int) TimeExact

+ func (t TimeExact) AddMonths(m int) TimeExact

+ func (t TimeExact) AddN(n int) TimeExact

+ func (t TimeExact) AddNano(n int) TimeExact

+ func (t TimeExact) AddSeconds(s int) TimeExact

+ func (t TimeExact) AddYears(y int) TimeExact

+ func (t TimeExact) After(s Span) bool

+ func (t TimeExact) AsDay() Day

+ func (t TimeExact) AsHour() Hour

+ func (t TimeExact) AsMicro() Micro

+ func (t TimeExact) AsMilli() Milli

+ func (t TimeExact) AsMinute() Minute

+ func (t TimeExact) AsMonth() Month

+ func (t TimeExact) AsSecond() Second

+ func (t TimeExact) AsTime() time.Time

+ func (t TimeExact) AsTimeExact() TimeExact

+ func (t TimeExact) AsYear() Year

+ func (t TimeExact) Before(s Span) bool

+ func (t TimeExact) Contains(s Span) bool

+ func (t TimeExact) Decrement(d dura.Time) TimeExact

+ func (t TimeExact) Duration() dura.Time

+ func (t TimeExact) End() TimeExact

+ func (t TimeExact) Increment(d dura.Time) TimeExact

+ func (t TimeExact) Start() TimeExact

+ func (t TimeExact) Value() (driver.Value, error)

+ type TimeSpan struct

+ func NewTimeSpan(start TimeExact, d dura.Time) *TimeSpan

+ func (s TimeSpan) After(t Span) bool

+ func (s TimeSpan) Before(t Span) bool

+ func (s TimeSpan) Contains(t Span) bool

+ func (s TimeSpan) Duration() dura.Time

+ func (s TimeSpan) End() TimeExact

+ func (s TimeSpan) Start() TimeExact

+ func (s TimeSpan) String() string

+ type Year struct

+ func NewYear(year int) Year

+ func ThisYear() Year

+ func YearOf(time time.Time) Year

+ func (y *Year) Scan(value interface{}) error

+ func (y Year) AddDays(d int) Day

+ func (y Year) AddHours(h int) Hour

+ func (y Year) AddMicro(m int) Micro

+ func (y Year) AddMillis(m int) Milli

+ func (y Year) AddMinutes(m int) Minute

+ func (y Year) AddMonths(m int) Month

+ func (y Year) AddN(n int) Year

+ func (y Year) AddNano(n int) TimeExact

+ func (y Year) AddSeconds(s int) Second

+ func (y Year) AddYears(ys int) Year

+ func (y Year) After(t Span) bool

+ func (y Year) AsDay() Day

+ func (y Year) AsHour() Hour

+ func (y Year) AsMicro() Micro

+ func (y Year) AsMilli() Milli

+ func (y Year) AsMinute() Minute

+ func (y Year) AsMonth() Month

+ func (y Year) AsSecond() Second

+ func (y Year) AsTime() time.Time

+ func (y Year) AsTimeExact() TimeExact

+ func (y Year) AsYear() Year

+ func (y Year) Before(t Span) bool

+ func (y Year) Contains(t Span) bool

+ func (y Year) Decrement(i dura.Time) TimeExact

+ func (y Year) Duration() dura.Time

+ func (y Year) End() TimeExact

+ func (y Year) Increment(i dura.Time) TimeExact

+ func (y Year) Start() TimeExact

+ func (y Year) Value() (driver.Value, error)