1 ///////////////////////////////////////////////////////////////////////////////
2 //
3 // (C) Copyright Ion Gaztanaga 2005-2012. Distributed under the Boost
4 // Software License, Version 1.0. (See accompanying file
5 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6 //
7 // See http://www.boost.org/libs/interprocess for documentation.
8 //
9 ///////////////////////////////////////////////////////////////////////////////
10
11 #ifndef BOOST_INTERPROCESS_DUMMY_TEST_ALLOCATOR_HPP
12 #define BOOST_INTERPROCESS_DUMMY_TEST_ALLOCATOR_HPP
13
14 #if defined (_MSC_VER)
15 # pragma once
16 #endif
17
18 #include <boost/interprocess/detail/config_begin.hpp>
19 #include <boost/interprocess/detail/workaround.hpp>
20
21 #include <boost/interprocess/interprocess_fwd.hpp>
22 #include <boost/interprocess/containers/allocation_type.hpp>
23 #include <boost/interprocess/detail/utilities.hpp>
24 #include <boost/interprocess/containers/version_type.hpp>
25 #include <boost/interprocess/exceptions.hpp>
26 #include <cstddef>
27
28 //!\file
29 //!Describes an allocator to test expand capabilities
30
31 namespace boost {
32 namespace interprocess {
33 namespace test {
34
35 //This allocator just allows two allocations. The first one will return
36 //mp_buffer + m_offset configured in the constructor. The second one
37 //will return mp_buffer.
38 template<class T>
39 class dummy_test_allocator
40 {
41 private:
42 typedef dummy_test_allocator<T> self_t;
43 typedef void * aux_pointer_t;
44 typedef const void * cvoid_ptr;
45
46 template<class T2>
47 dummy_test_allocator& operator=(const dummy_test_allocator<T2>&);
48
49 dummy_test_allocator& operator=(const dummy_test_allocator&);
50
51 public:
52 typedef T value_type;
53 typedef T * pointer;
54 typedef const T * const_pointer;
55 typedef typename ipcdetail::add_reference
56 <value_type>::type reference;
57 typedef typename ipcdetail::add_reference
58 <const value_type>::type const_reference;
59 typedef std::size_t size_type;
60 typedef std::ptrdiff_t difference_type;
61
62 // typedef boost::interprocess::version_type<dummy_test_allocator, 2> version;
63
64 template<class T2>
65 struct rebind
66 { typedef dummy_test_allocator<T2> other; };
67
68 //!Default constructor. Never throws
dummy_test_allocator()69 dummy_test_allocator()
70 {}
71
72 //!Constructor from other dummy_test_allocator. Never throws
dummy_test_allocator(const dummy_test_allocator &)73 dummy_test_allocator(const dummy_test_allocator &)
74 {}
75
76 //!Constructor from related dummy_test_allocator. Never throws
77 template<class T2>
dummy_test_allocator(const dummy_test_allocator<T2> &)78 dummy_test_allocator(const dummy_test_allocator<T2> &)
79 {}
80
address(reference value)81 pointer address(reference value)
82 { return pointer(addressof(value)); }
83
address(const_reference value) const84 const_pointer address(const_reference value) const
85 { return const_pointer(addressof(value)); }
86
allocate(size_type,cvoid_ptr=0)87 pointer allocate(size_type, cvoid_ptr = 0)
88 { return 0; }
89
deallocate(const pointer &,size_type)90 void deallocate(const pointer &, size_type)
91 { }
92
93 template<class Convertible>
construct(pointer,const Convertible &)94 void construct(pointer, const Convertible &)
95 {}
96
destroy(pointer)97 void destroy(pointer)
98 {}
99
max_size() const100 size_type max_size() const
101 { return 0; }
102
swap(self_t &,self_t &)103 friend void swap(self_t &, self_t &)
104 {}
105
106 //Experimental version 2 dummy_test_allocator functions
107
allocation_command(boost::interprocess::allocation_type,size_type,size_type &,pointer &)108 pointer allocation_command(boost::interprocess::allocation_type,
109 size_type, size_type &, pointer &)
110 { return pointer(); }
111
112 //!Returns maximum the number of objects the previously allocated memory
113 //!pointed by p can hold.
size(const pointer &) const114 size_type size(const pointer &) const
115 { return 0; }
116
117 //!Allocates just one object. Memory allocated with this function
118 //!must be deallocated only with deallocate_one().
119 //!Throws boost::interprocess::bad_alloc if there is no enough memory
allocate_one()120 pointer allocate_one()
121 { return pointer(); }
122
123 //!Deallocates memory previously allocated with allocate_one().
124 //!You should never use deallocate_one to deallocate memory allocated
125 //!with other functions different from allocate_one(). Never throws
deallocate_one(const pointer &)126 void deallocate_one(const pointer &)
127 {}
128 };
129
130 //!Equality test for same type of dummy_test_allocator
131 template<class T> inline
operator ==(const dummy_test_allocator<T> &,const dummy_test_allocator<T> &)132 bool operator==(const dummy_test_allocator<T> &,
133 const dummy_test_allocator<T> &)
134 { return false; }
135
136 //!Inequality test for same type of dummy_test_allocator
137 template<class T> inline
operator !=(const dummy_test_allocator<T> &,const dummy_test_allocator<T> &)138 bool operator!=(const dummy_test_allocator<T> &,
139 const dummy_test_allocator<T> &)
140 { return true; }
141
142 } //namespace test {
143 } //namespace interprocess {
144 } //namespace boost {
145
146 #include <boost/interprocess/detail/config_end.hpp>
147
148 #endif //BOOST_INTERPROCESS_DUMMY_TEST_ALLOCATOR_HPP
149
150