From 967be9e750221ab2ab783f95df79bb26d290a45e Mon Sep 17 00:00:00 2001
From: Martial Simon <msimon_fr@hotmail.com>
Date: Mon, 15 Sep 2025 01:07:58 +0200
Subject: add: added projects

---
 tiger-compiler/lib/misc/map.hxx | 176 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 176 insertions(+)
 create mode 100644 tiger-compiler/lib/misc/map.hxx

(limited to 'tiger-compiler/lib/misc/map.hxx')

diff --git a/tiger-compiler/lib/misc/map.hxx b/tiger-compiler/lib/misc/map.hxx
new file mode 100644
index 0000000..fb429ac
--- /dev/null
+++ b/tiger-compiler/lib/misc/map.hxx
@@ -0,0 +1,176 @@
+/**                                                     -*- C++ -*-
+ ** \file misc/map.hxx
+ ** \brief Implementation of misc::map.
+ */
+
+#pragma once
+
+#include <iostream>
+#include <sstream>
+
+#include <boost/lexical_cast.hpp>
+
+#include <misc/contract.hh>
+#include <misc/indent.hh>
+#include <misc/map.hh>
+
+namespace misc
+{
+  template <class T, class N> map<T, N>* map<T, N>::clone() const
+  {
+    return new map<T, N>(*this);
+  }
+
+  template <class T, class N>
+  typename map<T, N>::const_iterator map<T, N>::find(const T& t) const
+  {
+    return map_.find(t);
+  }
+
+  template <class T, class N>
+  typename map<T, N>::iterator map<T, N>::find(const T& t)
+  {
+    return map_.find(t);
+  }
+
+  template <class T, class N>
+  typename map<T, N>::iterator map<T, N>::xfind(const T& t)
+  {
+    if (auto&& ires = find(t); ires != map_.end())
+      return ires;
+    else
+      throw std::range_error(std::string("map: no mapping for ")
+                             + boost::lexical_cast<std::string>(t));
+  }
+
+  template <class T, class N>
+  typename map<T, N>::const_iterator map<T, N>::xfind(const T& t) const
+  {
+    if (const auto&& ires = find(t); ires != map_.end())
+      return ires;
+    else
+      throw std::range_error(std::string("map: no mapping for ")
+                             + boost::lexical_cast<std::string>(t));
+  }
+
+  template <class T, class N>
+  typename map<T, N>::key_compare map<T, N>::key_comp() const
+  {
+    return map_.key_comp();
+  }
+
+  template <class T, class N> N map<T, N>::operator()(const T& t) const
+  {
+    return xfind(t)->second;
+  }
+
+  template <class T, class N>
+  template <typename Container>
+    requires ConstIterableType<Container, T>
+  std::vector<N> map<T, N>::operator()(const Container& ts) const
+  {
+    std::vector<N> res;
+    for (const T& t : ts)
+      res.emplace_back(operator()(t));
+    return res;
+  }
+
+  template <class T, class N>
+  std::ostream& map<T, N>::print(std::ostream& ostr) const
+  {
+    for (const value_type& p : *this)
+      ostr << p.first << " -> " << p.second << misc::iendl;
+    return ostr;
+  }
+
+  template <class T, class N> N map<T, N>::operator[](const T& t) const
+  {
+    return operator()(t);
+  }
+
+  template <class T, class N> N& map<T, N>::operator[](const T& t)
+  {
+    return map_[t];
+  }
+
+  template <class T, class N> typename map<T, N>::iterator map<T, N>::begin()
+  {
+    return map_.begin();
+  }
+
+  template <class T, class N> typename map<T, N>::iterator map<T, N>::end()
+  {
+    return map_.end();
+  }
+
+  template <class T, class N>
+  typename map<T, N>::const_iterator map<T, N>::begin() const
+  {
+    return map_.begin();
+  }
+
+  template <class T, class N>
+  typename map<T, N>::const_iterator map<T, N>::end() const
+  {
+    return map_.end();
+  }
+
+  template <class T, class N>
+  typename map<T, N>::iterator map<T, N>::lower_bound(const T& k)
+  {
+    return map_.lower_bound(k);
+  }
+
+  template <class T, class N>
+  typename map<T, N>::const_iterator map<T, N>::lower_bound(const T& k) const
+  {
+    return map_.lower_bound(k);
+  }
+
+  template <class T, class N>
+  std::pair<typename map<T, N>::iterator, bool>
+  map<T, N>::insert(const std::pair<const T, N>& x)
+  {
+    return map_.insert(x);
+  }
+
+  template <class T, class N> void map<T, N>::insert(const map& other)
+  {
+    map_.insert(other.begin(), other.end());
+  }
+
+  template <class T, class N>
+  template <class... Args>
+  std::pair<typename map<T, N>::iterator, bool>
+  map<T, N>::emplace(Args&&... args)
+  {
+    return map_.emplace(std::forward<Args>(args)...);
+  }
+
+  template <class T, class N> bool map<T, N>::empty() const
+  {
+    return map_.empty();
+  }
+
+  template <class T, class N> size_t map<T, N>::size() const
+  {
+    return map_.size();
+  }
+
+  template <class T, class N> N map<T, N>::take(const T& t)
+  {
+    auto ires = xfind(t);
+    N elt = ires->second;
+    map_.erase(ires);
+    return elt;
+  }
+
+  template <class T, class N> void map<T, N>::clear() { map_.clear(); }
+
+  template <class T, class N>
+  std::ostream& operator<<(std::ostream& ostr, const map<T, N>& m)
+  {
+    return m.print(ostr);
+  }
+
+} // namespace misc
-- 
cgit v1.2.3