chromium/out/Default/gen/components/qr_code_generator/qr_code_generator_ffi_glue.rs.cc

#include "components/qr_code_generator/error.h"
#include <array>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <iterator>
#include <stdexcept>
#include <type_traits>
#include <vector>

namespace rust {
inline namespace cxxbridge1 {
// #include "rust/cxx.h"

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

namespace {
template <typename T>
class impl;
} // namespace

class Opaque;

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

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

template <>
struct copy_assignable_if<false> { … };
} // namespace detail

template <typename T>
class Slice final
    : private detail::copy_assignable_if<std::is_const<T>::value> { … };

template <typename T>
class Slice<T>::iterator final { … };

template <typename T>
Slice<T>::Slice() noexcept { … }

template <typename T>
Slice<T>::Slice(T *s, std::size_t count) noexcept { … }

template <typename T>
T *Slice<T>::data() const noexcept { … }

template <typename T>
std::size_t Slice<T>::size() const noexcept { … }

template <typename T>
std::size_t Slice<T>::length() const noexcept { … }

template <typename T>
bool Slice<T>::empty() const noexcept { … }

template <typename T>
T &Slice<T>::operator[](std::size_t n) const noexcept { … }

template <typename T>
T &Slice<T>::at(std::size_t n) const { … }

template <typename T>
T &Slice<T>::front() const noexcept { … }

template <typename T>
T &Slice<T>::back() const noexcept { … }

template <typename T>
typename Slice<T>::iterator::reference
Slice<T>::iterator::operator*() const noexcept { … }

template <typename T>
typename Slice<T>::iterator::pointer
Slice<T>::iterator::operator->() const noexcept { … }

template <typename T>
typename Slice<T>::iterator::reference Slice<T>::iterator::operator[](
    typename Slice<T>::iterator::difference_type n) const noexcept { … }

template <typename T>
typename Slice<T>::iterator &Slice<T>::iterator::operator++() noexcept { … }

template <typename T>
typename Slice<T>::iterator Slice<T>::iterator::operator++(int) noexcept { … }

template <typename T>
typename Slice<T>::iterator &Slice<T>::iterator::operator--() noexcept { … }

template <typename T>
typename Slice<T>::iterator Slice<T>::iterator::operator--(int) noexcept { … }

template <typename T>
typename Slice<T>::iterator &Slice<T>::iterator::operator+=(
    typename Slice<T>::iterator::difference_type n) noexcept { … }

template <typename T>
typename Slice<T>::iterator &Slice<T>::iterator::operator-=(
    typename Slice<T>::iterator::difference_type n) noexcept { … }

template <typename T>
typename Slice<T>::iterator Slice<T>::iterator::operator+(
    typename Slice<T>::iterator::difference_type n) const noexcept { … }

template <typename T>
typename Slice<T>::iterator Slice<T>::iterator::operator-(
    typename Slice<T>::iterator::difference_type n) const noexcept { … }

template <typename T>
typename Slice<T>::iterator::difference_type
Slice<T>::iterator::operator-(const iterator &other) const noexcept { … }

template <typename T>
bool Slice<T>::iterator::operator==(const iterator &other) const noexcept { … }

template <typename T>
bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept { … }

template <typename T>
bool Slice<T>::iterator::operator<(const iterator &other) const noexcept { … }

template <typename T>
bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept { … }

template <typename T>
bool Slice<T>::iterator::operator>(const iterator &other) const noexcept { … }

template <typename T>
bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept { … }

template <typename T>
typename Slice<T>::iterator Slice<T>::begin() const noexcept { … }

template <typename T>
typename Slice<T>::iterator Slice<T>::end() const noexcept { … }

template <typename T>
void Slice<T>::swap(Slice &rhs) noexcept { … }
#endif // CXXBRIDGE1_RUST_SLICE

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

#ifndef CXXBRIDGE1_LAYOUT
#define CXXBRIDGE1_LAYOUT
class layout { … };

template <typename T>
std::size_t size_of() { … }

template <typename T>
std::size_t align_of() { … }
#endif // CXXBRIDGE1_LAYOUT
} // namespace cxxbridge1
} // namespace rust

namespace qr_code_generator {
  Error;
}

namespace qr_code_generator {
static_assert …;
static_assert …;
static_assert …;
static_assert …;

extern "C" {
bool qr_code_generator$cxxbridge1$generate_qr_code_using_rust(::rust::Slice<::std::uint8_t const> data, ::std::int16_t min_version, ::std::vector<::std::uint8_t> &out_pixels, ::std::size_t &out_qr_size, ::qr_code_generator::Error &out_error) noexcept;
} // extern "C"

__attribute__((visibility("default"))) bool generate_qr_code_using_rust(::rust::Slice<::std::uint8_t const> data, ::std::int16_t min_version, ::std::vector<::std::uint8_t> &out_pixels, ::std::size_t &out_qr_size, ::qr_code_generator::Error &out_error) noexcept { … }
} // namespace qr_code_generator