Stack.h

Go to the documentation of this file.

#pragma once

#include <vector> 
#include <assert.h>
 
#include "Strings.h"

template<typename T>
class Stack  {
        
    
    
public:
std::vector<T> value;
    Stack() {
//      reserve(100); // does nothing
    }

    template<typename... Args>
    void emplace_back(Args... args) {
        value.emplace_back(args...);
    }
    
    void reserve(size_t t) {
        value.reserve(t);
    }
    
    void clear() {
        value.clear();
    }

    void push(const T& val) {
        value.push_back(val);
    }
    void push(const T&& val) {
        value.push_back(std::move(val));
    }
    
    void pop() {
        assert(!empty());
        value.pop_back();
    }
    
    void popn(size_t n) {
        for(size_t i=0;i<n;i++) {
            this->pop();
        }
    }
    
    /* There is a little sublety here -- for integral types, it's a pain to return a reference
     * so we want to just return T. But some optimizations of the virtual machine will do better
     * with references, leaving the top value on the stack. So by default we don't return a reference
     * with top() but we do with topref
     */
    
    [[nodiscard]] T top() {
        return value.back();
    }

    [[nodiscard]] T& topref() {
        return std::forward<T&>(value.back());
    }

    [[nodiscard]] T toppop() {
        auto o = value.back();
        pop();
        return o;
    }


    
    const std::vector<T>& get_value() const {
        return value;
    }
    
    size_t size() const { 
        return value.size();
    }
    
    bool empty() const {
        return value.empty();
    }
    
    std::string string() const {
        return str(value);
    }
    
//  void print_stack(std::string prefix) const {
//      for(size_t i=0;i<value.size();i++) {
//          print(prefix, "[i]=", value.at(i));
//      }
//  }
    
    auto begin() { return value.begin(); }
    auto end()   { return value.end(); }
    auto rbegin() { return value.rbegin(); }
    auto rend()   { return value.rend(); }
};

template<typename T>
std::string str(const Stack<T>& a ){
    return str(a.get_value());
}