breaking apart the large rrule.go

Author: stephens2424

expansions.go

@@ -12,7 +12,7 @@ func expandBySeconds(tt []time.Time, seconds ...int) []time.Time {
 
 	e := make([]time.Time, 0, len(tt)*len(seconds))
 	for _, t := range tt {
-		tmpl := t.Add(time.Duration(-1 * t.Second())* time.Second)
+		tmpl := t.Add(time.Duration(-1*t.Second()) * time.Second)
 		for _, s := range seconds {
 			if s < 0 {
 				s += 60
@@ -31,7 +31,7 @@ func expandByMinutes(tt []time.Time, minutes ...int) []time.Time {
 
 	e := make([]time.Time, 0, len(tt)*len(minutes))
 	for _, t := range tt {
-		tmpl := t.Add(time.Duration(-1 * t.Minute()) *time.Minute)
+		tmpl := t.Add(time.Duration(-1*t.Minute()) * time.Minute)
 		for _, m := range minutes {
 			if m < 0 {
 				m += 60
@@ -50,7 +50,7 @@ func expandByHours(tt []time.Time, hours ...int) []time.Time {
 
 	e := make([]time.Time, 0, len(tt)*len(hours))
 	for _, t := range tt {
-		tmpl := t.Add(time.Duration(-1 * t.Hour()) * time.Hour)
+		tmpl := t.Add(time.Duration(-1*t.Hour()) * time.Hour)
 		for _, h := range hours {
 			if h < 0 {
 				h += 24

frequency.go

@@ -0,0 +1,33 @@
+package rrule
+
+type Frequency int
+
+func (f Frequency) String() string {
+	switch f {
+	case Secondly:
+		return "SECONDLY"
+	case Minutely:
+		return "MINUTELY"
+	case Hourly:
+		return "HOURLY"
+	case Daily:
+		return "DAILY"
+	case Weekly:
+		return "WEEKLY"
+	case Monthly:
+		return "MONTHLY"
+	case Yearly:
+		return "YEARLY"
+	}
+	return ""
+}
+
+const (
+	Secondly Frequency = iota
+	Minutely
+	Hourly
+	Daily
+	Weekly
+	Monthly
+	Yearly
+)

invalidBehavior.go

@@ -0,0 +1,9 @@
+package rrule
+
+type InvalidBehavior int
+
+const (
+	OmitInvalid InvalidBehavior = iota
+	NextInvalid
+	PrevInvalid
+)

iterator.go

@@ -0,0 +1,91 @@
+package rrule
+
+import "time"
+
+type Iterator interface {
+	Next() *time.Time
+}
+
+type iterator struct {
+	queue       []time.Time
+	totalQueued uint64
+	queueCap    uint64
+	minTime     time.Time
+	maxTime     time.Time
+	pastMaxTime bool
+
+	// next finds the next key time.
+	next func() *time.Time
+
+	// variations returns all the possible variations
+	// of the key time t
+	variations func(t *time.Time) []time.Time
+
+	// valid determines if a particular key time is a valid recurrence.
+	valid func(t *time.Time) bool
+
+	setpos []int
+}
+
+func (i *iterator) Next() *time.Time {
+	if len(i.queue) > 0 {
+		r := i.queue[0]
+		i.queue = i.queue[1:]
+		return &r
+	}
+
+	if i.queueCap > 0 {
+		if i.totalQueued >= i.queueCap {
+			return nil
+		}
+	}
+
+	for {
+		if i.pastMaxTime {
+			return nil
+		}
+
+		key := i.next()
+		if key == nil {
+			return nil
+		}
+
+		if !i.valid(key) {
+			continue
+		}
+
+		variations := i.variations(key)
+
+		// remove any variations before the min time
+		for len(variations) > 0 && variations[0].Before(i.minTime) {
+			variations = variations[1:]
+		}
+
+		// remove any variations after the max time
+		if !i.maxTime.IsZero() {
+			for idx, v := range variations {
+				if v.After(i.maxTime) {
+					variations = variations[:idx]
+					i.pastMaxTime = true
+					break
+				}
+			}
+		}
+
+		// if we're left with nothing (or started there) skip this key time
+		if len(variations) == 0 {
+			continue
+		}
+
+		if i.queueCap > 0 {
+			if i.totalQueued+uint64(len(variations)) > i.queueCap {
+				variations = variations[:i.queueCap-i.totalQueued]
+			}
+		}
+
+		i.totalQueued += uint64(len(variations))
+
+		i.queue = variations[1:]
+		return &variations[0]
+	}
+}

limiters.go

@@ -0,0 +1,88 @@
+package rrule
+
+import (
+	"sort"
+	"time"
+)
+
+func limitBySetPos(tt []time.Time, setpos []int) []time.Time {
+	if len(setpos) == 0 {
+		return tt
+	}
+
+	// a map of tt indexes to include
+	include := map[int]bool{}
+
+	for _, sp := range setpos {
+		if sp < 0 {
+			sp = len(tt) + sp
+		} else {
+			sp-- // setpos is 1-indexed in the rrule. adjust here
+		}
+
+		include[sp] = true
+	}
+
+	ret := make([]time.Time, 0, len(include))
+	for included := range include {
+		if len(tt) > included {
+			ret = append(ret, tt[included])
+		}
+	}
+
+	sort.Slice(ret, func(i, j int) bool {
+		return ret[i].Before(ret[j])
+	})
+
+	return ret
+}
+
+func limitInstancesBySetPos(tt []int, setpos []int) []int {
+	if len(setpos) == 0 {
+		return tt
+	}
+
+	// a map of tt indexes to include
+	include := make(map[int]bool, len(setpos))
+
+	for _, sp := range setpos {
+		if sp < 0 {
+			sp = len(tt) + sp
+		} else {
+			sp-- // setpos is 1-indexed in the rrule. adjust here
+		}
+
+		include[sp] = true
+	}
+
+	ret := make([]int, 0, len(include))
+	for included := range include {
+		if len(tt) > included {
+			ret = append(ret, tt[included])
+		}
+	}
+
+	sort.Ints(ret)
+
+	return ret
+}
+
+func combineLimiters(ll ...validFunc) func(t *time.Time) bool {
+	return func(t *time.Time) bool {
+		for _, l := range ll {
+			if !l(t) {
+				return false
+			}
+		}
+		return true
+	}
+}
+
+func checkLimiters(t *time.Time, ll ...validFunc) bool {
+	for _, l := range ll {
+		if !l(t) {
+			return false
+		}
+	}
+	return true
+}

mappers.go

@@ -0,0 +1,27 @@
+package rrule
+
+import "time"
+
+func intmap(ints []int) map[int]bool {
+	m := make(map[int]bool, len(ints))
+	for _, v := range ints {
+		m[v] = true
+	}
+	return m
+}
+
+func weekdaymap(weekdays []QualifiedWeekday) map[time.Weekday]bool {
+	m := make(map[time.Weekday]bool, len(weekdays))
+	for _, v := range weekdays {
+		m[v.WD] = true
+	}
+	return m
+}
+
+func monthmap(months []time.Month) map[time.Month]bool {
+	m := make(map[time.Month]bool, len(months))
+	for _, v := range months {
+		m[v] = true
+	}
+	return m
+}