mpd/src/util/AllocatedArray.hxx

247 lines
5.9 KiB
C++
Raw Normal View History

2016-04-12 21:30:44 +02:00
/*
* Copyright 2010-2019 Max Kellermann <max.kellermann@gmail.com>
2016-04-12 21:30:44 +02:00
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef ALLOCATED_ARRAY_HXX
#define ALLOCATED_ARRAY_HXX
#include "ConstBuffer.hxx"
2016-04-12 21:30:44 +02:00
#include "WritableBuffer.hxx"
#include "Compiler.h"
#include <algorithm>
#include <cassert>
2016-04-12 21:30:44 +02:00
/**
* An array allocated on the heap with a length determined at runtime.
*/
template<class T>
class AllocatedArray {
typedef WritableBuffer<T> Buffer;
public:
using size_type = typename Buffer::size_type;
using reference = typename Buffer::reference;
using const_reference = typename Buffer::const_reference;
using iterator = typename Buffer::iterator;
using const_iterator = typename Buffer::const_iterator;
2016-04-12 21:30:44 +02:00
protected:
Buffer buffer{nullptr};
public:
constexpr AllocatedArray() = default;
2018-12-28 17:17:28 +01:00
explicit AllocatedArray(size_type _size) noexcept
:buffer{new T[_size], _size} {}
2016-04-12 21:30:44 +02:00
explicit AllocatedArray(ConstBuffer<T> src) noexcept {
if (src == nullptr)
return;
buffer = {new T[src.size], src.size};
std::copy_n(src.data, src.size, buffer.data);
2016-04-12 21:30:44 +02:00
}
explicit AllocatedArray(const AllocatedArray &other) noexcept
:AllocatedArray(other.buffer) {}
2018-12-28 17:17:28 +01:00
AllocatedArray(AllocatedArray &&other) noexcept
:buffer(std::exchange(other.buffer, nullptr)) {}
2016-04-12 21:30:44 +02:00
2018-12-28 17:17:28 +01:00
~AllocatedArray() noexcept {
2016-04-12 21:30:44 +02:00
delete[] buffer.data;
}
AllocatedArray &operator=(ConstBuffer<T> src) noexcept {
assert(size() == 0 || buffer.data != nullptr);
assert(src.size == 0 || src.data != nullptr);
ResizeDiscard(src.size);
std::copy_n(src.data, src.size, buffer.data);
return *this;
}
2018-12-28 17:17:28 +01:00
AllocatedArray &operator=(const AllocatedArray &other) noexcept {
2016-04-12 21:30:44 +02:00
assert(size() == 0 || buffer.data != nullptr);
assert(other.size() == 0 || other.buffer.data != nullptr);
if (&other == this)
return *this;
ResizeDiscard(other.size());
std::copy_n(other.buffer.data, other.buffer.size, buffer.data);
return *this;
}
2018-12-28 17:17:28 +01:00
AllocatedArray &operator=(AllocatedArray &&other) noexcept {
2018-12-28 17:18:41 +01:00
using std::swap;
swap(buffer, other.buffer);
2016-04-12 21:30:44 +02:00
return *this;
}
operator ConstBuffer<T>() const noexcept {
return buffer;
}
operator WritableBuffer<T>() noexcept {
return buffer;
}
2018-12-28 17:17:28 +01:00
constexpr bool IsNull() const noexcept {
2016-04-12 21:30:44 +02:00
return buffer.IsNull();
}
2018-12-28 17:17:28 +01:00
constexpr bool operator==(std::nullptr_t) const noexcept {
return buffer == nullptr;
}
2018-12-28 17:17:28 +01:00
constexpr bool operator!=(std::nullptr_t) const noexcept {
return buffer != nullptr;
}
2016-04-12 21:30:44 +02:00
/**
* Returns true if no memory was allocated so far.
*/
2018-12-28 17:17:28 +01:00
constexpr bool empty() const noexcept {
return buffer.empty();
2016-04-12 21:30:44 +02:00
}
/**
* Returns the number of allocated elements.
*/
2018-12-28 17:17:28 +01:00
constexpr size_type size() const noexcept {
2016-04-12 21:30:44 +02:00
return buffer.size;
}
/**
* Returns the number of allocated elements.
*/
constexpr size_type capacity() const noexcept {
return buffer.size;
}
reference front() noexcept {
2016-04-12 21:30:44 +02:00
return buffer.front();
}
const_reference front() const noexcept {
2016-04-12 21:30:44 +02:00
return buffer.front();
}
reference back() noexcept {
2016-04-12 21:30:44 +02:00
return buffer.back();
}
const_reference back() const noexcept {
2016-04-12 21:30:44 +02:00
return buffer.back();
}
/**
* Returns one element. No bounds checking.
*/
reference operator[](size_type i) noexcept {
return buffer[i];
2016-04-12 21:30:44 +02:00
}
/**
* Returns one constant element. No bounds checking.
*/
const_reference operator[](size_type i) const noexcept {
return buffer[i];
2016-04-12 21:30:44 +02:00
}
2018-12-28 17:17:28 +01:00
iterator begin() noexcept {
2016-04-12 21:30:44 +02:00
return buffer.begin();
}
2018-12-28 17:17:28 +01:00
constexpr const_iterator begin() const noexcept {
2016-04-12 21:30:44 +02:00
return buffer.cbegin();
}
2018-12-28 17:17:28 +01:00
iterator end() noexcept {
2016-04-12 21:30:44 +02:00
return buffer.end();
}
2018-12-28 17:17:28 +01:00
constexpr const_iterator end() const noexcept {
2016-04-12 21:30:44 +02:00
return buffer.cend();
}
/**
* Resizes the array, discarding old data.
*/
2018-12-28 17:17:28 +01:00
void ResizeDiscard(size_type _size) noexcept {
2016-04-12 21:30:44 +02:00
if (_size == buffer.size)
return;
delete[] buffer.data;
buffer.size = _size;
buffer.data = new T[buffer.size];
}
/**
* Grows the array to the specified size, discarding old data.
* Similar to ResizeDiscard(), but will never shrink the array to
* avoid expensive heap operations.
*/
2018-12-28 17:17:28 +01:00
void GrowDiscard(size_type _size) noexcept {
2016-04-12 21:30:44 +02:00
if (_size > buffer.size)
ResizeDiscard(_size);
}
/**
* Grows the array to the specified size, preserving the value of a
* range of elements, starting from the beginning.
*/
2018-12-28 17:17:28 +01:00
void GrowPreserve(size_type _size, size_type preserve) noexcept {
2016-04-12 21:30:44 +02:00
if (_size <= buffer.size)
return;
T *new_data = new T[_size];
std::move(buffer.data, buffer.data + preserve, new_data);
delete[] buffer.data;
buffer.data = new_data;
buffer.size = _size;
}
/**
* Declare that the buffer has the specified size. Must not be
* larger than the current size. Excess elements are not used (but
* they are still allocated).
*/
2018-12-28 17:17:28 +01:00
void SetSize(size_type _size) noexcept {
2016-04-12 21:30:44 +02:00
assert(_size <= buffer.size);
buffer.size = _size;
}
};
#endif