location.go

// Generated code
// run `make generate` to update

// Code generated by set-gen. DO NOT EDIT.

package sets

import (
	"reflect"
	"sort"

	voyager "github.com/atlassian/voyager"
)

// sets.Location is a set of voyager.Locations, implemented via map[voyager.Location]struct{} for minimal memory consumption.
type Location map[voyager.Location]Empty

// NewLocation creates a Location from a list of values.
func NewLocation(items ...voyager.Location) Location {
	ss := Location{}
	ss.Insert(items...)
	return ss
}

// LocationKeySet creates a Location from a keys of a map[voyager.Location](? extends interface{}).
// If the value passed in is not actually a map, this will panic.
func LocationKeySet(theMap interface{}) Location {
	v := reflect.ValueOf(theMap)
	ret := Location{}

	for _, keyValue := range v.MapKeys() {
		ret.Insert(keyValue.Interface().(voyager.Location))
	}
	return ret
}

// Insert adds items to the set.
func (s Location) Insert(items ...voyager.Location) {
	for _, item := range items {
		s[item] = Empty{}
	}
}

// Delete removes all items from the set.
func (s Location) Delete(items ...voyager.Location) {
	for _, item := range items {
		delete(s, item)
	}
}

// Has returns true if and only if item is contained in the set.
func (s Location) Has(item voyager.Location) bool {
	_, contained := s[item]
	return contained
}

// HasAll returns true if and only if all items are contained in the set.
func (s Location) HasAll(items ...voyager.Location) bool {
	for _, item := range items {
		if !s.Has(item) {
			return false
		}
	}
	return true
}

// HasAny returns true if any items are contained in the set.
func (s Location) HasAny(items ...voyager.Location) bool {
	for _, item := range items {
		if s.Has(item) {
			return true
		}
	}
	return false
}

// Difference returns a set of objects that are not in s2
// For example:
// s1 = {a1, a2, a3}
// s2 = {a1, a2, a4, a5}
// s1.Difference(s2) = {a3}
// s2.Difference(s1) = {a4, a5}
func (s Location) Difference(s2 Location) Location {
	result := NewLocation()
	for key := range s {
		if !s2.Has(key) {
			result.Insert(key)
		}
	}
	return result
}

// Union returns a new set which includes items in either s1 or s2.
// For example:
// s1 = {a1, a2}
// s2 = {a3, a4}
// s1.Union(s2) = {a1, a2, a3, a4}
// s2.Union(s1) = {a1, a2, a3, a4}
func (s1 Location) Union(s2 Location) Location {
	result := NewLocation()
	for key := range s1 {
		result.Insert(key)
	}
	for key := range s2 {
		result.Insert(key)
	}
	return result
}

// Intersection returns a new set which includes the item in BOTH s1 and s2
// For example:
// s1 = {a1, a2}
// s2 = {a2, a3}
// s1.Intersection(s2) = {a2}
func (s1 Location) Intersection(s2 Location) Location {
	var walk, other Location
	result := NewLocation()
	if s1.Len() < s2.Len() {
		walk = s1
		other = s2
	} else {
		walk = s2
		other = s1
	}
	for key := range walk {
		if other.Has(key) {
			result.Insert(key)
		}
	}
	return result
}

// IsSuperset returns true if and only if s1 is a superset of s2.
func (s1 Location) IsSuperset(s2 Location) bool {
	for item := range s2 {
		if !s1.Has(item) {
			return false
		}
	}
	return true
}

// Equal returns true if and only if s1 is equal (as a set) to s2.
// Two sets are equal if their membership is identical.
// (In practice, this means same elements, order doesn't matter)
func (s1 Location) Equal(s2 Location) bool {
	return len(s1) == len(s2) && s1.IsSuperset(s2)
}

type sortableSliceOfLocation []voyager.Location

func (s sortableSliceOfLocation) Len() int           { return len(s) }
func (s sortableSliceOfLocation) Less(i, j int) bool { return lessLocation(s[i], s[j]) }
func (s sortableSliceOfLocation) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

// List returns the contents as a sorted voyager.Location slice.
func (s Location) List() []voyager.Location {
	res := make(sortableSliceOfLocation, 0, len(s))
	for key := range s {
		res = append(res, key)
	}
	sort.Sort(res)
	return []voyager.Location(res)
}

// UnsortedList returns the slice with contents in random order.
func (s Location) UnsortedList() []voyager.Location {
	res := make([]voyager.Location, 0, len(s))
	for key := range s {
		res = append(res, key)
	}
	return res
}

// Returns a single element from the set.
func (s Location) PopAny() (voyager.Location, bool) {
	for key := range s {
		s.Delete(key)
		return key, true
	}
	var zeroValue voyager.Location
	return zeroValue, false
}

// Len returns the size of the set.
func (s Location) Len() int {
	return len(s)
}

func lessLocation(lhs, rhs voyager.Location) bool {
	if lhs.EnvType < rhs.EnvType {
		return true
	}
	if lhs.EnvType > rhs.EnvType {
		return false
	}
	if lhs.Account < rhs.Account {
		return true
	}
	if lhs.Account > rhs.Account {
		return false
	}
	if lhs.Region < rhs.Region {
		return true
	}
	if lhs.Region > rhs.Region {
		return false
	}
	if lhs.Label < rhs.Label {
		return true
	}
	if lhs.Label > rhs.Label {
		return false
	}
	return false
}