unordered_tuple_impl.hpp

Go to the documentation of this file.

/******************************************************************************
** Copyright © 2017 by J.M.McGuiness, libjmmcg@hussar.me.uk
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
 
namespace jmmcg { namespace LIBJMMCG_VER_NAMESPACE {
 
template<class KeyType, class MappedType, class Hasher, template<class> class ExtractHash, class ... MappedTypes>
inline
unordered_tuple<KeyType, MappedType, Hasher, ExtractHash, MappedTypes...>::unordered_tuple() noexcept(noexcept(default_ctors_t<MappedTypes...>::result(mapped_cont.data())))
: mapped_cont{{}} {
   if constexpr (noexcept(default_ctors_t<MappedTypes...>::result(mapped_cont.data()))) {
      default_ctors_t<MappedTypes...>::result(mapped_cont.data());
   } else {
      try {
         default_ctors_t<MappedTypes...>::result(mapped_cont.data());
      } catch (...) {
         dtors<MappedTypes...>::result(mapped_cont.data());
         throw;
      }
   }
}
 
template<class KeyType, class MappedType, class Hasher, template<class> class ExtractHash, class ... MappedTypes>
template<class MappedCtorArg, class... MappedCtorArgs, class> inline
unordered_tuple<KeyType, MappedType, Hasher, ExtractHash, MappedTypes...>::unordered_tuple(MappedCtorArg &&arg, MappedCtorArgs &&... args) noexcept(noexcept(ctors_t<MappedTypes...>::result(mapped_cont.data(), std::forward<MappedCtorArg>(arg), std::forward<MappedCtorArgs>(args)...)))
: mapped_cont{{}} {
   BOOST_MPL_ASSERT_RELATION(size, ==, sizeof...(MappedCtorArgs)+1);
   if constexpr (noexcept(ctors_t<MappedTypes...>::result(mapped_cont.data(), std::forward<MappedCtorArg>(arg), std::forward<MappedCtorArgs>(args)...))) {
      ctors_t<MappedTypes...>::result(mapped_cont.data(), std::forward<MappedCtorArg>(arg), std::forward<MappedCtorArgs>(args)...);
   } else {
      try {
         ctors_t<MappedTypes...>::result(mapped_cont.data(), std::forward<MappedCtorArg>(arg), std::forward<MappedCtorArgs>(args)...);
      } catch (...) {
         dtors<MappedTypes...>::result(mapped_cont.data());
         throw;
      }
   }
}
 
template<class KeyType, class MappedType, class Hasher, template<class> class ExtractHash, class ... MappedTypes> inline
unordered_tuple<KeyType, MappedType, Hasher, ExtractHash, MappedTypes...>::~unordered_tuple() noexcept(true) {
   dtors<MappedTypes...>::result(mapped_cont.data());
}
 
template<class KeyType, class MappedType, class Hasher, template<class> class ExtractHash, class ... MappedTypes> inline
constexpr typename unordered_tuple<KeyType, MappedType, Hasher, ExtractHash, MappedTypes...>::mapped_type const &
unordered_tuple<KeyType, MappedType, Hasher, ExtractHash, MappedTypes...>::operator[](const key_type mic) const noexcept(true) {
   const typename mapped_index_colln::mapped_type i=mapped_index_colln_t::find(mic)->second;
   mapped_type const &ret=reinterpret_cast<mapped_type const &>(mapped_cont[i]);
   return ret;
}
 
template<class KeyType, class MappedType, class Hasher, template<class> class ExtractHash, class ... MappedTypes> inline
constexpr typename unordered_tuple<KeyType, MappedType, Hasher, ExtractHash, MappedTypes...>::mapped_type &
unordered_tuple<KeyType, MappedType, Hasher, ExtractHash, MappedTypes...>::operator[](const key_type mic) noexcept(true) {
   const typename mapped_index_colln::mapped_type i=mapped_index_colln_t::find(mic)->second;
   mapped_type &ret=reinterpret_cast<mapped_type &>(mapped_cont[i]);
   return ret;
}
 
} }