FM / align

/usr/include/boost/align

Name	Size	Mode	Actions
detail/	-	0755	rm
align.hpp	404	0644	edit dl rm
aligned_alloc.hpp	1569	0644	edit dl rm
aligned_allocator.hpp	3725	0644	edit dl rm
aligned_allocator_adaptor.hpp	5107	0644	edit dl rm
aligned_allocator_adaptor_forward.hpp	468	0644	edit dl rm
aligned_allocator_forward.hpp	436	0644	edit dl rm
aligned_delete.hpp	671	0644	edit dl rm
aligned_delete_forward.hpp	368	0644	edit dl rm
alignment_of.hpp	1672	0644	edit dl rm
alignment_of_forward.hpp	375	0644	edit dl rm
align_down.hpp	593	0644	edit dl rm
align_up.hpp	608	0644	edit dl rm
assume_aligned.hpp	786	0644	edit dl rm
is_aligned.hpp	602	0644	edit dl rm

Edit: /usr/include/boost/align/aligned_allocator.hpp (3725B)

/*
Copyright 2014-2015 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_ALIGN_ALIGNED_ALLOCATOR_HPP
#define BOOST_ALIGN_ALIGNED_ALLOCATOR_HPP

#include <boost/align/detail/add_reference.hpp>
#include <boost/align/detail/is_alignment_constant.hpp>
#include <boost/align/detail/max_objects.hpp>
#include <boost/align/detail/max_size.hpp>
#include <boost/align/detail/throw_exception.hpp>
#include <boost/align/aligned_alloc.hpp>
#include <boost/align/aligned_allocator_forward.hpp>
#include <boost/align/alignment_of.hpp>
#include <boost/static_assert.hpp>
#include <new>

#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
#include <utility>
#endif

namespace boost {
namespace alignment {

template<class T, std::size_t Alignment>
class aligned_allocator {
    BOOST_STATIC_ASSERT(detail::is_alignment_constant<Alignment>::value);

public:
    typedef T value_type;
    typedef T* pointer;
    typedef const T* const_pointer;
    typedef void* void_pointer;
    typedef const void* const_void_pointer;
    typedef typename detail::add_lvalue_reference<T>::type reference;
    typedef typename detail::add_lvalue_reference<const
        T>::type const_reference;
    typedef std::size_t size_type;
    typedef std::ptrdiff_t difference_type;
    typedef detail::true_type propagate_on_container_move_assignment;
    typedef detail::true_type is_always_equal;

template<class U>
    struct rebind {
        typedef aligned_allocator<U, Alignment> other;
    };

#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
    aligned_allocator() = default;
#else
    aligned_allocator() BOOST_NOEXCEPT { }
#endif

template<class U>
    aligned_allocator(const aligned_allocator<U, Alignment>&)
        BOOST_NOEXCEPT { }

pointer allocate(size_type size, const_void_pointer = 0) {
        enum {
            m = detail::max_size<Alignment,
                alignment_of<value_type>::value>::value
        };
        if (size == 0) {
            return 0;
        }
        void* p = boost::alignment::aligned_alloc(m, sizeof(T) * size);
        if (!p) {
            detail::throw_exception(std::bad_alloc());
        }
        return static_cast<T*>(p);
    }

void deallocate(pointer ptr, size_type) {
        boost::alignment::aligned_free(ptr);
    }

BOOST_CONSTEXPR size_type max_size() const BOOST_NOEXCEPT {
        return detail::max_objects<T>::value;
    }

#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
    template<class U, class... Args>
    void construct(U* ptr, Args&&... args) {
        ::new((void*)ptr) U(std::forward<Args>(args)...);
    }
#else
    template<class U, class V>
    void construct(U* ptr, V&& value) {
        ::new((void*)ptr) U(std::forward<V>(value));
    }
#endif
#else
    template<class U, class V>
    void construct(U* ptr, const V& value) {
        ::new((void*)ptr) U(value);
    }

template<class U, class V>
    void construct(U* ptr, V& value) {
        ::new((void*)ptr) U(value);
    }
#endif

template<class U>
    void construct(U* ptr) {
        ::new((void*)ptr) U();
    }

template<class U>
    void destroy(U* ptr) {
        (void)ptr;
        ptr->~U();
    }
};

template<class T, class U, std::size_t Alignment>
inline bool
operator==(const aligned_allocator<T, Alignment>&,
    const aligned_allocator<U, Alignment>&) BOOST_NOEXCEPT
{
    return true;
}

template<class T, class U, std::size_t Alignment>
inline bool
operator!=(const aligned_allocator<T, Alignment>&,
    const aligned_allocator<U, Alignment>&) BOOST_NOEXCEPT
{
    return false;
}

} /* alignment */
} /* boost */

#endif

/* Copyright 2014-2015 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_ALIGN_ALIGNED_ALLOCATOR_HPP #define BOOST_ALIGN_ALIGNED_ALLOCATOR_HPP #include #include #include #include #include #include #include #include #include #include #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) #include #endif namespace boost { namespace alignment { template class aligned_allocator { BOOST_STATIC_ASSERT(detail::is_alignment_constant::value); public: typedef T value_type; typedef T* pointer; typedef const T* const_pointer; typedef void* void_pointer; typedef const void* const_void_pointer; typedef typename detail::add_lvalue_reference::type reference; typedef typename detail::add_lvalue_reference::type const_reference; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef detail::true_type propagate_on_container_move_assignment; typedef detail::true_type is_always_equal; template struct rebind { typedef aligned_allocator other; }; #if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) aligned_allocator() = default; #else aligned_allocator() BOOST_NOEXCEPT { } #endif template aligned_allocator(const aligned_allocator&) BOOST_NOEXCEPT { } pointer allocate(size_type size, const_void_pointer = 0) { enum { m = detail::max_size::value>::value }; if (size == 0) { return 0; } void* p = boost::alignment::aligned_alloc(m, sizeof(T) * size); if (!p) { detail::throw_exception(std::bad_alloc()); } return static_cast(p); } void deallocate(pointer ptr, size_type) { boost::alignment::aligned_free(ptr); } BOOST_CONSTEXPR size_type max_size() const BOOST_NOEXCEPT { return detail::max_objects::value; } #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) template void construct(U* ptr, Args&&... args) { ::new((void*)ptr) U(std::forward(args)...); } #else template void construct(U* ptr, V&& value) { ::new((void*)ptr) U(std::forward(value)); } #endif #else template void construct(U* ptr, const V& value) { ::new((void*)ptr) U(value); } template void construct(U* ptr, V& value) { ::new((void*)ptr) U(value); } #endif template void construct(U* ptr) { ::new((void*)ptr) U(); } template void destroy(U* ptr) { (void)ptr; ptr->~U(); } }; template inline bool operator==(const aligned_allocator&, const aligned_allocator&) BOOST_NOEXCEPT { return true; } template inline bool operator!=(const aligned_allocator&, const aligned_allocator&) BOOST_NOEXCEPT { return false; } } /* alignment */ } /* boost */ #endif