LibreOffice
LibreOffice 4.2 SDK C/C++ API Reference
 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: */
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:565
#define SAL_UNUSED_PARAMETER
Annotate unused but required C++ function parameters.
Definition: types.h:570
SAL_DLLPUBLIC void * rtl_allocateMemory(sal_Size Bytes) SAL_THROW_EXTERN_C()
Allocate memory.
sal_Bool operator==(const TTimeValue &rTimeA, const TTimeValue &rTimeB)
Definition: timer.hxx:118
SAL_DLLPUBLIC void rtl_freeMemory(void *Ptr) SAL_THROW_EXTERN_C()
Free memory.
#define SAL_THROW(exc)
Definition of function throw clause macros.
Definition: types.h:358