//
|
// SwiftDate
|
// Parse, validate, manipulate, and display dates, time and timezones in Swift
|
//
|
// Created by Daniele Margutti
|
// - Web: https://www.danielemargutti.com
|
// - Twitter: https://twitter.com/danielemargutti
|
// - Mail: hello@danielemargutti.com
|
//
|
// Copyright © 2019 Daniele Margutti. Licensed under MIT License.
|
//
|
|
import Foundation
|
|
// MARK: - Comparing DateInRegion
|
|
public func == (lhs: DateInRegion, rhs: DateInRegion) -> Bool {
|
return (lhs.date.timeIntervalSince1970 == rhs.date.timeIntervalSince1970)
|
}
|
|
public func <= (lhs: DateInRegion, rhs: DateInRegion) -> Bool {
|
let result = lhs.date.compare(rhs.date)
|
return (result == .orderedAscending || result == .orderedSame)
|
}
|
|
public func >= (lhs: DateInRegion, rhs: DateInRegion) -> Bool {
|
let result = lhs.date.compare(rhs.date)
|
return (result == .orderedDescending || result == .orderedSame)
|
}
|
|
public func < (lhs: DateInRegion, rhs: DateInRegion) -> Bool {
|
return lhs.date.compare(rhs.date) == .orderedAscending
|
}
|
|
public func > (lhs: DateInRegion, rhs: DateInRegion) -> Bool {
|
return lhs.date.compare(rhs.date) == .orderedDescending
|
}
|
|
// The type of comparison to do against today's date or with the suplied date.
|
///
|
/// - isToday: hecks if date today.
|
/// - isTomorrow: Checks if date is tomorrow.
|
/// - isYesterday: Checks if date is yesterday.
|
/// - isSameDay: Compares date days
|
/// - isThisWeek: Checks if date is in this week.
|
/// - isNextWeek: Checks if date is in next week.
|
/// - isLastWeek: Checks if date is in last week.
|
/// - isSameWeek: Compares date weeks
|
/// - isThisMonth: Checks if date is in this month.
|
/// - isNextMonth: Checks if date is in next month.
|
/// - isLastMonth: Checks if date is in last month.
|
/// - isSameMonth: Compares date months
|
/// - isThisYear: Checks if date is in this year.
|
/// - isNextYear: Checks if date is in next year.
|
/// - isLastYear: Checks if date is in last year.
|
/// - isSameYear: Compare date years
|
/// - isInTheFuture: Checks if it's a future date
|
/// - isInThePast: Checks if the date has passed
|
/// - isEarlier: Checks if earlier than date
|
/// - isLater: Checks if later than date
|
/// - isWeekday: Checks if it's a weekday
|
/// - isWeekend: Checks if it's a weekend
|
/// - isInDST: Indicates whether the represented date uses daylight saving time.
|
/// - isMorning: Return true if date is in the morning (>=5 - <12)
|
/// - isAfternoon: Return true if date is in the afternoon (>=12 - <17)
|
/// - isEvening: Return true if date is in the morning (>=17 - <21)
|
/// - isNight: Return true if date is in the morning (>=21 - <5)
|
public enum DateComparisonType {
|
|
// Days
|
case isToday
|
case isTomorrow
|
case isYesterday
|
case isSameDay(_ : DateRepresentable)
|
|
// Weeks
|
case isThisWeek
|
case isNextWeek
|
case isLastWeek
|
case isSameWeek(_: DateRepresentable)
|
|
// Months
|
case isThisMonth
|
case isNextMonth
|
case isLastMonth
|
case isSameMonth(_: DateRepresentable)
|
|
// Years
|
case isThisYear
|
case isNextYear
|
case isLastYear
|
case isSameYear(_: DateRepresentable)
|
|
// Relative Time
|
case isInTheFuture
|
case isInThePast
|
case isEarlier(than: DateRepresentable)
|
case isLater(than: DateRepresentable)
|
case isWeekday
|
case isWeekend
|
|
// Day time
|
case isMorning
|
case isAfternoon
|
case isEvening
|
case isNight
|
|
// TZ
|
case isInDST
|
}
|
|
public extension DateInRegion {
|
|
/// Decides whether a DATE is "close by" another one passed in parameter,
|
/// where "Being close" is measured using a precision argument
|
/// which is initialized a 300 seconds, or 5 minutes.
|
///
|
/// - Parameters:
|
/// - refDate: reference date compare against to.
|
/// - precision: The precision of the comparison (default is 5 minutes, or 300 seconds).
|
/// - Returns: A boolean; true if close by, false otherwise.
|
func compareCloseTo(_ refDate: DateInRegion, precision: TimeInterval = 300) -> Bool {
|
return (abs(date.timeIntervalSince(refDate.date)) <= precision)
|
}
|
|
/// Compare the date with the rule specified in the `compareType` parameter.
|
///
|
/// - Parameter compareType: comparison type.
|
/// - Returns: `true` if comparison succeded, `false` otherwise
|
func compare(_ compareType: DateComparisonType) -> Bool {
|
switch compareType {
|
case .isToday:
|
return compare(.isSameDay(region.nowInThisRegion()))
|
|
case .isTomorrow:
|
let tomorrow = DateInRegion(region: region).dateByAdding(1, .day)
|
return compare(.isSameDay(tomorrow))
|
|
case .isYesterday:
|
let yesterday = DateInRegion(region: region).dateByAdding(-1, .day)
|
return compare(.isSameDay(yesterday))
|
|
case .isSameDay(let refDate):
|
return calendar.isDate(date, inSameDayAs: refDate.date)
|
|
case .isThisWeek:
|
return compare(.isSameWeek(region.nowInThisRegion()))
|
|
case .isNextWeek:
|
let nextWeek = region.nowInThisRegion().dateByAdding(1, .weekOfYear)
|
return compare(.isSameWeek(nextWeek))
|
|
case .isLastWeek:
|
let lastWeek = region.nowInThisRegion().dateByAdding(-1, .weekOfYear)
|
return compare(.isSameWeek(lastWeek))
|
|
case .isSameWeek(let refDate):
|
guard weekOfYear == refDate.weekOfYear else {
|
return false
|
}
|
// Ensure time interval is under 1 week
|
return (abs(date.timeIntervalSince(refDate.date)) < 1.weeks.timeInterval)
|
|
case .isThisMonth:
|
return compare(.isSameMonth(region.nowInThisRegion()))
|
|
case .isNextMonth:
|
let nextMonth = region.nowInThisRegion().dateByAdding(1, .month)
|
return compare(.isSameMonth(nextMonth))
|
|
case .isLastMonth:
|
let lastMonth = region.nowInThisRegion().dateByAdding(-1, .month)
|
return compare(.isSameMonth(lastMonth))
|
|
case .isSameMonth(let refDate):
|
return (date.year == refDate.date.year) && (date.month == refDate.date.month)
|
|
case .isThisYear:
|
return compare(.isSameYear(region.nowInThisRegion()))
|
|
case .isNextYear:
|
let nextYear = region.nowInThisRegion().dateByAdding(1, .year)
|
return compare(.isSameYear(nextYear))
|
|
case .isLastYear:
|
let lastYear = region.nowInThisRegion().dateByAdding(-1, .year)
|
return compare(.isSameYear(lastYear))
|
|
case .isSameYear(let refDate):
|
return (date.year == refDate.date.year)
|
|
case .isInTheFuture:
|
return compare(.isLater(than: region.nowInThisRegion()))
|
|
case .isInThePast:
|
return compare(.isEarlier(than: region.nowInThisRegion()))
|
|
case .isEarlier(let refDate):
|
return ((date as NSDate).earlierDate(refDate.date) == date)
|
|
case .isLater(let refDate):
|
return ((date as NSDate).laterDate(refDate.date) == date)
|
|
case .isWeekday:
|
return !compare(.isWeekend)
|
|
case .isWeekend:
|
let range = calendar.maximumRange(of: Calendar.Component.weekday)!
|
return (weekday == range.lowerBound || weekday == range.upperBound - range.lowerBound)
|
|
case .isInDST:
|
return region.timeZone.isDaylightSavingTime(for: date)
|
|
case .isMorning:
|
return (hour >= 5 && hour < 12)
|
|
case .isAfternoon:
|
return (hour >= 12 && hour < 17)
|
|
case .isEvening:
|
return (hour >= 17 && hour < 21)
|
|
case .isNight:
|
return (hour >= 21 || hour < 5)
|
|
}
|
}
|
|
/// Returns a ComparisonResult value that indicates the ordering of two given dates based on
|
/// their components down to a given unit granularity.
|
///
|
/// - parameter date: date to compare.
|
/// - parameter granularity: The smallest unit that must, along with all larger units
|
/// - returns: `ComparisonResult`
|
func compare(toDate refDate: DateInRegion, granularity: Calendar.Component) -> ComparisonResult {
|
switch granularity {
|
case .nanosecond:
|
// There is a possible rounding error using Calendar to compare two dates below the minute granularity
|
// So we've added this trick and use standard Date compare which return correct results in this case
|
// https://github.com/malcommac/SwiftDate/issues/346
|
return date.compare(refDate.date)
|
default:
|
return region.calendar.compare(date, to: refDate.date, toGranularity: granularity)
|
}
|
}
|
|
/// Compares whether the receiver is before/before equal `date` based on their components down to a given unit granularity.
|
///
|
/// - Parameters:
|
/// - refDate: reference date
|
/// - orEqual: `true` to also check for equality
|
/// - granularity: smallest unit that must, along with all larger units, be less for the given dates
|
/// - Returns: Boolean
|
func isBeforeDate(_ date: DateInRegion, orEqual: Bool = false, granularity: Calendar.Component) -> Bool {
|
let result = compare(toDate: date, granularity: granularity)
|
return (orEqual ? (result == .orderedSame || result == .orderedAscending) : result == .orderedAscending)
|
}
|
|
/// Compares whether the receiver is after `date` based on their components down to a given unit granularity.
|
///
|
/// - Parameters:
|
/// - refDate: reference date
|
/// - orEqual: `true` to also check for equality
|
/// - granularity: Smallest unit that must, along with all larger units, be greater for the given dates.
|
/// - Returns: Boolean
|
func isAfterDate(_ refDate: DateInRegion, orEqual: Bool = false, granularity: Calendar.Component) -> Bool {
|
let result = compare(toDate: refDate, granularity: granularity)
|
return (orEqual ? (result == .orderedSame || result == .orderedDescending) : result == .orderedDescending)
|
}
|
|
/// Compares equality of two given dates based on their components down to a given unit
|
/// granularity.
|
///
|
/// - parameter date: date to compare
|
/// - parameter granularity: The smallest unit that must, along with all larger units, be equal for the given
|
/// dates to be considered the same.
|
///
|
/// - returns: `true` if the dates are the same down to the given granularity, otherwise `false`
|
func isInside(date: DateInRegion, granularity: Calendar.Component) -> Bool {
|
return (compare(toDate: date, granularity: granularity) == .orderedSame)
|
}
|
|
/// Return `true` if receiver data is contained in the range specified by two dates.
|
///
|
/// - Parameters:
|
/// - startDate: range upper bound date
|
/// - endDate: range lower bound date
|
/// - orEqual: `true` to also check for equality on date and date2, default is `true`
|
/// - granularity: smallest unit that must, along with all larger units, be greater
|
/// - Returns: Boolean
|
func isInRange(date startDate: DateInRegion, and endDate: DateInRegion, orEqual: Bool = true, granularity: Calendar.Component = .nanosecond) -> Bool {
|
return isAfterDate(startDate, orEqual: orEqual, granularity: granularity) && isBeforeDate(endDate, orEqual: orEqual, granularity: granularity)
|
}
|
|
// MARK: - Date Earlier/Later
|
|
/// Return the earlier of two dates, between self and a given date.
|
///
|
/// - Parameter date: The date to compare to self
|
/// - Returns: The date that is earlier
|
func earlierDate(_ date: DateInRegion) -> DateInRegion {
|
return self.date.timeIntervalSince(date.date) <= 0 ? self : date
|
}
|
|
/// Return the later of two dates, between self and a given date.
|
///
|
/// - Parameter date: The date to compare to self
|
/// - Returns: The date that is later
|
func laterDate(_ date: DateInRegion) -> DateInRegion {
|
return self.date.timeIntervalSince(date.date) >= 0 ? self : date
|
}
|
|
/// Returns the difference in the calendar component given (like day, month or year)
|
/// with respect to the other date as a positive integer
|
func difference(in component: Calendar.Component, from other: DateInRegion) -> Int? {
|
return self.date.difference(in: component, from: other.date)
|
}
|
|
/// Returns the differences in the calendar components given (like day, month and year)
|
/// with respect to the other date as dictionary with the calendar component as the key
|
/// and the diffrence as a positive integer as the value
|
func differences(in components: Set<Calendar.Component>, from other: DateInRegion) -> [Calendar.Component: Int] {
|
return self.date.differences(in: components, from: other.date)
|
}
|
|
}
|
