Line data    Source code

       1              : //
       2              : // Copyright (c) 2023 Christian Mazakas
       3              : // Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
       4              : //
       5              : // Distributed under the Boost Software License, Version 1.0. (See accompanying
       6              : // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
       7              : //
       8              : // Official repository: https://github.com/cppalliance/http_proto
       9              : //
      10              : 
      11              : #ifndef BOOST_HTTP_PROTO_DETAIL_TYPE_INDEX_HPP
      12              : #define BOOST_HTTP_PROTO_DETAIL_TYPE_INDEX_HPP
      13              : 
      14              : #include <boost/container_hash/hash.hpp>
      15              : #include <boost/core/typeinfo.hpp>
      16              : #include <boost/config.hpp>
      17              : 
      18              : namespace boost {
      19              : namespace http_proto {
      20              : namespace detail {
      21              : 
      22              : struct type_index_impl {
      23              : private:
      24              :   boost::core::typeinfo const *pdata_ = nullptr;
      25              : 
      26         1109 :   std::size_t get_raw_name_length() const noexcept {
      27              :     // Boost.TypeIndex has a dramatically more sophisticated implementation here
      28              :     // see if this eventually turns out to matter and if it does, essentially
      29              :     // just do more copy-paste
      30         1109 :     return std::strlen(raw_name());
      31              :   }
      32              : 
      33         1045 :   bool equal(type_index_impl const &rhs) const noexcept {
      34         1045 :     return raw_name() == rhs.raw_name() ||
      35         1045 :            !std::strcmp(raw_name(), rhs.raw_name());
      36              :   }
      37              : 
      38              : public:
      39         1077 :   type_index_impl(boost::core::typeinfo const &type_info) noexcept
      40         1077 :       : pdata_(&type_info) {}
      41              : 
      42              :   type_index_impl(type_index_impl const &) = default;
      43              :   type_index_impl &operator=(type_index_impl const &) = default;
      44              : 
      45              :   ~type_index_impl() = default;
      46              : 
      47         1077 :   template <class T> static type_index_impl type_id() noexcept {
      48         1077 :     return type_index_impl(BOOST_CORE_TYPEID(T));
      49              :   }
      50              : 
      51         5417 :   char const *raw_name() const noexcept { return pdata_->name(); }
      52              : 
      53         1109 :   std::size_t hash_code() const noexcept {
      54         1109 :     return boost::hash_range(raw_name(), raw_name() + get_raw_name_length());
      55              :   }
      56              : 
      57         1045 :   bool operator==(type_index_impl const &rhs) const noexcept {
      58         1045 :     return equal(rhs);
      59              :   }
      60              : 
      61              :   bool operator!=(type_index_impl const &rhs) const noexcept {
      62              :     return !equal(rhs);
      63              :   }
      64              : };
      65              : 
      66              : // like std::type_index,
      67              : // but without requiring RTTI
      68              : using type_index = type_index_impl;
      69              : 
      70         1077 : template <class T> type_index get_type_index() noexcept {
      71         1077 :   return type_index_impl::type_id<T>();
      72              : }
      73              : 
      74              : struct type_index_hasher {
      75         1109 :   std::size_t operator()(type_index const &tid) const noexcept {
      76         1109 :     return tid.hash_code();
      77              :   }
      78              : };
      79              : 
      80         1045 : template <class U, class T> U downcast(T *p) {
      81              : #ifdef BOOST_NO_RTTI
      82              :   return static_cast<U>(p);
      83              : #else
      84         1045 :   return dynamic_cast<U>(p);
      85              : #endif
      86              : }
      87              : 
      88           32 : template <class U, class T> U downcast(T &p) {
      89              : #ifdef BOOST_NO_RTTI
      90              :   return static_cast<U>(p);
      91              : #else
      92           32 :   return dynamic_cast<U>(p);
      93              : #endif
      94              : }
      95              : 
      96              : } // namespace detail
      97              : } // namespace http_proto
      98              : } // namespace boost
      99              : 
     100              : #endif