🍕 SliceOps - Advanced C++ Pizza Shop Management System

An enterprise-grade desktop order fulfillment and delivery logistics system written in C++ (Dev-C++). The application demonstrates the practical orchestration of multiple advanced Data Structures and Algorithms (DSA)—including Heaps, Queues, Graphs (Dijkstra's Shortest Path), and Self-Balancing AVL Trees—to manage operations for a high-volume pizza restaurant.

📋 Table of Contents

• Core Feature Subsystems
• Algorithmic Architecture Breakdown
• Product Flow Blueprint
• Technical Stack & Design Elements
• Project Layout Mapping
• Getting Started
• Author

---

🚀 Core Feature Subsystems

• Multi-Channel Order Queuing: Segregates incoming traffic into specialized processing routes based on fulfillment type (Take-Away, Dine-In, or Delivery).
• Age-Prioritized Processing: Automatically elevates senior or elderly clients to the front of the take-away lane using automated sorting invariants.
• Geospatial Logistics Route Optimization: Maps delivery destinations on a directional weighted adjacency graph and uses greedy pathing to estimate runtime distance and compute fees.
• Balanced Auditing Index: Logs processed orders inside a balanced binary search space to guarantee fast, non-degrading performance queries as history expands.
• Color-Coded Dashboard Interface: Implements styled Windows console system formatting to organize operations visually into structured interaction cards.

---

🧱 Algorithmic Architecture Breakdown

Business Domain	Chosen Data Structure / Algorithm	Technical Justification & Complexity
Take-Away Orders	Max-Heap (via Linked Structure)	Prioritizes clients based on age metrics. Up-heapify and down-heapify steps run at $O(\log N)$ scale.
Dine-In Orders	Queue (First-In, First-Out)	Enforces precise entry order processing loops ($O(1)$ insertions).
Home Delivery	Stack Structure (Last-In, First-Out)	Models batch delivery stack loading frameworks for route optimization.
Delivery Logistics	Graph Adjacency List & Dijkstra's	Determines shortest geographic route weights from the restaurant node ($O(V^2)$ performance profile).
Historical Auditing	Self-Balancing AVL Tree	Holds archival customer invoices. Prevents tree skewing to secure true $O(\log N)$ structural lookup speeds.

---

🔄 Product Flow Blueprint

                     [ Customer Order Placement ]
                                  │
         ┌────────────────────────┼────────────────────────┐
         ▼                        ▼                        ▼
   ( Take-Away )             ( Dine-In )            ( Home Delivery )
  [ Age Max-Heap ]         [ FIFO Queue ]          [ Graph Network ]
         │                        │                        │
         │                        │                        ▼
         │                        │              [ Dijkstra's Algorithm ]
         │                        │             Find Shortest Delivery Path
         │                        │                        │
         └────────────────────────┼────────────────────────┘
                                  │
                                  ▼
                        [ Order Service Engine ]
                                  │
                                  ▼
                     [ Archive Invoices to AVL ]
                     (Self-Balancing Audit Tree)
                                  │
         ┌────────────────────────┴────────────────────────┐
         ▼                                                 ▼
 [ Update Logs to disk ]                          [ In-Order Traversal ]
  (order/served .txt)                            Real-time Revenue Analysis

---

🛠️ Technical Stack & Design Elements

• Language Core: C++ Standard Library (<bits/stdc++.h>)
• Operating Environment: Native Windows Console Interface APIs (<windows.h>)
• Logistics Engine Framework: Programmatic implementation of Dijkstra's single-source shortest path optimization.
• Data Persistence Engine: Standard Input/Output File Streams (<fstream>) tracking persistent order ledgers.

---

📁 Project Layout Mapping

├── header.h               # Central data definitions, structures, and function signposts
├── implementation.cpp     # Execution rules for order routing, heaps, and queues
├── graph.h / graph.cpp    # Adjacency matrix construction and path routing algorithms
├── avl.h / avl.cpp        # Self-balancing binary tree mechanics and calculation modules
├── main.cpp               # Color-coded UI loop, choice navigation, and initialization
└── .gitignore             # Suppresses tracking of temporary IDE files (*.o, *.exe, Makefile)

---

🔧 Getting Started

Prerequisites

• Windows OS.
• Dev-C++ IDE or any alternative C++ workspace environment configured with standard GCC compilers.

Compilation Pipeline

1. Launch Dev-C++, select File -> New -> Project, choose an empty project, and import all .h and .cpp project files from this directory.
2. Compile and run the project (F11).
3. The application will initialize and automatically format and clear local logging data sheets (order.txt, served.txt) inside your folder structure.

---

🙋 Author

Rayan Ahmer - Software Engineering

---

⭐ Star this repository if you found it helpful!