chron

package module
v1.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 4, 2018 License: MIT Imports: 7 Imported by: 3

README

chron

it's time :]

Chron is a general purpose time library that embeds time.Time and can be used as a replacement. Chron uses time.Time for calculations, so you can trust it's accuracy.

Why? There are many reasons, but the central one is that time.Time is often used as an interface. Holidays, credit card expiration dates, hourly reporting times, postgres timestamps; all these things have different time precisions, some are used as instants, while others are used as timespans.

Chron aims to wrap time.Time and provide a more specific type system that is consistent with simplicity of beauty of time.Time and time.Duration. Chron's type system breaks up the idea of time into three interfaces:

chron.Time // a specific nanosecond in time
dura.Time  // an exact or fuzzy length of time
chron.Span // a time interval with an exact start and end, like the year 2018

The implementations of these interfaces map to different time precisions. These types make it easier to reason about the times, durations, and spans represented in your program. They also provide ways to operate on times in a way that clearly shows precision. The type system is shown below:

chron.Time implementations

chron.Year ... chron.Chron are structs that embed time.Time and are truncated to a certain precision. You know that chron.Hour will always have 0 min, sec and nanoseconds. chron.Chron is the replacement for time.Time with nanosecond precision. These structs implement chron.Time which requires conversion functions to all other types.

now := chron.Now()          // type chron.Chron 2018-02-04 04:25:20.056473271 +0000 UTC
this_micro := now.AsMicro() // type chron.Micro 2018-02-04 04:25:20.056473 +0000 UTC
this_milli := now.AsMilli() // type chron.Milli 2018-02-04 04:25:20.056 +0000 UTC
...
this_month := now.AsMonth() // type chron.Month 2018-02-01 00:00:00 +0000 UTC
this_year := now.AsYear()   // type chron.Year 2018-01-01 00:00:00 +0000 UTC
time_time := now.AsTime()   // type time.Time 2018-02-04 04:25:20.056473271 +0000 UTC

Increment and Decrement functions are also required as part of the chron.Time interface. These functions handle any possible fuzzy or exact duration (dura.Time) and return a new chron.Chron

h := chron.Now().Increment(dura.NewDuration(1, 5, 32, time.Hour * 4 + time.Minute * 15 + time.Second * 30)).AsHour()
// the hour 1 year, 5 months, 32 days, 4 hour, 15 minutes, and 30 seconds from now

While Increment and Decrement handle any time duration, simple operations are better done using the many convenience methods.

now := chron.Now() // type chron.Chron 
next_hour := chron.ThisHour().AddN(1) // type chron.Hour
five_minutes_ago := now.AddMinutes(-5) // type chron.Chron
previous_second := chron.ThisSecond().AddN(-1) // type chron.Second

JSON Unmarshaling methods support 25 different formats--more can be added by appending to chron.ParseFormats. Scan and Value methods are also implemented to allow DB support.

Becuase time.Time is embedded, time package methods can be accessed directly. Before, After, and UnmarshalJSON are overwritten, but will provide the same functionality. Before and After now handle the overlapping nature of timespans, and UnmarshalJSON adds more formats besides time.RFC3339.

Time Zones

I have been burned by timezoned time data. I am of the opinion that all times belong in UTC until a human being wants to see them. I could be naive or wrong about this. Currently chron converts all times to UTC, so using the constructors will guarantee UTC internal times. If a chron user wants to create intances via chron.Chron{...}, it is their responsibility to ensure the underlying time is in UTC.

dura.Time implmentations

dura.Time is an interface that represents the same thing as a time.Duration with one key difference. dura.Time implementations can handle fuzzy durations. The concepts Month and Year don't have fixed lengths until matched with a specific instant in time.

time.Time uses Add and AddDate to deal with these differences, but there isn't currently a way to hold an pass around a duration that has months and years in it. If time libraries start handling leap seconds in a similar way, week, day, hour, minute and second will also become fuzzy.

There are currently 2 implementations of dura.Time: dura.Duration as struct that holds years, months, days, and a time.Duration, and dura.Unit an int enum that defines standard units of time.

d := dura.NewDuration(1, 3, 15, time.Hour*12)
d = d.Mult(3) // 3 years, 9 months, 45 days, 36 hours
now := chron.Now() // 2018-02-04 21:09:50.096961028 +0000 UTC
future := now.Increment(d) //2021-12-21 09:09:50.096961028 +0000 UTC

Convenience methods have overcome the original uses for dura.Unit constants, there are left here for possible use in switch statements and as the hard coded durations in chron.Span implementations.

today := chron.today()
// before 
noon := today.Increment(dura.Hour.Mult(12)).AsHour()
// new
noon := today.AddHours(12)
chron.Span implementations

chron.Span is just a time combined with a duration. Each of the chron.Time implementations also implement chron.Span. This interface allows the compairson of timespans rather than just time instants.

tomorrow := chron.Today().AddDays(1)
noon_tomorrow := tomorrow.AddHours(12)
if tomorrow.Contains(noon_tomorrow) {
    fmt.Println(:])
}
if chron.Today().Before(tomorrow) {
    fmt.Println(:])
}
Future Plans

I actually set out to write a scheduler, then I decided I needed a library that could output a stream of times base on input arguments. Then I decided to write some time conveniece stuff to make all the odd time precision and fuzzy duration issues easier to deal with. Chron will eventually become the second thing. I plan to add time series, time sequence and relative time functionality in the near future. What exists now though is solid, all changes to current code will preserve backward compatibility.

Issues

Please make issues if you have things you want to discuss or that you think need fixing. I'm all ears.

Documentation

Index

Constants

View Source 
const (
	DashDDMMMYY       = "02-Jan-06"
	DashDDMMMYYYY     = "02-Jan-2006"
	DashMMDDYY        = "01-02-06"
	DashMMDDYYYY      = "01-02-2006"
	SlashMMDDYY       = "01/02/06"
	SlashMMDDYYYY     = "01/02/2006"
	ShortDateTime     = SlashMMDDYYYY + " 15:04 PM"
	ShortSecond       = SlashMMDDYYYY + " 15:04:05 PM"
	ShortDateTime24   = SlashMMDDYYYY + " 15:04"
	ShortSecond24     = SlashMMDDYYYY + " 15:04:05"
	DashMonth         = "Jan-2006"
	DashMonthShort    = "Jan-06"
	DashNumMonth      = "01-2006"
	DashNumMonthShort = "01-06"
	CCMonth           = "01/06"
	YearFmt           = "2006"
)

Variables

View Source 
var ParseFormats = []string{
	time.RFC3339,
	time.RFC3339Nano,
	time.RFC822,
	time.RFC822Z,
	time.UnixDate,
	time.ANSIC,
	time.RubyDate,
	time.RFC1123,
	time.RFC1123Z,
	time.RFC850,
	DashDDMMMYY,
	DashDDMMMYYYY,
	DashMMDDYY,
	DashMMDDYYYY,
	SlashMMDDYY,
	SlashMMDDYYYY,
	ShortDateTime,
	ShortSecond,
	ShortDateTime24,
	ShortSecond24,
	DashMonth,
	DashMonthShort,
	DashNumMonth,
	DashNumMonthShort,
	CCMonth,
	YearFmt,
}
View Source 
var ParseFunctions = []func(string) (time.Time, error){
	ParseWithFormats,
	ParseUnixSeconds,
}

Functions

func ErrJoin added in v1.0.0 

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

func Parse added in v1.0.0 

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

func ParseUnixSeconds added in v1.0.0 

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

func ParseWithFormats added in v1.0.0 

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

func ZeroTime added in v1.0.0 

func ZeroTime() time.Time

Types

type Chron added in v1.0.0 

type Chron struct {
	time.Time
}

Chron is analogous to time.Time. Chron has nanosecond precision and implements the Time and Span interfaces.

func MaxValue 

func MaxValue() Chron

func MinValue 

func MinValue() Chron

func NewTime 

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

func Now 

func Now() Chron

func TimeOf 

func TimeOf(t time.Time) Chron

func ZeroUnix 

func ZeroUnix() Chron

func ZeroValue 

func ZeroValue() Chron

func ZeroYear 

func ZeroYear() Chron

func (Chron) AddDays added in v1.0.0 

func (t Chron) AddDays(d int) Chron

func (Chron) AddHours added in v1.0.0 

func (t Chron) AddHours(h int) Chron

func (Chron) AddMicros added in v1.0.0 

func (t Chron) AddMicros(m int) Chron

func (Chron) AddMillis added in v1.0.0 

func (t Chron) AddMillis(m int) Chron

func (Chron) AddMinutes added in v1.0.0 

func (t Chron) AddMinutes(m int) Chron

func (Chron) AddMonths added in v1.0.0 

func (t Chron) AddMonths(m int) Chron

func (Chron) AddN added in v1.0.0 

func (t Chron) AddN(n int) Chron

AddN adds n Nanoseconds to the TimeExact

func (Chron) AddNanos added in v1.0.0 

func (t Chron) AddNanos(n int) Chron

func (Chron) AddSeconds added in v1.0.0 

func (t Chron) AddSeconds(s int) Chron

func (Chron) AddYears added in v1.0.0 

func (t Chron) AddYears(y int) Chron

func (Chron) After added in v1.0.0 

func (t Chron) After(s Span) bool

func (Chron) AsChron added in v1.0.0 

func (t Chron) AsChron() Chron

func (Chron) AsDay added in v1.0.0 

func (t Chron) AsDay() Day

func (Chron) AsHour added in v1.0.0 

func (t Chron) AsHour() Hour

func (Chron) AsMicro added in v1.0.0 

func (t Chron) AsMicro() Micro

func (Chron) AsMilli added in v1.0.0 

func (t Chron) AsMilli() Milli

func (Chron) AsMinute added in v1.0.0 

func (t Chron) AsMinute() Minute

func (Chron) AsMonth added in v1.0.0 

func (t Chron) AsMonth() Month

func (Chron) AsSecond added in v1.0.0 

func (t Chron) AsSecond() Second

func (Chron) AsTime added in v1.0.0 

func (t Chron) AsTime() time.Time

func (Chron) AsYear added in v1.0.0 

func (t Chron) AsYear() Year

func (Chron) Before added in v1.0.0 

func (t Chron) Before(s Span) bool

func (Chron) Contains added in v1.0.0 

func (t Chron) Contains(s Span) bool

func (Chron) Decrement added in v1.0.0 

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

func (Chron) Duration added in v1.0.0 

func (t Chron) Duration() dura.Time

func (Chron) End added in v1.0.0 

func (t Chron) End() Chron

func (Chron) Increment added in v1.0.0 

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

func (*Chron) Scan added in v1.0.0 

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

func (Chron) Start added in v1.0.0 

func (t Chron) Start() Chron

span.Time implementation

func (Chron) Value added in v1.0.0 

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

type Comparer added in v1.0.0 

type Comparer interface {
	Before(Span) bool
	After(Span) bool
	Contains(Span) bool
}

type Day 

type Day struct {
	time.Time
}

func DayOf 

func DayOf(t time.Time) Day

func NewDay 

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

Constructors

func Today 

func Today() Day

func (Day) AddDays 

func (d Day) AddDays(ds int) Day

func (Day) AddHours 

func (d Day) AddHours(h int) Hour

func (Day) AddMicros added in v1.0.0 

func (d Day) AddMicros(m int) Micro

func (Day) AddMillis 

func (d Day) AddMillis(m int) Milli

func (Day) AddMinutes 

func (d Day) AddMinutes(m int) Minute

func (Day) AddMonths 

func (d Day) AddMonths(m int) Day

needs a global setting. i.e. july 31 - 1 month

func (Day) AddN 

func (d Day) AddN(n int) Day

func (Day) AddNanos added in v1.0.0 

func (d Day) AddNanos(n int) Chron

func (Day) AddSeconds 

func (d Day) AddSeconds(s int) Second

func (Day) AddYears 

func (d Day) AddYears(y int) Day

func (Day) After 

func (d Day) After(t Span) bool

func (Day) AsChron added in v1.0.0 

func (d Day) AsChron() Chron

func (Day) AsDay 

func (d Day) AsDay() Day

func (Day) AsHour 

func (d Day) AsHour() Hour

func (Day) AsMicro 

func (d Day) AsMicro() Micro

func (Day) AsMilli 

func (d Day) AsMilli() Milli

func (Day) AsMinute 

func (d Day) AsMinute() Minute

func (Day) AsMonth 

func (d Day) AsMonth() Month

func (Day) AsSecond 

func (d Day) AsSecond() Second

func (Day) AsTime 

func (d Day) AsTime() time.Time

func (Day) AsYear 

func (d Day) AsYear() Year

chron.Time implementation

func (Day) Before 

func (d Day) Before(t Span) bool

func (Day) Contains 

func (d Day) Contains(t Span) bool

func (Day) Decrement 

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

func (Day) Duration 

func (d Day) Duration() dura.Time

func (Day) End 

func (d Day) End() Chron

func (Day) Increment 

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

func (*Day) Scan 

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

func (Day) Start 

func (d Day) Start() Chron

span.Time implementation

func (*Day) UnmarshalJSON added in v1.0.0 

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

func (Day) Value 

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

it is the callers responsibility to manage the db specific date range.

type Hour 

type Hour struct {
	time.Time
}

func HourOf 

func HourOf(t time.Time) Hour

func NewHour 

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

func ThisHour 

func ThisHour() Hour

func (Hour) AddDays 

func (h Hour) AddDays(d int) Hour

func (Hour) AddHours 

func (h Hour) AddHours(hs int) Hour

func (Hour) AddMicros added in v1.0.0 

func (h Hour) AddMicros(m int) Micro

func (Hour) AddMillis 

func (h Hour) AddMillis(m int) Milli

func (Hour) AddMinutes 

func (h Hour) AddMinutes(m int) Minute

func (Hour) AddMonths 

func (h Hour) AddMonths(m int) Hour

func (Hour) AddN 

func (h Hour) AddN(n int) Hour

func (Hour) AddNanos added in v1.0.0 

func (h Hour) AddNanos(n int) Chron

func (Hour) AddSeconds 

func (h Hour) AddSeconds(s int) Second

func (Hour) AddYears 

func (h Hour) AddYears(y int) Hour

func (Hour) After 

func (h Hour) After(t Span) bool

func (Hour) AsChron added in v1.0.0 

func (h Hour) AsChron() Chron

func (Hour) AsDay 

func (h Hour) AsDay() Day

func (Hour) AsHour 

func (h Hour) AsHour() Hour

func (Hour) AsMicro 

func (h Hour) AsMicro() Micro

func (Hour) AsMilli 

func (h Hour) AsMilli() Milli

func (Hour) AsMinute 

func (h Hour) AsMinute() Minute

func (Hour) AsMonth 

func (h Hour) AsMonth() Month

func (Hour) AsSecond 

func (h Hour) AsSecond() Second

func (Hour) AsTime 

func (h Hour) AsTime() time.Time

func (Hour) AsYear 

func (h Hour) AsYear() Year

func (Hour) Before 

func (h Hour) Before(t Span) bool

func (Hour) Contains 

func (h Hour) Contains(t Span) bool

func (Hour) Decrement 

func (h Hour) Decrement(l dura.Time) Chron

func (Hour) Duration 

func (h Hour) Duration() dura.Time

func (Hour) End 

func (h Hour) End() Chron

func (Hour) Increment 

func (h Hour) Increment(l dura.Time) Chron

func (*Hour) Scan 

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

func (Hour) Start 

func (h Hour) Start() Chron

span.Time implementation

func (*Hour) UnmarshalJSON added in v1.0.0 

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

func (Hour) Value 

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

type Incrementer added in v1.0.0 

type Incrementer interface {
	Increment(dura.Time) Chron
	Decrement(dura.Time) Chron
}

Incrementer implementations take in a dura.Time (similar to time.Duration) and return a nanosecond precision Chron instance. While Add and Sub functions are available via the internal time.Time, these functions allow addition and subtraction of fuzzy durations, Example: 1 year, 13 months, 54 days, and 3409853 seconds year and month would increment the fuzzy year and month durations, while days and seconds would increment by the exact values.

type Interval added in v1.0.0 

type Interval struct {
	// contains filtered or unexported fields
}

func NewInterval added in v1.0.0 

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

func (Interval) After added in v1.0.0 

func (s Interval) After(t Span) bool

func (Interval) Before added in v1.0.0 

func (s Interval) Before(t Span) bool

func (Interval) Contains added in v1.0.0 

func (s Interval) Contains(t Span) bool

func (Interval) Duration added in v1.0.0 

func (s Interval) Duration() dura.Time

func (Interval) End added in v1.0.0 

func (s Interval) End() Chron

func (Interval) Start added in v1.0.0 

func (s Interval) Start() Chron

func (Interval) String added in v1.0.0 

func (s Interval) String() string

type Micro 

type Micro struct {
	time.Time
}

func MicroOf 

func MicroOf(t time.Time) Micro

func NewMicro 

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

func ThisMicro 

func ThisMicro() Micro

func (Micro) AddDays 

func (m Micro) AddDays(d int) Micro

func (Micro) AddHours 

func (m Micro) AddHours(h int) Micro

func (Micro) AddMicros added in v1.0.0 

func (m Micro) AddMicros(ms int) Micro

func (Micro) AddMillis 

func (m Micro) AddMillis(ms int) Micro

func (Micro) AddMinutes 

func (m Micro) AddMinutes(ms int) Micro

func (Micro) AddMonths 

func (m Micro) AddMonths(ms int) Micro

func (Micro) AddN 

func (m Micro) AddN(n int) Micro

func (Micro) AddNanos added in v1.0.0 

func (m Micro) AddNanos(n int) Chron

func (Micro) AddSeconds 

func (m Micro) AddSeconds(s int) Micro

func (Micro) AddYears 

func (m Micro) AddYears(y int) Micro

func (Micro) After 

func (m Micro) After(t Span) bool

func (Micro) AsChron added in v1.0.0 

func (m Micro) AsChron() Chron

func (Micro) AsDay 

func (m Micro) AsDay() Day

func (Micro) AsHour 

func (m Micro) AsHour() Hour

func (Micro) AsMicro 

func (m Micro) AsMicro() Micro

func (Micro) AsMilli 

func (m Micro) AsMilli() Milli

func (Micro) AsMinute 

func (m Micro) AsMinute() Minute

func (Micro) AsMonth 

func (m Micro) AsMonth() Month

func (Micro) AsSecond 

func (m Micro) AsSecond() Second

func (Micro) AsTime 

func (m Micro) AsTime() time.Time

func (Micro) AsYear 

func (m Micro) AsYear() Year

func (Micro) Before 

func (m Micro) Before(t Span) bool

func (Micro) Contains 

func (m Micro) Contains(t Span) bool

func (Micro) Decrement 

func (m Micro) Decrement(l dura.Time) Chron

func (Micro) Duration 

func (m Micro) Duration() dura.Time

func (Micro) End 

func (m Micro) End() Chron

func (Micro) Increment 

func (m Micro) Increment(l dura.Time) Chron

func (*Micro) Scan 

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

func (Micro) Start 

func (m Micro) Start() Chron

span.Time implementation

func (*Micro) UnmarshalJSON added in v1.0.0 

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

func (Micro) Value 

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

type Milli 

type Milli struct {
	time.Time
}

func MilliOf 

func MilliOf(t time.Time) Milli

func NewMilli 

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

func ThisMilli 

func ThisMilli() Milli

func (Milli) AddDays 

func (m Milli) AddDays(d int) Milli

func (Milli) AddHours 

func (m Milli) AddHours(h int) Milli

func (Milli) AddMicros added in v1.0.0 

func (m Milli) AddMicros(ms int) Micro

func (Milli) AddMillis 

func (m Milli) AddMillis(ms int) Milli

func (Milli) AddMinutes 

func (m Milli) AddMinutes(ms int) Milli

func (Milli) AddMonths 

func (m Milli) AddMonths(ms int) Milli

func (Milli) AddN 

func (m Milli) AddN(n int) Milli

func (Milli) AddNanos added in v1.0.0 

func (m Milli) AddNanos(n int) Chron

func (Milli) AddSeconds 

func (m Milli) AddSeconds(s int) Milli

func (Milli) AddYears 

func (m Milli) AddYears(y int) Milli

func (Milli) After 

func (m Milli) After(t Span) bool

func (Milli) AsChron added in v1.0.0 

func (m Milli) AsChron() Chron

func (Milli) AsDay 

func (m Milli) AsDay() Day

func (Milli) AsHour 

func (m Milli) AsHour() Hour

func (Milli) AsMicro 

func (m Milli) AsMicro() Micro

func (Milli) AsMilli 

func (m Milli) AsMilli() Milli

func (Milli) AsMinute 

func (m Milli) AsMinute() Minute

func (Milli) AsMonth 

func (m Milli) AsMonth() Month

func (Milli) AsSecond 

func (m Milli) AsSecond() Second

func (Milli) AsTime 

func (m Milli) AsTime() time.Time

func (Milli) AsYear 

func (m Milli) AsYear() Year

func (Milli) Before 

func (m Milli) Before(t Span) bool

func (Milli) Contains 

func (m Milli) Contains(t Span) bool

func (Milli) Decrement 

func (m Milli) Decrement(l dura.Time) Chron

func (Milli) Duration 

func (m Milli) Duration() dura.Time

func (Milli) End 

func (m Milli) End() Chron

func (Milli) Increment 

func (m Milli) Increment(l dura.Time) Chron

func (*Milli) Scan 

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

func (Milli) Start 

func (m Milli) Start() Chron

span.Time implementation

func (*Milli) UnmarshalJSON added in v1.0.0 

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

func (Milli) Value 

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

type Minute 

type Minute struct {
	time.Time
}

func MinuteOf 

func MinuteOf(t time.Time) Minute

func NewMinute 

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

func ThisMinute 

func ThisMinute() Minute

func (Minute) AddDays 

func (m Minute) AddDays(d int) Minute

func (Minute) AddHours 

func (m Minute) AddHours(h int) Minute

func (Minute) AddMicros added in v1.0.0 

func (m Minute) AddMicros(ms int) Micro

func (Minute) AddMillis 

func (m Minute) AddMillis(ms int) Milli

func (Minute) AddMinutes 

func (m Minute) AddMinutes(ms int) Minute

func (Minute) AddMonths 

func (m Minute) AddMonths(ms int) Minute

func (Minute) AddN 

func (m Minute) AddN(n int) Minute

func (Minute) AddNanos added in v1.0.0 

func (m Minute) AddNanos(n int) Chron

func (Minute) AddSeconds 

func (m Minute) AddSeconds(s int) Second

func (Minute) AddYears 

func (m Minute) AddYears(y int) Minute

func (Minute) After 

func (m Minute) After(t Span) bool

func (Minute) AsChron added in v1.0.0 

func (m Minute) AsChron() Chron

func (Minute) AsDay 

func (m Minute) AsDay() Day

func (Minute) AsHour 

func (m Minute) AsHour() Hour

func (Minute) AsMicro 

func (m Minute) AsMicro() Micro

func (Minute) AsMilli 

func (m Minute) AsMilli() Milli

func (Minute) AsMinute 

func (m Minute) AsMinute() Minute

func (Minute) AsMonth 

func (m Minute) AsMonth() Month

func (Minute) AsSecond 

func (m Minute) AsSecond() Second

func (Minute) AsTime 

func (m Minute) AsTime() time.Time

func (Minute) AsYear 

func (m Minute) AsYear() Year

func (Minute) Before 

func (m Minute) Before(t Span) bool

func (Minute) Contains 

func (m Minute) Contains(t Span) bool

func (Minute) Decrement 

func (m Minute) Decrement(l dura.Time) Chron

func (Minute) Duration 

func (m Minute) Duration() dura.Time

func (Minute) End 

func (m Minute) End() Chron

func (Minute) Increment 

func (m Minute) Increment(l dura.Time) Chron

func (*Minute) Scan 

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

func (Minute) Start 

func (m Minute) Start() Chron

span.Time implementation

func (*Minute) UnmarshalJSON added in v1.0.0 

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

func (Minute) Value 

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

type Month 

type Month struct {
	time.Time
}

func MonthOf 

func MonthOf(t time.Time) Month

func NewMonth 

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

func ThisMonth 

func ThisMonth() Month

func (Month) AddDays 

func (m Month) AddDays(d int) Day

func (Month) AddHours 

func (m Month) AddHours(h int) Hour

func (Month) AddMicros added in v1.0.0 

func (m Month) AddMicros(mi int) Micro

func (Month) AddMillis 

func (m Month) AddMillis(mi int) Milli

func (Month) AddMinutes 

func (m Month) AddMinutes(mi int) Minute

func (Month) AddMonths 

func (m Month) AddMonths(ms int) Month

func (Month) AddN 

func (m Month) AddN(n int) Month

func (Month) AddNanos added in v1.0.0 

func (m Month) AddNanos(n int) Chron

func (Month) AddSeconds 

func (m Month) AddSeconds(s int) Second

func (Month) AddYears 

func (m Month) AddYears(y int) Month

func (Month) After 

func (m Month) After(t Span) bool

func (Month) AsChron added in v1.0.0 

func (m Month) AsChron() Chron

func (Month) AsDay 

func (m Month) AsDay() Day

func (Month) AsHour 

func (m Month) AsHour() Hour

func (Month) AsMicro 

func (m Month) AsMicro() Micro

func (Month) AsMilli 

func (m Month) AsMilli() Milli

func (Month) AsMinute 

func (m Month) AsMinute() Minute

func (Month) AsMonth 

func (m Month) AsMonth() Month

func (Month) AsSecond 

func (m Month) AsSecond() Second

func (Month) AsTime 

func (m Month) AsTime() time.Time

func (Month) AsYear 

func (m Month) AsYear() Year

func (Month) Before 

func (m Month) Before(t Span) bool

func (Month) Contains 

func (m Month) Contains(t Span) bool

func (Month) Decrement 

func (m Month) Decrement(l dura.Time) Chron

func (Month) Duration 

func (m Month) Duration() dura.Time

func (Month) End 

func (m Month) End() Chron

func (Month) Increment 

func (m Month) Increment(l dura.Time) Chron

func (*Month) Scan 

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

func (Month) Start 

func (m Month) Start() Chron

span.Time implementation

func (*Month) UnmarshalJSON added in v1.0.0 

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

func (Month) Value 

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

type Second 

type Second struct {
	time.Time
}

func NewSecond 

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

func SecondOf 

func SecondOf(t time.Time) Second

func ThisSecond 

func ThisSecond() Second

func (Second) AddDays 

func (s Second) AddDays(d int) Second

func (Second) AddHours 

func (s Second) AddHours(h int) Second

func (Second) AddMicros added in v1.0.0 

func (s Second) AddMicros(m int) Micro

func (Second) AddMillis 

func (s Second) AddMillis(m int) Milli

func (Second) AddMinutes 

func (s Second) AddMinutes(m int) Second

func (Second) AddMonths 

func (s Second) AddMonths(m int) Second

func (Second) AddN 

func (s Second) AddN(n int) Second

func (Second) AddNanos added in v1.0.0 

func (s Second) AddNanos(n int) Chron

func (Second) AddSeconds 

func (s Second) AddSeconds(secs int) Second

func (Second) AddYears 

func (s Second) AddYears(y int) Second

func (Second) After 

func (s Second) After(t Span) bool

func (Second) AsChron added in v1.0.0 

func (s Second) AsChron() Chron

func (Second) AsDay 

func (s Second) AsDay() Day

func (Second) AsHour 

func (s Second) AsHour() Hour

func (Second) AsMicro 

func (s Second) AsMicro() Micro

func (Second) AsMilli 

func (s Second) AsMilli() Milli

func (Second) AsMinute 

func (s Second) AsMinute() Minute

func (Second) AsMonth 

func (s Second) AsMonth() Month

func (Second) AsSecond 

func (s Second) AsSecond() Second

func (Second) AsTime 

func (s Second) AsTime() time.Time

func (Second) AsYear 

func (s Second) AsYear() Year

func (Second) Before 

func (s Second) Before(t Span) bool

func (Second) Contains 

func (s Second) Contains(t Span) bool

func (Second) Decrement 

func (s Second) Decrement(l dura.Time) Chron

func (Second) Duration 

func (s Second) Duration() dura.Time

func (Second) End 

func (s Second) End() Chron

func (Second) Increment 

func (s Second) Increment(l dura.Time) Chron

func (*Second) Scan 

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

func (Second) Start 

func (s Second) Start() Chron

/ span.Time implementation

func (*Second) UnmarshalJSON added in v1.0.0 

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

func (Second) Value 

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

type Span 

type Span interface {
	Start() Chron
	End() Chron
	Duration() dura.Time
	Comparer
}

type Time 

type Time interface {
	AsYear() Year
	AsMonth() Month
	AsDay() Day
	AsHour() Hour
	AsMinute() Minute
	AsSecond() Second
	AsMilli() Milli
	AsMicro() Micro
	AsChron() Chron
	AsTime() time.Time
	Incrementer
}

Time implementations are instants in time that are transferable to other instants with a different precision--year, month, day, hour, minute, second, milli, micro, chron--which has nanosecond precision. Implementations are also transferable to an underlying time.Time via AsTime(). Transferring to a type with lower precision truncates. the underlying structs (Year, Month, ...) each wrap an anonymous time.Time allowing access to general time.Time functionality.

type Year 

type Year struct {
	time.Time
}

func NewYear 

func NewYear(year int) Year

func ThisYear 

func ThisYear() Year

func YearOf 

func YearOf(t time.Time) Year

func (Year) AddDays 

func (y Year) AddDays(d int) Day

func (Year) AddHours 

func (y Year) AddHours(h int) Hour

func (Year) AddMicros added in v1.0.0 

func (y Year) AddMicros(m int) Micro

func (Year) AddMillis 

func (y Year) AddMillis(m int) Milli

func (Year) AddMinutes 

func (y Year) AddMinutes(m int) Minute

func (Year) AddMonths 

func (y Year) AddMonths(m int) Month

func (Year) AddN 

func (y Year) AddN(n int) Year

func (Year) AddNanos added in v1.0.0 

func (y Year) AddNanos(n int) Chron

func (Year) AddSeconds 

func (y Year) AddSeconds(s int) Second

func (Year) AddYears 

func (y Year) AddYears(ys int) Year

func (Year) After 

func (y Year) After(t Span) bool

func (Year) AsChron added in v1.0.0 

func (y Year) AsChron() Chron

func (Year) AsDay 

func (y Year) AsDay() Day

func (Year) AsHour 

func (y Year) AsHour() Hour

func (Year) AsMicro 

func (y Year) AsMicro() Micro

func (Year) AsMilli 

func (y Year) AsMilli() Milli

func (Year) AsMinute 

func (y Year) AsMinute() Minute

func (Year) AsMonth 

func (y Year) AsMonth() Month

func (Year) AsSecond 

func (y Year) AsSecond() Second

func (Year) AsTime 

func (y Year) AsTime() time.Time

func (Year) AsYear 

func (y Year) AsYear() Year

func (Year) Before 

func (y Year) Before(t Span) bool

func (Year) Contains 

func (y Year) Contains(t Span) bool

func (Year) Decrement 

func (y Year) Decrement(i dura.Time) Chron

func (Year) Duration 

func (y Year) Duration() dura.Time

func (Year) End 

func (y Year) End() Chron

func (Year) Increment 

func (y Year) Increment(i dura.Time) Chron

func (*Year) Scan 

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

func (Year) Start 

func (y Year) Start() Chron

span.Time implementation

func (*Year) UnmarshalJSON added in v1.0.0 

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

func (Year) Value 

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

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.