201705.mbox/raw/%3c9c47a0e2cc094470a906ef6837e937f9@git.apache.org%3e

 // Licensed to the Apache Software Foundation (ASF) under one

- // or more contributor license agreements.  See the NOTICE file

- // distributed with this work for additional information

- // regarding copyright ownership.  The ASF licenses this file

- // to you under the Apache License, Version 2.0 (the

- // "License"); you may not use this file except in compliance

- // with the License.  You may obtain a copy of the License at

- //

- //   http://www.apache.org/licenses/LICENSE-2.0

- //

- // Unless required by applicable law or agreed to in writing,

- // software distributed under the License is distributed on an

- // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

- // KIND, either express or implied.  See the License for the

- // specific language governing permissions and limitations

- // under the License.

-

- #ifndef ARROW_ALLOCATOR_H

- #define ARROW_ALLOCATOR_H

-

- #include <cstddef>

- #include <memory>

- #include <utility>

-

- #include "arrow/memory_pool.h"

- #include "arrow/status.h"

-

- namespace arrow {

-

- template <class T>

- class stl_allocator {

-  public:

-   using value_type = T;

-   using pointer = T*;

-   using const_pointer = const T*;

-   using reference = T&;

-   using const_reference = const T&;

-   using size_type = std::size_t;

-   using difference_type = std::ptrdiff_t;

-

-   template <class U>

-   struct rebind {

-     using other = stl_allocator<U>;

-   };

-

-   stl_allocator() noexcept : pool_(default_memory_pool()) {}

-   explicit stl_allocator(MemoryPool* pool) noexcept : pool_(pool) {}

-

-   template <class U>

-   stl_allocator(const stl_allocator<U>& rhs) noexcept : pool_(rhs.pool_) {}

-

-   ~stl_allocator() { pool_ = nullptr; }

-

-   pointer address(reference r) const noexcept { return std::addressof(r); }

-

-   const_pointer address(const_reference r) const noexcept { return std::addressof(r); }

-

-   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {

-     uint8_t* data;

-     Status s = pool_->Allocate(n * sizeof(T), &data);

-     if (!s.ok()) throw std::bad_alloc();

-     return reinterpret_cast<pointer>(data);

-   }

-

-   void deallocate(pointer p, size_type n) {

-     pool_->Free(reinterpret_cast<uint8_t*>(p), n * sizeof(T));

-   }

-

-   size_type size_max() const noexcept { return size_type(-1) / sizeof(T); }

-

-   template <class U, class... Args>

-   void construct(U* p, Args&&... args) {

-     new (reinterpret_cast<void*>(p)) U(std::forward<Args>(args)...);

-   }

-

-   template <class U>

-   void destroy(U* p) {

-     p->~U();

-   }

-

-   MemoryPool* pool() const noexcept { return pool_; }

-

-  private:

-   MemoryPool* pool_;

- };

-

- template <class T1, class T2>

- bool operator==(const stl_allocator<T1>& lhs, const stl_allocator<T2>& rhs) noexcept {

-   return lhs.pool() == rhs.pool();

- }

-

- template <class T1, class T2>

- bool operator!=(const stl_allocator<T1>& lhs, const stl_allocator<T2>& rhs) noexcept {

-   return !(lhs == rhs);

- }

-

- }  // namespace arrow

-

- #endif  // ARROW_ALLOCATOR_H

-arrow::stl_allocator::destroy
void destroy(U *p)
Definition: allocator.h:77

-arrow::MemoryPool::Allocate
virtual Status Allocate(int64_t size, uint8_t **out)=0
Allocate a new memory region of at least size bytes.

+Go to the documentation of this file. // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
    6 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed
  under the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.

 #ifndef ARROW_ALLOCATOR_H
 #define ARROW_ALLOCATOR_H

 #include <cstddef>
 #include <memory>
 #include <utility>

 #include "arrow/memory_pool.h"
 #include &
 quot;arrow/status.h"

 namespace arrow {

 template <class T>
 class stl_allocator {
  pu
 blic:
   using value_type = T;
   using pointer = T*;
   using const_pointer = const T*;
   using reference = T&;
   using const_reference = const T&;
   using size_type = std::size_t;
   using difference_type = std::ptrdiff_t;

   template <class U>
   struct rebind {
     using other = stl_allocator<U>;
   };

   stl_allocator() noexcept : pool_(default_memory_pool()) {}
   explicit stl_allocator(MemoryPool* pool) noexcept : pool_(pool) {}

   template <class U>
   stl_allocator(const stl_allocator<U>& rhs) noexcept : pool_(rhs.pool_) {}

   ~stl_allocator() { pool_ = nullptr; }

   pointer address(reference r) const noexcept { return std::addressof(r); }

   const_pointer address(const_reference r) const noexcept { return std::addressof(r); }

   pointer allocate(size_type n, const void* /*hint*/ = nullptr) {
     uint8_t* data;
     Status s = pool_->Allocate(n * sizeof(T), &data);
     if (!s.ok()) throw std::bad_alloc();
     return reinterpret_cast<pointer>(data);
   }

   void deallocate(pointer p, size_type n) {
     pool_->Free(reinterpret_cast<uint8_t*>(p), n * sizeof(T));
   }

   size_type size_max() const noexcept { return size_type(-1) / sizeof(T); }

   template <class U, class... Args>
   void cons
 truct(U* p, Args&&... args) {
     new (reinterpret_cast<void*>(p)) U(std::forward<Args>(args)...);
   }

   template <class U>
   void destroy(U* p) {     p->~U();
   }

   MemoryPool* pool() const noexcept { return pool_; }

  private:
   MemoryPool* pool_;
 };

 template <class T1, class T2>
 bool operator==(const stl_allocator<T1>& lhs, const stl_allocator<T2>& rhs) noexcept
 {
   return lhs.pool() == rhs.pool();
 }

 template <class T1, class T2>
 bool operator!=(const stl_allocator<T1>& lhs, const stl_allocator<T2>& rhs) noexcept {
   return !(lhs == rhs);
 }

 }  // namespace arrow

 #endif  // ARROW_ALLOCATOR_H
arrow::stl_allocator::destroyvoid destroy(U *p)
Definition: allocator.h:77

 arrow::stl_allocator::allocate
pointer allocate(size_type n, const void *=nullptr)
Definition: allocator.h:58

 arrow::stl_allocator::const_pointer
const T * const_pointer
Definition: allocator.h:35

 arrow::stl_allocator::address
const_pointer address(const_reference r) const noexcept
Definition: allocator.h:56

@@ -198,34 +75,34 @@ var searchBox = new SearchBox("searchBox", "search",false,'Search');
 arrow::stl_allocator::pointer
T * pointer
Definition: allocator.h:34

 arrow::stl_allocator::size_type
std::size_t size_type
Definition: allocator.h:38

 arrow::Status
Definition: status.h:88

+arrow::Status::ok
bool ok() const
Definition: status.h:133

 arrow::stl_allocator::stl_allocator
stl_allocator(const stl_allocator< U > &rhs) noexcept
Definition: allocator.h:50

 arrow::operator!=
bool operator!=(const stl_allocator< T1 > &lhs, const stl_allocator< T2 > &rhs) noexcept
Definition: allocator.h:93

 arrow::stl_allocator::rebind
Definition: allocator.h:42

 memory_pool.h

 arrow::stl_allocator::size_max
size_type size_max() const noexcept
Definition: allocator.h:69

+arrow
Public API for the "Feather" file format, originally created at http://github.com/wesm/feather.
Definition: allocator.h:28

 arrow::stl_allocator::pool
MemoryPool * pool() const noexcept
Definition: allocator.h:81

 arrow::stl_allocator
Definition: allocator.h:31

 status.h

 arrow::stl_allocator::~stl_allocator
~stl_allocator()
Definition: allocator.h:52

 arrow::stl_allocator::reference
T & reference
Definition: allocator.h:36

 arrow::stl_allocator::const_reference
const T & const_reference
Definition: allocator.h:37

-arrow::MemoryPool::Free
virtual void Free(uint8_t *buffer, int64_t size)=0
Free an allocated region.

 arrow::stl_allocator::deallocate
void deallocate(pointer p, size_type n)
Definition: allocator.h:65

-arrow::stl_allocator::construct
void construct(U *p, Args &&...args)
Definition: allocator.h:72

 arrow::operator==
bool operator==(const stl_allocator< T1 > &lhs, const stl_allocator< T2 > &rhs) noexcept
Definition: allocator.h:88

 arrow::stl_allocator::difference_type
std::ptrdiff_t difference_type
Definition: allocator.h:39

 arrow::stl_allocator::address
pointer address(reference r) const noexcept
Definition: allocator.h:54

 arrow::MemoryPool
Base class for memory allocation.
Definition: memory_pool.h:35

 arrow::stl_allocator::stl_allocator
stl_allocator(MemoryPool *pool) noexcept
Definition: allocator.h:47

+arrow::stl_allocator::construct
void construct(U *p, Args &&... args)
Definition: allocator.h:72

 arrow::stl_allocator::stl_allocator
stl_allocator() noexcept
Definition: allocator.h:46

-arrow::Status::ok
bool ok() const
Definition: status.h:134

 arrow::default_memory_pool
MemoryPool * default_memory_pool()
Definition: memory_pool.cc:133


 Generated by

- 1.8.6
+ 1.8.13