Fixed container (#19)

* added FixedCapacityContainer

* added empty to FixedCapacityContainer

* removed commented out section

* added FixedCapacityContainer to public headers

slsSupportLib/include/FixedCapacityContainer.h

@@ -0,0 +1,172 @@
+
+#pragma once
+#include <array>
+#include <cassert>
+#include <stdexcept>
+#include <vector>
+
+namespace sls {
+template <typename T, size_t Capacity> class FixedCapacityContainer {
+  public:
+    FixedCapacityContainer() = default;
+    explicit FixedCapacityContainer(std::initializer_list<T> l);
+    explicit FixedCapacityContainer(const std::vector<T> &v);
+
+    FixedCapacityContainer &operator=(const std::vector<T> &other);
+
+    bool operator==(const std::vector<T> &other) const;
+    bool operator!=(const std::vector<T> &other) const;
+
+    template <size_t OtherCapacity>
+    bool
+    operator==(const FixedCapacityContainer<T, OtherCapacity> &other) const;
+
+    template <size_t OtherCapacity>
+    bool
+    operator!=(const FixedCapacityContainer<T, OtherCapacity> &other) const;
+
+    T &operator[](size_t i) { return data_[i]; }
+    const T &operator[](size_t i) const { return data_[i]; }
+
+    size_t size() const { return size_; }
+    bool empty() const{ return size_ == 0;}
+    size_t capacity() const { return Capacity; }
+
+    void push_back(const T &value);
+    void resize(size_t new_size);
+    void erase(T *ptr);
+    T &front() { return data_.front(); }
+    T &back() { return data_[size_ - 1]; }
+    const T &front() const { return data_.front(); }
+    const T &back() const { return data_[size_ - 1]; }
+
+    // iterators
+    T *begin() { return &data_[0]; }
+    T *end() { return &data_[size_]; }
+    const T *cbegin() const { return &data_[0]; }
+    const T *cend() const { return &data_[size_]; }
+
+  private:
+    size_t size_{0};
+    std::array<T, Capacity> data_;
+} __attribute__((packed));
+
+/* Member functions */
+template <typename T, size_t Capacity>
+FixedCapacityContainer<T, Capacity>::FixedCapacityContainer(
+    std::initializer_list<T> l) {
+    size_ = l.size();
+    std::copy(l.begin(), l.end(), data_.begin());
+}
+
+template <typename T, size_t Capacity>
+FixedCapacityContainer<T, Capacity>::FixedCapacityContainer(
+    const std::vector<T> &v) {
+    size_ = v.size();
+    std::copy(v.begin(), v.end(), data_.begin());
+}
+
+template <typename T, size_t Capacity>
+void FixedCapacityContainer<T, Capacity>::push_back(const T &value) {
+    if (size_ == Capacity) {
+        throw std::runtime_error("Container is full");
+    } else {
+        data_[size_] = value;
+        ++size_;
+    }
+}
+template <typename T, size_t Capacity>
+void FixedCapacityContainer<T, Capacity>::resize(size_t new_size) {
+    if (new_size > Capacity) {
+        throw std::runtime_error("Cannot resize beyond capacity");
+    } else {
+        size_ = new_size;
+    }
+}
+
+template <typename T, size_t Capacity>
+FixedCapacityContainer<T, Capacity> &FixedCapacityContainer<T, Capacity>::
+operator=(const std::vector<T> &other) {
+    std::copy(other.begin(), other.end(), data_.begin());
+    size_ = other.size();
+    return *this;
+}
+
+template <typename T, size_t Capacity>
+bool FixedCapacityContainer<T, Capacity>::
+operator==(const std::vector<T> &other) const {
+    if (size_ != other.size()) {
+        return false;
+    } else {
+        for (size_t i = 0; i != size_; ++i) {
+            if (data_[i] != other[i]) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+template <typename T, size_t Capacity>
+bool FixedCapacityContainer<T, Capacity>::
+operator!=(const std::vector<T> &other) const {
+    return !(*this == other);
+}
+
+template <typename T, size_t Capacity>
+template <size_t OtherCapacity>
+bool FixedCapacityContainer<T, Capacity>::
+operator==(const FixedCapacityContainer<T, OtherCapacity> &other) const {
+    if (size_ != other.size()) {
+        return false;
+    } else {
+        for (size_t i = 0; i != size_; ++i) {
+            if (data_[i] != other[i]) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+template <typename T, size_t Capacity>
+template <size_t OtherCapacity>
+bool FixedCapacityContainer<T, Capacity>::
+operator!=(const FixedCapacityContainer<T, OtherCapacity> &other) const {
+    return !(*this == other);
+}
+
+template <typename T, size_t Capacity>
+void FixedCapacityContainer<T, Capacity>::erase(T *ptr) {
+    if (ptr >= begin() && ptr < end()) {
+        size_ = static_cast<size_t>(ptr - begin());
+    } else {
+        throw std::runtime_error("tried to erase with a ptr outside obj");
+    }
+}
+
+/* Free function concerning FixedCapacityContainer */
+
+template <typename T, size_t Capacity>
+T *begin(FixedCapacityContainer<T, Capacity> &container) {
+    return container.begin();
+}
+
+template <typename T, size_t Capacity>
+T *end(FixedCapacityContainer<T, Capacity> &container) {
+    return container.end();
+}
+
+template <typename T, size_t Capacity>
+bool operator==(const std::vector<T> &vec,
+                const FixedCapacityContainer<T, Capacity> &fixed_container) {
+    return fixed_container == vec;
+}
+
+template <typename T, size_t Capacity>
+bool operator!=(const std::vector<T> &vec,
+                const FixedCapacityContainer<T, Capacity> &fixed_container) {
+    return fixed_container != vec;
+}
+
+} // namespace sls