FTL: Make StaticVector::replace infallible

namespace android::ftl {

constexpr struct IteratorRangeTag {} IteratorRange;

// Fixed-capacity, statically allocated counterpart of std::vector. Akin to std::array, StaticVector

// allocates contiguous storage for N elements of type T at compile time, but stores at most (rather

// than exactly) N elements. Unlike std::array, its default constructor does not require T to have a

// default constructor, since elements are constructed in-place as the vector grows. Operations that

// insert an element, such as push_back and emplace, fail when the vector is full. The API otherwise

// adheres to standard containers, except the unstable_erase operation that does not shift elements,

// insert an element (emplace_back, push_back, etc.) fail when the vector is full. The API otherwise

// adheres to standard containers, except the unstable_erase operation that does not preserve order,

// and the replace operation that destructively emplaces.

//

// StaticVector<T, 1> is analogous to an iterable std::optional, but StaticVector<T, 0> is an error.

//     assert(vector == (ftl::StaticVector{'h', 'i', '\0'}));

//

template <typename T, size_t N>

class StaticVector {

class StaticVector final {

    static_assert(N > 0);

    template <typename I>

    using IsInputIterator = std::is_base_of<std::input_iterator_tag,

                                            typename std::iterator_traits<I>::iterator_category>;

    // There is ambiguity when constructing from two iterator-like elements like pointers:

    // they could be an iterator range, or arguments for in-place construction. Assume the

    // latter unless they are input iterators and cannot be used to construct elements. If

    // the former is intended, the caller can pass an IteratorRangeTag to disambiguate.

    template <typename I, typename Traits = std::iterator_traits<I>>

    using IsInputIterator = std::conjunction<

            std::is_base_of<std::input_iterator_tag, typename Traits::iterator_category>,

            std::negation<std::is_constructible<T, I>>>;

public:

    using value_type = T;

    StaticVector() = default;

    // Copies and moves a vector, respectively.

    StaticVector(const StaticVector& other) : StaticVector(other.begin(), other.end()) {}

    StaticVector(const StaticVector& other)

          : StaticVector(IteratorRange, other.begin(), other.end()) {}

    StaticVector(StaticVector&& other) { swap<Empty>(other); }

    // Copies at most N elements from a smaller convertible vector.

    template <typename U, size_t M, typename = std::enable_if_t<M <= N>>

    StaticVector(const StaticVector<U, M>& other) : StaticVector(other.begin(), other.end()) {}

    StaticVector(const StaticVector<U, M>& other)

          : StaticVector(IteratorRange, other.begin(), other.end()) {}

    // Copies at most N elements from an array.

    template <typename U, size_t M>

    explicit StaticVector(U (&array)[M]) : StaticVector(std::begin(array), std::end(array)) {}

    explicit StaticVector(U (&array)[M])

          : StaticVector(IteratorRange, std::begin(array), std::end(array)) {}

    // Copies at most N elements from the range [first, last).

    //

    // IteratorRangeTag disambiguates with initialization from two iterator-like elements.

    //

    template <typename Iterator, typename = std::enable_if_t<IsInputIterator<Iterator>{}>>

    StaticVector(Iterator first, Iterator last)

    StaticVector(Iterator first, Iterator last) : StaticVector(IteratorRange, first, last) {

        using V = typename std::iterator_traits<Iterator>::value_type;

        static_assert(std::is_constructible_v<value_type, V>, "Incompatible iterator range");

    }

    template <typename Iterator>

    StaticVector(IteratorRangeTag, Iterator first, Iterator last)

          : mSize(std::min(max_size(), static_cast<size_type>(std::distance(first, last)))) {

        std::uninitialized_copy(first, first + mSize, begin());

    }

    template <typename = void>

    void swap(StaticVector&);

    size_type max_size() const { return N; }

    static constexpr size_type max_size() { return N; }

    size_type size() const { return mSize; }

    bool empty() const { return size() == 0; }

    reference operator[](size_type i) { return *(begin() + i); }

    const_reference operator[](size_type i) const { return mut()[i]; }

    // Replaces an element, and returns an iterator to it. If the vector is full, the element is not

    // replaced, and the end iterator is returned.

    // Replaces an element, and returns a reference to it. The iterator must be dereferenceable, so

    // replacing at end() is erroneous.

    //

    // The element is emplaced via move constructor, so type T does not need to define copy/move

    // assignment, e.g. its data members may be const.

    //

    // The arguments may directly or indirectly refer to the element being replaced.

    //

    // Iterators to the replaced element point to its replacement, and others remain valid.

    //

    template <typename... Args>

    iterator replace(const_iterator cit, Args&&... args) {

        if (full()) return end();

        // Append element, and move into place if not last.

        emplace_back(std::forward<Args>(args)...);

        if (cit != last()) unstable_erase(cit);

        return const_cast<iterator>(cit);

    reference replace(const_iterator it, Args&&... args) {

        value_type element{std::forward<Args>(args)...};

        std::destroy_at(it);

        // This is only safe because exceptions are disabled.

        return *construct_at(it, std::move(element));

    }

    // Appends an element, and returns an iterator to it. If the vector is full, the element is not

    // inserted, and the end iterator is returned.

    // inserted, and the end() iterator is returned.

    //

    // On success, the end() iterator is invalidated.

    //

    template <typename... Args>

    iterator emplace_back(Args&&... args) {

        if (full()) return end();

        return it;

    }

    // Appends an element unless the vector is full, and returns whether the element was inserted.

    //

    // On success, the end() iterator is invalidated.

    //

    bool push_back(value_type v) {

        // Two statements for sequence point.

        const iterator it = emplace_back(std::move(v));

        return it != end();

    }

    // Removes the last element. The vector must not be empty, or the call is erroneous.

    //

    // The last() and end() iterators are invalidated.

    //

    void pop_back() { unstable_erase(last()); }

    // Erases an element, but does not preserve order. Rather than shifting subsequent elements,

    // this moves the last element to the slot of the erased element.

    //

    // The last() and end() iterators, as well as those to the erased element, are invalidated.

    //

    void unstable_erase(const_iterator it) {

        std::destroy_at(it);

        if (it != last()) {

            // Move last element and destroy its source for destructor side effects.

            // Move last element and destroy its source for destructor side effects. This is only

            // safe because exceptions are disabled.

            construct_at(it, std::move(back()));

            std::destroy_at(last());

        }

        --mSize;

    }

    bool push_back(value_type v) {

        // Two statements for sequence point.

        const iterator it = emplace_back(std::move(v));

        return it != end();

    }

    void pop_back() { unstable_erase(last()); }

private:

    struct Empty {};

        static_assert(std::is_same_v<decltype(vector), StaticVector<std::string, 3>>);

        EXPECT_EQ(vector, (StaticVector{"red"s, "velvet"s, "cake"s}));

    }

    {

        struct String {

            explicit String(const char* str) : str(str) {}

            explicit String(const char** ptr) : str(*ptr) {}

            const char* str;

        };

        const char* kStrings[] = {"a", "b", "c", "d"};

        {

            // Two iterator-like elements.

            StaticVector<String, 3> vector(kStrings, kStrings + 3);

            ASSERT_EQ(vector.size(), 2u);

            EXPECT_STREQ(vector[0].str, "a");

            EXPECT_STREQ(vector[1].str, "d");

        }

        {

            // Disambiguating iterator constructor.

            StaticVector<String, 3> vector(ftl::IteratorRange, kStrings, kStrings + 3);

            ASSERT_EQ(vector.size(), 3u);

            EXPECT_STREQ(vector[0].str, "a");

            EXPECT_STREQ(vector[1].str, "b");

            EXPECT_STREQ(vector[2].str, "c");

        }

    }

}

TEST(StaticVector, String) {

    EXPECT_EQ(string.size(), 7u);

    // Similar to emplace, but replaces rather than inserts.

    const auto it = string.replace(string.begin() + 5, '\0');

    EXPECT_NE(it, string.end());

    string.replace(string.begin() + 5, '\0');

    EXPECT_STREQ(string.begin(), "12345");

    swap(chars, string);

        ASSERT_FALSE(rit == strings.rend());

        std::initializer_list<char> list = {'t', 'a', 'r', 't'};

        const auto it = strings.replace(rit.base() - 1, list);

        EXPECT_NE(it, strings.end());

        strings.replace(rit.base() - 1, list);

    }

    strings.front().assign("pie");

    EXPECT_EQ(strings, (StaticVector{"pie"s, "quince"s, "tart"s, "red"s, "velvet"s, "cake"s}));

}

TEST(StaticVector, Replace) {

    // Replacing does not require a copy/move assignment operator.

    struct Word {

        explicit Word(std::string str) : str(std::move(str)) {}

        const std::string str;

    };

    StaticVector words(std::in_place_type<Word>, "red", "velour", "cake");

    // The replaced element can be referenced by the replacement.

    const auto it = words.begin() + 1;

    const Word& word = words.replace(it, it->str.substr(0, 3) + "vet");

    EXPECT_EQ(word.str, "velvet");

}

TEST(StaticVector, ReverseTruncate) {

    StaticVector<std::string, 10> strings("pie", "quince", "tart", "red", "velvet", "cake");

    EXPECT_FALSE(strings.full());

    EXPECT_LT(sorted, strings);

    // Append remaining elements, such that "pie" is the only difference.

    sorted.replace(sorted.end(), "quince");

    for (const char* str : {"red", "tart", "velvet"}) sorted.emplace_back(str);

    for (const char* str : {"quince", "red", "tart", "velvet"}) {

        sorted.emplace_back(str);

    }

    EXPECT_NE(sorted, strings);

    sorted.replace(sorted.begin() + 1, "pie");

    // Replace second element with "pie".

    const auto it = sorted.begin() + 1;

    EXPECT_EQ(sorted.replace(it, 'p' + it->substr(1)), "pie");

    EXPECT_EQ(sorted, strings);

}