advent2020

type Action string

type BagRules map[string]map[string]int

type Bus struct {
	ID, ArrivalOffset int
}

type Card int

type CardQueue interface {
	Enqueue(Card)
	Dequeue() (Card, error)
	Peek() (Card, error)
	Size() int
}

type Circle struct {
	Cups      *ring.Ring
	CupsByID  map[int]*ring.Ring
	Current   *ring.Ring
	Low, High int
}

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

type Computer struct {
	Version Version
	Mask    string
	Memory  map[int]int
}

type CoordinateQueue interface {
	Enqueue(location.Coordinate)
	Dequeue() (location.Coordinate, error)
	Peek() (location.Coordinate, error)
	Size() int
}

type Cube struct {
	CellsByLocation map[location.Point]CubeCell
}

type CubeCell struct {
	Coordinate location.Point
	Status     CubeStatus
}

type CubeStatus int

type Deck struct {
	Player int
	Queue  *cardQueue
}

type Door struct {
	Encryptor
}

type Edge uint16

type Encryptor struct {
	LoopNumber int
}

type Expression []Token

type Floor struct {
	AllDirections [][]HexDirection
	// contains filtered or unexported fields
}

type Food struct {
	Ingredients []string
	Allergens   []string
}

type FoodListing []Food

type Group struct {
	Affirmatives map[int]map[rune]struct{}
}

type HexDirection string

type Instruction struct {
	Operation       Op
	Location, Value int
	Mask            string
}

type Itinerary struct {
	EarliestDeparture int
	Busses            []Bus
}

type NavigationInstruction struct {
	Action Action
	Value  int
}

type NeighboringStrategy func(location.Coordinate, map[location.Coordinate]Seat) []Seat

type Op int

type Operand int

type Operation string

type Operator string

type Orientation int

type Passport struct {
	BirthYear, IssueYear, ExpirationYear, Height string
	HairColor, EyeColor, PassportID, CountryID   string
}

type PasswordDBEntry struct {
	Policy   PasswordPolicy
	Password string
}

type PasswordPolicy struct {
	Character                      rune
	MinOccurrences, MaxOccurrences int
}

type Pixel rune

type PolicyType int

type Program []Instruction

type Queue interface {
	Enqueue(string)
	Dequeue() (string, error)
	Size() int
}

type RangeValidator struct {
	LowerBound, UpperBound int
}

type RoomCard struct {
	Encryptor
}

type Rule struct {
	ID       int
	Letter   string
	Subrules [][]int
}

type Ruleset map[int]Rule

type Seat struct {
	Location location.Coordinate
	Status   State
}

type SeatingArrangement []Seat

type Ship struct {
	Location    location.Point
	Orientation Orientation
	Waypoint    location.Point
}

type Side int

type Stack interface {
	Push(i int)
	Pop() (int, error)
	Peek() (int, error)
	Size() int
}

type State int

type TicketRules map[string][]Validator

type Tile struct {
	ID     int
	Pixels [][]Pixel
}

type Tileset []Tile

type Token interface {
	Value() string
}

type TokenQueue interface {
	Enqueue(Token)
	Dequeue() (Token, error)
	Peek() (Token, error)
	Size() int
}

type TokenStack interface {
	Push(Token)
	Pop() (Token, error)
	Peek() (Token, error)
	Size() int
}

type TrajectoryMap struct {
	Trees         map[location.Coordinate]struct{}
	Rows, Columns int
}

type Validator interface {
	Validate(int) bool
}

type Version int