Master Queues - FIFO Data Structure

class Queue {
    constructor(capacity = 100) {
        this.items = [];
        this.capacity = capacity;
        this.front = 0;
        this.rear = -1;
        this.size = 0;
    }

    enqueue(value) {
        if (this.size >= this.capacity) {
            throw new Error("Queue Overflow");
        }
        this.items.push(value);
        this.rear++;
        this.size++;
        return true;
    }

    dequeue() {
        if (this.isEmpty()) {
            throw new Error("Queue Underflow");
        }
        const value = this.items[this.front];
        this.front++;
        this.size--;
        return value;
    }

    peek() {
        if (this.isEmpty()) {
            throw new Error("Queue is empty");
        }
        return this.items[this.front];
    }

    rearValue() {
        if (this.isEmpty()) {
            throw new Error("Queue is empty");
        }
        return this.items[this.rear];
    }

    isEmpty() {
        return this.size === 0;
    }

    getSize() {
        return this.size;
    }
}

// Usage
const queue = new Queue();
queue.enqueue(10);
queue.enqueue(20);
queue.enqueue(30);
console.log(queue.peek());      // Output: 10 (FIFO - First In)
console.log(queue.dequeue());   // Output: 10
console.log(queue.getSize());   // Output: 2

package main

import "errors"

type Queue struct {
    items    []int
    capacity int
    front    int
    rear     int
    size     int
}

func NewQueue(capacity int) *Queue {
    return &Queue{
        items:    make([]int, 0, capacity),
        capacity: capacity,
        front:    0,
        rear:     -1,
        size:     0,
    }
}

func (q *Queue) Enqueue(value int) error {
    if q.size >= q.capacity {
        return errors.New("queue overflow")
    }
    q.items = append(q.items, value)
    q.rear++
    q.size++
    return nil
}

func (q *Queue) Dequeue() (int, error) {
    if q.IsEmpty() {
        return 0, errors.New("queue underflow")
    }
    value := q.items[q.front]
    q.front++
    q.size--
    return value, nil
}

func (q *Queue) Peek() (int, error) {
    if q.IsEmpty() {
        return 0, errors.New("queue is empty")
    }
    return q.items[q.front], nil
}

func (q *Queue) Rear() (int, error) {
    if q.IsEmpty() {
        return 0, errors.New("queue is empty")
    }
    return q.items[q.rear], nil
}

func (q *Queue) IsEmpty() bool {
    return q.size == 0
}

func (q *Queue) Size() int {
    return q.size
}

public class Queue {
    private int[] items;
    private int front;
    private int rear;
    private int size;
    private int capacity;

    public Queue(int capacity) {
        this.items = new int[capacity];
        this.capacity = capacity;
        this.front = 0;
        this.rear = -1;
        this.size = 0;
    }

    public void enqueue(int value) {
        if (size >= capacity) {
            throw new RuntimeException("Queue Overflow");
        }
        rear++;
        items[rear] = value;
        size++;
    }

    public int dequeue() {
        if (isEmpty()) {
            throw new RuntimeException("Queue Underflow");
        }
        int value = items[front];
        front++;
        size--;
        return value;
    }

    public int peek() {
        if (isEmpty()) {
            throw new RuntimeException("Queue is empty");
        }
        return items[front];
    }

    public int rear() {
        if (isEmpty()) {
            throw new RuntimeException("Queue is empty");
        }
        return items[rear];
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public int size() {
        return size;
    }
}

#include <vector>
#include <stdexcept>

class Queue {
private:
    std::vector<int> items;
    int capacity;
    int front;
    int rear;
    int size;

public:
    Queue(int cap = 100) : capacity(cap), front(0), rear(-1), size(0) {
        items.reserve(capacity);
    }

    void enqueue(int value) {
        if (size >= capacity) {
            throw std::overflow_error("Queue Overflow");
        }
        items.push_back(value);
        rear++;
        size++;
    }

    int dequeue() {
        if (isEmpty()) {
            throw std::underflow_error("Queue Underflow");
        }
        int value = items[front];
        front++;
        size--;
        return value;
    }

    int peek() {
        if (isEmpty()) {
            throw std::runtime_error("Queue is empty");
        }
        return items[front];
    }

    int rearValue() {
        if (isEmpty()) {
            throw std::runtime_error("Queue is empty");
        }
        return items[rear];
    }

    bool isEmpty() {
        return size == 0;
    }

    int getSize() {
        return size;
    }
};

pub struct Queue {
    items: Vec<i32>,
    capacity: usize,
    front: usize,
    rear: isize,
    size: usize,
}

impl Queue {
    pub fn new(capacity: usize) -> Self {
        Queue {
            items: Vec::with_capacity(capacity),
            capacity,
            front: 0,
            rear: -1,
            size: 0,
        }
    }

    pub fn enqueue(&mut self, value: i32) -> Result<(), &'static str> {
        if self.size >= self.capacity {
            return Err("Queue Overflow");
        }
        self.items.push(value);
        self.rear += 1;
        self.size += 1;
        Ok(())
    }

    pub fn dequeue(&mut self) -> Option<i32> {
        if self.is_empty() {
            return None;
        }
        let value = self.items[self.front];
        self.front += 1;
        self.size -= 1;
        Some(value)
    }

    pub fn peek(&self) -> Option<i32> {
        if self.is_empty() {
            return None;
        }
        Some(self.items[self.front])
    }

    pub fn rear_value(&self) -> Option<i32> {
        if self.is_empty() {
            return None;
        }
        Some(self.items[self.rear as usize])
    }

    pub fn is_empty(&self) -> bool {
        self.size == 0
    }

    pub fn size(&self) -> usize {
        self.size
    }
}