LibreOffice LibreOffice 4.1 SDK C/C++ API Reference

- Main Page
- Related Pages
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
allocator.hxx
Go to the documentation of this file.
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19 #ifndef INCLUDED_RTL_ALLOCATOR_HXX
20 #define INCLUDED_RTL_ALLOCATOR_HXX
21
22 #include "sal/config.h"
23
24 #include "sal/types.h"
25 #include "rtl/alloc.h"
26 #include <cstddef>
27
29
30 //######################################################
31 // This is no general purpose STL allocator but one
32 // necessary to use STL for some implementation but
33 // avoid linking sal against the STLPort library!!!
34 // For more information on when and how to define a
35 // custom stl allocator have a look at Scott Meyers:
36 // "Effective STL", Nicolai M. Josuttis:
37 // "The C++ Standard Library - A Tutorial and Reference"
38 // and at http://www.josuttis.com/cppcode/allocator.html
39
40 namespace rtl {
41
42 template<class T>
43 class Allocator
44 {
45 public:
46 typedef T value_type;
47 typedef T* pointer;
48 typedef const T* const_pointer;
49 typedef T& reference;
50 typedef const T& const_reference;
51 typedef ::std::size_t size_type;
52 typedef ::std::ptrdiff_t difference_type;
53
54 //-----------------------------------------
55 template<class U>
56 struct rebind
57 {
58 typedef Allocator<U> other;
59 };
60
61 //-----------------------------------------
62 pointer address (reference value) const
63 {
64 return &value;
65 }
66
67 //-----------------------------------------
68 const_pointer address (const_reference value) const
69 {
70 return &value;
71 }
72
73 //-----------------------------------------
74 Allocator() SAL_THROW(())
75 {}
76
77 //-----------------------------------------
78 template<class U>
79 Allocator (SAL_UNUSED_PARAMETER const Allocator<U>&) SAL_THROW(())
80 {}
81
82 //-----------------------------------------
83 Allocator(const Allocator&) SAL_THROW(())
84 {}
85
86 //-----------------------------------------
87 ~Allocator() SAL_THROW(())
88 {}
89
90 //-----------------------------------------
91 size_type max_size() const SAL_THROW(())
92 {
93 return size_type(-1)/sizeof(T);
94 }
95
96 //-----------------------------------------
97 /* Normally the code for allocate should
98 throw a std::bad_alloc exception if the
99 requested memory could not be allocated:
100 (C++ standard 20.4.1.1):
101
102 pointer allocate (size_type n, const void* hint = 0)
103 {
104 pointer p = reinterpret_cast<pointer>(
105 rtl_allocateMemory(sal_uInt32(n * sizeof(T))));
106
107 if (NULL == p)
108 throw ::std::bad_alloc();
109
110 return p;
111 }
112
113 but some compilers do not compile it if exceptions
114 are not enabled, e.g. GCC under Linux and it is
115 in general not desired to compile sal with exceptions
116 enabled. */
117 pointer allocate (size_type n, SAL_UNUSED_PARAMETER const void* = 0)
118 {
119 return reinterpret_cast<pointer>(
120 rtl_allocateMemory(sal_uInt32(n * sizeof(T))));
121 }
122
123 //-----------------------------------------
124 void deallocate (pointer p, SAL_UNUSED_PARAMETER size_type /* n */)
125 {
126 rtl_freeMemory(p);
127 }
128
129 //-----------------------------------------
130 #if HAVE_CXX11_PERFECT_FORWARDING && !defined(_LIBCPP_VERSION)
131 template< typename... Args >
132 void construct (pointer p, Args &&... value)
133 {
134 new ((void*)p)T(std::forward< Args >(value)...);
135 }
136 #else
137 void construct (pointer p, const T& value)
138 {
139 new ((void*)p)T(value);
140 }
141 #endif
142
143 //-----------------------------------------
144 void destroy (pointer p)
145 {
146 p->~T();
147 (void)p; //MSVC2005 annoyingly warns this is unused
148 }
149 };
150
151 //######################################################
152 // Custom STL allocators must be stateless (see
153 // references above) that's why the operators below
154 // return always true or false
155
156 template<class T, class U> inline bool operator ==(
157 SAL_UNUSED_PARAMETER const Allocator<T>&,
158 SAL_UNUSED_PARAMETER const Allocator<U>&) SAL_THROW(())
159 {
160 return true;
161 }
162
163 template<class T, class U>
164 inline bool operator!= (const Allocator<T>&, const Allocator<U>&) SAL_THROW(())
165 {
166 return false;
167 }
168
169 } /* namespace rtl */
170
172
173 #endif /* INCLUDED_RTL_ALLOCATOR_HXX */
174
175 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
com::sun::star::uno::operator!=
sal_Bool operator!=(const Any &rAny, const C &value)
Template unequality operator: compares set value of left side any to right side value.
Definition: Any.hxx:558
SAL_UNUSED_PARAMETER
#define SAL_UNUSED_PARAMETER
Annotate unused but required C++ function parameters.
Definition: types.h:540
SAL_THROW
#define SAL_THROW(exc)
Definition of function throw clause macros.
Definition: types.h:356
salhelper::operator==
sal_Bool operator==(const TTimeValue &rTimeA, const TTimeValue &rTimeB)
Definition: timer.hxx:118
rtl_allocateMemory
SAL_DLLPUBLIC void * rtl_allocateMemory(sal_Size Bytes) SAL_THROW_EXTERN_C()
Allocate memory.
config.h
rtl_freeMemory
SAL_DLLPUBLIC void rtl_freeMemory(void *Ptr) SAL_THROW_EXTERN_C()
Free memory.
types.h
alloc.h