In this article, we’ll go through a low-level design (LLD) implementation of a parking lot system in Go. We'll explore different aspects of the system and see how each component interacts with the rest. This implementation focuses on clarity and real-world usefulness, so you can extend it easily if you want to add features like more vehicle types, multiple payment options, or spot reservations.
The system handles tasks like managing parking floors and spots, parking and unparking vehicles, and processing payments. We’ll also ensure it’s thread-safe for concurrent access, so if we need to expand it into a larger system, it won’t break down under pressure.
Core Components
Our design includes six main components:
- Parking Lot - The main entry point managing floors and parking operations.
- Parking Floor - Each floor contains multiple parking spots for different types of vehicles.
- Parking Spot - Represents a parking spot that can hold a specific type of vehicle.
- Parking Ticket - Tracks entry/exit times, parking charges, and the associated vehicle.
- Payment System - Handles parking fee calculations and payment processing.
- Vehicle Types - Supports different types of vehicles (cars, vans, trucks, and motorcycles). Each type has a different hourly charge.
Singleton Parking Lot
Our ParkingLot
uses the Singleton pattern. This means there’s only one instance of the parking lot, which is created once and reused across the application. Here’s the code to get that working:
var (
parkingLotInstance *ParkingLot
once sync.Once
)
type ParkingLot struct {
Name string
floors []*ParkingFloor
}
func GetParkingLotInstance() *ParkingLot {
once.Do(func() {
parkingLotInstance = &ParkingLot{}
})
return parkingLotInstance
}
Using sync.Once
, we ensure that only one instance is created, even when accessed by multiple goroutines.
Managing Floors in the Parking Lot
The parking lot has multiple floors, each with designated parking spots for different vehicle types (e.g., cars, vans, trucks, and motorcycles). To add a floor to the parking lot, we use the AddFloor
method:
func (p *ParkingLot) AddFloor(floorID int) {
p.floors = append(p.floors, NewParkingFloor(floorID))
}
Each floor is created using the NewParkingFloor
function, which organizes spots by vehicle type.
Parking Spots
Each ParkingSpot
is associated with a specific vehicle type (like a car or motorcycle). This allows the system to manage and restrict which vehicles can park in each spot. Here’s the ParkingSpot structure and the ParkVehicle
method:
type ParkingSpot struct {
SpotID int
VehicleType vehicles.VehicleType
CurrentVehicle *vehicles.VehicleInterface
lock sync.Mutex
}
func (p *ParkingSpot) ParkVehicle(vehicle vehicles.VehicleInterface) error {
p.lock.Lock()
defer p.lock.Unlock()
if vehicle.GetVehicleType() != p.VehicleType {
return fmt.Errorf("vehicle type mismatch: expected %s, got %s", p.VehicleType, vehicle.GetVehicleType())
}
if p.CurrentVehicle != nil {
return fmt.Errorf("parking spot already occupied")
}
p.CurrentVehicle = &vehicle
return nil
}
We use a Mutex
lock to make sure only one vehicle can park in a spot at a time.
Parking Ticket
Every vehicle gets a ticket with the entry time, exit time, parking spot, and total charge. This ticket will be updated when the vehicle exits, and charges will be calculated based on the time spent parked.
type ParkingTicket struct {
EntryTime time.Time
ExitTime time.Time
Vehicle vehicles.VehicleInterface
Spot *ParkingSpot
TotalCharge float64
}
func NewParkingTicket(vehicle vehicles.VehicleInterface, spot *ParkingSpot) *ParkingTicket {
return &ParkingTicket{EntryTime: time.Now(), ExitTime: time.Time{}, Vehicle: vehicle, Spot: spot, TotalCharge: 0.00}
}
The CalculateTotalCharge
method calculates parking fees based on the vehicle type and duration.
Payment System
The PaymentSystem
class processes the payment, updating the payment status based on whether the required amount is paid:
type PaymentSystem struct {
Status Status
Amount float64
ParkingTicket *ParkingTicket
}
func (p *PaymentSystem) ProcessPayment() error {
if p.ParkingTicket == nil {
return fmt.Errorf("payment failed: no parking ticket found")
}
if p.ParkingTicket.TotalCharge < p.Amount {
p.Status = PaymentStatusFailed
return fmt.Errorf("payment failed: insufficient funds")
}
p.Status = PaymentStatusCompleted
return nil
}
The ProcessPayment
function checks the amount and updates the payment status to Completed
or Failed
.
Adding Vehicle Types
Our system supports different types of vehicles (cars, vans, trucks, and motorcycles). Each type has a different hourly charge. This is achieved by setting up a VehicleType
and VehicleInterface
in a separate vehicles
package:
package vehicles
type VehicleType string
const (
CarType VehicleType = "Car"
VanType VehicleType = "Van"
TruckType VehicleType = "Truck"
MotorcycleType VehicleType = "Motorcycle"
)
type VehicleInterface interface {
GetLicenceNumber() string
GetVehicleType() VehicleType
GetVehicleCost() float64
}
We can create new vehicles by calling NewCar
, NewVan
, NewTruck
, etc., each of which implements VehicleInterface
.
Bringing It All Together
Let’s see how the pieces fit together in a flow:
- Create a Parking Lot: Call GetParkingLotInstance() and add floors with AddFloor.
- Find Parking Spot and Park Vehicle: ParkVehicle method finds an available spot, validates it against the vehicle type, and generates a ticket.
- Unpark Vehicle and Process Payment: UnparkVehicle generates the total charge, initiates the payment system, and completes the transaction.
This parking lot system is a simplified starting point for building more complex systems. We covered the basics of floor and spot management, vehicle parking and unparking, and a basic payment process.
For full code implementation, check the following repository:
thesaltree / low-level-design-golang
Low level system design solutions in Golang
Low-Level System Design in Go
Welcome to the Low-Level System Design in Go repository! This repository contains various low-level system design problems and their solutions implemented in Go. The primary aim is to demonstrate the design and architecture of systems through practical examples.
Table of Contents
- Overview
- Parking Lot System
- Elevator System
- Library Management System
- Vending Machine System
- Social Media Platform
Overview
Low-level system design involves understanding the core concepts of system architecture and designing scalable, maintainable, and efficient systems. This repository will try to cover solutions of various problems and scenarios using Go.
Parking Lot System
The first project in this repository is a Parking Lot System. This system simulates a parking lot where vehicles can be parked and unparked. It demonstrates:
- Singleton design pattern for managing the parking lot instance.
- Handling different types of vehicles (e.g., cars, trucks).
- Parking space management across multiple floors.
- Payment processing for…
Top comments (0)