#pragma once
#include <algorithm>
#include <array>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <exception>
#include <initializer_list>
#include <iosfwd>
#include <iterator>
#include <new>
#if __cplusplus >= 202002L
#include <ranges>
#endif
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
#if defined(_WIN32)
#include <basetsd.h>
#else
#include <sys/types.h>
#endif

namespace rust {
  inline namespace cxxbridge1 {

    struct unsafe_bitcopy_t;

    namespace {
      template <typename T> class impl;
    }

#ifndef CXXBRIDGE1_RUST_STRING
#define CXXBRIDGE1_RUST_STRING
    // https://cxx.rs/binding/string.html
    class String final {
    public:
      String() noexcept;
      String(const String &) noexcept;
      String(String &&) noexcept;
      ~String() noexcept;

      String(const std::string &);
      String(const char *);
      String(const char *, std::size_t);
      String(const char16_t *);
      String(const char16_t *, std::size_t);
#if __cplusplus >= 202002L
      String(const char8_t *s);
      String(const char8_t *s, std::size_t len);
#endif

      // Replace invalid Unicode data with the replacement character (U+FFFD).
      static String lossy(const std::string &) noexcept;
      static String lossy(const char *) noexcept;
      static String lossy(const char *, std::size_t) noexcept;
      static String lossy(const char16_t *) noexcept;
      static String lossy(const char16_t *, std::size_t) noexcept;

      String &operator=(const String &) & noexcept;
      String &operator=(String &&) & noexcept;

      explicit operator std::string() const;

      // Note: no null terminator.
      const char *data() const noexcept;
      std::size_t size() const noexcept;
      std::size_t length() const noexcept;
      bool empty() const noexcept;

      const char *c_str() noexcept;

      std::size_t capacity() const noexcept;
      void reserve(size_t new_cap) noexcept;

      using iterator = char *;
      iterator begin() noexcept;
      iterator end() noexcept;

      using const_iterator = const char *;
      const_iterator begin() const noexcept;
      const_iterator end() const noexcept;
      const_iterator cbegin() const noexcept;
      const_iterator cend() const noexcept;

      bool operator==(const String &) const noexcept;
      bool operator!=(const String &) const noexcept;
      bool operator<(const String &) const noexcept;
      bool operator<=(const String &) const noexcept;
      bool operator>(const String &) const noexcept;
      bool operator>=(const String &) const noexcept;

      void swap(String &) noexcept;

      // Internal API only intended for the cxxbridge code generator.
      String(unsafe_bitcopy_t, const String &) noexcept;

    private:
      struct lossy_t;
      String(lossy_t, const char *, std::size_t) noexcept;
      String(lossy_t, const char16_t *, std::size_t) noexcept;
      friend void swap(String &lhs, String &rhs) noexcept { lhs.swap(rhs); }

      // Size and alignment statically verified by rust_string.rs.
      std::array<std::uintptr_t, 3> repr;
    };
#endif // CXXBRIDGE1_RUST_STRING

#ifndef CXXBRIDGE1_RUST_STR
#define CXXBRIDGE1_RUST_STR
    // https://cxx.rs/binding/str.html
    class Str final {
    public:
      Str() noexcept;
      Str(const String &) noexcept;
      Str(const std::string &);
      Str(const char *);
      Str(const char *, std::size_t);

      Str &operator=(const Str &) & noexcept = default;

      explicit operator std::string() const;

      // Note: no null terminator.
      const char *data() const noexcept;
      std::size_t size() const noexcept;
      std::size_t length() const noexcept;
      bool empty() const noexcept;

      // Important in order for System V ABI to pass in registers.
      Str(const Str &) noexcept = default;
      ~Str() noexcept = default;

      using iterator = const char *;
      using const_iterator = const char *;
      const_iterator begin() const noexcept;
      const_iterator end() const noexcept;
      const_iterator cbegin() const noexcept;
      const_iterator cend() const noexcept;

      bool operator==(const Str &) const noexcept;
      bool operator!=(const Str &) const noexcept;
      bool operator<(const Str &) const noexcept;
      bool operator<=(const Str &) const noexcept;
      bool operator>(const Str &) const noexcept;
      bool operator>=(const Str &) const noexcept;

      void swap(Str &) noexcept;

    private:
      class uninit;
      Str(uninit) noexcept;
      friend impl<Str>;

      std::array<std::uintptr_t, 2> repr;
    };
#endif // CXXBRIDGE1_RUST_STR

#ifndef CXXBRIDGE1_RUST_SLICE
    namespace detail {
      template <bool> struct copy_assignable_if {};

      template <> struct copy_assignable_if<false> {
        copy_assignable_if() noexcept = default;
        copy_assignable_if(const copy_assignable_if &) noexcept = default;
        copy_assignable_if &operator=(const copy_assignable_if &) & noexcept = delete;
        copy_assignable_if &operator=(copy_assignable_if &&) & noexcept = default;
      };
    } // namespace detail

    // https://cxx.rs/binding/slice.html
    template <typename T>
    class Slice final : private detail::copy_assignable_if<std::is_const<T>::value> {
    public:
      using value_type = T;

      Slice() noexcept;
      Slice(T *, std::size_t count) noexcept;

      template <typename C> explicit Slice(C &c) : Slice(c.data(), c.size()) {}

      Slice &operator=(const Slice<T> &) & noexcept = default;
      Slice &operator=(Slice<T> &&) & noexcept = default;

      T *data() const noexcept;
      std::size_t size() const noexcept;
      std::size_t length() const noexcept;
      bool empty() const noexcept;

      T &operator[](std::size_t n) const noexcept;
      T &at(std::size_t n) const;
      T &front() const noexcept;
      T &back() const noexcept;

      // Important in order for System V ABI to pass in registers.
      Slice(const Slice<T> &) noexcept = default;
      ~Slice() noexcept = default;

      class iterator;
      iterator begin() const noexcept;
      iterator end() const noexcept;

      void swap(Slice &) noexcept;

    private:
      class uninit;
      Slice(uninit) noexcept;
      friend impl<Slice>;
      friend void sliceInit(void *, const void *, std::size_t) noexcept;
      friend void *slicePtr(const void *) noexcept;
      friend std::size_t sliceLen(const void *) noexcept;

      std::array<std::uintptr_t, 2> repr;
    };

    template <typename T> class Slice<T>::iterator final {
    public:
#if __cplusplus >= 202002L
      using iterator_category = std::contiguous_iterator_tag;
#else
      using iterator_category = std::random_access_iterator_tag;
#endif
      using value_type = T;
      using difference_type = std::ptrdiff_t;
      using pointer = typename std::add_pointer<T>::type;
      using reference = typename std::add_lvalue_reference<T>::type;

      reference operator*() const noexcept;
      pointer operator->() const noexcept;
      reference operator[](difference_type) const noexcept;

      iterator &operator++() noexcept;
      iterator operator++(int) noexcept;
      iterator &operator--() noexcept;
      iterator operator--(int) noexcept;

      iterator &operator+=(difference_type) noexcept;
      iterator &operator-=(difference_type) noexcept;
      iterator operator+(difference_type) const noexcept;
      friend inline iterator operator+(difference_type lhs, iterator rhs) noexcept {
        return rhs + lhs;
      }
      iterator operator-(difference_type) const noexcept;
      difference_type operator-(const iterator &) const noexcept;

      bool operator==(const iterator &) const noexcept;
      bool operator!=(const iterator &) const noexcept;
      bool operator<(const iterator &) const noexcept;
      bool operator<=(const iterator &) const noexcept;
      bool operator>(const iterator &) const noexcept;
      bool operator>=(const iterator &) const noexcept;

    private:
      friend class Slice;
      void *pos;
      std::size_t stride;
    };

#if __cplusplus >= 202002L
    static_assert(std::ranges::contiguous_range<rust::Slice<const uint8_t>>);
    static_assert(std::contiguous_iterator<rust::Slice<const uint8_t>::iterator>);
#endif

#endif // CXXBRIDGE1_RUST_SLICE

#ifndef CXXBRIDGE1_RUST_BOX
    // https://cxx.rs/binding/box.html
    template <typename T> class Box final {
    public:
      using element_type = T;
      using const_pointer = typename std::add_pointer<typename std::add_const<T>::type>::type;
      using pointer = typename std::add_pointer<T>::type;

      Box() = delete;
      Box(Box &&) noexcept;
      ~Box() noexcept;

      explicit Box(const T &);
      explicit Box(T &&);

      Box &operator=(Box &&) & noexcept;

      const T *operator->() const noexcept;
      const T &operator*() const noexcept;
      T *operator->() noexcept;
      T &operator*() noexcept;

      template <typename... Fields> static Box in_place(Fields &&...);

      void swap(Box &) noexcept;

      // Important: requires that `raw` came from an into_raw call. Do not pass a
      // pointer from `new` or any other source.
      static Box from_raw(T *) noexcept;

      T *into_raw() noexcept;

      /* Deprecated */ using value_type = element_type;

    private:
      class uninit;
      class allocation;
      Box(uninit) noexcept;
      void drop() noexcept;

      friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }

      T *ptr;
    };
#endif // CXXBRIDGE1_RUST_BOX

#ifndef CXXBRIDGE1_RUST_VEC
    // https://cxx.rs/binding/vec.html
    template <typename T> class Vec final {
    public:
      using value_type = T;

      Vec() noexcept;
      Vec(std::initializer_list<T>);
      Vec(const Vec &);
      Vec(Vec &&) noexcept;
      ~Vec() noexcept;

      Vec &operator=(Vec &&) & noexcept;
      Vec &operator=(const Vec &) &;

      std::size_t size() const noexcept;
      bool empty() const noexcept;
      const T *data() const noexcept;
      T *data() noexcept;
      std::size_t capacity() const noexcept;

      const T &operator[](std::size_t n) const noexcept;
      const T &at(std::size_t n) const;
      const T &front() const noexcept;
      const T &back() const noexcept;

      T &operator[](std::size_t n) noexcept;
      T &at(std::size_t n);
      T &front() noexcept;
      T &back() noexcept;

      void reserve(std::size_t new_cap);
      void push_back(const T &value);
      void push_back(T &&value);
      template <typename... Args> void emplace_back(Args &&...args);
      void truncate(std::size_t len);
      void clear();

      using iterator = typename Slice<T>::iterator;
      iterator begin() noexcept;
      iterator end() noexcept;

      using const_iterator = typename Slice<const T>::iterator;
      const_iterator begin() const noexcept;
      const_iterator end() const noexcept;
      const_iterator cbegin() const noexcept;
      const_iterator cend() const noexcept;

      void swap(Vec &) noexcept;

      // Internal API only intended for the cxxbridge code generator.
      Vec(unsafe_bitcopy_t, const Vec &) noexcept;

    private:
      void reserve_total(std::size_t new_cap) noexcept;
      void set_len(std::size_t len) noexcept;
      void drop() noexcept;

      friend void swap(Vec &lhs, Vec &rhs) noexcept { lhs.swap(rhs); }

      // Size and alignment statically verified by rust_vec.rs.
      std::array<std::uintptr_t, 3> repr;
    };
#endif // CXXBRIDGE1_RUST_VEC

#ifndef CXXBRIDGE1_RUST_FN
    // https://cxx.rs/binding/fn.html
    template <typename Signature> class Fn;

    template <typename Ret, typename... Args> class Fn<Ret(Args...)> final {
    public:
      Ret operator()(Args... args) const noexcept;
      Fn operator*() const noexcept;

    private:
      Ret (*trampoline)(Args..., void *fn) noexcept;
      void *fn;
    };
#endif // CXXBRIDGE1_RUST_FN

#ifndef CXXBRIDGE1_RUST_ERROR
#define CXXBRIDGE1_RUST_ERROR
    // https://cxx.rs/binding/result.html
    class Error final : public std::exception {
    public:
      Error(const Error &);
      Error(Error &&) noexcept;
      ~Error() noexcept override;

      Error &operator=(const Error &) &;
      Error &operator=(Error &&) & noexcept;

      const char *what() const noexcept override;

    private:
      Error() noexcept = default;
      friend impl<Error>;
      const char *msg;
      std::size_t len;
    };
#endif // CXXBRIDGE1_RUST_ERROR

#ifndef CXXBRIDGE1_RUST_ISIZE
#define CXXBRIDGE1_RUST_ISIZE
#if defined(_WIN32)
    using isize = SSIZE_T;
#else
    using isize = ssize_t;
#endif
#endif // CXXBRIDGE1_RUST_ISIZE

    std::ostream &operator<<(std::ostream &, const String &);
    std::ostream &operator<<(std::ostream &, const Str &);

#ifndef CXXBRIDGE1_RUST_OPAQUE
#define CXXBRIDGE1_RUST_OPAQUE
    // Base class of generated opaque Rust types.
    class Opaque {
    public:
      Opaque() = delete;
      Opaque(const Opaque &) = delete;
      ~Opaque() = delete;
    };
#endif // CXXBRIDGE1_RUST_OPAQUE

    template <typename T> std::size_t size_of();
    template <typename T> std::size_t align_of();

    // IsRelocatable<T> is used in assertions that a C++ type passed by value
    // between Rust and C++ is soundly relocatable by Rust.
    //
    // There may be legitimate reasons to opt out of the check for support of types
    // that the programmer knows are soundly Rust-movable despite not being
    // recognized as such by the C++ type system due to a move constructor or
    // destructor. To opt out of the relocatability check, do either of the
    // following things in any header used by `include!` in the bridge.
    //
    //      --- if you define the type:
    //      struct MyType {
    //        ...
    //    +   using IsRelocatable = std::true_type;
    //      };
    //
    //      --- otherwise:
    //    + template <>
    //    + struct rust::IsRelocatable<MyType> : std::true_type {};
    template <typename T> struct IsRelocatable;

    using u8 = std::uint8_t;
    using u16 = std::uint16_t;
    using u32 = std::uint32_t;
    using u64 = std::uint64_t;
    using usize = std::size_t; // see static asserts in cxx.cc
    using i8 = std::int8_t;
    using i16 = std::int16_t;
    using i32 = std::int32_t;
    using i64 = std::int64_t;
    using f32 = float;
    using f64 = double;

    // Snake case aliases for use in code that uses this style for type names.
    using string = String;
    using str = Str;
    template <typename T> using slice = Slice<T>;
    template <typename T> using box = Box<T>;
    template <typename T> using vec = Vec<T>;
    using error = Error;
    template <typename Signature> using fn = Fn<Signature>;
    template <typename T> using is_relocatable = IsRelocatable<T>;

    ////////////////////////////////////////////////////////////////////////////////
    /// end public API, begin implementation details

#ifndef CXXBRIDGE1_PANIC
#define CXXBRIDGE1_PANIC
    template <typename Exception> void panic [[noreturn]] (const char *msg);
#endif // CXXBRIDGE1_PANIC

#ifndef CXXBRIDGE1_RUST_FN
#define CXXBRIDGE1_RUST_FN
    template <typename Ret, typename... Args>
    Ret Fn<Ret(Args...)>::operator()(Args... args) const noexcept {
      return (*this->trampoline)(std::forward<Args>(args)..., this->fn);
    }

    template <typename Ret, typename... Args>
    Fn<Ret(Args...)> Fn<Ret(Args...)>::operator*() const noexcept {
      return *this;
    }
#endif // CXXBRIDGE1_RUST_FN

#ifndef CXXBRIDGE1_RUST_BITCOPY_T
#define CXXBRIDGE1_RUST_BITCOPY_T
    struct unsafe_bitcopy_t final {
      explicit unsafe_bitcopy_t() = default;
    };
#endif // CXXBRIDGE1_RUST_BITCOPY_T

#ifndef CXXBRIDGE1_RUST_BITCOPY
#define CXXBRIDGE1_RUST_BITCOPY
    constexpr unsafe_bitcopy_t unsafe_bitcopy{};
#endif // CXXBRIDGE1_RUST_BITCOPY

#ifndef CXXBRIDGE1_RUST_SLICE
#define CXXBRIDGE1_RUST_SLICE
    template <typename T> Slice<T>::Slice() noexcept {
      sliceInit(this, reinterpret_cast<void *>(align_of<T>()), 0);
    }

    template <typename T> Slice<T>::Slice(T *s, std::size_t count) noexcept {
      assert(s != nullptr || count == 0);
      sliceInit(this,
                s == nullptr && count == 0 ? reinterpret_cast<void *>(align_of<T>())
                                           : const_cast<typename std::remove_const<T>::type *>(s),
                count);
    }

    template <typename T> T *Slice<T>::data() const noexcept {
      return reinterpret_cast<T *>(slicePtr(this));
    }

    template <typename T> std::size_t Slice<T>::size() const noexcept { return sliceLen(this); }

    template <typename T> std::size_t Slice<T>::length() const noexcept { return this->size(); }

    template <typename T> bool Slice<T>::empty() const noexcept { return this->size() == 0; }

    template <typename T> T &Slice<T>::operator[](std::size_t n) const noexcept {
      assert(n < this->size());
      auto ptr = static_cast<char *>(slicePtr(this)) + size_of<T>() * n;
      return *reinterpret_cast<T *>(ptr);
    }

    template <typename T> T &Slice<T>::at(std::size_t n) const {
      if (n >= this->size()) {
        panic<std::out_of_range>("rust::Slice index out of range");
      }
      return (*this)[n];
    }

    template <typename T> T &Slice<T>::front() const noexcept {
      assert(!this->empty());
      return (*this)[0];
    }

    template <typename T> T &Slice<T>::back() const noexcept {
      assert(!this->empty());
      return (*this)[this->size() - 1];
    }

    template <typename T>
    typename Slice<T>::iterator::reference Slice<T>::iterator::operator*() const noexcept {
      return *static_cast<T *>(this->pos);
    }

    template <typename T>
    typename Slice<T>::iterator::pointer Slice<T>::iterator::operator->() const noexcept {
      return static_cast<T *>(this->pos);
    }

    template <typename T>
    typename Slice<T>::iterator::reference
    Slice<T>::iterator::operator[](typename Slice<T>::iterator::difference_type n) const noexcept {
      auto ptr = static_cast<char *>(this->pos) + this->stride * n;
      return *reinterpret_cast<T *>(ptr);
    }

    template <typename T> typename Slice<T>::iterator &Slice<T>::iterator::operator++() noexcept {
      this->pos = static_cast<char *>(this->pos) + this->stride;
      return *this;
    }

    template <typename T> typename Slice<T>::iterator Slice<T>::iterator::operator++(int) noexcept {
      auto ret = iterator(*this);
      this->pos = static_cast<char *>(this->pos) + this->stride;
      return ret;
    }

    template <typename T> typename Slice<T>::iterator &Slice<T>::iterator::operator--() noexcept {
      this->pos = static_cast<char *>(this->pos) - this->stride;
      return *this;
    }

    template <typename T> typename Slice<T>::iterator Slice<T>::iterator::operator--(int) noexcept {
      auto ret = iterator(*this);
      this->pos = static_cast<char *>(this->pos) - this->stride;
      return ret;
    }

    template <typename T>
    typename Slice<T>::iterator &
    Slice<T>::iterator::operator+=(typename Slice<T>::iterator::difference_type n) noexcept {
      this->pos = static_cast<char *>(this->pos) + this->stride * n;
      return *this;
    }

    template <typename T>
    typename Slice<T>::iterator &
    Slice<T>::iterator::operator-=(typename Slice<T>::iterator::difference_type n) noexcept {
      this->pos = static_cast<char *>(this->pos) - this->stride * n;
      return *this;
    }

    template <typename T>
    typename Slice<T>::iterator
    Slice<T>::iterator::operator+(typename Slice<T>::iterator::difference_type n) const noexcept {
      auto ret = iterator(*this);
      ret.pos = static_cast<char *>(this->pos) + this->stride * n;
      return ret;
    }

    template <typename T>
    typename Slice<T>::iterator
    Slice<T>::iterator::operator-(typename Slice<T>::iterator::difference_type n) const noexcept {
      auto ret = iterator(*this);
      ret.pos = static_cast<char *>(this->pos) - this->stride * n;
      return ret;
    }

    template <typename T>
    typename Slice<T>::iterator::difference_type
    Slice<T>::iterator::operator-(const iterator &other) const noexcept {
      auto diff = std::distance(static_cast<char *>(other.pos), static_cast<char *>(this->pos));
      return diff / static_cast<typename Slice<T>::iterator::difference_type>(this->stride);
    }

    template <typename T>
    bool Slice<T>::iterator::operator==(const iterator &other) const noexcept {
      return this->pos == other.pos;
    }

    template <typename T>
    bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept {
      return this->pos != other.pos;
    }

    template <typename T> bool Slice<T>::iterator::operator<(const iterator &other) const noexcept {
      return this->pos < other.pos;
    }

    template <typename T>
    bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept {
      return this->pos <= other.pos;
    }

    template <typename T> bool Slice<T>::iterator::operator>(const iterator &other) const noexcept {
      return this->pos > other.pos;
    }

    template <typename T>
    bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept {
      return this->pos >= other.pos;
    }

    template <typename T> typename Slice<T>::iterator Slice<T>::begin() const noexcept {
      iterator it;
      it.pos = slicePtr(this);
      it.stride = size_of<T>();
      return it;
    }

    template <typename T> typename Slice<T>::iterator Slice<T>::end() const noexcept {
      iterator it = this->begin();
      it.pos = static_cast<char *>(it.pos) + it.stride * this->size();
      return it;
    }

    template <typename T> void Slice<T>::swap(Slice &rhs) noexcept { std::swap(*this, rhs); }
#endif // CXXBRIDGE1_RUST_SLICE

#ifndef CXXBRIDGE1_RUST_BOX
#define CXXBRIDGE1_RUST_BOX
    template <typename T> class Box<T>::uninit {};

    template <typename T> class Box<T>::allocation {
      static T *alloc() noexcept;
      static void dealloc(T *) noexcept;

    public:
      allocation() noexcept : ptr(alloc()) {}
      ~allocation() noexcept {
        if (this->ptr) {
          dealloc(this->ptr);
        }
      }
      T *ptr;
    };

    template <typename T> Box<T>::Box(Box &&other) noexcept : ptr(other.ptr) {
      other.ptr = nullptr;
    }

    template <typename T> Box<T>::Box(const T &val) {
      allocation alloc;
      ::new (alloc.ptr) T(val);
      this->ptr = alloc.ptr;
      alloc.ptr = nullptr;
    }

    template <typename T> Box<T>::Box(T &&val) {
      allocation alloc;
      ::new (alloc.ptr) T(std::move(val));
      this->ptr = alloc.ptr;
      alloc.ptr = nullptr;
    }

    template <typename T> Box<T>::~Box() noexcept {
      if (this->ptr) {
        this->drop();
      }
    }

    template <typename T> Box<T> &Box<T>::operator=(Box &&other) & noexcept {
      if (this->ptr) {
        this->drop();
      }
      this->ptr = other.ptr;
      other.ptr = nullptr;
      return *this;
    }

    template <typename T> const T *Box<T>::operator->() const noexcept { return this->ptr; }

    template <typename T> const T &Box<T>::operator*() const noexcept { return *this->ptr; }

    template <typename T> T *Box<T>::operator->() noexcept { return this->ptr; }

    template <typename T> T &Box<T>::operator*() noexcept { return *this->ptr; }

    template <typename T>
    template <typename... Fields>
    Box<T> Box<T>::in_place(Fields &&...fields) {
      allocation alloc;
      auto ptr = alloc.ptr;
      ::new (ptr) T{std::forward<Fields>(fields)...};
      alloc.ptr = nullptr;
      return from_raw(ptr);
    }

    template <typename T> void Box<T>::swap(Box &rhs) noexcept {
      using std::swap;
      swap(this->ptr, rhs.ptr);
    }

    template <typename T> Box<T> Box<T>::from_raw(T *raw) noexcept {
      Box box = uninit{};
      box.ptr = raw;
      return box;
    }

    template <typename T> T *Box<T>::into_raw() noexcept {
      T *raw = this->ptr;
      this->ptr = nullptr;
      return raw;
    }

    template <typename T> Box<T>::Box(uninit) noexcept {}
#endif // CXXBRIDGE1_RUST_BOX

#ifndef CXXBRIDGE1_RUST_VEC
#define CXXBRIDGE1_RUST_VEC
    template <typename T> Vec<T>::Vec(std::initializer_list<T> init) : Vec{} {
      this->reserve_total(init.size());
      std::move(init.begin(), init.end(), std::back_inserter(*this));
    }

    template <typename T> Vec<T>::Vec(const Vec &other) : Vec() {
      this->reserve_total(other.size());
      std::copy(other.begin(), other.end(), std::back_inserter(*this));
    }

    template <typename T> Vec<T>::Vec(Vec &&other) noexcept : repr(other.repr) {
      new (&other) Vec();
    }

    template <typename T> Vec<T>::~Vec() noexcept { this->drop(); }

    template <typename T> Vec<T> &Vec<T>::operator=(Vec &&other) & noexcept {
      this->drop();
      this->repr = other.repr;
      new (&other) Vec();
      return *this;
    }

    template <typename T> Vec<T> &Vec<T>::operator=(const Vec &other) & {
      if (this != &other) {
        this->drop();
        new (this) Vec(other);
      }
      return *this;
    }

    template <typename T> bool Vec<T>::empty() const noexcept { return this->size() == 0; }

    template <typename T> T *Vec<T>::data() noexcept {
      return const_cast<T *>(const_cast<const Vec<T> *>(this)->data());
    }

    template <typename T> const T &Vec<T>::operator[](std::size_t n) const noexcept {
      assert(n < this->size());
      auto data = reinterpret_cast<const char *>(this->data());
      return *reinterpret_cast<const T *>(data + n * size_of<T>());
    }

    template <typename T> const T &Vec<T>::at(std::size_t n) const {
      if (n >= this->size()) {
        panic<std::out_of_range>("rust::Vec index out of range");
      }
      return (*this)[n];
    }

    template <typename T> const T &Vec<T>::front() const noexcept {
      assert(!this->empty());
      return (*this)[0];
    }

    template <typename T> const T &Vec<T>::back() const noexcept {
      assert(!this->empty());
      return (*this)[this->size() - 1];
    }

    template <typename T> T &Vec<T>::operator[](std::size_t n) noexcept {
      assert(n < this->size());
      auto data = reinterpret_cast<char *>(this->data());
      return *reinterpret_cast<T *>(data + n * size_of<T>());
    }

    template <typename T> T &Vec<T>::at(std::size_t n) {
      if (n >= this->size()) {
        panic<std::out_of_range>("rust::Vec index out of range");
      }
      return (*this)[n];
    }

    template <typename T> T &Vec<T>::front() noexcept {
      assert(!this->empty());
      return (*this)[0];
    }

    template <typename T> T &Vec<T>::back() noexcept {
      assert(!this->empty());
      return (*this)[this->size() - 1];
    }

    template <typename T> void Vec<T>::reserve(std::size_t new_cap) {
      this->reserve_total(new_cap);
    }

    template <typename T> void Vec<T>::push_back(const T &value) { this->emplace_back(value); }

    template <typename T> void Vec<T>::push_back(T &&value) {
      this->emplace_back(std::move(value));
    }

    template <typename T> template <typename... Args> void Vec<T>::emplace_back(Args &&...args) {
      auto size = this->size();
      this->reserve_total(size + 1);
      ::new (reinterpret_cast<T *>(reinterpret_cast<char *>(this->data()) + size * size_of<T>()))
          T(std::forward<Args>(args)...);
      this->set_len(size + 1);
    }

    template <typename T> void Vec<T>::clear() { this->truncate(0); }

    template <typename T> typename Vec<T>::iterator Vec<T>::begin() noexcept {
      return Slice<T>(this->data(), this->size()).begin();
    }

    template <typename T> typename Vec<T>::iterator Vec<T>::end() noexcept {
      return Slice<T>(this->data(), this->size()).end();
    }

    template <typename T> typename Vec<T>::const_iterator Vec<T>::begin() const noexcept {
      return this->cbegin();
    }

    template <typename T> typename Vec<T>::const_iterator Vec<T>::end() const noexcept {
      return this->cend();
    }

    template <typename T> typename Vec<T>::const_iterator Vec<T>::cbegin() const noexcept {
      return Slice<const T>(this->data(), this->size()).begin();
    }

    template <typename T> typename Vec<T>::const_iterator Vec<T>::cend() const noexcept {
      return Slice<const T>(this->data(), this->size()).end();
    }

    template <typename T> void Vec<T>::swap(Vec &rhs) noexcept {
      using std::swap;
      swap(this->repr, rhs.repr);
    }

    // Internal API only intended for the cxxbridge code generator.
    template <typename T>
    Vec<T>::Vec(unsafe_bitcopy_t, const Vec &bits) noexcept : repr(bits.repr) {}
#endif // CXXBRIDGE1_RUST_VEC

#ifndef CXXBRIDGE1_IS_COMPLETE
#define CXXBRIDGE1_IS_COMPLETE
    namespace detail {
      namespace {
        template <typename T, typename = std::size_t> struct is_complete : std::false_type {};
        template <typename T> struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
      } // namespace
    } // namespace detail
#endif // CXXBRIDGE1_IS_COMPLETE

#ifndef CXXBRIDGE1_LAYOUT
#define CXXBRIDGE1_LAYOUT
    class layout {
      template <typename T> friend std::size_t size_of();
      template <typename T> friend std::size_t align_of();
      template <typename T>
      static typename std::enable_if<std::is_base_of<Opaque, T>::value, std::size_t>::type
      do_size_of() {
        return T::layout::size();
      }
      template <typename T>
      static typename std::enable_if<!std::is_base_of<Opaque, T>::value, std::size_t>::type
      do_size_of() {
        return sizeof(T);
      }
      template <typename T>
      static typename std::enable_if<detail::is_complete<T>::value, std::size_t>::type size_of() {
        return do_size_of<T>();
      }
      template <typename T>
      static typename std::enable_if<std::is_base_of<Opaque, T>::value, std::size_t>::type
      do_align_of() {
        return T::layout::align();
      }
      template <typename T>
      static typename std::enable_if<!std::is_base_of<Opaque, T>::value, std::size_t>::type
      do_align_of() {
        return alignof(T);
      }
      template <typename T>
      static typename std::enable_if<detail::is_complete<T>::value, std::size_t>::type align_of() {
        return do_align_of<T>();
      }
    };

    template <typename T> std::size_t size_of() { return layout::size_of<T>(); }

    template <typename T> std::size_t align_of() { return layout::align_of<T>(); }
#endif // CXXBRIDGE1_LAYOUT

#ifndef CXXBRIDGE1_RELOCATABLE
#define CXXBRIDGE1_RELOCATABLE
    namespace detail {
      template <typename... Ts> struct make_void {
        using type = void;
      };

      template <typename... Ts> using void_t = typename make_void<Ts...>::type;

      template <typename Void, template <typename...> class, typename...>
      struct detect : std::false_type {};
      template <template <typename...> class T, typename... A>
      struct detect<void_t<T<A...>>, T, A...> : std::true_type {};

      template <template <typename...> class T, typename... A>
      using is_detected = detect<void, T, A...>;

      template <typename T> using detect_IsRelocatable = typename T::IsRelocatable;

      template <typename T>
      struct get_IsRelocatable : std::is_same<typename T::IsRelocatable, std::true_type> {};
    } // namespace detail

    template <typename T>
    struct IsRelocatable
        : std::conditional<
              detail::is_detected<detail::detect_IsRelocatable, T>::value,
              detail::get_IsRelocatable<T>,
              std::integral_constant<bool, std::is_trivially_move_constructible<T>::value &&
                                               std::is_trivially_destructible<T>::value>>::type {};
#endif // CXXBRIDGE1_RELOCATABLE

  } // namespace cxxbridge1
} // namespace rust