feat: multiset and unordered multiset iterators

include/jlcxx/stl.hpp

@@ -60,9 +60,11 @@ class JLCXX_API StlWrappers
   TypeWrapper1 stack;
   TypeWrapper1 set_iterator;
   TypeWrapper1 set;
+  TypeWrapper1 multiset_iterator;
   TypeWrapper1 multiset;
   TypeWrapper1 unordered_set_iterator;
   TypeWrapper1 unordered_set;
+  TypeWrapper1 unordered_multiset_iterator;
   TypeWrapper1 unordered_multiset;
   TypeWrapper1 list_iterator;
   TypeWrapper1 list;
@@ -88,9 +90,11 @@ void apply_priority_queue(TypeWrapper1& priority_queue);
 void apply_stack(TypeWrapper1& stack);
 void apply_set_iterator(TypeWrapper1& set_iterator);
 void apply_set(TypeWrapper1& set);
+void apply_multiset_iterator(TypeWrapper1& multiset_iterator);
 void apply_multiset(TypeWrapper1& multiset);
 void apply_unordered_set_iterator(TypeWrapper1& unordered_set_iterator);
 void apply_unordered_set(TypeWrapper1& unordered_set);
+void apply_unordered_multiset_iterator(TypeWrapper1& unordered_multiset_iterator);
 void apply_unordered_multiset(TypeWrapper1& unordered_multiset);
 void apply_list_iterator(TypeWrapper1& list_iterator);
 void apply_list(TypeWrapper1& list);
@@ -426,6 +430,18 @@ struct WrapUnorderedSet
   }
 };
 
+template <typename valueT>
+struct MultisetIteratorWrapper
+{
+  using value_type = valueT;
+  using iterator_type = typename std::multiset<
+      valueT,
+      std::less<valueT>,
+      std::allocator<valueT>
+  >::iterator;
+  iterator_type value;
+};
+
 struct WrapMultiset
 {
   template<typename TypeWrapperT>
@@ -443,10 +459,25 @@ struct WrapMultiset
     wrapped.method("multiset_delete!", [] (WrappedT&v, const T& val) { v.erase(val); });
     wrapped.method("multiset_in", [] (WrappedT& v, const T& val) { return v.count(val) != 0; });
     wrapped.method("multiset_count", [] (WrappedT& v, const T& val) { return v.count(val); });
+    wrapped.method("iteratorbegin", [] (WrappedT& v) { return MultisetIteratorWrapper<T>{v.begin()}; });
+    wrapped.method("iteratorend", [] (WrappedT& v) { return MultisetIteratorWrapper<T>{v.end()}; });
     wrapped.module().unset_override_module();
   }
 };
 
+template <typename valueT>
+struct UnorderedMultisetIteratorWrapper
+{
+  using value_type = valueT;
+  using iterator_type = typename std::unordered_multiset<
+      valueT,
+      std::hash<valueT>,
+      std::equal_to<valueT>,
+      std::allocator<valueT>
+  >::iterator;
+  iterator_type value;
+};
+
 struct WrapUnorderedMultiset
 {
   template<typename TypeWrapperT>
@@ -464,6 +495,8 @@ struct WrapUnorderedMultiset
     wrapped.method("multiset_delete!", [] (WrappedT&v, const T& val) { v.erase(val); });
     wrapped.method("multiset_in", [] (WrappedT& v, const T& val) { return v.count(val) != 0; });
     wrapped.method("multiset_count", [] (WrappedT& v, const T& val) { return v.count(val); });
+    wrapped.method("iteratorbegin", [] (WrappedT& v) { return UnorderedMultisetIteratorWrapper<T>{v.begin()}; });
+    wrapped.method("iteratorend", [] (WrappedT& v) { return UnorderedMultisetIteratorWrapper<T>{v.end()}; });
     wrapped.module().unset_override_module();
   }
 };
@@ -583,13 +616,15 @@ inline void apply_stl(jlcxx::Module& mod)
   {
     TypeWrapper1(mod, StlWrappers::instance().set_iterator).apply<stl::SetIteratorWrapper<T>>(WrapIterator());
     TypeWrapper1(mod, StlWrappers::instance().set).apply<std::set<T>>(WrapSet());
+    TypeWrapper1(mod, StlWrappers::instance().multiset_iterator).apply<stl::MultisetIteratorWrapper<T>>(WrapIterator());
     TypeWrapper1(mod, StlWrappers::instance().multiset).apply<std::multiset<T>>(WrapMultiset());
     TypeWrapper1(mod, StlWrappers::instance().priority_queue).apply<std::priority_queue<T>>(WrapPriorityQueue());
   }
   if constexpr (is_hashable<T>::value)
   {
     TypeWrapper1(mod, StlWrappers::instance().unordered_set_iterator).apply<stl::UnorderedSetIteratorWrapper<T>>(WrapIterator());
     TypeWrapper1(mod, StlWrappers::instance().unordered_set).apply<std::unordered_set<T>>(WrapUnorderedSet());
+    TypeWrapper1(mod, StlWrappers::instance().unordered_multiset_iterator).apply<stl::UnorderedMultisetIteratorWrapper<T>>(WrapIterator());
     TypeWrapper1(mod, StlWrappers::instance().unordered_multiset).apply<std::unordered_multiset<T>>(WrapUnorderedMultiset());
   }
   TypeWrapper1(mod, StlWrappers::instance().list_iterator).apply<stl::ListIteratorWrapper<T>>(WrapIterator());

src/stl.cpp

@@ -26,9 +26,11 @@ JLCXX_API void StlWrappers::instantiate(Module& mod)
   apply_stack(m_instance->stack);
   apply_set_iterator(m_instance->set_iterator);
   apply_set(m_instance->set);
+  apply_multiset_iterator(m_instance->multiset_iterator);
   apply_multiset(m_instance->multiset);
   apply_unordered_set_iterator(m_instance->unordered_set_iterator);
   apply_unordered_set(m_instance->unordered_set);
+  apply_unordered_multiset_iterator(m_instance->unordered_multiset_iterator);
   apply_unordered_multiset(m_instance->unordered_multiset);
   apply_list_iterator(m_instance->list_iterator);
   apply_list(m_instance->list);
@@ -65,9 +67,11 @@ JLCXX_API StlWrappers::StlWrappers(Module& stl) :
   stack(stl.add_type<Parametric<TypeVar<1>>>("StdStack")),
   set_iterator(stl.add_type<Parametric<TypeVar<1>>>("StdSetIterator")),
   set(stl.add_type<Parametric<TypeVar<1>>>("StdSet")),
+  multiset_iterator(stl.add_type<Parametric<TypeVar<1>>>("StdMultisetIterator")),
   multiset(stl.add_type<Parametric<TypeVar<1>>>("StdMultiset")),
   unordered_set_iterator(stl.add_type<Parametric<TypeVar<1>>>("StdUnorderedSetIterator")),
   unordered_set(stl.add_type<Parametric<TypeVar<1>>>("StdUnorderedSet")),
+  unordered_multiset_iterator(stl.add_type<Parametric<TypeVar<1>>>("StdUnorderedMultisetIterator")),
   unordered_multiset(stl.add_type<Parametric<TypeVar<1>>>("StdUnorderedMultiset")),
   list_iterator(stl.add_type<Parametric<TypeVar<1>>>("StdListIterator")),
   list(stl.add_type<Parametric<TypeVar<1>>>("StdList")),

src/stl_multiset.cpp

@@ -6,6 +6,11 @@ namespace jlcxx
 namespace stl
 {
 
+void apply_multiset_iterator(TypeWrapper1& multiset_iterator)
+{
+  multiset_iterator.apply_combination<stl::MultisetIteratorWrapper, stltypes>(stl::WrapIterator());
+}
+
 void apply_multiset(TypeWrapper1& multiset)
 {
   multiset.apply_combination<std::multiset, stltypes>(stl::WrapMultiset());

src/stl_unordered_multiset.cpp

@@ -6,6 +6,11 @@ namespace jlcxx
 namespace stl
 {
 
+void apply_unordered_multiset_iterator(TypeWrapper1& unordered_multiset_iterator)
+{
+  unordered_multiset_iterator.apply_combination<stl::UnorderedMultisetIteratorWrapper, stltypes>(stl::WrapIterator());
+}
+
 void apply_unordered_multiset(TypeWrapper1& unordered_multiset)
 {
   unordered_multiset.apply_combination<std::unordered_multiset, stltypes>(stl::WrapUnorderedMultiset());