add lict.hpp

Author: luk036

include/py2cpp/dict.hpp

@@ -38,6 +38,7 @@ class dict : public std::unordered_map<Key, T> {
 
 public:
   using value_type = std::pair<const Key, T>;
+  using key_type = Key;
 
   /**
    * @brief Construct a new dict object

include/py2cpp/lict.hpp

@@ -0,0 +1,57 @@
+#pragma once
+
+#include "enumerate.hpp"
+#include "range.hpp"
+#include <vector>
+
+namespace py {
+
+template <typename T> class Lict {
+  using key_type = size_t;
+  using value_type = std::pair<size_t, T>;
+  using iterator = py::Range<key_type>::iterator;
+
+private:
+  std::vector<T> _lst;
+  py::Range<key_type> _rng;
+
+public:
+  Lict(std::vector<T> lst)
+      : _lst(std::move(lst)), _rng{py::range(lst.size())} {}
+
+  T &operator[](const key_type &key) { return this->_lst[key]; }
+
+  const T &operator[](const key_type &key) const { return this->_lst[key]; }
+
+  // void __delitem__() { throw std::runtime_error("NotImplementedError"); }
+
+  iterator begin() { return this->_rng.begin(); }
+
+  iterator end() { return this->_rng.end(); }
+
+  bool contains(const key_type& key) const {
+    return this->_rng.contains(key);
+  }
+
+  size_t size() { return this->_lst.size(); }
+
+  auto& values() { return this->_lst; }
+
+  const auto& values() const { return this->_lst; }
+
+  auto items() { return py::enumerate(this->_lst); }
+};
+
+} // namespace py
+
+// int main() {
+//   Lict<int> a(std::vector<int>(8, 0));
+//   for (int i : a) {
+//     a[i] = i * i;
+//   }
+//   for (auto i : a) {
+//     std::cout << i << ": " << a[i] << std::endl;
+//   }
+//   std::cout << a.__contains__(3) << std::endl;
+//   return 0;
+// }

include/py2cpp/range.hpp

@@ -12,8 +12,6 @@
 
 namespace py {
 
-namespace detail {
-
 template <typename T> struct RangeIterator {
   using iterator_category = std::output_iterator_tag;
   using difference_type = std::ptrdiff_t;
@@ -43,7 +41,7 @@ template <typename T> struct RangeIterator {
   }
 };
 
-template <typename T> struct RangeIterableWrapper {
+template <typename T> struct Range {
 public:
   using iterator = RangeIterator<T>;
   using value_type = T;
@@ -68,18 +66,17 @@ template <typename T> struct RangeIterableWrapper {
   }
 };
 
-} // namespace detail
 
 template <typename T>
-CONSTEXPR14 auto range(T start, T stop) -> detail::RangeIterableWrapper<T> {
+CONSTEXPR14 auto range(T start, T stop) -> Range<T> {
   if (stop < start) {
     stop = start;
   }
-  return detail::RangeIterableWrapper<T>{start, stop};
+  return Range<T>{start, stop};
 }
 
 template <typename T>
-CONSTEXPR14 auto range(T stop) -> detail::RangeIterableWrapper<T> {
+CONSTEXPR14 auto range(T stop) -> Range<T> {
   return range(T(0), stop);
 }