FM / detail

/usr/include/boost/poly_collection/detail/

/usr/include/boost/poly_collection/detail

Name	Size	Mode	Actions
allocator_adaptor.hpp	9222	0644	edit dl rm
any_iterator.hpp	2356	0644	edit dl rm
any_model.hpp	6018	0644	edit dl rm
auto_iterator.hpp	1474	0644	edit dl rm
base_model.hpp	3294	0644	edit dl rm
callable_wrapper.hpp	2673	0644	edit dl rm
callable_wrapper_iterator.hpp	2610	0644	edit dl rm
functional.hpp	5202	0644	edit dl rm
function_model.hpp	3441	0644	edit dl rm
is_acceptable.hpp	1235	0644	edit dl rm
is_constructible.hpp	1459	0644	edit dl rm
is_equality_comparable.hpp	817	0644	edit dl rm
is_final.hpp	1419	0644	edit dl rm
is_invocable.hpp	2264	0644	edit dl rm
is_nothrow_eq_comparable.hpp	1064	0644	edit dl rm
iterator_impl.hpp	7050	0644	edit dl rm
iterator_traits.hpp	3056	0644	edit dl rm
packed_segment.hpp	9916	0644	edit dl rm
poly_collection.hpp	34291	0644	edit dl rm
segment.hpp	9731	0644	edit dl rm
segment_backend.hpp	3234	0644	edit dl rm
segment_split.hpp	4448	0644	edit dl rm
split_segment.hpp	13524	0644	edit dl rm
stride_iterator.hpp	4404	0644	edit dl rm
type_info_map.hpp	7309	0644	edit dl rm
type_restitution.hpp	5515	0644	edit dl rm
value_holder.hpp	7388	0644	edit dl rm

Edit: /usr/include/boost/poly_collection/detail/callable_wrapper.hpp (2673B)

#ifndef BOOST_POLY_COLLECTION_DETAIL_CALLABLE_WRAPPER_HPP
#define BOOST_POLY_COLLECTION_DETAIL_CALLABLE_WRAPPER_HPP

#if defined(_MSC_VER)
#pragma once
#endif

#include <boost/poly_collection/detail/is_invocable.hpp>
#include <functional>
#include <type_traits>
#include <typeinfo>

namespace boost{

namespace poly_collection{

namespace detail{

/* lightweight std::function look-alike over non-owned callable entities */

template<typename Signature>
class callable_wrapper;

template<typename R,typename... Args>
class callable_wrapper<R(Args...)>
{
public:
  // TODO: we should prevent assignment by user code
  template<
    typename Callable,
    typename std::enable_if<
      !std::is_same<Callable,callable_wrapper>::value&&
      is_invocable_r<R,Callable,Args...>::value
    >::type* =nullptr
  >
  explicit callable_wrapper(Callable& x)noexcept:pt{info(x)},px{&x}{}
  callable_wrapper(const callable_wrapper&)=default;
  callable_wrapper& operator=(const callable_wrapper&)=default;

explicit operator bool()const noexcept{return true;}

R operator()(Args... args)const
    {return pt->call(px,std::forward<Args>(args)...);}

const std::type_info& target_type()const noexcept{return pt->info;}

template<typename T>
  T*       target()noexcept
             {return typeid(T)==pt->info?static_cast<T*>(px):nullptr;}
  template<typename T>
  const T* target()const noexcept
             {return typeid(T)==pt->info?static_cast<const T*>(px):nullptr;}

/* not in std::function interface */

operator std::function<R(Args...)>()const noexcept{return pt->convert(px);}

void*       data()noexcept{return px;}
  const void* data()const noexcept{return px;}

private:
  struct table
  {
    R(*call)(void*,Args...);
    const std::type_info& info;
    std::function<R(Args...)> (*convert)(void*);
  };

template<typename Callable>
  static table* info(Callable&)noexcept
  {
    static table t={
      [](void* p,Args... args){
        auto r=std::ref(*static_cast<Callable*>(p));
        return static_cast<R>(r(std::forward<Args>(args)...));
      },
      typeid(Callable),
      [](void* p){
        auto r=std::ref(*static_cast<Callable*>(p));
        return std::function<R(Args...)>{r};
      }
    };
    return &t;
  }

table* pt;
  void*  px;
};

} /* namespace poly_collection::detail */

} /* namespace poly_collection */

} /* namespace boost */

#endif

/* Copyright 2016-2017 Joaquin M Lopez Munoz. * Distributed under the Boost Software License, Version 1.0. * (See accompanying file LICENSE_1_0.txt or copy at * http://www.boost.org/LICENSE_1_0.txt) * * See http://www.boost.org/libs/poly_collection for library home page. */ #ifndef BOOST_POLY_COLLECTION_DETAIL_CALLABLE_WRAPPER_HPP #define BOOST_POLY_COLLECTION_DETAIL_CALLABLE_WRAPPER_HPP #if defined(_MSC_VER) #pragma once #endif #include #include #include #include namespace boost{ namespace poly_collection{ namespace detail{ /* lightweight std::function look-alike over non-owned callable entities */ template class callable_wrapper; template class callable_wrapper { public: // TODO: we should prevent assignment by user code template< typename Callable, typename std::enable_if< !std::is_same::value&& is_invocable_r::value >::type* =nullptr > explicit callable_wrapper(Callable& x)noexcept:pt{info(x)},px{&x}{} callable_wrapper(const callable_wrapper&)=default; callable_wrapper& operator=(const callable_wrapper&)=default; explicit operator bool()const noexcept{return true;} R operator()(Args... args)const {return pt->call(px,std::forward(args)...);} const std::type_info& target_type()const noexcept{return pt->info;} template T* target()noexcept {return typeid(T)==pt->info?static_cast(px):nullptr;} template const T* target()const noexcept {return typeid(T)==pt->info?static_cast(px):nullptr;} /* not in std::function interface */ operator std::function()const noexcept{return pt->convert(px);} void* data()noexcept{return px;} const void* data()const noexcept{return px;} private: struct table { R(*call)(void*,Args...); const std::type_info& info; std::function (*convert)(void*); }; template static table* info(Callable&)noexcept { static table t={ [](void* p,Args... args){ auto r=std::ref(*static_cast(p)); return static_cast(r(std::forward(args)...)); }, typeid(Callable), [](void* p){ auto r=std::ref(*static_cast(p)); return std::function{r}; } }; return &t; } table* pt; void* px; }; } /* namespace poly_collection::detail */ } /* namespace poly_collection */ } /* namespace boost */ #endif