:github_url: https://github.com/svenevs/exhale-companion


.. _program_listing_file_py2cpp_py2cpp.hpp:

Program Listing for File py2cpp.hpp
===================================

|exhale_lsh| :ref:`Return to documentation for file <file_py2cpp_py2cpp.hpp>` (``py2cpp/py2cpp.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #pragma once
   
   #include <initializer_list>
   #include <range/v3/view/iota.hpp>
   #include <tuple>
   #include <type_traits>
   #include <unordered_map>
   #include <unordered_set>
   #include <utility>
   
   template <typename T>
   using Value_type = typename T::value_type;
   
   namespace py
   {
   
   // template <typename T>
   // constexpr auto range(T stop) {
   //     struct iterator {
   //         T i;
   //         constexpr bool operator!=(const iterator &other) const { return i !=
   //         other.i; } constexpr bool operator==(const iterator &other) const {
   //         return i == other.i; } constexpr T operator*() const { return i; }
   //         constexpr iterator &operator++() {
   //             ++i;
   //             return *this;
   //         }
   //     };
   
   //     struct iterable_wrapper {
   //         using value_type = T; // luk
   //         T stop;
   //         constexpr auto begin() const { return iterator{0}; }
   //         constexpr auto end() const { return iterator{stop}; }
   //         constexpr auto empty() const -> bool { return stop == 0; }
   //         constexpr auto size() const -> size_t { return stop; }
   //         constexpr auto operator[](size_t n) const -> T { return n; } // no
   //         bounds checking constexpr auto contains(T n) const -> bool { return n
   //         < stop; }
   //     };
   
   //     if (stop < 0) stop = 0;
   //     return iterable_wrapper{stop};
   // }
   
   template <typename T>
   inline constexpr auto range(T start, T stop)
   {
       struct _iterator
       {
           T i;
           constexpr auto operator!=(const _iterator& other) const -> bool
           {
               return this->i != other.i;
           }
           constexpr auto operator==(const _iterator& other) const -> bool
           {
               return this->i == other.i;
           }
           constexpr auto operator*() const -> T
           {
               return this->i;
           }
           constexpr auto operator++() -> _iterator&
           {
               ++this->i;
               return *this;
           }
           constexpr auto operator++(int) -> _iterator
           {
               auto temp = *this;
               ++*this;
               return temp;
           }
       };
   
       struct iterable_wrapper
       {
         public:
           using value_type [[maybe_unused]] = T; // luk:
           using key_type [[maybe_unused]] = T;   // luk:
           using iterator = _iterator;            // luk
           T start;
           T stop;
           [[nodiscard]] constexpr auto begin() const
           {
               return iterator {this->start};
           }
           [[nodiscard]] constexpr auto end() const
           {
               return iterator {this->stop};
           }
           [[nodiscard]] constexpr auto empty() const -> bool
           {
               return this->stop == this->start;
           }
           [[nodiscard]] constexpr auto size() const -> size_t
           {
               return static_cast<size_t>(this->stop - this->start);
           }
           constexpr auto operator[](size_t n) const -> T
           {
               return T(this->start + n);
           } // no bounds checking
           [[nodiscard]] constexpr auto contains(T n) const -> bool
           {
               return !(n < this->start) && n < this->stop;
           }
       };
   
       if (stop < start) {
           stop = start;
       }
       return iterable_wrapper {start, stop};
   }
   
   // template <typename T>
   // inline auto range(T start, T stop)
   // {
   //     using iota_return_type = decltype(ranges::views::iota(start, stop));
   
   //     class iterable_wrapper : public iota_return_type
   //     {
   //       public:
   //         using value_type [[maybe_unused]] = T; // luk:
   //         using key_type [[maybe_unused]] = T;   // luk:
   
   //         iterable_wrapper(iota_return_type&& base)
   //             : iota_return_type{std::forward<iota_return_type>(base)}
   //         {
   //         }
   
   //         [[nodiscard]] auto contains(T n) const -> bool
   //         {
   //             return !(n < *this->begin()) && n < *this->end();
   //         }
   //     };
       
   //     return iterable_wrapper {ranges::views::iota(start, stop)};
   // }
   
   template <typename T>
   inline auto range(T stop)
   {
       return range(T(0), stop);
   }
   
   template <typename Key>
   class set : public std::unordered_set<Key>
   {
       using Self = set<Key>;
   
     public:
       set()
           : std::unordered_set<Key> {}
       {
       }
   
       template <typename FwdIter>
       set(const FwdIter& start, const FwdIter& stop)
           : std::unordered_set<Key>(start, stop)
       {
       }
   
       set(std::initializer_list<Key> init)
           : std::unordered_set<Key> {init}
       {
       }
   
       auto contains(const Key& key) const -> bool
       {
           return this->find(key) != this->end();
       }
   
       auto copy() const -> set
       {
           return *this;
       }
   
       auto operator=(const set&) -> set& = delete;
   
       auto operator=(set&&) noexcept -> set& = default;
   
       set(set<Key>&&) noexcept = default;
   
       // private:
       set(const set<Key>&) = default;
   };
   
   template <typename Key>
   inline auto operator<(const Key& key, const set<Key>& m) -> bool
   {
       return m.contains(key);
   }
   
   template <typename Key>
   inline auto len(const set<Key>& m) -> size_t
   {
       return m.size();
   }
   
   // template <typename Key>
   // set(std::initializer_list<Key>) -> set<Key>;
   
   // template <typename Key>
   // set(std::initializer_list<const char*> ) -> set<std::string>;
   
   template <typename Iter>
   struct key_iterator : Iter
   {
       explicit key_iterator(Iter it)
           : Iter(it)
       {
       }
       auto operator*() const
       {
           return Iter::operator*().first;
       }
       auto operator++() -> key_iterator&
       {
           Iter::operator++();
           return *this;
       }
   };
   
   template <typename Key, typename T>
   class dict : public std::unordered_map<Key, T>
   {
       using Self = dict<Key, T>;
       using Base = std::unordered_map<Key, T>;
   
     public:
       using value_type = std::pair<const Key, T>;
   
       dict()
           : std::unordered_map<Key, T> {}
       {
       }
   
       dict(std::initializer_list<value_type> init)
           : std::unordered_map<Key, T> {init}
       {
       }
   
       // template <class Sequence>
       // explicit dict(const Sequence &S) {
       //     this->reserve(S.size());
       //     for (const auto& [i_v, v] : py::enumerate(S)) {
       //         (*this)[v] = i_v;
       //     }
       // }
   
       auto contains(const Key& key) const -> bool
       {
           return this->find(key) != this->end();
       }
   
       auto get(const Key& key, const T& default_value) -> T
       {
           if (!contains(key))
           {
               return default_value;
           }
           return (*this)[key];
       }
   
       auto begin() const
       {
           using Iter = decltype(std::unordered_map<Key, T>::begin());
           return key_iterator<Iter> {std::unordered_map<Key, T>::begin()};
       }
   
       auto end() const
       {
           using Iter = decltype(std::unordered_map<Key, T>::end());
           return key_iterator<Iter> {std::unordered_map<Key, T>::end()};
       }
   
       auto items() -> std::unordered_map<Key, T>&
       {
           return *this;
       }
   
       auto items() const -> const std::unordered_map<Key, T>&
       {
           return *this;
       }
   
       auto copy() const -> Self
       {
           return *this;
       }
   
       auto operator[](const Key& k) const -> const T&
       {
           return this->at(k); // luk: a bug in std::unordered_map?
       }
   
       auto operator[](const Key& k) -> T&
       {
           return Base::operator[](k);
       }
   
       auto operator=(const Self&) -> Self& = delete;
   
       auto operator=(Self&&) noexcept -> dict& = default;
   
       dict(dict<Key, T>&&) noexcept = default;
   
       ~dict() = default;
   
       // private:
       dict(const dict<Key, T>&) = default;
   };
   
   template <typename Key, typename T>
   inline auto operator<(const Key& key, const dict<Key, T>& m) -> bool
   {
       return m.contains(key);
   }
   
   template <typename Key, typename T>
   inline auto len(const dict<Key, T>& m) -> size_t
   {
       return m.size();
   }
   
   // template <typename Key, typename T>
   // dict(std::initializer_list<std::pair<const Key, T>>) -> dict<Key, T>;
   
   // template <class Sequence>
   // dict(const Sequence& S)
   //     -> dict<std::remove_cv_t<decltype(*std::begin(S))>, size_t>;
   
   } // namespace py