FM / common

/usr/include/stxxl/bits/common

Name	Size	Mode	Actions
addressable_queues.h	6036	0644	edit dl rm
aligned_alloc.h	5387	0644	edit dl rm
binary_buffer.h	20063	0644	edit dl rm
cmdline.h	23482	0644	edit dl rm
condition_variable.h	2141	0644	edit dl rm
counting_ptr.h	16404	0644	edit dl rm
error_handling.h	7702	0644	edit dl rm
exceptions.h	2000	0644	edit dl rm
exithandler.h	1400	0644	edit dl rm
external_shared_ptr.h	3760	0644	edit dl rm
is_sorted.h	1818	0644	edit dl rm
log.h	1265	0644	edit dl rm
mutex.h	3332	0644	edit dl rm
new_alloc.h	3901	0644	edit dl rm
onoff_switch.h	2146	0644	edit dl rm
rand.h	8191	0644	edit dl rm
seed.h	863	0644	edit dl rm
semaphore.h	2449	0644	edit dl rm
settings.h	971	0644	edit dl rm
simple_vector.h	4639	0644	edit dl rm
state.h	1687	0644	edit dl rm
timer.h	4662	0644	edit dl rm
tmeta.h	2988	0644	edit dl rm
tuple.h	19553	0644	edit dl rm
types.h	1923	0644	edit dl rm
uint_types.h	9572	0644	edit dl rm
utils.h	8380	0644	edit dl rm

Edit: /usr/include/stxxl/bits/common/new_alloc.h (3901B)

/***************************************************************************
 *  include/stxxl/bits/common/new_alloc.h
 *
 *  Part of the STXXL. See http://stxxl.sourceforge.net
 *
 *  Copyright (C) 2002-2006 Roman Dementiev <dementiev@mpi-sb.mpg.de>
 *  Copyright (C) 2007, 2008, 2010 Andreas Beckmann <beckmann@cs.uni-frankfurt.de>
 *
 *  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)
 **************************************************************************/

#ifndef STXXL_COMMON_NEW_ALLOC_HEADER
#define STXXL_COMMON_NEW_ALLOC_HEADER

#include <memory>
#include <limits>
#include <stxxl/bits/namespace.h>

STXXL_BEGIN_NAMESPACE

template <class Type>
class new_alloc;

template <typename Type, typename Rebind>
struct new_alloc_rebind;

template <typename Type>
struct new_alloc_rebind<Type, Type>{
    typedef new_alloc<Type> other;
};

template <typename Type, typename Rebind>
struct new_alloc_rebind {
    typedef std::allocator<Rebind> other;
};

// designed for typed_block (to use with std::vector)
template <class Type>
class new_alloc
{
public:
    // type definitions
    typedef Type value_type;
    typedef Type* pointer;
    typedef const Type* const_pointer;
    typedef Type& reference;
    typedef const Type& const_reference;
    typedef std::size_t size_type;
    typedef std::ptrdiff_t difference_type;

// rebind allocator to type Rebind, use new_alloc only if Rebind == Type
    template <class Rebind>
    struct rebind {
        typedef typename new_alloc_rebind<Type, Rebind>::other other;
    };

// return address of values
    pointer address(reference value) const
    {
        return &value;
    }
    const_pointer address(const_reference value) const
    {
        return &value;
    }

new_alloc() throw () { }
    new_alloc(const new_alloc&) throw () { }
    template <class Rebind>
    new_alloc(const new_alloc<Rebind>&) throw () { }
    ~new_alloc() throw () { }

template <class Rebind>
    operator std::allocator<Rebind>()
    {
        static std::allocator<Rebind> helper_allocator;
        return helper_allocator;
    }

// return maximum number of elements that can be allocated
    size_type max_size() const throw ()
    {
        return std::numeric_limits<size_type>::max() / sizeof(Type);
    }

// allocate but don't initialize num elements of type Type
    pointer allocate(size_type num, const void* = 0)
    {
        return static_cast<Type*>(Type::operator new (num * sizeof(Type)));
    }

// _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 402. wrong new expression in [some_] allocator::construct
    // initialize elements of allocated storage p with value value
    void construct(pointer p, const Type& value)
    {
        // initialize memory with placement new
        ::new ((void*)p)Type(value);
    }

#ifdef __GXX_EXPERIMENTAL_CXX0X__
    template <typename ... Args>
    void construct(pointer p, Args&& ... args)
    {
        ::new ((void*)p)Type(std::forward<Args>(args) ...);
    }
#endif

// destroy elements of initialized storage p
    void destroy(pointer p)
    {
        // destroy objects by calling their destructor
        p->~Type();
    }

// deallocate storage p of deleted elements
    void deallocate(pointer p, size_type /*num*/)
    {
        Type::operator delete (p);
    }
};

// return that all specializations of this allocator are interchangeable
template <class Type1, class Type2>
inline bool operator == (const new_alloc<Type1>&,
                         const new_alloc<Type2>&) throw ()
{
    return true;
}

template <class Type1, class Type2>
inline bool operator != (const new_alloc<Type1>&,
                         const new_alloc<Type2>&) throw ()
{
    return false;
}

STXXL_END_NAMESPACE

#endif // !STXXL_COMMON_NEW_ALLOC_HEADER
// vim: et:ts=4:sw=4

cmd: