[go: up one dir, main page]

cxx 0.1.2

Safe interop between Rust and C++
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

#pragma once
#include <array>
#include <cstdint>
#include <iostream>
#include <string>

namespace cxxbridge01 {

class RustString final {
public:
  RustString() noexcept;
  RustString(const RustString &other) noexcept;
  RustString(RustString &&other) noexcept;
  RustString(const char *s);
  RustString(const std::string &s);
  RustString &operator=(const RustString &other) noexcept;
  RustString &operator=(RustString &&other) noexcept;
  ~RustString() noexcept;
  operator std::string() const;

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

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

class RustStr final {
public:
  RustStr() noexcept;
  RustStr(const char *s);
  RustStr(const std::string &s);
  RustStr(std::string &&s) = delete;
  RustStr(const RustStr &other) noexcept;
  RustStr &operator=(RustStr other) noexcept;
  operator std::string() const;

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

  // Repr is PRIVATE; must not be used other than by our generated code.
  //
  // Not necessarily ABI compatible with &str. Codegen will translate to
  // cxx::rust_str::RustStr which matches this layout.
  struct Repr {
    const char *ptr;
    size_t len;
  };
  RustStr(Repr repr) noexcept;
  operator Repr() noexcept;

private:
  Repr repr;
};

#ifndef CXXBRIDGE01_RUST_BOX
#define CXXBRIDGE01_RUST_BOX
template <typename T> class RustBox final {
public:
  RustBox(const RustBox &other) : RustBox(*other) {}
  RustBox(RustBox &&other) noexcept : repr(other.repr) { other.repr = 0; }
  RustBox(const T &val) {
    this->uninit();
    new (this->deref_mut()) T(val);
  }
  RustBox &operator=(const RustBox &other) {
    if (this != &other) {
      if (this->repr) {
        **this = *other;
      } else {
        this->uninit();
        new (this->deref_mut()) T(*other);
      }
    }
    return *this;
  }
  RustBox &operator=(RustBox &&other) noexcept {
    if (this->repr) {
      this->drop();
    }
    this->repr = other.repr;
    other.repr = 0;
    return *this;
  }
  ~RustBox() noexcept {
    if (this->repr) {
      this->drop();
    }
  }

  const T *operator->() const noexcept { return this->deref(); }
  const T &operator*() const noexcept { return *this->deref(); }
  T *operator->() noexcept { return this->deref_mut(); }
  T &operator*() noexcept { return *this->deref_mut(); }

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

  T *into_raw() noexcept {
    T *raw = this->deref_mut();
    this->repr = 0;
    return raw;
  }

private:
  RustBox() noexcept {}
  void uninit() noexcept;
  void set_raw(T *) noexcept;
  T *get_raw() noexcept;
  void drop() noexcept;
  const T *deref() const noexcept;
  T *deref_mut() noexcept;
  uintptr_t repr;
};
#endif // CXXBRIDGE01_RUST_BOX

std::ostream &operator<<(std::ostream &os, const RustString &s);
std::ostream &operator<<(std::ostream &os, const RustStr &s);

} // namespace cxxbridge01

namespace cxxbridge = cxxbridge01;