smartvector.hpp

Go to the documentation of this file.

#pragma once
 
#include "shared/utilities/serialize_macro.hpp"
 
#include <vector>
#include <unordered_set>
 
template<typename T>
class SmartVector {
public:
    explicit SmartVector(size_t max_size) {
        //this->max_size = max_size;
        this->wrapped_vector.reserve(max_size);
    }
 
    SmartVector() : SmartVector(1) {}
 
    size_t push(T object) {
 
        //  See if there's an empty index
        size_t index;
        auto it = freelist.begin();
        if (it != freelist.end()) {
            index = *it;
            freelist.erase(index);
 
            wrapped_vector[index] = object;
        }
        else {
            index = wrapped_vector.size();
 
            //  Check that the wrapped vector can be safely pushed to (without 
            //  causing reallocation)
            //assert(this->max_size > index);
 
            wrapped_vector.push_back(object);
        }
 
        return index;
    }
 
    bool set(T object, size_t index) {
        if (index >= wrapped_vector.size())
            return false;
 
        //  Remove index from free list if the specified index is currently
        //  empty
        auto it = freelist.find(index);
 
        if (it != freelist.end()) {
            freelist.erase(*it);
        }
 
        wrapped_vector[index] = object;
 
        return true;
    }
 
    size_t pushEmpty() {
        size_t index = wrapped_vector.size();
 
        //  Check that the wrapped vector can be safely pushed to (without 
        //  causing reallocation)
        //assert(this->max_size > index);
 
        freelist.insert(index);
        wrapped_vector.push_back({});
 
        return index;
    }
 
    bool remove(size_t index) {
        //  Check that index is in bounds
        if (index < wrapped_vector.size()) {
            //  Add index to freelist
            freelist.insert(index);
 
            return true;
        }
 
        return false;
    }
 
    const T get(size_t index) const {
        //  Check that the index is in bounds
        if (index >= wrapped_vector.size())
        {
            //  Index is out of bounds
            return nullptr;
        }
        //  Check that index isn't free
        if (freelist.find(index) != freelist.end()) {
            //  Index is free
            return nullptr;
        }
 
        //  Return pointer to object stored at the given index
        return &wrapped_vector[index];
    }
 
    // https://stackoverflow.com/questions/38790352/how-can-you-return-a-non-const-reference-to-an-element-in-a-stdvector-data-mem
    T get(size_t index) {
        //  Check that the index is in bounds
        if (index >= wrapped_vector.size())
        {
            //  Index is out of bounds
            return nullptr;
        }
        //  Check that index isn't free
        if (freelist.find(index) != freelist.end()) {
            //  Index is free
            return nullptr;
        }
 
        //  Return pointer to object stored at the given index
        return wrapped_vector[index];
    }
 
    size_t size() const {
        return wrapped_vector.size();
    }
 
    size_t numElements() const {
        return wrapped_vector.size() - freelist.size();
    }
 
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar& wrapped_vector& freelist;
    }
 
private:
    //size_t max_size;
    std::vector<T> wrapped_vector;
    std::unordered_set<size_t> freelist;
};