టెంప్లేట్లు & Generic Programming

#include <iostream>
#include <string>

// జెనరిక్ ఫంక్షన్ టెంప్లేట్
template <typename T>
T findMax(T a, T b) {
    return (a > b) ? a : b;
}

// బహుళ విభిన్న టైప్‌ల టెంప్లేట్ (Multi-type Template)
template <typename T, typename U>
void printPair(T first, U second) {
    std::cout << "జత: [" << first << ", " << second << "]\n";
}

int main() {
    std::cout << "పూర్ణాంకాల గరిష్టం (int):   " << findMax(25, 42) << "\n";
    std::cout << "దశాంశాల గరిష్టం (double): " << findMax(99.45, 12.30) << "\n";
    std::cout << "అక్షరాల గరిష్టం (string): " << findMax(std::string("Hyderabad"), std::string("Bengaluru")) << "\n";

    std::cout << "\nబహుళ టైప్ జతలు:\n";
    printPair("RollNo", 101);
    printPair(3.14159, "PI Value");
    return 0;
}

#include <iostream>
#include <string>

// జెనరిక్ క్లాస్ టెంప్లేట్
template <typename T>
class SecureBox {
private:
    T content;
public:
    SecureBox(T val) : content(val) {}

    void setContent(T val) { content = val; }
    T getContent() const { return content; }

    void inspect() const {
        std::cout << "  📦 [SecureBox] డేటా విలువ: " << content 
                  << " (సైజ్: " << sizeof(content) << " Bytes)\n";
    }
};

int main() {
    SecureBox<int> intBox(5000);
    SecureBox<double> dblBox(999.85);
    SecureBox<std::string> strBox("Secret-Bank-Vault-Token");

    intBox.inspect();
    dblBox.inspect();
    strBox.inspect();
    return 0;
}

#include <iostream>

// T అనేది డేటా టైప్, Size అనేది NTTP సంఖ్య!
template <typename T, size_t Size>
class StaticStack {
private:
    T buffer[Size];
    size_t count = 0;

public:
    bool push(const T& val) {
        if (count >= Size) return false;
        buffer[count++] = val;
        return true;
    }

    T pop() {
        if (count == 0) throw std::underflow_error("స్టాక్ ఖాళీగా ఉంది!");
        return buffer[--count];
    }

    size_t capacity() const { return Size; }
    size_t size() const { return count; }
};

int main() {
    // 5 ఎలిమెంట్ల ఫిక్స్‌డ్ సైజ్ స్టాక్ (హీప్ అలొకేషన్ లేదు - 100% స్టాక్ మెమరీ!)
    StaticStack<int, 5> fastStack;
    fastStack.push(10);
    fastStack.push(20);
    fastStack.push(30);

    std::cout << "స్టాక్ సామర్థ్యం: " << fastStack.capacity() << " | ఎలిమెంట్లు: " << fastStack.size() << "\n";
    std::cout << "పాప్ చేసిన విలువ: " << fastStack.pop() << "\n";
    return 0;
}

#include <iostream>

// 1. సాధారణ జెనరిక్ టెంప్లేట్
template <typename T>
class Formatter {
public:
    static void print(T val) {
        std::cout << "  [సాధారణ ఫార్మాట్]: " << val << "\n";
    }
};

// 2. Full Specialization for bool (0/1 కాకుండా True/False ప్రింట్ కొరకు)
template <>
class Formatter<bool> {
public:
    static void print(bool val) {
        std::cout << "  [బూలియన్ స్పెషలైజ్డ్ ఫార్మాట్]: " << (val ? "TRUE (నిజం)" : "FALSE (అబద్ధం)") << "\n";
    }
};

int main() {
    Formatter<int>::print(100);
    Formatter<double>::print(3.14);
    Formatter<bool>::print(true); // స్పెషలైజ్డ్ వెర్షన్ అమలవుతుంది!
    return 0;
}

#include <iostream>

// C++17 Fold Expression ద్వారా ఎన్ని సంఖ్యలనైనా ఒక్క లైన్‌లో కూడటం!
template <typename... Args>
auto sumAll(Args... args) {
    return (args + ...); // Unary Right Fold: (a1 + (a2 + (a3 + ...)))
}

int main() {
    std::cout << "3 సంఖ్యల మొత్తం:  " << sumAll(10, 20, 30) << "\n";
    std::cout << "5 సంఖ్యల మొత్తం:  " << sumAll(1.5, 2.5, 3.0, 4.0, 5.0) << "\n";
    std::cout << "స్ట్రింగ్స్ కలయిక: " << sumAll(std::string("C++20 "), std::string("Fold "), std::string("Magic!")) << "\n";
    return 0;
}

#include <iostream>
#include <type_traits>

template <typename T>
void processData(T val) {
    if constexpr (std::is_pointer_v<T>) {
        std::cout << "  పాయింటర్ డేటా డీరిఫరెన్స్: " << *val << "\n";
    } else {
        std::cout << "  డైరెక్ట్ వాల్యూ డేటా: " << val << "\n";
    }
}

int main() {
    int num = 42;
    processData(num);  // else బ్రాంచ్ మాత్రమే కంపైల్ అవుతుంది!
    processData(&num); // if బ్రాంచ్ మాత్రమే కంపైల్ అవుతుంది!
    return 0;
}

#include <iostream>
#include <concepts>

// C++20 Standard Concept: std::integral (పూర్ణాంకాలు మాత్రమే!)
template <std::integral T>
T computeModulo(T a, T b) {
    return a % b;
}

// Custom Concept: నంబర్లు (int లేదా float) మాత్రమే
template <typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

template <Numeric T>
T average(T a, T b) {
    return (a + b) / 2;
}

int main() {
    std::cout << "Modulo (15 % 4): " << computeModulo(15, 4) << "\n";
    // computeModulo(15.5, 4.2); // ❌ కంపైలర్ క్లీన్ ఎర్రర్: Constraints not satisfied!

    std::cout << "Average: " << average(10.5, 20.5) << "\n";
    return 0;
}

#include <iostream>
#include <string>
#include <type_traits>
#include <concepts>
#include <optional>

// C++20 Concept: కాపీ కన్‌స్ట్రక్ట్ చేయగల టైప్‌లకు మాత్రమే అనుమతి!
template <typename T>
concept Bufferable = std::is_copy_constructible_v<T>;

// జెనరిక్ రింగ్ బఫర్ క్లాస్ టెంప్లేట్ విత్ NTTP Capacity
template <Bufferable T, size_t Capacity>
class RingBuffer {
    static_assert(Capacity > 0, "❌ బఫర్ కెపాసిటీ ఖచ్చితంగా 0 కంటే ఎక్కువ ఉండాలి!");

private:
    T buffer[Capacity]; // ఫిక్స్‌డ్ సైజ్ స్టాక్ బఫర్ (జీరో హీప్ ఓవర్‌హెడ్!)
    size_t head = 0;
    size_t tail = 0;
    size_t currentSize = 0;

public:
    RingBuffer() = default;

    bool enqueue(const T& item) {
        if (currentSize == Capacity) {
            return false; // బఫర్ ఫుల్!
        }
        buffer[tail] = item;
        tail = (tail + 1) % Capacity;
        currentSize++;
        return true;
    }

    std::optional<T> dequeue() {
        if (currentSize == 0) {
            return std::nullopt; // బఫర్ ఖాళీ!
        }
        T item = buffer[head];
        head = (head + 1) % Capacity;
        currentSize--;
        return item;
    }

    size_t size() const { return currentSize; }
    size_t maxCapacity() const { return Capacity; }
    bool isEmpty() const { return currentSize == 0; }
    bool isFull() const { return currentSize == Capacity; }
};

struct TelemetryLog {
    int sensorId;
    double reading;
};

int main() {
    std::cout << "=======================================================================\n";
    std::cout << "🔄 [ENTERPRISE GENERIC RING BUFFER & CIRCULAR QUEUE ENGINE]\n";
    std::cout << "=======================================================================\n";

    // 1. పూర్ణాంకాల (int) రింగ్ బఫర్ (సామర్థ్యం: 4)
    RingBuffer<int, 4> intQueue;
    std::cout << "\n[టెస్ట్ 1: పూర్ణాంకాల రింగ్ బఫర్ (Capacity: 4)]:\n";
    intQueue.enqueue(101);
    intQueue.enqueue(102);
    intQueue.enqueue(103);
    intQueue.enqueue(104);

    if (!intQueue.enqueue(105)) {
        std::cout << "  ⚠️ బఫర్ నిండిపోయింది (105 డ్రాప్ చేయబడింది!)\n";
    }

    while (!intQueue.isEmpty()) {
        std::cout << "  రీడ్ చేసిన ఐటెమ్: " << *intQueue.dequeue() << "\n";
    }

    // 2. కస్టమ్ స్ట్రక్చర్ (TelemetryLog) రింగ్ బఫర్
    RingBuffer<TelemetryLog, 3> telemetryQueue;
    std::cout << "\n[టెస్ట్ 2: జెనరిక్ టెలిమెట్రీ సెన్సార్ స్ట్రీమ్]:\n";
    telemetryQueue.enqueue({0xAA1, 38.4});
    telemetryQueue.enqueue({0xAA2, 42.1});

    while (auto item = telemetryQueue.dequeue()) {
        std::cout << "  📡 సెన్సార్ ID: 0x" << std::hex << item->sensorId 
                  << std::dec << " | ఉష్ణోగ్రత: " << item->reading << " °C\n";
    }

    std::cout << "\n=======================================================================\n";
    std::cout << "✅ C++20 Concepts తో జెనరిక్ రింగ్ బఫర్ ఎగ్జిక్యూషన్ విజయవంతమైంది!\n";
    std::cout << "=======================================================================\n";
    return 0;
}