/*
- * Copyright 2014 Facebook, Inc.
+ * Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#ifndef FOLLY_SMALL_VECTOR_H_
#define FOLLY_SMALL_VECTOR_H_
-#include "Portability.h"
-
#include <stdexcept>
#include <cstdlib>
#include <type_traits>
#include <boost/mpl/count.hpp>
#include <boost/mpl/max.hpp>
+#include <folly/FormatTraits.h>
#include <folly/Malloc.h>
+#include <folly/Portability.h>
-#if defined(__GNUC__) && FOLLY_X64
-# include "folly/SmallLocks.h"
+#if defined(__GNUC__) && (FOLLY_X64 || FOLLY_PPC64)
+# include <folly/SmallLocks.h>
# define FB_PACK_ATTR FOLLY_PACK_ATTR
# define FB_PACK_PUSH FOLLY_PACK_PUSH
# define FB_PACK_POP FOLLY_PACK_POP
!FOLLY_IS_TRIVIALLY_COPYABLE(T)
>::type
moveToUninitialized(T* first, T* last, T* out) {
- auto const count = last - first;
std::size_t idx = 0;
try {
- for (; idx < count; ++first, ++idx) {
+ for (; first != last; ++first, ++idx) {
new (&out[idx]) T(std::move(*first));
}
} catch (...) {
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
- explicit small_vector() {}
+ explicit small_vector() = default;
small_vector(small_vector const& o) {
auto n = o.size();
try {
std::uninitialized_copy(o.begin(), o.end(), begin());
} catch (...) {
- if (this->isExtern()) u.freeHeap();
+ if (this->isExtern()) {
+ u.freeHeap();
+ }
throw;
}
this->setSize(n);
}
- small_vector(small_vector&& o) {
+ small_vector(small_vector&& o)
+ noexcept(std::is_nothrow_move_constructible<Value>::value) {
if (o.isExtern()) {
swap(o);
} else {
emplaceBack(std::forward<Args>(args)...);
}
+ void emplace_back(const value_type& t) {
+ push_back(t);
+ }
+ void emplace_back(value_type& t) {
+ push_back(t);
+ }
+
+ void emplace_back(value_type&& t) {
+ push_back(std::move(t));
+ }
+
void push_back(value_type&& t) {
if (capacity() == size()) {
makeSize(std::max(size_type(2), 3 * size() / 2), &t, size());
}
void push_back(value_type const& t) {
- // Make a copy and forward to the rvalue value_type&& overload
- // above.
- push_back(value_type(t));
+ // TODO: we'd like to make use of makeSize (it can be optimized better,
+ // because it manipulates the internals)
+ // unfortunately the current implementation only supports moving from
+ // a supplied rvalue, and doing an extra move just to reuse it is a perf
+ // net loss
+ if (size() == capacity()) {// && isInside(&t)) {
+ value_type tmp(t);
+ emplaceBack(std::move(tmp));
+ } else {
+ emplaceBack(t);
+ }
}
void pop_back() {
this->setSize(size() + 1);
}
- /*
- * Special case of emplaceBack for rvalue
- */
- void emplaceBack(value_type&& t) {
- push_back(std::move(t));
- }
-
static iterator unconst(const_iterator it) {
return const_cast<iterator>(it);
}
// With iterators that only allow a single pass, we can't really
// do anything sane here.
while (first != last) {
- push_back(*first++);
+ emplace_back(*first++);
}
return;
}
auto distance = std::distance(first, last);
makeSize(distance);
this->setSize(distance);
-
- detail::populateMemForward(data(), distance,
- [&] (void* p) { new (p) value_type(*first++); }
- );
+ try {
+ detail::populateMemForward(data(), distance,
+ [&] (void* p) { new (p) value_type(*first++); }
+ );
+ } catch (...) {
+ if (this->isExtern()) {
+ u.freeHeap();
+ }
+ throw;
+ }
}
void doConstruct(size_type n, value_type const& val) {
makeSize(n);
this->setSize(n);
- detail::populateMemForward(data(), n,
- [&] (void* p) { new (p) value_type(val); }
- );
+ try {
+ detail::populateMemForward(data(), n,
+ [&] (void* p) { new (p) value_type(val); }
+ );
+ } catch (...) {
+ if (this->isExtern()) {
+ u.freeHeap();
+ }
+ throw;
+ }
}
// The true_type means we should forward to the size_t,value_type
}
} FB_PACK_ATTR;
-#if FOLLY_X64
+#if (FOLLY_X64 || FOLLY_PPC64)
typedef unsigned char InlineStorageType[sizeof(value_type) * MaxInline];
#else
typedef typename std::aligned_storage<
//////////////////////////////////////////////////////////////////////
-}
+namespace detail {
+
+// Format support.
+template <class T, size_t M, class A, class B, class C>
+struct IndexableTraits<small_vector<T, M, A, B, C>>
+ : public IndexableTraitsSeq<small_vector<T, M, A, B, C>> {
+};
+
+} // namespace detail
+
+} // namespace folly
#pragma GCC diagnostic pop