RPM build fix (reverted CI changes which will need to be un-reverted or made conditional) and vendor Rust dependencies to make builds much faster in any CI system.

zeroidc/vendor/cbindgen/tests/expectations/transform_op.cpp

@@ -0,0 +1,393 @@
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+#include <cassert>
+
+template<typename T>
+struct StylePoint {
+  T x;
+  T y;
+};
+
+template<typename T>
+union StyleFoo {
+  enum class Tag : uint8_t {
+    Foo,
+    Bar,
+    Baz,
+    Bazz,
+  };
+
+  struct Foo_Body {
+    Tag tag;
+    int32_t x;
+    StylePoint<T> y;
+    StylePoint<float> z;
+  };
+
+  struct Bar_Body {
+    Tag tag;
+    T _0;
+  };
+
+  struct Baz_Body {
+    Tag tag;
+    StylePoint<T> _0;
+  };
+
+  struct {
+    Tag tag;
+  };
+  Foo_Body foo;
+  Bar_Body bar;
+  Baz_Body baz;
+
+  static StyleFoo Foo(const int32_t &x,
+                      const StylePoint<T> &y,
+                      const StylePoint<float> &z) {
+    StyleFoo result;
+    ::new (&result.foo.x) (int32_t)(x);
+    ::new (&result.foo.y) (StylePoint<T>)(y);
+    ::new (&result.foo.z) (StylePoint<float>)(z);
+    result.tag = Tag::Foo;
+    return result;
+  }
+
+  bool IsFoo() const {
+    return tag == Tag::Foo;
+  }
+
+  const Foo_Body& AsFoo() const {
+    assert(IsFoo());
+    return foo;
+  }
+
+  Foo_Body& AsFoo() {
+    assert(IsFoo());
+    return foo;
+  }
+
+  static StyleFoo Bar(const T &_0) {
+    StyleFoo result;
+    ::new (&result.bar._0) (T)(_0);
+    result.tag = Tag::Bar;
+    return result;
+  }
+
+  bool IsBar() const {
+    return tag == Tag::Bar;
+  }
+
+  const T& AsBar() const {
+    assert(IsBar());
+    return bar._0;
+  }
+
+  T& AsBar() {
+    assert(IsBar());
+    return bar._0;
+  }
+
+  static StyleFoo Baz(const StylePoint<T> &_0) {
+    StyleFoo result;
+    ::new (&result.baz._0) (StylePoint<T>)(_0);
+    result.tag = Tag::Baz;
+    return result;
+  }
+
+  bool IsBaz() const {
+    return tag == Tag::Baz;
+  }
+
+  const StylePoint<T>& AsBaz() const {
+    assert(IsBaz());
+    return baz._0;
+  }
+
+  StylePoint<T>& AsBaz() {
+    assert(IsBaz());
+    return baz._0;
+  }
+
+  static StyleFoo Bazz() {
+    StyleFoo result;
+    result.tag = Tag::Bazz;
+    return result;
+  }
+
+  bool IsBazz() const {
+    return tag == Tag::Bazz;
+  }
+};
+
+template<typename T>
+struct StyleBar {
+  enum class Tag {
+    Bar1,
+    Bar2,
+    Bar3,
+    Bar4,
+  };
+
+  struct StyleBar1_Body {
+    int32_t x;
+    StylePoint<T> y;
+    StylePoint<float> z;
+    int32_t (*u)(int32_t);
+  };
+
+  struct StyleBar2_Body {
+    T _0;
+  };
+
+  struct StyleBar3_Body {
+    StylePoint<T> _0;
+  };
+
+  Tag tag;
+  union {
+    StyleBar1_Body bar1;
+    StyleBar2_Body bar2;
+    StyleBar3_Body bar3;
+  };
+
+  static StyleBar Bar1(const int32_t &x,
+                       const StylePoint<T> &y,
+                       const StylePoint<float> &z,
+                       int32_t (*&u)(int32_t)) {
+    StyleBar result;
+    ::new (&result.bar1.x) (int32_t)(x);
+    ::new (&result.bar1.y) (StylePoint<T>)(y);
+    ::new (&result.bar1.z) (StylePoint<float>)(z);
+    ::new (&result.bar1.u) (int32_t(*)(int32_t))(u);
+    result.tag = Tag::Bar1;
+    return result;
+  }
+
+  bool IsBar1() const {
+    return tag == Tag::Bar1;
+  }
+
+  const StyleBar1_Body& AsBar1() const {
+    assert(IsBar1());
+    return bar1;
+  }
+
+  StyleBar1_Body& AsBar1() {
+    assert(IsBar1());
+    return bar1;
+  }
+
+  static StyleBar Bar2(const T &_0) {
+    StyleBar result;
+    ::new (&result.bar2._0) (T)(_0);
+    result.tag = Tag::Bar2;
+    return result;
+  }
+
+  bool IsBar2() const {
+    return tag == Tag::Bar2;
+  }
+
+  const T& AsBar2() const {
+    assert(IsBar2());
+    return bar2._0;
+  }
+
+  T& AsBar2() {
+    assert(IsBar2());
+    return bar2._0;
+  }
+
+  static StyleBar Bar3(const StylePoint<T> &_0) {
+    StyleBar result;
+    ::new (&result.bar3._0) (StylePoint<T>)(_0);
+    result.tag = Tag::Bar3;
+    return result;
+  }
+
+  bool IsBar3() const {
+    return tag == Tag::Bar3;
+  }
+
+  const StylePoint<T>& AsBar3() const {
+    assert(IsBar3());
+    return bar3._0;
+  }
+
+  StylePoint<T>& AsBar3() {
+    assert(IsBar3());
+    return bar3._0;
+  }
+
+  static StyleBar Bar4() {
+    StyleBar result;
+    result.tag = Tag::Bar4;
+    return result;
+  }
+
+  bool IsBar4() const {
+    return tag == Tag::Bar4;
+  }
+};
+
+union StyleBaz {
+  enum class Tag : uint8_t {
+    Baz1,
+    Baz2,
+    Baz3,
+  };
+
+  struct Baz1_Body {
+    Tag tag;
+    StyleBar<uint32_t> _0;
+  };
+
+  struct Baz2_Body {
+    Tag tag;
+    StylePoint<int32_t> _0;
+  };
+
+  struct {
+    Tag tag;
+  };
+  Baz1_Body baz1;
+  Baz2_Body baz2;
+
+  static StyleBaz Baz1(const StyleBar<uint32_t> &_0) {
+    StyleBaz result;
+    ::new (&result.baz1._0) (StyleBar<uint32_t>)(_0);
+    result.tag = Tag::Baz1;
+    return result;
+  }
+
+  bool IsBaz1() const {
+    return tag == Tag::Baz1;
+  }
+
+  const StyleBar<uint32_t>& AsBaz1() const {
+    assert(IsBaz1());
+    return baz1._0;
+  }
+
+  StyleBar<uint32_t>& AsBaz1() {
+    assert(IsBaz1());
+    return baz1._0;
+  }
+
+  static StyleBaz Baz2(const StylePoint<int32_t> &_0) {
+    StyleBaz result;
+    ::new (&result.baz2._0) (StylePoint<int32_t>)(_0);
+    result.tag = Tag::Baz2;
+    return result;
+  }
+
+  bool IsBaz2() const {
+    return tag == Tag::Baz2;
+  }
+
+  const StylePoint<int32_t>& AsBaz2() const {
+    assert(IsBaz2());
+    return baz2._0;
+  }
+
+  StylePoint<int32_t>& AsBaz2() {
+    assert(IsBaz2());
+    return baz2._0;
+  }
+
+  static StyleBaz Baz3() {
+    StyleBaz result;
+    result.tag = Tag::Baz3;
+    return result;
+  }
+
+  bool IsBaz3() const {
+    return tag == Tag::Baz3;
+  }
+};
+
+struct StyleTaz {
+  enum class Tag : uint8_t {
+    Taz1,
+    Taz2,
+    Taz3,
+  };
+
+  struct StyleTaz1_Body {
+    StyleBar<uint32_t> _0;
+  };
+
+  struct StyleTaz2_Body {
+    StyleBaz _0;
+  };
+
+  Tag tag;
+  union {
+    StyleTaz1_Body taz1;
+    StyleTaz2_Body taz2;
+  };
+
+  static StyleTaz Taz1(const StyleBar<uint32_t> &_0) {
+    StyleTaz result;
+    ::new (&result.taz1._0) (StyleBar<uint32_t>)(_0);
+    result.tag = Tag::Taz1;
+    return result;
+  }
+
+  bool IsTaz1() const {
+    return tag == Tag::Taz1;
+  }
+
+  const StyleBar<uint32_t>& AsTaz1() const {
+    assert(IsTaz1());
+    return taz1._0;
+  }
+
+  StyleBar<uint32_t>& AsTaz1() {
+    assert(IsTaz1());
+    return taz1._0;
+  }
+
+  static StyleTaz Taz2(const StyleBaz &_0) {
+    StyleTaz result;
+    ::new (&result.taz2._0) (StyleBaz)(_0);
+    result.tag = Tag::Taz2;
+    return result;
+  }
+
+  bool IsTaz2() const {
+    return tag == Tag::Taz2;
+  }
+
+  const StyleBaz& AsTaz2() const {
+    assert(IsTaz2());
+    return taz2._0;
+  }
+
+  StyleBaz& AsTaz2() {
+    assert(IsTaz2());
+    return taz2._0;
+  }
+
+  static StyleTaz Taz3() {
+    StyleTaz result;
+    result.tag = Tag::Taz3;
+    return result;
+  }
+
+  bool IsTaz3() const {
+    return tag == Tag::Taz3;
+  }
+};
+
+extern "C" {
+
+void foo(const StyleFoo<int32_t> *foo,
+         const StyleBar<int32_t> *bar,
+         const StyleBaz *baz,
+         const StyleTaz *taz);
+
+} // extern "C"