|  | Home | Libraries | People | FAQ | More | 
void*
            align(std::size_t alignment, std::size_t
            size,
            void*&
            ptr,
            std::size_t&
            space);
                      #include <boost/align/align.hpp>
                    
                      If it is possible to fit size
                      bytes of storage aligned by alignment
                      into the buffer pointed to by ptr
                      with length space,
                      the function updates ptr
                      to point to the first possible address of such storage and
                      decreases space
                      by the number of bytes used for alignment. Otherwise, the function
                      does nothing.
                    
alignment
                          shall be a power of two
                        ptr shall
                          point to contiguous storage of at least space
                          bytes
                        ptr.
                    
                      The function updates its ptr
                      and space arguments
                      so that it can be called repeatedly with possibly different
                      alignment and
                      sizearguments
                      for the same buffer.
                    
template<class T> constexpr
            T align_up(T value, std::size_t alignment) noexcept;
                      #include <boost/align/align_up.hpp>
                    
                      T is not a
                      pointer type
                    
                      alignment shall
                      be a power of two
                    
                      A value at or after value
                      that is a multiple of alignment.
                    
template<class T> constexpr
            T align_down(T value, std::size_t alignment) noexcept;
                      #include <boost/align/align_down.hpp>
                    
                      T is not a
                      pointer type
                    
                      alignment shall
                      be a power of two
                    
                      A value at or before value
                      that is a multiple of alignment.
                    
void*
            aligned_alloc(std::size_t alignment, std::size_t
            size);
                      #include <boost/align/aligned_alloc.hpp>
                    
                      Allocates space for an object whose alignment is specified
                      by alignment,
                      whose size is specified by size,
                      and whose value is indeterminate.
                    
                      alignment shall
                      be a power of two.
                    
A null pointer or a pointer to the allocated space.
                      On certain platforms, the space allocated may be slightly larger
                      than size bytes,
                      to allow for alignment.
                    
void aligned_free(void* ptr);
                      #include <boost/align/aligned_alloc.hpp>
                    
                      Causes the space pointed to by ptr
                      to be deallocated, that is, made available for further allocation.
                      If ptr is a
                      null pointer, no action occurs. Otherwise, if the argument
                      does not match a pointer earlier returned by the aligned_alloc()
                      function, or if the space has been deallocated by a call to
                      aligned_free(), the behavior is undefined.
                    
                      ptr is a null
                      pointer or a pointer earlier returned by the aligned_alloc()
                      function that has not been deallocated by a call to aligned_free().
                    
                      The aligned_free() function returns no value.
                    
bool is_aligned(const volatile void* ptr, std::size_t
            alignment)
            noexcept;
                      #include <boost/align/is_aligned.hpp>
                    
                      alignment shall
                      be a power of two.
                    
                      true if ptr is aligned on the boundary
                      specified by alignment,
                      otherwise false.
                    
template<class T> constexpr
            bool is_aligned(T value, std::size_t alignment) noexcept;
                      #include <boost/align/is_aligned.hpp>
                    
                      T is not a
                      pointer type
                    
                      alignment shall
                      be a power of two.
                    
                      true if the value
                      of value is
                      aligned on the boundary specified by alignment,
                      otherwise false.
                    
template<class T, std::size_t
            Alignment =
            1>
            class aligned_allocator;
                      #include <boost/align/aligned_allocator.hpp>
                    
                      Using the aligned allocator with a minimum Alignment value
                      is generally only useful with containers that are not node-based
                      such as vector.
                      With node-based containers, such as list,
                      the node object would have the minimum alignment instead of
                      the value type object.
                    
typedef T
              value_type;
            typedef T* pointer;
            typedef const
              T*
              const_pointer;
            typedef void* void_pointer;
            typedef const
              void*
              const_void_pointer;
            typedef std::add_lvalue_reference_t<T> reference;
            typedef std::add_lvalue_reference_t<const
              T>
              const_reference;
            typedef std::size_t
              size_type;
            typedef std::ptrdiff_t
              difference_type;
            typedef std::true_type
              propagate_on_container_move_assignment;
            typedef std::true_type
              is_always_equal;
            template<class U> struct
              rebind {
              typedef aligned_allocator<U, Alignment> other; };
            
aligned_allocator() = default;
Constructs the allocator.
template<class U> aligned_allocator(const aligned_allocator<U, Alignment>&)
            noexcept;
Constructs the allocator.
Except for the destructor, member functions of the aligned allocator shall not introduce data races as a result of concurrent calls to those member functions from different threads. Calls to these functions that allocate or deallocate a particular unit of storage shall occur in a single total order, and each such deallocation call shall happen before the next allocation (if any) in this order.
pointer allocate(size_type
            size,
            const_void_pointer =
            0);
                      A pointer to the initial element of an array of storage of
                      size n *
                      sizeof(T),
                      aligned on the maximum of the minimum alignment specified and
                      the alignment of objects of type T.
                    
                      The storage is obtained by calling aligned_alloc(std::size_t, std::size_t).
                    
                      std::bad_alloc if the storage
                      cannot be obtained.
                    
void deallocate(pointer
            ptr,
            size_type);
                      ptr shall be
                      a pointer value obtained from allocate().
                    
                      Deallocates the storage referenced by ptr.
                    
                      Uses aligned_free(void*).
                    
size_type max_size() const noexcept;
                      The largest value N
                      for which the call allocate(N) might succeed.
                    
template<class U, class... Args> void construct(U* ptr, Args&&...
            args);
                      ::new((void*)ptr) U(std::forward<Args>(args)...).
                    
template<class U> void destroy(U* ptr);
                      ptr->~U().
                    
template<class T1, class T2, std::size_t Alignment> bool operator==(const aligned_allocator<T1, Alignment>&, const
            aligned_allocator<T2, Alignment>&)
            noexcept;
                      true
                    
template<class T1, class T2, std::size_t Alignment> bool operator!=(const aligned_allocator<T1, Alignment>&, const
            aligned_allocator<T2, Alignment>&)
            noexcept;
                      false
                    
template<class Allocator, std::size_t
            Alignment =
            1>
            class aligned_allocator_adaptor;
                      #include <boost/align/aligned_allocator_adaptor.hpp>
                    
This adaptor can be used with a C++11 Allocator whose pointer type is a smart pointer but the adaptor can choose to expose only raw pointer types.
typedef typename
              Allocator::value_type value_type;
            typedef value_type* pointer;
            typedef const
              value_type*
              const_pointer;
            typedef void* void_pointer;
            typedef const
              void*
              const_void_pointer;
            typedef std::size_t
              size_type;
            typedef std::ptrdiff_t
              difference_type;
            template<class U> struct
              rebind {
              typedef aligned_allocator_adaptor<typename
              std::allocator_traits<Allocator>::template rebind_alloc<U>, Alignment> other; };
            
aligned_allocator_adaptor() = default;
                      Value-initializes the Allocator
                      base class.
                    
template<class A> aligned_allocator_adaptor(A&& alloc) noexcept;
                      Allocator shall
                      be constructible from A.
                    
                      Initializes the Allocator
                      base class with std::forward<A>(alloc).
                    
template<class U> aligned_allocator_adaptor(const aligned_allocator_adaptor<U, Alignment>&
            other)
            noexcept;
                      Allocator shall
                      be constructible from A.
                    
                      Initializes the Allocator
                      base class with other.base().
                    
Allocator&
            base()
            noexcept;
                      static_cast<Allocator&>(*this)
                    
const Allocator& base() const noexcept;
                      static_cast<const Allocator&>(*this)
                    
pointer allocate(size_type
            size);
                      A pointer to the initial element of an array of storage of
                      size n *
                      sizeof(value_type),
                      aligned on the maximum of the minimum alignment specified and
                      the alignment of objects of type value_type.
                    
                      The storage is obtained by calling A2::allocate() on an object a2, where a2
                      of type A2
                      is a rebound copy of base() where its value_type
                      is implementation defined.
                    
                      Throws an exception thrown from A2::allocate() if the storage cannot be
                      obtained.
                    
pointer allocate(size_type
            size,
            const_void_pointer hint);
                      hint is a value
                      obtained by calling allocate() on any equivalent allocator
                      object, or else a null pointer.
                    
                      A pointer to the initial element of an array of storage of
                      size n *
                      sizeof(value_type),
                      aligned on the maximum of the minimum alignment specified and
                      the alignment of objects of type value_type.
                    
                      The storage is obtained by calling A2::allocate() on an object a2, where a2
                      of type A2
                      is a rebound copy of base() where its value_type
                      is an implementation defined.
                    
                      Throws an exception thrown from A2::allocate() if the storage cannot be
                      obtained.
                    
void deallocate(pointer
            ptr,
            size_type size);
ptr shall
                          be a pointer value obtained from allocate()
                        size shall
                          equal the value passed as the first argument to the invocation
                          of allocate() which returned ptr.
                        ptr.
                    
                      Uses A2::deallocate()
                      on an object a2,
                      where a2 of
                      type A2 is
                      a rebound copy of base() where its value_type
                      is implementation defined.
                    
template<class A1, class A2, std::size_t Alignment> bool operator==(const aligned_allocator_adaptor<A1, Alignment>& a1, const aligned_allocator_adaptor<A2, Alignment>&
            a2)
            noexcept;
                      a1.base()
                      == a2.base()
                    
template<class A1, class A2, std::size_t Alignment> bool operator!=(const aligned_allocator_adaptor<A1, Alignment>& a1, const aligned_allocator_adaptor<A2, Alignment>&
            a2)
            noexcept;
                      !(a1
                      == a2)
                    
class aligned_delete;
                      #include <boost/align/aligned_delete.hpp>
                    
template<class T> void operator()(T* ptr) noexcept(noexcept(ptr->~T()));
                      Calls ~T() on ptr
                      to destroy the object and then calls aligned_free() on ptr
                      to free the allocated memory.
                    
                      If T is an
                      incomplete type, the program is ill-formed.
                    
template<class T> struct
            alignment_of;
                      #include <boost/align/alignment_of.hpp>
                    
                      The alignment requirement of the type T
                      as an integral constant of type std::size_t.
                      When T is a
                      reference array type, the value shall be the alignment of the
                      referenced type. When T
                      is an array type, the value shall be the alignment of the element
                      type.
                    
                      T shall be
                      a complete object type, or an array thereof, or a reference
                      to one of those types.
                    
BOOST_ALIGN_ASSUME_ALIGNED(ptr, alignment)
                      #include <boost/align/assume_aligned.hpp>
                    
alignment
                          shall be a power of two
                        ptr shall
                          be mutable
                        ptr may be
                      modified in an implementation specific way to inform the compiler
                      of its alignment.