int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
MyClass myClass(0);
QQmlApplicationEngine engine(QUrl("qrc:/src/ui/main.qml"));
engine.rootContext()->setContextProperty("myClass", &myClass);
/*QObject::connect(engine, SIGNAL(qmlSignal(QString)),
&myClass, SLOT(cppSlot(QString)));*/
return app.exec();
}
class_< Box<T> > bindBox(const char *bindName)
{
void (Box<T>::*eb1)(const T&) = &Box<T>::extendBy;
void (Box<T>::*eb2)(const Box<T>&) = &Box<T>::extendBy;
bool (Box<T>::*i1)(const T&) const = &Box<T>::intersects;
bool (Box<T>::*i2)(const Box<T>&) const = &Box<T>::intersects;
class_< Box<T> > myClass(bindName);
myClass.def_readwrite("min", &Box<T>::min)
.def_readwrite("max", &Box<T>::max)
.def(init<>())
.def(init<T>())
.def(init<T, T>())
.def(self == self)
.def(self != self)
.def("makeEmpty", &Box<T>::makeEmpty)
.def("extendBy", eb1)
.def("extendBy", eb2)
.def("size", &Box<T>::size)
.def("center", &Box<T>::center)
.def("intersects", i1)
.def("intersects", i2)
.def("contains", &boxContains<Box<T> > )
.def("majorAxis", &Box<T>::majorAxis)
.def("isEmpty", &Box<T>::isEmpty)
.def("hasVolume", &Box<T>::hasVolume)
.def("dimensions", &VectorTraits<T>::dimensions).staticmethod("dimensions")
.def( "__str__", &IECorePython::str<Box<T> > )
.def( "__repr__", &IECorePython::repr<Box<T> > )
.def( "split", &split1<T> )
.def( "split", &split2<T> )
;
return myClass;
}
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
QQmlApplicationEngine engine;
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
QObject *rootObj = engine.rootObjects().first();
QObject *item = rootObj->findChild<QObject*>("mainButtonMouseArea");
MyClass myClass(rootObj);
// Connect QML to C++
QObject::connect(item, SIGNAL(qmlSignalMain(QString)),
&myClass, SLOT(cppSlotInMain(QString)));
return app.exec();
}
void testingFunction2() {
FunctionClass myClass(2.0);
double x = 12.0;
boost::function<double(FunctionClass*, double)> funcPtr, funcPtr1;
funcPtr = &FunctionClass::multWithA;
funcPtr1 = &FunctionClass::operator();
std::cout << myClass.multWithA(x) << std::endl;
std::cout << funcPtr(&myClass, x) << std::endl;
std::cout << funcPtr1(&myClass, x) << std::endl;
// bind the function with the class instance
boost::function<double (double)> funcPtrNew;
funcPtrNew = boost::bind(funcPtr, &myClass, _1);
std::cout << funcPtrNew(x) << std::endl;
}
// CK2: %class.zoo = type { i32 (...)**, %class.waldo }
// CK2: %class.waldo = type { i32, i32 }
int fooz()
{
int i = 0;
plugh<int,int> myClass(100);
myClass.setH(1);
myClass.setW(2);
zoo<int>& spinner = myClass;
#pragma omp target
{
// It is intentionally commented as we don't support dynamic virtual func in device.
//spinner.getAll_V();
spinner.getAll_H();
}
// CK2: define {{.*}}void @__omp_offloading_[[FILEID:[0-9a-f]+_[0-9a-f]+]]__{{.+}}fooz
// CK2: call i32 @_{{.+}}zoo{{.+}}getAll_H{{.+}}(%class.zoo
// CK2-NOT: call i32 @_{{.+}}plugh{{.+}}getAll_H{{.+}}(%class.plugh
// CK2: define linkonce_odr i32 @_{{.+}}zoo{{.+}}getAll_H{{.+}}(%class.zoo
// CK2-NOT: define linkonce_odr i32 @_{{.+}}plugh{{.+}}getAll_H{{.+}}(%class.plugh
return i;
}
TEST(IEWorker, BasicTest)
{
// Init
IEWorker worker;
worker.Start();
// Test Standard Function
auto result = worker.AddJob(&functionAdd, 22, 14);
EXPECT_EQ(36, result.get());
worker.AddJob(funcVoid, true);
// Test Lambda
auto voidLambda = [](bool b) { EXPECT_TRUE(b); };
auto returnLambda = [](int answer) { return answer; };
result = worker.AddJob(returnLambda, 22);
EXPECT_EQ(22, result.get());
worker.AddJob(voidLambda, true);
// Test Member Function
TestClass myClass(123);
auto result2 = worker.AddJob(&TestClass::IntMember, &myClass, 22);
EXPECT_EQ(145, result2.get());
EXPECT_EQ(145, myClass.a);
auto result3 = worker.AddJob(&TestClass::IntConstMember, &myClass, 22);
EXPECT_EQ(22, result3.get());
auto result4 = worker.AddJob(&TestClass::VoidMember, &myClass, 999);
result4.wait();
EXPECT_EQ(999, myClass.a);
worker.AddJob(&TestClass::VoidConstMember, &myClass, true);
worker.Stop();
}
int _tmain(int argc, _TCHAR* argv[])
{
std::vector<int> iv;
for(int currVal = 0;
currVal < 10;
currVal++)
{
iv.push_back(currVal);
}
std::for_each( iv.begin(),
iv.end(),
outputI); // using function pointer
std::cout << std::endl;
std::for_each( iv.begin(),
iv.end(),
[](int i)
{
std::cout << i << " ";
} ); // using lambda
std::cout << std::endl;
std::vector<int> ivSquares;
// lambda's with return values..
// int paramter returns double
std::transform( iv.begin(),
iv.end(),
back_inserter(ivSquares),
[] (int n) -> int
{
return n*n;
} );
std::for_each( ivSquares.begin(),
ivSquares.end(),
[](int i)
{
std::cout << i << " ";
} ); // using lambda
std::cout << std::endl;
//use capture clause..
int x = 3;
int y = 7;
// capture clause [x,y]
// makes copies of these local variables and makes those values
// available to the lambda during execution..
std::for_each( iv.begin(),
iv.end(),
[x,y](int i)
{
if(i >= x && i <= y)
{
std::cout << "within range[" << i << "]" << std::endl;
}
} );
std::cout << std::endl;
// capture 'all' semantically useful variables clause [=]
// makes copies of these local variables and makes those values
// available to the lambda during execution..
x =4;
y=6;
std::for_each( iv.begin(),
iv.end(),
[=](int i)
{
if(i >= x && i <= y)
{
std::cout << "within range[" << i << "]" << std::endl;
}
} );
std::cout << std::endl;
//change values in vector..
// mutable + paramter reference..
x =4;
y=6;
std::for_each( iv.begin(),
iv.end(),
[=](int &r) mutable
{
const int old = r;
r *= 2;
x = y;
y = old;
} );
std::for_each( iv.begin(),
iv.end(),
[](int i)
{
std::cout << i << " ";
} ); // using lambda
std::cout << std::endl;
std::cout << "x[" << x << "] y[" << y << "]" << std::endl;
//change values in vector with references for captures..
// mutable + paramter reference..
x =4;
y=6;
std::for_each( iv.begin(),
iv.end(),
[&x,&y](int &r) mutable
{
const int old = r;
r *= 2;
x = y;
y = old;
} );
std::for_each( iv.begin(),
iv.end(),
[](int i)
{
std::cout << i << " ";
} ); // using lambda
std::cout << std::endl;
std::cout << "x[" << x << "] y[" << y << "]" << std::endl;
// shorthand initialization of a vector using a reference lambda..
iv.clear();
int i = 0;
std::generate_n(back_inserter(iv),
20,
[&i]
{
return i++;
} ); // lambda is called once per insert operation...
// notice no parameter list!
std::for_each( iv.begin(),
iv.end(),
[](int i)
{
std::cout << i << " ";
} ); // using lambda
std::cout << std::endl;
// example of updating a class iteratively using for_each and lambdas (vector)..
std::vector<myClass> vmc;
for(int i = 1; i <= 10; i++)
{
vmc.push_back(myClass(i));
}
std::for_each( vmc.begin(),
vmc.end(),
[](myClass &mc)
{
std::cout << mc.get() << " ";
}
);
std::cout << std::endl;
std::for_each( vmc.begin(),
vmc.end(),
[](myClass &mc)
{
mc.increment();
}
);
std::for_each( vmc.begin(),
vmc.end(),
[](myClass &mc)
{
std::cout << mc.get() << " ";
}
);
std::cout << std::endl;
// example of updating a class iteratively using for_each and lambdas (vector)..
std::map<int,myClass> mmc;
for(int i = 1; i <= 10; i++)
{
mmc.insert(std::pair<int,myClass>(i,myClass(i)));
}
std::for_each( mmc.begin(),
mmc.end(),
[](std::pair<int,myClass> mc)
{
std::cout << "myClass(f[" << mc.first << "] s[" << mc.second.get() << "]) " << std::endl;
}
);
std::cout << std::endl;
std::for_each( mmc.begin(),
mmc.end(),
[](std::pair<const int,myClass> &mc) // this syntax allows for reference semantics on maps..
{
mc.second.increment();
}
);
std::for_each( mmc.begin(),
mmc.end(),
[](std::pair<int,myClass> mc)
{
std::cout << "myClass(f[" << mc.first << "] s[" << mc.second.get() << "]) " << std::endl;
}
);
std::cout << std::endl;
// simply boolean lambda..
auto mod2func =
[](int x) -> bool
{
return (x % 2) == 0;
};
for(int x = 0; x < 4; x++)
{
if (mod2func(x))
{
std::cout << "x[" << x << "] " << "is TRUE" << std::endl;
}
else
{
std::cout << "x[" << x << "] " << "is FALSE" << std::endl;
}
}
return 0;
}
void script_enviroment::BindSquirrel()
{
vm_squirrel_ = sq_open(1024); //creates a VM with initial stack size 1024
Sqrat::DefaultVM::Set(vm_squirrel_);
Sqrat::Table myTable(vm_squirrel_);
myTable.Func("MyFunc", &myFunc);
Sqrat::RootTable(vm_squirrel_).SetValue("myVal",0);
//this sets the print function :)
Sqrat::RootTable(vm_squirrel_).Func<void (*)(std::string)>("print", &print_zax);
/*Sqrat::Class<enemigo> class_enemigo(vm_squirrel_);
class_enemigo.Var("status",&enemigo::status_);
*/
Sqrat::Class<MyClass> myClass(vm_squirrel_);
myClass.Func("Foo", &MyClass::Foo);
myClass.Var("bar", &MyClass::bar);
Sqrat::Class<console_manager> Console_Manager(vm_squirrel_);
Console_Manager.Func("print", &console_manager::add_message);
//RootTable(vm).BindValue("other_var", &var_test);
Sqrat::RootTable(vm_squirrel_).Bind("MyTable", myTable);
Sqrat::RootTable(vm_squirrel_).Bind("MyClass", myClass);
//Sqrat::RootTable(vm_squirrel_).Bind("enemigo", class_enemigo);
Sqrat::RootTable(vm_squirrel_).Bind("console_manager", Console_Manager);
Sqrat::RootTable(vm_squirrel_).SetInstance("console_test", g_console); /* now the variable c in C++ appears as the variable c in the root table in Squirrel */
Sqrat::Class<global_vars_> _global_vars;
_global_vars.Var("var_test", &global_vars_::var_test);
Sqrat::RootTable(vm_squirrel_).Bind("global_vars_", _global_vars);
Sqrat::RootTable(vm_squirrel_).SetInstance("global_vars", &global_vars); /* now the variable c in C++ appears as the variable c in the root table in Squirrel */
/*Sqrat::Script *t = new Sqrat::Script();
sq_scripts_.push_back(t);
//script1->CompileString("MyTable.MyFunc(); myVal = myVal + 1;");
t->CompileString("global_vars.var_test += 1; print(\"Val: Well this is my script running (I'm testing) \" + global_vars.var_test); function Add_FuncTest(a, b) { return a + b; }");
Sqrat::Script *script2 = new Sqrat::Script();
script2->CompileString("function Add_FuncTest(a, b) { return (a * b * 0)+test(); }function test(){ return 15;}");
script2->Run();
funcA2 = new Sqrat::Function(Sqrat::RootTable(vm_squirrel_), "Add_FuncTest"); // Via the constructor
sq_scripts_.push_back(script2);
//delete(script2);*/
/*Sqrat::Script *temp = new Sqrat::Script();
temp->CompileString("console_test.print(\"There was a respawn\"); function test(){ return 25;}console_test.print(\"n:\"+test()); function on_respawn_enemy(enem_){console_test.print(\"There is from the default function \"+enem_.status);enem_.status = 4;}");
unit_event *temp2 = new unit_event();
temp2->script_ = temp;
temp2->event_id_ = get_event_by_name("enemy_respawn");
set_function(temp2);
enemy_scripts_.push_back(temp2);*/
}
/*
* Class: org_mahu_proto_jnitest_nativewrapper_HelloJNI
* Method: testSpecial
* Signature: (I)I
*/
jint Java_org_mahu_proto_jnitest_nativewrapper_HelloJNI_testSpecial_helper
(JNIEnv *env, jobject obj, jint test)
{
std::cout << "### Java_org_mahu_proto_jnitest_nativewrapper_HelloJNI_testSpecial, test " << test << std::endl;
switch(test) {
case 0: // call method on object that returns a string.
{
JavaObject javaObjectDataClass(env,"org/mahu/proto/jnitest/nativewrapper/DataClass");
jobject stringObj = javaObjectDataClass.getObject("getStringValue","()Ljava/lang/String;");
JavaObject stringJavaObj(env, "java/lang/String",stringObj);
jint length = stringJavaObj.getInt("length");
std::cout << "Length of string is: " << length << std::endl;
return 0;
}
case 1: // call field on object that returns a string.
{
JavaObject javaObjectDataClass(env,"org/mahu/proto/jnitest/nativewrapper/DataClass1");
jobject stringObj = javaObjectDataClass.getObjectField("stringValue","Ljava/lang/String;");
JavaObject stringJavaObj(env, "java/lang/String",stringObj);
jint length = stringJavaObj.getInt("length");
std::cout << "Length of string is: " << length << std::endl;
return 0;
}
case 2:
{
MyClass myClass(env, *myGlobalClass, obj);
int value = myClass.test.get()+10;
myClass.test.set(value);
return myClass.test.get();
}
case 3: // JNI_SPECIAL_CASE_MYCLASS_GET_METHOD_INT
{
MyClass myClass(env, *myGlobalClass, obj);
int value = myClass.intMethod.get()+10;
myClass.intMethod.set(value);
return myClass.intMethod.get();
}
case 4: // JNI_SPECIAL_CASE_GET_SIZEOF_VOID_POINTER
{
return sizeof(void *);
}
case 5: // JNI_SPECIAL_CASE_GET_SIZEOF_JLONG
{
return sizeof(jlong);
}
case 6: // JNI_SPECIAL_CASE_LOAD_CLASS
{
JavaObject javaObjectDataClass(env,"org/mahu/proto/jnitest/nativewrapper/DataClass2");
jint intValue = javaObjectDataClass.getIntField("intValue");
return intValue;
}
case 7: // SEGV
{
// baz();
return 1;
}
case 8: // JNI_SPECIAL_CASE_PRINT_OBJECTREF
{
std::cout << "HelloJNI objRef " << std::hex << std::showbase << obj << std::dec << std::endl;
for(int i=0; i<100; i++) {
JavaObject javaObjectDataClass(env,"org/mahu/proto/jnitest/nativewrapper/DataClass2");
std::cout << "DataClass2 objRef " << std::hex << std::showbase
<< javaObjectDataClass.getJObject() << std::dec << std::endl;
}
break;
}
case 9: // JNI_SPECIAL_CASE_BIG_ARRAY_READ
{
JavaObject javaObject(env, "org/mahu/proto/jnitest/nativewrapper/HelloJNI", obj);
JByteArrayPtrIn byteArray(env, javaObject.getBytesField("specialBytes"));
return 1;
}
default:
break;
}
return 1;
}
