FM / core

/usr/include/boost/core

Name	Size	Mode	Actions
addressof.hpp	6153	0644	edit dl rm
allocator_access.hpp	15944	0644	edit dl rm
alloc_construct.hpp	3436	0644	edit dl rm
checked_delete.hpp	1677	0644	edit dl rm
default_allocator.hpp	3333	0644	edit dl rm
demangle.hpp	3034	0644	edit dl rm
empty_value.hpp	3324	0644	edit dl rm
enable_if.hpp	3315	0644	edit dl rm
exchange.hpp	911	0644	edit dl rm
explicit_operator_bool.hpp	5354	0644	edit dl rm
first_scalar.hpp	813	0644	edit dl rm
ignore_unused.hpp	1976	0644	edit dl rm
is_same.hpp	793	0644	edit dl rm
lightweight_test.hpp	18443	0644	edit dl rm
lightweight_test_trait.hpp	3973	0644	edit dl rm
noinit_adaptor.hpp	1791	0644	edit dl rm
noncopyable.hpp	1911	0644	edit dl rm
no_exceptions_support.hpp	1872	0644	edit dl rm
null_deleter.hpp	1232	0644	edit dl rm
nvp.hpp	1000	0644	edit dl rm
pointer_traits.hpp	5072	0644	edit dl rm
quick_exit.hpp	1098	0644	edit dl rm
ref.hpp	5976	0644	edit dl rm
scoped_enum.hpp	7880	0644	edit dl rm
swap.hpp	2123	0644	edit dl rm
typeinfo.hpp	3151	0644	edit dl rm
uncaught_exceptions.hpp	6819	0644	edit dl rm
underlying_type.hpp	2205	0644	edit dl rm
use_default.hpp	300	0644	edit dl rm

Edit: /usr/include/boost/core/pointer_traits.hpp (5072B)

/*
Copyright 2017-2018 Glen Joseph Fernandes
(glenjofe@gmail.com)

Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_CORE_POINTER_TRAITS_HPP
#define BOOST_CORE_POINTER_TRAITS_HPP

#include <boost/config.hpp>
#if !defined(BOOST_NO_CXX11_POINTER_TRAITS)
#include <memory>
#else
#include <boost/core/addressof.hpp>
#include <cstddef>
#endif

namespace boost {

#if !defined(BOOST_NO_CXX11_POINTER_TRAITS)
template<class T>
struct pointer_traits
    : std::pointer_traits<T> {
    template<class U>
    struct rebind_to {
        typedef typename std::pointer_traits<T>::template rebind<U> type;
    };
};

template<class T>
struct pointer_traits<T*>
    : std::pointer_traits<T*> {
    template<class U>
    struct rebind_to {
        typedef U* type;
    };
};
#else
namespace detail {

template<class>
struct ptr_void {
    typedef void type;
};

template<class T>
struct ptr_first;

#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
template<template<class, class...> class T, class U, class... Args>
struct ptr_first<T<U, Args...> > {
    typedef U type;
};
#else
template<template<class> class T, class U>
struct ptr_first<T<U> > {
    typedef U type;
};

template<template<class, class> class T, class U1, class U2>
struct ptr_first<T<U1, U2> > {
    typedef U1 type;
};

template<template<class, class, class> class T, class U1, class U2, class U3>
struct ptr_first<T<U1, U2, U3> > {
    typedef U1 type;
};
#endif

template<class T, class = void>
struct ptr_element {
    typedef typename ptr_first<T>::type type;
};

template<class T>
struct ptr_element<T, typename ptr_void<typename T::element_type>::type> {
    typedef typename T::element_type type;
};

template<class, class = void>
struct ptr_difference {
    typedef std::ptrdiff_t type;
};

template<class T>
struct ptr_difference<T,
    typename ptr_void<typename T::difference_type>::type> {
    typedef typename T::difference_type type;
};

template<class T, class V>
struct ptr_transform;

#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
template<template<class, class...> class T, class U, class... Args, class V>
struct ptr_transform<T<U, Args...>, V> {
    typedef T<V, Args...> type;
};
#else
template<template<class> class T, class U, class V>
struct ptr_transform<T<U>, V> {
    typedef T<V> type;
};

template<template<class, class> class T, class U1, class U2, class V>
struct ptr_transform<T<U1, U2>, V> {
    typedef T<V, U2> type;
};

template<template<class, class, class> class T,
    class U1, class U2, class U3, class V>
struct ptr_transform<T<U1, U2, U3>, V> {
    typedef T<V, U2, U3> type;
};
#endif

template<class T, class U, class = void>
struct ptr_rebind {
    typedef typename ptr_transform<T, U>::type type;
};

#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
template<class T, class U>
struct ptr_rebind<T, U,
    typename ptr_void<typename T::template rebind<U> >::type> {
    typedef typename T::template rebind<U> type;
};
#endif

template<class T>
struct ptr_value {
    typedef T type;
};

template<>
struct ptr_value<void> {
    typedef struct { } type;
};

} /* detail */

template<class T>
struct pointer_traits {
    typedef T pointer;
    typedef typename detail::ptr_element<T>::type element_type;
    typedef typename detail::ptr_difference<T>::type difference_type;
    template<class U>
    struct rebind_to {
        typedef typename detail::ptr_rebind<T, U>::type type;
    };
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
    template<class U>
    using rebind = typename detail::ptr_rebind<T, U>::type;
#endif
    static pointer
    pointer_to(typename detail::ptr_value<element_type>::type& v) {
        return pointer::pointer_to(v);
    }
};

template<class T>
struct pointer_traits<T*> {
    typedef T* pointer;
    typedef T element_type;
    typedef std::ptrdiff_t difference_type;
    template<class U>
    struct rebind_to {
        typedef U* type;
    };
#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
    template<class U>
    using rebind = U*;
#endif
    static T*
    pointer_to(typename detail::ptr_value<T>::type& v) BOOST_NOEXCEPT {
        return boost::addressof(v);
    }
};
#endif

template<class T>
BOOST_CONSTEXPR inline T*
to_address(T* v) BOOST_NOEXCEPT
{
    return v;
}

#if !defined(BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION)
namespace detail {

template<class T>
inline T*
ptr_address(T* v, int) BOOST_NOEXCEPT
{
    return v;
}

template<class T>
inline auto
ptr_address(const T& v, int) BOOST_NOEXCEPT
-> decltype(boost::pointer_traits<T>::to_address(v))
{
    return boost::pointer_traits<T>::to_address(v);
}

template<class T>
inline auto
ptr_address(const T& v, long) BOOST_NOEXCEPT
{
    return boost::detail::ptr_address(v.operator->(), 0);
}

} /* detail */

template<class T>
inline auto
to_address(const T& v) BOOST_NOEXCEPT
{
    return boost::detail::ptr_address(v, 0);
}
#else
template<class T>
inline typename pointer_traits<T>::element_type*
to_address(const T& v) BOOST_NOEXCEPT
{
    return boost::to_address(v.operator->());
}
#endif

} /* boost */

#endif

/* Copyright 2017-2018 Glen Joseph Fernandes (glenjofe@gmail.com) Distributed under the Boost Software License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_CORE_POINTER_TRAITS_HPP #define BOOST_CORE_POINTER_TRAITS_HPP #include #if !defined(BOOST_NO_CXX11_POINTER_TRAITS) #include #else #include #include #endif namespace boost { #if !defined(BOOST_NO_CXX11_POINTER_TRAITS) template struct pointer_traits : std::pointer_traits { template struct rebind_to { typedef typename std::pointer_traits::template rebind type; }; }; template struct pointer_traits : std::pointer_traits { template struct rebind_to { typedef U* type; }; }; #else namespace detail { template struct ptr_void { typedef void type; }; template struct ptr_first; #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) template class T, class U, class... Args> struct ptr_first > { typedef U type; }; #else template class T, class U> struct ptr_first > { typedef U type; }; template class T, class U1, class U2> struct ptr_first > { typedef U1 type; }; template class T, class U1, class U2, class U3> struct ptr_first > { typedef U1 type; }; #endif template struct ptr_element { typedef typename ptr_first::type type; }; template struct ptr_element::type> { typedef typename T::element_type type; }; template struct ptr_difference { typedef std::ptrdiff_t type; }; template struct ptr_difference::type> { typedef typename T::difference_type type; }; template struct ptr_transform; #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) template class T, class U, class... Args, class V> struct ptr_transform, V> { typedef T type; }; #else template class T, class U, class V> struct ptr_transform, V> { typedef T type; }; template class T, class U1, class U2, class V> struct ptr_transform, V> { typedef T type; }; template class T, class U1, class U2, class U3, class V> struct ptr_transform, V> { typedef T type; }; #endif template struct ptr_rebind { typedef typename ptr_transform::type type; }; #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) template struct ptr_rebind >::type> { typedef typename T::template rebind type; }; #endif template struct ptr_value { typedef T type; }; template<> struct ptr_value { typedef struct { } type; }; } /* detail */ template struct pointer_traits { typedef T pointer; typedef typename detail::ptr_element::type element_type; typedef typename detail::ptr_difference::type difference_type; template struct rebind_to { typedef typename detail::ptr_rebind::type type; }; #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) template using rebind = typename detail::ptr_rebind::type; #endif static pointer pointer_to(typename detail::ptr_value::type& v) { return pointer::pointer_to(v); } }; template struct pointer_traits { typedef T* pointer; typedef T element_type; typedef std::ptrdiff_t difference_type; template struct rebind_to { typedef U* type; }; #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) template using rebind = U*; #endif static T* pointer_to(typename detail::ptr_value::type& v) BOOST_NOEXCEPT { return boost::addressof(v); } }; #endif template BOOST_CONSTEXPR inline T* to_address(T* v) BOOST_NOEXCEPT { return v; } #if !defined(BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION) namespace detail { template inline T* ptr_address(T* v, int) BOOST_NOEXCEPT { return v; } template inline auto ptr_address(const T& v, int) BOOST_NOEXCEPT -> decltype(boost::pointer_traits::to_address(v)) { return boost::pointer_traits::to_address(v); } template inline auto ptr_address(const T& v, long) BOOST_NOEXCEPT { return boost::detail::ptr_address(v.operator->(), 0); } } /* detail */ template inline auto to_address(const T& v) BOOST_NOEXCEPT { return boost::detail::ptr_address(v, 0); } #else template inline typename pointer_traits::element_type* to_address(const T& v) BOOST_NOEXCEPT { return boost::to_address(v.operator->()); } #endif } /* boost */ #endif