Class SmallVectorTemplate

Sources/Shared/Containers/SmallVector.h:356–463

	template<typename T, bool = std::is_trivially_copy_constructible<T>::value &&
		std::is_trivially_move_constructible<T>::value && std::is_trivially_destructible<T>::value>
	class SmallVectorTemplate : public SmallVectorTemplateCommon<T>
	{
		friend class SmallVectorTemplateCommon<T>;

	protected:
		/** @brief Whether it's cheap enough to take parameters by value, always `false` for non-trivial types */
		static constexpr bool TakesParamByValue = false;
		/** @brief Either `const T&` or `T`, depending on whether it's cheap enough to take parameters by value, always `const T&` for non-trivial types */
		using ValueParamT = const T&;

		SmallVectorTemplate(std::size_t size) : SmallVectorTemplateCommon<T>(size) {}

		/** @brief Calls destructor on every element in the specified range if needed */
		static void destroyRange(T* s, T* e) {
			while (s != e) {
				--e;
				e->~T();
			}
		}

		/** @brief Moves the range [I, E) into the uninitialized memory starting with @p dest, constructing elements as needed */
		template<typename It1, typename It2>
		static void uninitializedMove(It1 i, It1 e, It2 dest) {
			std::uninitialized_move(i, e, dest);
		}

		/** @brief Copies the range [I, E) onto the uninitialized memory starting with @p dest, constructing elements as needed */
		template<typename It1, typename It2>
		static void uninitializedCopy(It1 i, It1 e, It2 dest) {
			std::uninitialized_copy(i, e, dest);
		}

		/** @brief Grows the allocated memory (without initializing new elements), doubling the size of the allocated memory */
		void grow(std::size_t minSize = 0);

		/** @brief Creates a new allocation big enough for @p minSize and pass back its size in @p newCapacity */
		T* mallocForGrow(std::size_t minSize, std::size_t& newCapacity);

		/** @brief Move existing elements over to the new allocation @p newElts */
		void moveElementsForGrow(T* newElts);

		/** @brief Transfers ownership of the allocation */
		void takeAllocationForGrow(T* newElts, std::size_t newCapacity);

		/** @brief Reserves enough space to add one element, and returns the updated element pointer in case it was a reference to the storage */
		const T* reserveForParamAndGetAddress(const T& elt, std::size_t n = 1) {
			return this->reserveForParamAndGetAddressImpl(this, elt, n);
		}

		/** @overload */
		T* reserveForParamAndGetAddress(T& elt, std::size_t n = 1) {
			return const_cast<T*>(
				this->reserveForParamAndGetAddressImpl(this, elt, n));
		}

		/** @brief Forwards a value */
		static T&& forwardValueParam(T&& v) {
			return Death::move(v);