daterange

package module

v1.0.0 Latest Latest Go to latest Published: Apr 30, 2024 License: MIT Imports: 3 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/felixenescu/date-range

Links

Open Source Insights

README ¶

date-range

Introduction

daterange is a powerful and intuitive Go package designed for handling date intervals efficiently and effectively. This library simplifies operations such as comparing dates, checking overlaps, and processing date ranges in Go applications.

Features

Easy comparison of date ranges Checking for overlaps and inclusions between date intervals Automatic normalization of date ranges Processing and manipulation of date intervals

Potential Use Cases

Event Planning and Scheduling: The Date-Range library can be used in applications that deal with event scheduling, helping to check for conflicts in dates and times.
Reservation Systems: For systems that handle reservations, such as hotel booking or venue reservation systems, this library can assist in managing availability and booking dates.
Data Analysis and Reporting: In data analysis, particularly when dealing with time series data, the Date-Range library can help in segmenting data into specific time intervals for better insights.
Financial Applications: In financial applications, the library can be used to calculate durations for interest calculations, investment maturity periods, and more.
Educational Tools: For educational software that schedules courses or exams, the library can help in managing and visualizing course timelines.
Healthcare Applications: In healthcare applications, the library can be used to manage patient appointments, medication schedules, and other time-sensitive data.

Usage

DateRange

Overview

DateRange represents an inclusive range of dates. It is defined by two time.Time values, from and to.

Constructors

NewDateRange(from, to time.Time): Creates a new DateRange instance. The input dates are automatically ordered.
MustNewDateRange(from, to time.Time): Similar to NewDateRange but panics if the from date is after the to date.

Methods

String() string: Returns a string representation of the DateRange.
IsZero() bool: Checks if both dates in the range are zero values.
Contains(date time.Time) bool: Returns true if the given date is within the range.
Overlaps(other DateRange) bool: Checks if the given DateRange overlaps with this range.
Includes(other DateRange) bool: Checks if the given DateRange is included within this range.
Intersection(other DateRange) DateRange: Returns the intersection of two DateRanges.
Union(other DateRange) DateRanges: Returns a DateRanges collection that is the union of two DateRanges.
Difference(other DateRange) DateRanges: Returns a DateRanges collection that is the difference between two DateRanges.

Use Cases and Examples

Checking if a date is within a range

package main

import (
	"fmt"
	"time"

	dr "github.com/felixenescu/date-range"
)

func main() {
	start := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)
	end := time.Date(2024, 12, 31, 0, 0, 0, 0, time.UTC)
	dateRange := dr.NewDateRange(start, end)

	dateToCheck := time.Date(2024, 6, 15, 0, 0, 0, 0, time.UTC)
	fmt.Println("Date within range:", dateRange.Contains(dateToCheck))
	// Date within range: true
}

Finding overlap between two date ranges

package main

import (
	"fmt"
	"time"

	dr "github.com/felixenescu/date-range"
)

func main() {
	firstRange := dr.NewDateRange(time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, 6, 30, 0, 0, 0, 0, time.UTC))
	secondRange := dr.NewDateRange(time.Date(2024, 5, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, 12, 31, 0, 0, 0, 0, time.UTC))

	fmt.Println("Ranges overlap:", firstRange.Overlaps(secondRange))
	// Ranges overlap: true
}

Calculating the union of two date ranges

package main

import (
	"fmt"
	"time"

	dr "github.com/felixenescu/date-range"
)

func main() {
	firstRange := dr.NewDateRange(time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, 3, 31, 0, 0, 0, 0, time.UTC))
	secondRange := dr.NewDateRange(time.Date(2024, 4, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, 6, 30, 0, 0, 0, 0, time.UTC))

	unionRanges := firstRange.Union(secondRange)
	fmt.Println(unionRanges)
	// [{2024-01-01 - 2024-06-30}]
}

Calculating the difference of two date ranges

package main

import (
	"fmt"
	"time"

	dr "github.com/felixenescu/date-range"
)

func main() {
	firstRange := dr.NewDateRange(time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, 3, 31, 0, 0, 0, 0, time.UTC))
	secondRange := dr.NewDateRange(time.Date(2024, 2, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, 3, 10, 0, 0, 0, 0, time.UTC))

	diffRanges := firstRange.Difference(secondRange)
	fmt.Println(diffRanges)
	// [{2024-01-01 - 2024-01-31} {2024-03-11 - 2024-03-31}]
}

DateRanges

Overview

DateRanges represents a collection of DateRange instances. It provides methods for managing and processing multiple date ranges.

Constructor

NewDateRanges(dataRanges ...DateRange): Creates a new DataRanges collection with given elements.

Methods

String() string: Returns a string representation of the collection. Items are guaranteed to be sorted and non-overlapping. Any adjacent periods are merged.
ToSlice() []DateRange: Returns the members of the collection as a slice. Items are guaranteed to be sorted, non-overlapping and non-zero. Any adjacent periods are merged..
IsZero() bool: Returns true if the collection is empty.
Len() int: Returns the number of elements in the collection.
FirstDate() time.Time: Returns the first date of the collection.
LastDate() time.Time: Returns the last date of the collection.
Equal(other DateRanges) bool: Returns true if the collection is equal to the given collection.
Append(dataRange ...DateRange): Adds the given elements to the collection.
Contains(date time.Time) bool: Returns true if the given date is in the collection.
IsAnyDateIn(date time.Time) bool: Returns true if any date in the given DateRange is in the collection. Zero DateRange is always considered to be in the collection.
IsAllDatesIn(date time.Time) bool: Returns true if all dates in the given DateRange are in the collection. Zero DateRange is always considered to be in the collection.
SplitInclusive(date time.Time) (DateRanges, DateRanges): Splits the collection into two collections at the given date. The given date is included in both collections.

Use Cases and Examples

Normalize a list of intervals

package main

import (
	"fmt"
	"time"

	dr "github.com/felixenescu/date-range"
)

func main() {

	drs := []dr.DateRange{
		dr.NewDateRange(time.Date(2019, 1, 9, 0, 0, 0, 0, time.UTC), time.Date(2019, 1, 12, 0, 0, 0, 0, time.UTC)),
		dr.NewDateRange(time.Date(2019, 1, 2, 0, 0, 0, 0, time.UTC), time.Date(2019, 1, 4, 0, 0, 0, 0, time.UTC)),
		dr.NewDateRange(time.Date(2019, 1, 10, 0, 0, 0, 0, time.UTC), time.Date(2019, 1, 14, 0, 0, 0, 0, time.UTC)),
		dr.NewDateRange(time.Date(2019, 1, 10, 0, 0, 0, 0, time.UTC), time.Date(2019, 1, 11, 0, 0, 0, 0, time.UTC)),
	}
	cleanRanges := dr.NewDateRanges(drs...)
	fmt.Println(cleanRanges)
	// [{2019-01-02 - 2019-01-04} {2019-01-09 - 2019-01-14}]

	// extract normalized intervals
	for idx, dataRange := range cleanRanges.ToSlice() {
		fmt.Println(idx, dataRange.From(), dataRange.To())
	}
	// 0 2019-01-02 00:00:00 +0000 UTC 2019-01-04 00:00:00 +0000 UTC
	// 1 2019-01-09 00:00:00 +0000 UTC 2019-01-14 00:00:00 +0000 UTC
}

Check if a date is in a collection

package main

import (
	"fmt"
	"time"

	dr "github.com/felixenescu/date-range"
)

func main() {

	drs := []dr.DateRange{
		dr.NewDateRange(time.Date(2019, 1, 9, 0, 0, 0, 0, time.UTC), time.Date(2019, 1, 12, 0, 0, 0, 0, time.UTC)),
		dr.NewDateRange(time.Date(2019, 1, 13, 0, 0, 0, 0, time.UTC), time.Date(2019, 1, 15, 0, 0, 0, 0, time.UTC)),
		dr.NewDateRange(time.Date(2019, 1, 20, 0, 0, 0, 0, time.UTC), time.Date(2019, 1, 24, 0, 0, 0, 0, time.UTC)),
		dr.NewDateRange(time.Date(2019, 1, 10, 0, 0, 0, 0, time.UTC), time.Date(2019, 1, 11, 0, 0, 0, 0, time.UTC)),
	}
	reservations := dr.NewDateRanges(drs...)
	fmt.Println(reservations)
	// [{2019-01-09 - 2019-01-15} {2019-01-20 - 2019-01-24}]

	newReservation := dr.NewDateRange(time.Date(2019, 1, 10, 0, 0, 0, 0, time.UTC), time.Date(2019, 1, 17, 0, 0, 0, 0, time.UTC))
	if reservations.IsAnyDateIn(newReservation) {
		fmt.Println(newReservation, "conflicts with existing reservations")
	} else {
		fmt.Println(newReservation, "does not conflicts with existing reservations")
	}
	// {2019-01-10 - 2019-01-17} conflicts with existing reservations

}

Check if all dates are in a collection

package main

import (
	"fmt"
	"time"

	dr "github.com/felixenescu/date-range"
)

func main() {

	drs := []dr.DateRange{
		dr.NewDateRange(time.Date(2019, 1, 9, 0, 0, 0, 0, time.UTC), time.Date(2019, 1, 12, 0, 0, 0, 0, time.UTC)),
		dr.NewDateRange(time.Date(2019, 1, 13, 0, 0, 0, 0, time.UTC), time.Date(2019, 1, 15, 0, 0, 0, 0, time.UTC)),
		dr.NewDateRange(time.Date(2019, 1, 20, 0, 0, 0, 0, time.UTC), time.Date(2019, 1, 24, 0, 0, 0, 0, time.UTC)),
		dr.NewDateRange(time.Date(2019, 1, 10, 0, 0, 0, 0, time.UTC), time.Date(2019, 1, 11, 0, 0, 0, 0, time.UTC)),
	}
	availableDates := dr.NewDateRanges(drs...)
	fmt.Println(availableDates)
	// [{2019-01-09 - 2019-01-15} {2019-01-20 - 2019-01-24}]

	newReservation := dr.NewDateRange(time.Date(2019, 1, 10, 0, 0, 0, 0, time.UTC), time.Date(2019, 1, 17, 0, 0, 0, 0, time.UTC))
	if availableDates.IsAllDatesIn(newReservation) {
		fmt.Println(newReservation, "there is availability for new reservations")
	} else {
		fmt.Println(newReservation, "there is no availability for new reservations")
	}
	// {2019-01-10 - 2019-01-17} there is no availability for new reservations
}

Split a collection at a given date

package main

import (
	"fmt"
	"time"

	dr "github.com/felixenescu/date-range"
)

func main() {

	drs := []dr.DateRange{
		dr.NewDateRange(time.Date(2019, 1, 9, 0, 0, 0, 0, time.UTC), time.Date(2019, 1, 12, 0, 0, 0, 0, time.UTC)),
		dr.NewDateRange(time.Date(2019, 1, 13, 0, 0, 0, 0, time.UTC), time.Date(2019, 1, 15, 0, 0, 0, 0, time.UTC)),
		dr.NewDateRange(time.Date(2019, 1, 20, 0, 0, 0, 0, time.UTC), time.Date(2019, 1, 24, 0, 0, 0, 0, time.UTC)),
		dr.NewDateRange(time.Date(2019, 1, 10, 0, 0, 0, 0, time.UTC), time.Date(2019, 1, 11, 0, 0, 0, 0, time.UTC)),
	}
	reservations := dr.NewDateRanges(drs...)
	fmt.Println(reservations)
	// [{2019-01-09 - 2019-01-15} {2019-01-20 - 2019-01-24}]

	splitDate := time.Date(2019, 1, 14, 0, 0, 0, 0, time.UTC)
	before, after := reservations.SplitInclusive(splitDate)
	fmt.Println("Before:", before)
	// [{2019-01-09 - 2019-01-14}]
	fmt.Println("After:", after)
	// [{2019-01-14 - 2019-01-15} {2019-01-20 - 2019-01-24}]
}

Documentation ¶

Overview ¶

Package daterange is a powerful and intuitive Go package designed for handling date intervals efficiently and effectively. This library simplifies operations such as comparing dates, checking overlaps, and processing date ranges in Go applications.

Index ¶

type DateRange
- func MustNewDateRange(from, to time.Time) DateRange
- func NewDateRange(from, to time.Time) DateRange
type DateRanges
- func NewDateRanges(dataRanges ...DateRange) DateRanges

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

This section is empty.

Types ¶

type DateRange ¶

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

DateRange is an **inclusive** range of dates. The range is defined by two dates.

func MustNewDateRange ¶

func MustNewDateRange(from, to time.Time) DateRange

MustNewDateRange returns a new DateRange from the given dates. This automatically truncates the time portion of the dates, ignoring the time zone (for example 2024-01-26 9pm EST will still be the 26th of January 2024). This panics if the truncated `from` date is after the truncated `to` date. Use NewDateRange if you want to automatically order input dates.

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRange
	dr := daterange.MustNewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC))
	fmt.Println(dr.String())
}

Output:
{2024-01-26 - 2024-01-28}

func NewDateRange ¶

func NewDateRange(from, to time.Time) DateRange

NewDateRange returns a new DateRange from the given dates. This automatically order input dates and truncates the time portion of the dates, ignoring the time zone (for example 2024-01-26 9pm EST will still be the 26th of January 2024). Use MustNewDateRange if you want to panic if `from` date if after the `to`date .

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRange
	dr := daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC))
	fmt.Println(dr.String())
}

Output:
{2024-01-26 - 2024-01-28}

func (DateRange) Contains ¶

func (d DateRange) Contains(date time.Time) bool

Contains returns true if the given date is in the range. The range is inclusive.

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRange
	dr := daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC))
	fmt.Println(dr.Contains(time.Date(2024, 1, 27, 0, 0, 0, 0, time.UTC)))
}

Output:
true

func (DateRange) Difference ¶

func (d DateRange) Difference(other DateRange) DateRanges

Difference returns a DateRanges collection that is the difference of the two DateRanges

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRange
	dr := daterange.NewDateRange(time.Date(2024, 1, 16, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC))
	fmt.Println(dr.Difference(daterange.NewDateRange(time.Date(2024, 1, 20, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 24, 0, 0, 0, 0, time.UTC))).String())
}

Output:
[{2024-01-16 - 2024-01-19} {2024-01-25 - 2024-01-28}]

func (DateRange) From ¶

func (d DateRange) From() time.Time

From returns the start date of the range, as midnight of that day, UTC time.

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRange
	dr := daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC))
	fmt.Println(dr.From().Format("2006-01-02"))
}

Output:
2024-01-26

func (DateRange) Includes ¶

func (d DateRange) Includes(other DateRange) bool

Includes returns true if the given range is included in the range. The range is inclusive.

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRange
	dr := daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC))
	fmt.Println(dr.Includes(daterange.NewDateRange(time.Date(2024, 1, 27, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 27, 0, 0, 0, 0, time.UTC))))
}

Output:
true

func (DateRange) Intersection ¶

func (d DateRange) Intersection(other DateRange) DateRange

Intersection returns the intersection of the two DateRanges

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRange
	dr := daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC))
	fmt.Println(dr.Intersection(daterange.NewDateRange(time.Date(2024, 1, 27, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 29, 0, 0, 0, 0, time.UTC))).String())
}

Output:
{2024-01-27 - 2024-01-28}

func (DateRange) IsZero ¶

func (d DateRange) IsZero() bool

IsZero returns true if the both dates of range are zero

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRange
	dr := daterange.NewDateRange(time.Time{}, time.Time{})
	fmt.Println(dr.IsZero())
}

Output:
true

func (DateRange) Overlaps ¶

func (d DateRange) Overlaps(other DateRange) bool

Overlaps returns true if the given range overlaps with the range. The range is inclusive.

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRange
	dr := daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC))
	fmt.Println(dr.Overlaps(daterange.NewDateRange(time.Date(2024, 1, 27, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 29, 0, 0, 0, 0, time.UTC))))
}

Output:
true

func (DateRange) String ¶

func (d DateRange) String() string

String returns a string representation of the DateRange

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRange
	dr := daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC))
	fmt.Println(dr.String())
}

Output:
{2024-01-26 - 2024-01-28}

func (DateRange) To ¶

func (d DateRange) To() time.Time

To returns the end date of the range, as midnight of that day, UTC time.

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRange
	dr := daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC))
	fmt.Println(dr.To().Format("2006-01-02"))
}

Output:
2024-01-28

func (DateRange) Union ¶

func (d DateRange) Union(other DateRange) DateRanges

Union returns a DateRanges collection that is the union of the two DateRanges

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRange
	dr := daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC))
	fmt.Println(dr.Union(daterange.NewDateRange(time.Date(2024, 1, 27, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 29, 0, 0, 0, 0, time.UTC))).String())
}

Output:
[{2024-01-26 - 2024-01-29}]

type DateRanges ¶

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

DataRanges is a collection of DateRange elements

func NewDateRanges ¶

func NewDateRanges(dataRanges ...DateRange) DateRanges

NewDateRanges returns a new collection with given elements

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRanges
	drs := daterange.NewDateRanges(
		daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC)),
		daterange.NewDateRange(time.Date(2024, 1, 29, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 31, 0, 0, 0, 0, time.UTC)),
	)
	fmt.Println(drs.String())
}

Output:
[{2024-01-26 - 2024-01-31}]

func (*DateRanges) Append ¶

func (drs *DateRanges) Append(dataRange ...DateRange)

Append adds the given elements to the collection

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRanges
	drs := daterange.NewDateRanges(
		daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC)),
	)
	drs.Append(daterange.NewDateRange(time.Date(2024, 1, 29, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 31, 0, 0, 0, 0, time.UTC)))
	fmt.Println(drs.String())
}

Output:
[{2024-01-26 - 2024-01-31}]

func (*DateRanges) Contains ¶

func (drs *DateRanges) Contains(date time.Time) bool

Contains returns true if the given date is in the collection

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRanges
	drs := daterange.NewDateRanges(
		daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC)),
	)
	fmt.Println(drs.Contains(time.Date(2024, 1, 27, 0, 0, 0, 0, time.UTC)))
}

Output:
true

func (*DateRanges) Equal ¶

func (drs *DateRanges) Equal(other DateRanges) bool

Equal returns true if the collection is equal to the given collection

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRanges
	drs1 := daterange.NewDateRanges(
		daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC)),
		daterange.NewDateRange(time.Date(2024, 1, 29, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 31, 0, 0, 0, 0, time.UTC)),
	)
	drs2 := daterange.NewDateRanges(
		daterange.NewDateRange(time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 31, 0, 0, 0, 0, time.UTC)),
		daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 27, 0, 0, 0, 0, time.UTC)),
	)
	fmt.Println(drs1.Equal(drs2))
}

Output:
true

func (*DateRanges) FirstDate ¶

func (drs *DateRanges) FirstDate() time.Time

FirstDate returns the first date of the collection

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRanges
	drs := daterange.NewDateRanges(
		daterange.NewDateRange(time.Date(2024, 1, 29, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 31, 0, 0, 0, 0, time.UTC)),
		daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC)),
	)
	fmt.Println(drs.FirstDate().Format("2006-01-02"))
}

Output:
2024-01-26

func (*DateRanges) IsAllDatesIn ¶

func (drs *DateRanges) IsAllDatesIn(other DateRange) bool

IsAllDatesIn returns true if all dates in the given DateRange are in the collection Zero DateRange is always considered to be in the collection

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRanges
	drs := daterange.NewDateRanges(
		daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC)),
	)
	fmt.Println(drs.IsAllDatesIn(
		daterange.NewDateRange(time.Date(2024, 1, 27, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC)),
	))
}

Output:
true

func (*DateRanges) IsAnyDateIn ¶

func (drs *DateRanges) IsAnyDateIn(other DateRange) bool

IsAnyDateIn returns true if any date in the given DateRange is in the collection Zero DateRange is always considered to be in the collection

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRanges
	drs := daterange.NewDateRanges(
		daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC)),
	)
	fmt.Println(drs.IsAnyDateIn(
		daterange.NewDateRange(time.Date(2024, 1, 27, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 29, 0, 0, 0, 0, time.UTC)),
	))
}

Output:
true

func (*DateRanges) IsZero ¶

func (drs *DateRanges) IsZero() bool

IsZero returns true if the collection is empty

Example ¶

package main

import (
	"fmt"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRanges
	drs := daterange.NewDateRanges()
	fmt.Println(drs.IsZero())
}

Output:
true

func (*DateRanges) LastDate ¶

func (drs *DateRanges) LastDate() time.Time

LastDate returns the last date of the collection

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRanges
	drs := daterange.NewDateRanges(
		daterange.NewDateRange(time.Date(2024, 1, 29, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 31, 0, 0, 0, 0, time.UTC)),
		daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC)),
	)
	fmt.Println(drs.LastDate().Format("2006-01-02"))
}

Output:
2024-01-31

func (*DateRanges) Len ¶

func (drs *DateRanges) Len() int

Len returns the number of elements in the collection

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRanges
	drs := daterange.NewDateRanges(
		daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC)),
		daterange.NewDateRange(time.Date(2024, 1, 29, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 31, 0, 0, 0, 0, time.UTC)),
	)
	fmt.Println(drs.Len())
}

Output:
1

func (*DateRanges) SplitInclusive ¶ added in v1.0.0

func (drs *DateRanges) SplitInclusive(date time.Time) (DateRanges, DateRanges)

SplitInclusive splits the collection into two collections based on the given date The given date is included in both collections

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRanges
	drs := daterange.NewDateRanges(
		daterange.NewDateRange(time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 3, 0, 0, 0, 0, time.UTC)),
		daterange.NewDateRange(time.Date(2024, 1, 15, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 27, 0, 0, 0, 0, time.UTC)),
	)
	before, after := drs.SplitInclusive(time.Date(2024, 1, 20, 0, 0, 0, 0, time.UTC))
	fmt.Println(before.String(), after.String())
}

Output:
[{2024-01-01 - 2024-01-03} {2024-01-15 - 2024-01-20}] [{2024-01-20 - 2024-01-27}]

func (DateRanges) String ¶

func (drs DateRanges) String() string

String returns a string representation of the collection. Items are guaranteed to be sorted, non-overlapping and non-zero. Any adjacent periods are merged.

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRanges
	drs := daterange.NewDateRanges(
		daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC)),
		daterange.NewDateRange(time.Date(2024, 1, 29, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 31, 0, 0, 0, 0, time.UTC)),
	)
	fmt.Println(drs.String())
}

Output:
[{2024-01-26 - 2024-01-31}]

func (*DateRanges) ToSlice ¶

func (drs *DateRanges) ToSlice() []DateRange

ToSlice returns the members of the collection as a slice. Items are guaranteed to be sorted, non-overlapping and non-zero. Any adjacent periods are merged.

Example ¶

package main

import (
	"fmt"
	"time"

	daterange "github.com/felixenescu/date-range"
)

func main() {
	// Create a new DateRanges
	drs := daterange.NewDateRanges(
		daterange.NewDateRange(time.Date(2024, 1, 26, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 28, 0, 0, 0, 0, time.UTC)),
		daterange.NewDateRange(time.Date(2024, 1, 29, 0, 0, 0, 0, time.UTC), time.Date(2024, 1, 31, 0, 0, 0, 0, time.UTC)),
	)
	fmt.Println(drs.ToSlice())
}

Output:
[{2024-01-26 - 2024-01-31}]

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL

README ¶

date-range

Introduction

Features

Potential Use Cases

Usage

DateRange

Overview

Constructors

Methods

Use Cases and Examples

DateRanges

Overview

Constructor

Methods

Use Cases and Examples

Documentation ¶

Overview ¶

Index ¶

Examples ¶

Constants ¶

Variables ¶

Functions ¶

Types ¶

type DateRange ¶

func MustNewDateRange ¶

func NewDateRange ¶

func (DateRange) Contains ¶

func (DateRange) Difference ¶

func (DateRange) From ¶

func (DateRange) Includes ¶

func (DateRange) Intersection ¶

func (DateRange) IsZero ¶

func (DateRange) Overlaps ¶

func (DateRange) String ¶

func (DateRange) To ¶

func (DateRange) Union ¶

type DateRanges ¶

func NewDateRanges ¶

func (*DateRanges) Append ¶

func (*DateRanges) Contains ¶

func (*DateRanges) Equal ¶

func (*DateRanges) FirstDate ¶

func (*DateRanges) IsAllDatesIn ¶

func (*DateRanges) IsAnyDateIn ¶

func (*DateRanges) IsZero ¶

func (*DateRanges) LastDate ¶

func (*DateRanges) Len ¶

func (*DateRanges) SplitInclusive ¶ added in v1.0.0

func (DateRanges) String ¶

func (*DateRanges) ToSlice ¶

Source Files ¶