diff options
Diffstat (limited to 'tests/embind/embind_test.cpp')
| -rw-r--r-- | tests/embind/embind_test.cpp | 4290 |
1 files changed, 2176 insertions, 2114 deletions
diff --git a/tests/embind/embind_test.cpp b/tests/embind/embind_test.cpp index f2359955..23761efc 100644 --- a/tests/embind/embind_test.cpp +++ b/tests/embind/embind_test.cpp @@ -1,2114 +1,2176 @@ -#include <string>
-#include <malloc.h>
-#include <functional>
-#include <emscripten/bind.h>
-
-using namespace emscripten;
-
-val emval_test_mallinfo() {
- const auto& i = mallinfo();
- val rv(val::object());
- rv.set("arena", val(i.arena));
- rv.set("ordblks", val(i.ordblks));
- rv.set("smblks", val(i.smblks));
- rv.set("hblks", val(i.hblks));
- rv.set("usmblks", val(i.usmblks));
- rv.set("fsmblks", val(i.fsmblks));
- rv.set("uordblks", val(i.uordblks));
- rv.set("fordblks", val(i.fordblks));
- rv.set("keepcost", val(i.keepcost));
- return rv;
-}
-
-val emval_test_new_integer() {
- return val(15);
-}
-
-val emval_test_new_string() {
- return val("Hello everyone");
-}
-
-std::string emval_test_get_string_from_val(val v) {
- return v["key"].as<std::string>();
-}
-
-val emval_test_new_object() {
- val rv(val::object());
- rv.set("foo", val("bar"));
- rv.set("baz", val(1));
- return rv;
-}
-
-unsigned emval_test_passthrough_unsigned(unsigned v) {
- return v;
-}
-
-val emval_test_passthrough(val v) {
- return v;
-}
-
-void emval_test_return_void() {
-}
-
-bool emval_test_not(bool b) {
- return !b;
-}
-
-unsigned emval_test_as_unsigned(val v) {
- return v.as<unsigned>();
-}
-
-unsigned emval_test_get_length(val v) {
- return v["length"].as<unsigned>();
-}
-
-double emval_test_add(char c, signed char sc, unsigned char uc, signed short ss, unsigned short us, signed int si, unsigned int ui, signed long sl, unsigned long ul, float f, double d) {
- return c + sc + uc + ss + us + si + ui + sl + ul + f + d;
-}
-
-float const_ref_adder(const int& i, const float& f) {
- return i + f;
-}
-
-unsigned emval_test_sum(val v) {
- unsigned length = v["length"].as<unsigned>();
- double rv = 0;
- for (unsigned i = 0; i < length; ++i) {
- rv += v[i].as<double>();
- }
- return rv;
-}
-
-std::string get_non_ascii_string() {
- char c[128 + 1];
- c[128] = 0;
- for (int i = 0; i < 128; ++i) {
- c[i] = 128 + i;
- }
- return c;
-}
-
-std::wstring get_non_ascii_wstring() {
- std::wstring ws(4, 0);
- ws[0] = 10;
- ws[1] = 1234;
- ws[2] = 2345;
- ws[3] = 65535;
- return ws;
-}
-
-std::string emval_test_take_and_return_const_char_star(const char* str) {
- return str;
-}
-
-std::string emval_test_take_and_return_std_string(std::string str) {
- return str;
-}
-
-std::string emval_test_take_and_return_std_string_const_ref(const std::string& str) {
- return str;
-}
-
-std::wstring take_and_return_std_wstring(std::wstring str) {
- return str;
-}
-
-std::function<std::string (std::string)> emval_test_get_function_ptr() {
- return emval_test_take_and_return_std_string;
-}
-
-std::string emval_test_take_and_call_functor(std::function<std::string(std::string)> func) {
- return func("asdf");
-}
-
-class ValHolder {
-public:
- ValHolder(val v)
- : v_(v)
- {}
-
- val getVal() const {
- return v_;
- }
-
- val getValNonConst() {
- return v_;
- }
-
- const val getConstVal() const {
- return v_;
- }
-
- const val& getValConstRef() const {
- return v_;
- }
-
- void setVal(val v) {
- this->v_ = v;
- }
-
- static int some_class_method(int i) {
- return i;
- }
-
- static const ValHolder* makeConst(val v) {
- return new ValHolder(v);
- }
-
- static ValHolder makeValHolder(val v) {
- return ValHolder(v);
- }
-
- static void set_via_raw_pointer(ValHolder* vh, val v) {
- vh->setVal(v);
- }
-
- static val get_via_raw_pointer(const ValHolder* vh) {
- return vh->getVal();
- }
-
- static void transfer_via_raw_pointer(ValHolder* target, const ValHolder* source) {
- target->setVal(source->getVal());
- }
-
- static val getValNonMember(const ValHolder& target) {
- return target.getVal();
- }
-
-private:
- val v_;
-};
-
-ValHolder emval_test_return_ValHolder() {
- return val::object();
-}
-
-void emval_test_set_ValHolder_to_empty_object(ValHolder& vh) {
- vh.setVal(val::object());
-}
-
-class StringHolder {
-public:
- StringHolder(const std::string& s)
- : str_(s)
- {}
-
- void set(const std::string& s) {
- str_ = s;
- }
-
- std::string get() const {
- return str_;
- }
-
- std::string& get_ref() {
- return str_;
- }
-
- const std::string& get_const_ref() const {
- return str_;
- }
-
-private:
- std::string str_;
-};
-
-class SharedPtrHolder {
-public:
- SharedPtrHolder()
- : ptr_(new StringHolder("a string"))
- {}
-
- std::shared_ptr<StringHolder> get() const {
- return ptr_;
- }
-
- void set(std::shared_ptr<StringHolder> p) {
- ptr_ = p;
- }
-private:
- std::shared_ptr<StringHolder> ptr_;
-};
-
-class VectorHolder {
-public:
- VectorHolder() {
- v_.push_back(StringHolder("string #1"));
- v_.push_back(StringHolder("string #2"));
- }
-
- std::vector<StringHolder> get() const {
- return v_;
- }
-
- void set(std::vector<StringHolder> vec) {
- v_ = vec;
- }
-
-private:
- std::vector<StringHolder> v_;
-};
-
-class SmallClass {
-public:
- SmallClass(): member(7) {};
- int member;
-};
-
-class BigClass {
-public:
- BigClass(): member(11) {};
- int member;
- int otherMember;
- int yetAnotherMember;
-
- int getMember() {
- return member;
- }
-};
-
-class ParentClass {
-public:
- ParentClass(): bigClass() {};
-
- BigClass bigClass;
-
- const BigClass& getBigClass() {
- return bigClass;
- };
-};
-
-template<typename T>
-class TemplateClass {
-public:
- TemplateClass(T a, T b, T c) {
- members[0] = a;
- members[1] = b;
- members[2] = c;
- };
-
- const T getMember(int n) {
- return members[n];
- }
-
-protected:
- T members[3];
-};
-
-class ContainsTemplatedMemberClass {
-public:
- ContainsTemplatedMemberClass(): testTemplate(86, 87, 88) {};
-
- TemplateClass<int> testTemplate;
-
- const TemplateClass<int>& getTestTemplate() {
- return testTemplate;
- };
-};
-
-// Begin Inheritance Hierarchy Class Definitions
-
-class Base {
-public:
- Base(): name("Base"),
- member(0),
- baseMember(0)
- {}
-
- std::string getClassName() const {
- return name;
- }
- std::string getClassNameFromBase() const {
- return name;
- }
- std::string getClassNameNotAvailableInDerivedClasses() {
- // but wait -- if you act now we will throw in a SECOND base class method ABSOLUTELY FREE!!
- return name;
- }
- void setMember(int value) {
- member = value;
- }
- int getMember() {
- return member;
- }
- void setBaseMember(int value) {
- baseMember = value;
- }
- int getBaseMember() {
- return baseMember;
- }
- std::string name;
- int member;
- int baseMember;
-};
-
-class SecondBase {
-public:
- SecondBase()
- : name("SecondBase"),
- member(0),
- secondBaseMember(0)
- {}
-
- std::string getClassName() const {
- return name;
- }
- std::string getClassNameNotAvailableInDerivedClasses() {
- return name;
- }
- std::string getClassNameFromSecondBase() const {
- return name;
- }
- void setMember(int value) {
- member = value;
- }
- int getMember() {
- return member;
- }
- void setSecondBaseMember(int value) {
- secondBaseMember = value;
- }
- int getSecondBaseMember() {
- return secondBaseMember;
- }
- std::string name;
- int member;
- int secondBaseMember;
-};
-
-class Derived : public Base{
-public:
- Derived()
- : Base()
- , member(0)
- , name_("Derived")
- {}
-
- std::string getClassName() const {
- return name_;
- }
- void setMember(int value) {
- member = value;
- }
- int getMember() {
- return member;
- }
- int member;
-private:
- std::string name_;
-};
-
-class DerivedHolder {
-public:
- DerivedHolder() {
- derived_.reset();
- }
- void newDerived() {
- deleteDerived();
- derived_ = std::shared_ptr<Derived>(new Derived());
- }
- void deleteDerived() {
- derived_.reset();
- }
- std::shared_ptr<Derived> getDerived() {
- return derived_;
- }
- std::string getDerivedClassName() {
- return derived_->getClassName();
- }
-private:
- std::shared_ptr<Derived> derived_;
-};
-
-class SiblingDerived : public Base {
-public:
- SiblingDerived()
- : Base(),
- name_("SiblingDerived")
- {}
-
- std::string getClassName() const {
- return name_;
- }
-
-private:
- std::string name_;
-};
-
-class MultiplyDerived : public Base, public SecondBase {
-public:
- MultiplyDerived()
- : Base(), SecondBase(),
- name_("MultiplyDerived")
- { instanceCount_ ++; }
-
- ~MultiplyDerived()
- { instanceCount_ --; }
-
- std::string getClassName() const {
- return name_;
- }
-
- static int getInstanceCount() {
- return instanceCount_;
- }
-private:
- std::string name_;
- static int instanceCount_;
-};
-int MultiplyDerived::instanceCount_ = 0;
-
-class DerivedTwice : public Derived {
-public:
- DerivedTwice()
- : Derived(),
- name_("DerivedTwice")
- {}
-
- std::string getClassName() const {
- return name_;
- }
-private:
- std::string name_;
-};
-
-class DerivedTwiceNotBound : public Derived {
-public:
- DerivedTwiceNotBound()
- : Derived(),
- name_("DerivedTwiceNotBound")
- {}
-
- std::string getClassName() const {
- return name_;
- }
-private:
- std::string name_;
-};
-
-class DerivedThrice: public DerivedTwiceNotBound {
-public:
- DerivedThrice()
- : DerivedTwiceNotBound(),
- name_("DerivedThrice")
- {}
-
- std::string getClassName() const {
- return name_;
- }
-private:
- std::string name_;
-};
-
-class DerivedFourTimesNotBound: public DerivedThrice {
-public:
- DerivedFourTimesNotBound()
- : DerivedThrice(),
- name_("DerivedFourTimesNotBound")
- {}
-
- std::string getClassName() const {
- return name_;
- }
-private:
- std::string name_;
-};
-
-class PolyBase {
-public:
- PolyBase(const std::string& s)
- : str_(s),
- name_("PolyBase")
- {}
-
- PolyBase(): name_("PolyBase") {}
-
- virtual ~PolyBase() {}
-
- virtual std::string virtualGetClassName() const {
- return name_;
- }
-
- std::string getClassName() const {
- return name_;
- }
-
-private:
- std::string str_;
- std::string name_;
-};
-
-class PolySecondBase {
-public:
- PolySecondBase(): name_("PolySecondBase")
- {}
-
- virtual ~PolySecondBase() {}
-
- std::string getClassName() const {
- return name_;
- }
-private:
- std::string name_;
-};
-
-class PolyDerived : public PolyBase{
-public:
- PolyDerived()
- : PolyBase("PolyDerived"),
- name_("PolyDerived")
- {}
-
- std::string virtualGetClassName() const {
- return name_;
- }
-
- std::string getClassName() const {
- return name_;
- }
-
- static void setPtrDerived() {
- ptr_ = std::shared_ptr<PolyDerived>(new PolyDerived());
- }
-
- static void releasePtr() {
- ptr_.reset();
- }
-
- static std::string getPtrClassName() {
- return ptr_->getClassName();
- }
-
- static std::shared_ptr<PolyBase> getPtr() {
- return ptr_;
- }
-
-private:
- std::string name_;
- static std::shared_ptr<PolyBase> ptr_;
-};
-std::shared_ptr<PolyBase> PolyDerived::ptr_;
-
-class PolySiblingDerived : public PolyBase {
-public:
- PolySiblingDerived()
- : PolyBase(),
- name_("PolySiblingDerived")
- {}
-
- std::string getClassName() const {
- return name_;
- }
-private:
- std::string name_;
-};
-
-class PolyMultiplyDerived : public PolyBase, public PolySecondBase {
-public:
- PolyMultiplyDerived()
- : PolyBase(), PolySecondBase(),
- name_("PolyMultiplyDerived")
- {}
-
- std::string getClassName() const {
- return name_;
- }
-private:
- std::string name_;
-};
-
-class PolyDerivedTwiceWithoutSmartPointer: public PolyDerived {
-public:
- PolyDerivedTwiceWithoutSmartPointer()
- : PolyDerived(),
- name_("PolyDerivedTwiceWithoutSmartPointer")
- {}
-
- std::string getClassName() const {
- return name_;
- }
-private:
- std::string name_;
-};
-
-class PolyDerivedTwiceNotBound : public PolyDerived {
-public:
- PolyDerivedTwiceNotBound()
- : PolyDerived(),
- name_("PolyDerivedTwiceNotBound")
- {}
-
- std::string getClassName() const {
- return name_;
- }
-private:
- std::string name_;
-};
-
-class PolyDerivedThrice: public PolyDerivedTwiceNotBound {
-public:
- PolyDerivedThrice()
- : PolyDerivedTwiceNotBound(),
- name_("PolyDerivedThrice")
- {}
-
- std::string getClassName() const {
- return name_;
- }
-private:
- std::string name_;
-};
-
-class PolyDerivedFourTimesNotBound: public PolyDerivedThrice {
-public:
- PolyDerivedFourTimesNotBound()
- : PolyDerivedThrice(),
- name_("PolyDerivedFourTimesNotBound")
- {}
-
- std::string getClassName() const {
- return name_;
- }
-private:
- std::string name_;
-};
-
-class PolyDiamondBase {
-public:
- PolyDiamondBase():
- name_("PolyBase")
- {}
- ~PolyDiamondBase() {}
-
- std::string getClassName() const {
- return name_;
- }
-private:
- std::string name_;
-};
-
-class PolyDiamondDerived: public PolyDiamondBase {
-public:
- PolyDiamondDerived()
- : PolyDiamondBase(),
- name_("PolyDiamondDerived")
- {}
-
- std::string getClassName() const {
- return name_;
- }
-private:
- std::string name_;
-};
-
-class PolyDiamondSiblingDerived: public PolyDiamondBase {
-public:
- PolyDiamondSiblingDerived()
- : PolyDiamondBase(),
- name_("PolyDiamondSiblingDerived")
- {}
-
- std::string getClassName() const {
- return name_;
- }
-private:
- std::string name_;
-};
-
-class PolyDiamondMultiplyDerived: public PolyDiamondDerived, public PolyDiamondSiblingDerived {
-public:
- PolyDiamondMultiplyDerived()
- : PolyDiamondDerived(), PolyDiamondSiblingDerived(),
- name_("PolyDiamondMultiplyDerived")
- {}
-
- std::string getClassName() const {
- return name_;
- }
-private:
- std::string name_;
-};
-
-// End Inheritance Hierarchy Class Definitions
-
-std::map<std::string, int> embind_test_get_string_int_map() {
- std::map<std::string, int> m;
-
- m["one"] = 1;
- m["two"] = 2;
-
- return m;
-};
-
-struct Vector {
- Vector() = delete;
-
- Vector(float x_, float y_, float z_, float w_)
- : x(x_)
- , y(y_)
- , z(z_)
- , w(w_)
- {}
-
- float x, y, z, w;
-
- float& operator[](int i) {
- return (&x)[i];
- }
-
- const float& operator[](int i) const {
- return (&x)[i];
- }
-
- float getY() const {
- return y;
- }
- void setY(float _y) {
- y = _y;
- }
-};
-
-struct DummyDataToTestPointerAdjustment {
- std::string dummy;
-};
-
-struct TupleVector : DummyDataToTestPointerAdjustment, Vector {
- TupleVector(): Vector(0, 0, 0, 0) {}
- TupleVector(float x, float y, float z, float w): Vector(x, y, z, w) {}
-};
-
-struct StructVector : DummyDataToTestPointerAdjustment, Vector {
- StructVector(): Vector(0, 0, 0, 0) {}
- StructVector(float x, float y, float z, float w): Vector(x, y, z, w) {}
-};
-
-float readVectorZ(const Vector& v) {
- return v.z;
-}
-
-void writeVectorZ(Vector& v, float z) {
- v.z = z;
-}
-
-struct TupleVectorTuple {
- TupleVector v = TupleVector(0, 0, 0, 0);
-};
-
-TupleVector emval_test_return_TupleVector() {
- return TupleVector(1, 2, 3, 4);
-}
-
-TupleVector emval_test_take_and_return_TupleVector(TupleVector v) {
- return v;
-}
-
-TupleVectorTuple emval_test_return_TupleVectorTuple() {
- TupleVectorTuple cvt;
- cvt.v = emval_test_return_TupleVector();
- return cvt;
-}
-
-StructVector emval_test_return_StructVector() {
- return StructVector(1, 2, 3, 4);
-}
-
-StructVector emval_test_take_and_return_StructVector(StructVector v) {
- return v;
-}
-
-struct CustomStruct {
- CustomStruct()
- : field(10)
- {}
-
- const int& getField() const {
- return field;
- }
-
- int field;
-};
-
-struct TupleInStruct {
- TupleVector field;
-};
-
-TupleInStruct emval_test_take_and_return_TupleInStruct(TupleInStruct cs) {
- return cs;
-}
-
-enum Enum { ONE, TWO };
-
-Enum emval_test_take_and_return_Enum(Enum e) {
- return e;
-}
-
-enum class EnumClass { ONE, TWO };
-
-EnumClass emval_test_take_and_return_EnumClass(EnumClass e) {
- return e;
-}
-
-void emval_test_call_function(val v, int i, float f, TupleVector tv, StructVector sv) {
- v(i, f, tv, sv);
-}
-
-std::unique_ptr<ValHolder> emval_test_return_unique_ptr() {
- return std::unique_ptr<ValHolder>(new ValHolder(val::object()));
-}
-
-std::shared_ptr<ValHolder> emval_test_return_shared_ptr() {
- return std::shared_ptr<ValHolder>(new ValHolder(val::object()));
-}
-
-std::shared_ptr<ValHolder> emval_test_return_empty_shared_ptr() {
- return std::shared_ptr<ValHolder>();
-}
-
-bool emval_test_is_shared_ptr_null(std::shared_ptr<ValHolder> p) {
- return !p;
-}
-
-static SmallClass smallClass;
-static BigClass bigClass;
-
-SmallClass embind_test_return_small_class_instance() {
- return smallClass;
-}
-
-BigClass embind_test_return_big_class_instance() {
- return bigClass;
-}
-
-int embind_test_accept_small_class_instance(SmallClass c) {
- return c.member;
-}
-
-int embind_test_accept_big_class_instance(BigClass c) {
- return c.member;
-}
-
-// Begin Inheritance Hierarchy Test Wrappers
-
-Base* embind_test_return_raw_base_ptr() {
- return new Base();
-}
-
-Base* embind_test_return_raw_derived_ptr_as_base() {
- return new Derived();
-}
-
-Base* embind_test_return_raw_sibling_derived_ptr_as_base() {
- return new SiblingDerived();
-}
-
-PolyBase* embind_test_return_raw_polymorphic_derived_ptr_as_base() {
- return new PolyDerived();
-}
-
-PolyBase* embind_test_return_raw_polymorphic_sibling_derived_ptr_as_base() {
- return new PolySiblingDerived();
-}
-
-PolyBase* embind_test_return_raw_polymorphic_multiply_derived_ptr_as_base() {
- return new PolyMultiplyDerived();
-}
-
-PolySecondBase* embind_test_return_raw_polymorphic_multiply_derived_ptr_as_second_base() {
- return new PolyMultiplyDerived();
-}
-
-PolyBase* embind_test_return_raw_polymorphic_derived_four_times_not_bound_as_base() {
- return new PolyDerivedFourTimesNotBound();
-}
-
-std::shared_ptr<Base> embind_test_return_smart_base_ptr() {
- return std::shared_ptr<Base>(new Base());
-}
-
-std::shared_ptr<PolyBase> embind_test_return_smart_polymorphic_base_ptr() {
- return std::shared_ptr<PolyBase>(new PolyBase("PolyBase"));
-}
-
-std::shared_ptr<Derived> embind_test_return_smart_derived_ptr() {
- return std::shared_ptr<Derived>(new Derived());
-}
-
-std::shared_ptr<SiblingDerived> embind_test_return_smart_sibling_derived_ptr() {
- return std::shared_ptr<SiblingDerived>(new SiblingDerived());
-}
-
-std::shared_ptr<MultiplyDerived> embind_test_return_smart_multiply_derived_ptr() {
- return std::shared_ptr<MultiplyDerived>(new MultiplyDerived());
-}
-
-std::shared_ptr<DerivedThrice> embind_test_return_smart_derived_thrice_ptr() {
- return std::shared_ptr<DerivedThrice>(new DerivedThrice());
-}
-
-std::shared_ptr<PolyDerived> embind_test_return_smart_polymorphic_derived_ptr() {
- return std::shared_ptr<PolyDerived>(new PolyDerived());
-}
-
-std::shared_ptr<PolySiblingDerived> embind_test_return_smart_polymorphic_sibling_derived_ptr() {
- return std::shared_ptr<PolySiblingDerived>(new PolySiblingDerived());
-}
-
-std::shared_ptr<PolyMultiplyDerived> embind_test_return_smart_polymorphic_multiply_derived_ptr() {
- return std::shared_ptr<PolyMultiplyDerived>(new PolyMultiplyDerived());
-}
-
-std::shared_ptr<PolyBase> embind_test_return_poly_derived_twice_without_smart_pointer_as_poly_base() {
- return std::shared_ptr<PolyBase>(new PolyDerivedTwiceWithoutSmartPointer());
-}
-
-std::shared_ptr<PolyDerivedThrice> embind_test_return_smart_poly_derived_thrice_ptr() {
- return std::shared_ptr<PolyDerivedThrice>(new PolyDerivedThrice());
-}
-
-std::shared_ptr<PolyBase> embind_test_return_smart_derived_ptr_as_base() {
- return std::shared_ptr<PolyBase>(new PolyDerived());
-}
-
-val embind_test_return_smart_derived_ptr_as_val() {
- return val(std::shared_ptr<PolyBase>(new PolyDerived()));
-}
-
-std::shared_ptr<PolyBase> embind_test_return_smart_polymorphic_derived_ptr_as_base() {
- return std::shared_ptr<PolyBase>(new PolyDerived());
-}
-
-std::shared_ptr<PolyBase> embind_test_return_smart_polymorphic_sibling_derived_ptr_as_base() {
- return std::shared_ptr<PolyBase>(new PolySiblingDerived());
-}
-
-std::string embind_test_get_class_name_via_base_ptr(Base *p) {
- return p->getClassName();
-}
-
-std::string embind_test_get_class_name_via_second_base_ptr(SecondBase *p) {
- return p->getClassName();
-}
-
-std::string embind_test_get_class_name_via_polymorphic_base_ptr(PolyBase *p) {
- return p->getClassName();
-}
-
-std::string embind_test_get_class_name_via_polymorphic_second_base_ptr(PolySecondBase *p) {
- return p->getClassName();
-}
-
-std::string embind_test_get_class_name_via_smart_base_ptr(std::shared_ptr<Base> p) {
- return p->getClassName();
-}
-
-std::string embind_test_get_class_name_via_reference_to_smart_base_ptr(std::shared_ptr<Base>& p) {
- return p->getClassName();
-}
-
-std::string embind_test_get_class_name_via_smart_second_base_ptr(std::shared_ptr<SecondBase> p) {
- return p->getClassName();
-}
-
-std::string embind_test_get_class_name_via_smart_polymorphic_base_ptr(std::shared_ptr<PolyBase> p) {
- return p->getClassName();
-}
-
-std::string embind_test_get_virtual_class_name_via_smart_polymorphic_base_ptr(std::shared_ptr<PolyBase> p) {
- return p->virtualGetClassName();
-}
-
-std::string embind_test_get_class_name_via_smart_polymorphic_second_base_ptr(std::shared_ptr<PolySecondBase> p) {
- return p->getClassName();
-}
-
-void embind_modify_smart_pointer_passed_by_reference(std::shared_ptr<Base>& p) {
- p = std::shared_ptr<Base>(new Base());
- p->name = "Changed";
-}
-
-void embind_attempt_to_modify_smart_pointer_when_passed_by_value(std::shared_ptr<Base> p) {
- p = std::shared_ptr<Base>(new Base());
- p->name = "Changed";
-}
-
-static std::shared_ptr<Base> savedBasePointer;
-
-void embind_save_smart_base_pointer(std::shared_ptr<Base> p) {
- savedBasePointer = p;
-}
-
-// End Inheritance Hierarchy Test Wrappers
-
-std::vector<int> emval_test_return_vector() {
- int myints[] = { 10, 20, 30 };
- return std::vector<int>(myints, myints + sizeof(myints) / sizeof(int));
-}
-
-std::vector<std::vector<int> > emval_test_return_vector_of_vectors() {
- int myints1[] = { 10, 20, 30 };
- int myints2[] = { 40, 50, 60 };
- std::vector<int> vec1(myints1, myints1 + sizeof(myints1) / sizeof(int));
- std::vector<int> vec2(myints2, myints2 + sizeof(myints2) / sizeof(int));
- std::vector<std::vector<int>>vec3;
- vec3.emplace_back(vec1);
- vec3.emplace_back(vec2);
- return vec3;
-}
-
-std::vector<std::shared_ptr<StringHolder>> emval_test_return_shared_ptr_vector() {
- std::vector<std::shared_ptr<StringHolder>> sharedStrVector;
- sharedStrVector.push_back(std::shared_ptr<StringHolder>(new StringHolder("string #1")));
- sharedStrVector.push_back(std::shared_ptr<StringHolder>(new StringHolder("string #2")));
-
- return sharedStrVector;
-}
-
-void test_string_with_vec(const std::string& p1, std::vector<std::string>& v1) {
- // THIS DOES NOT WORK -- need to get as val and then call vecFromJSArray
- printf("%s\n", p1.c_str());
-}
-
-val embind_test_new_Object() {
- return val::global("Object").new_();
-}
-
-val embind_test_new_factory(val factory, val argument) {
- return factory.new_(10, std::string("hello"), argument);
-}
-
-class AbstractClass {
-public:
- virtual ~AbstractClass() {}
- virtual std::string abstractMethod() const = 0;
- virtual std::string optionalMethod(std::string s) const {
- return "optional" + s;
- }
-};
-
-EMSCRIPTEN_SYMBOL(optionalMethod);
-
-class AbstractClassWrapper : public wrapper<AbstractClass> {
-public:
- EMSCRIPTEN_WRAPPER(AbstractClassWrapper);
-
- std::string abstractMethod() const {
- return call<std::string>("abstractMethod");
- }
- std::string optionalMethod(std::string s) const {
- return optional_call<std::string>(optionalMethod_symbol, [&] {
- return AbstractClass::optionalMethod(s);
- }, s);
- }
-};
-
-class ConcreteClass : public AbstractClass {
- std::string abstractMethod() const {
- return "from concrete";
- }
-};
-
-std::shared_ptr<AbstractClass> getAbstractClass() {
- return std::make_shared<ConcreteClass>();
-}
-
-std::string callAbstractMethod(AbstractClass& ac) {
- return ac.abstractMethod();
-}
-
-std::string callOptionalMethod(AbstractClass& ac, std::string s) {
- return ac.optionalMethod(s);
-}
-
-class HasExternalConstructor {
-public:
- HasExternalConstructor(const std::string& str)
- : m(str)
- {}
-
- std::string getString() const {
- return m;
- }
-
- std::string m;
-};
-
-HasExternalConstructor* createHasExternalConstructor(const std::string& str) {
- return new HasExternalConstructor(str);
-}
-
-template<typename T>
-class CustomSmartPtr {
-public:
- CustomSmartPtr()
- : CustomSmartPtr(nullptr)
- {
- std::fill(d_, d_ + N_, Valid);
- }
-
- explicit CustomSmartPtr(T* t)
- : ptr_(t)
- {
- std::fill(d_, d_ + N_, Valid);
- }
-
- CustomSmartPtr(const CustomSmartPtr& other)
- : ptr_(other.ptr_)
- {
- other.verify();
- std::fill(d_, d_ + N_, Valid);
- if (ptr_) {
- ++(ptr_->refcount);
- }
- }
-
- ~CustomSmartPtr() {
- verify();
- std::fill(d_, d_ + N_, Deleted);
-
- if (ptr_ && --ptr_->refcount == 0) {
- delete ptr_;
- }
- }
-
- T* get_raw() const {
- return ptr_;
- }
-
-private:
- void verify() const {
- for (size_t i = 0; i < N_; ++i) {
- if (d_[i] != Valid) {
- abort();
- }
- }
- }
-
- enum {
- Valid = 255,
- Deleted = 127,
- };
- static constexpr size_t N_ = 1000000;
- unsigned char d_[N_];
- T* ptr_;
-
- CustomSmartPtr& operator=(const CustomSmartPtr&) = delete;
-};
-
-class HeldBySmartPtr {
-public:
- HeldBySmartPtr(int i, const std::string& s)
- : i(i)
- , s(s)
- {}
-
- static CustomSmartPtr<HeldBySmartPtr> newCustomPtr(int i, const std::string& s) {
- return CustomSmartPtr<HeldBySmartPtr>(new HeldBySmartPtr(i, s));
- }
-
- int refcount = 1;
- int i;
- std::string s;
-};
-
-HeldBySmartPtr takesHeldBySmartPtr(HeldBySmartPtr p) {
- return p;
-}
-std::shared_ptr<HeldBySmartPtr> takesHeldBySmartPtrSharedPtr(std::shared_ptr<HeldBySmartPtr> p) {
- return p;
-}
-
-namespace emscripten {
- template<typename T>
- struct smart_ptr_trait<CustomSmartPtr<T>> {
- typedef T element_type;
-
- static sharing_policy get_sharing_policy() {
- return sharing_policy::NONE;
- }
-
- static T* get(const CustomSmartPtr<T>& p) {
- return p.get_raw();
- }
-
- static CustomSmartPtr<T> share(const CustomSmartPtr<T>& r, T* ptr) {
- ++ptr->refcount; // implement an adopt API?
- return CustomSmartPtr<T>(ptr);
- }
- };
-}
-
-typedef CustomSmartPtr<class HeldByCustomSmartPtr> HeldByCustomSmartPtrPtr;
-
-class HeldByCustomSmartPtr {
-public:
- HeldByCustomSmartPtr(int i, const std::string& s)
- : i(i)
- , s(s)
- {}
-
- static HeldByCustomSmartPtrPtr create(int i, const std::string& s) {
- return HeldByCustomSmartPtrPtr(new HeldByCustomSmartPtr(i, s));
- }
-
- static std::shared_ptr<HeldByCustomSmartPtr> createSharedPtr(int i, const std::string& s) {
- return std::make_shared<HeldByCustomSmartPtr>(i, s);
- };
-
- int refcount = 1;
- int i;
- std::string s;
-};
-
-HeldByCustomSmartPtr* passThroughRawPtr(HeldByCustomSmartPtr* p) {
- return p;
-}
-HeldByCustomSmartPtrPtr passThroughCustomSmartPtr(HeldByCustomSmartPtrPtr p) {
- return p;
-}
-
-struct Base1 {
-public:
- Base1(): field1("Base1") {}
- std::string field1;
-
- std::string getField() const {
- return field1;
- }
-};
-
-struct Base2 {
-public:
- Base2(): field2("Base2") {}
- std::string field2;
-
- std::string getFiel |