QObject* QtJambiShell_QDeclarativeListProperty::object()
{
QTJAMBI_DEBUG_TRACE("(shell) entering: QDeclarativeListProperty::object()");
jmethodID method_id = m_vtable->method(8);
if (method_id) {
JNIEnv *__jni_env = qtjambi_current_environment();
if (!__jni_env) {
return QtjambiDeclarativeListProperty::object();
}
__jni_env->PushLocalFrame(100);
QObject* __qt_return_value;
jobject __java_return_value_object = m_link->javaObject(__jni_env);
if(__jni_env->IsSameObject(__java_return_value_object, 0) == JNI_FALSE) {
jobject __java_return_value = __jni_env->CallObjectMethod(__java_return_value_object, method_id);
qtjambi_exception_check(__jni_env);
QObject* __qt_return_value_tmp = (QObject* ) qtjambi_to_qobject(__jni_env, __java_return_value);
QTJAMBI_EXCEPTION_CHECK(__jni_env);
__qt_return_value = __qt_return_value_tmp;
} else {
qtjambishell_throw_nullpointerexception(__jni_env, "QDeclarativeListProperty::object()");
__qt_return_value = 0;
}
qtjambi_exception_check(__jni_env);
__jni_env->PopLocalFrame(0);
QTJAMBI_DEBUG_TRACE("(shell) -> leaving: QDeclarativeListProperty::object()");
return __qt_return_value;
} else {
QTJAMBI_DEBUG_TRACE("(shell) -> super() and leaving: QDeclarativeListProperty::object()");
return QtjambiDeclarativeListProperty::object();
}
}
void init(jclass declaringClass, jobjectArray javaArguments, QVarLengthArray<jvalue> convertedArgs, jintArray conversionScheme) {
JNIEnv *env = qtjambi_current_environment();
Q_ASSERT(env != 0);
if (env != 0) {
if (declaringClass != 0)
m_declaring_class = reinterpret_cast<jclass>(env->NewGlobalRef(declaringClass));
if (conversionScheme != 0)
m_conversion_scheme = reinterpret_cast<jintArray>(env->NewGlobalRef(conversionScheme));
if (javaArguments != 0) {
// Convert all the arguments
m_arguments = qtjambi_from_jobjectArray(env, javaArguments, m_conversion_scheme, true);
} else {
// Copy the converted arguments
jint *a = m_conversion_scheme != 0 ? env->GetIntArrayElements(m_conversion_scheme, 0) : 0;
for (int i=0; i<convertedArgs.size(); ++i) {
if (a != 0 && a[i] == 'L') {
jvalue val;
val.l = env->NewGlobalRef(convertedArgs[i].l);
m_arguments.append(val);
} else {
m_arguments.append(convertedArgs[i]);
}
}
env->ReleaseIntArrayElements(m_conversion_scheme, a, JNI_ABORT);
}
}
}
void QtJambiShell_QDeclarativeListProperty::clear()
{
QTJAMBI_DEBUG_TRACE("(shell) entering: QDeclarativeListProperty::clear()");
jmethodID method_id = m_vtable->method(6);
if (method_id) {
JNIEnv *__jni_env = qtjambi_current_environment();
if (!__jni_env) {
QtjambiDeclarativeListProperty::clear();
return;
}
__jni_env->PushLocalFrame(100);
jobject __java_return_value_object = m_link->javaObject(__jni_env);
if(__jni_env->IsSameObject(__java_return_value_object, 0) == JNI_FALSE) {
__jni_env->CallVoidMethod(__java_return_value_object, method_id);
qtjambi_exception_check(__jni_env);
} else {
qtjambishell_throw_nullpointerexception(__jni_env, "QDeclarativeListProperty::clear()");
}
qtjambi_exception_check(__jni_env);
__jni_env->PopLocalFrame(0);
QTJAMBI_DEBUG_TRACE("(shell) -> leaving: QDeclarativeListProperty::clear()");
} else {
QTJAMBI_DEBUG_TRACE("(shell) -> super() and leaving: QDeclarativeListProperty::clear()");
QtjambiDeclarativeListProperty::clear();
}
}
void operator()() {
JNIEnv *env = qtjambi_current_environment();
Q_ASSERT(env != 0);
if (env != 0 && m_method_id != 0) {
qtjambi_invoke_method(env, m_functor, m_method_id, m_result_type, m_arguments);
} else {
qWarning("Run functor called with invalid data. JNI Environment == %p, method_id == %p",
env, m_method_id);
}
}
JObjectWrapper operator()() {
JNIEnv *env = qtjambi_current_environment();
Q_ASSERT(env != 0);
if (env != 0 && m_method_id != 0) {
jobject javaResult = qtjambi_invoke_method(env, m_functor, m_method_id, m_result_type, m_arguments);
return javaResult != 0 ? qtjambi_to_jobjectwrapper(env, javaResult) : JObjectWrapper();
} else {
qWarning("Run functor called with invalid data. JNI Environment == %p, method id == %p",
env, m_method_id);
return JObjectWrapper();
}
}
int main(int argc, char **argv)
{
if (argc < 2) {
printf("Usage:\n"
" jambi <vm options> [classname] options\n");
return 0;
}
int start = 2;
QStringList vm_parameters;
for(int i=1; i<argc; i++){
QString arg = QLatin1String(argv[i]);
if(arg.startsWith("-")){
vm_parameters << arg;
start++;
}else{
break;
}
}
qtjambi_initialize_vm(vm_parameters);
JNIEnv *env = qtjambi_current_environment();
QString class_name = QLatin1String(argv[start-1]);
jclass java_class = env->FindClass(class_name.replace('.', '/').toLatin1());
if (!java_class) {
printf("failed to find class: '%s'\n", qPrintable(class_name));
return 0;
}
jmethodID main_id = env->GetStaticMethodID(java_class, "main", "([Ljava/lang/String;)V");
if (!main_id) {
printf("failed to find main(String[])\n");
return 0;
}
jclass string_class = env->FindClass("java/lang/String");
Q_ASSERT(string_class);
jobjectArray args = env->NewObjectArray(argc - start, string_class, 0);
for (int i = start; i < argc; ++i) {
env->SetObjectArrayElement(args, i - start, qtjambi_from_qstring(env, QLatin1String(argv[i])));
}
env->CallStaticVoidMethod(java_class, main_id, args);
qtjambi_exception_check(env);
qtjambi_destroy_vm();
return 0;
}
// emitting (writeShellDestructor)
QtJambiShell_QDeclarativeListProperty::~QtJambiShell_QDeclarativeListProperty()
{
QTJAMBI_DEBUG_TRACE("(shell) entering: QtJambiShell_QDeclarativeListProperty::~QtJambiShell_QDeclarativeListProperty()");
#ifdef QT_DEBUG
if (m_vtable)
m_vtable->deref();
#endif
if (m_link) {
JNIEnv *__jni_env = qtjambi_current_environment();
if (__jni_env != 0) m_link->nativeShellObjectDestroyed(__jni_env);
}
QTJAMBI_DEBUG_TRACE("(shell) leaving: QtJambiShell_QDeclarativeListProperty::~QtJambiShell_QDeclarativeListProperty()");
}
void operator ()(JObjectWrapper &wrapper)
{
JNIEnv *env = qtjambi_current_environment();
if (env != 0 && m_functor) {
jobject javaObject = qtjambi_from_jobjectwrapper(env, wrapper);
StaticCache *sc = StaticCache::instance();
sc->resolveQtConcurrent_MapFunctor();
if (javaObject != 0)
env->CallVoidMethod(m_functor, sc->QtConcurrent_MapFunctor.map, javaObject);
} else {
qWarning("Map functor called with invalid data. JNI Environment == %p, java functor object == %p",
env, m_functor);
}
}
bool operator()(const JObjectWrapper &wrapper) {
JNIEnv *env = qtjambi_current_environment();
if (env != 0 && m_functor != 0) {
jobject javaObject = qtjambi_from_jobjectwrapper(env, wrapper);
StaticCache *sc = StaticCache::instance();
sc->resolveQtConcurrent_FilteredFunctor();
return env->CallBooleanMethod(m_functor, sc->QtConcurrent_FilteredFunctor.filter, javaObject);
} else {
qWarning("Filtered functor called with invalid data. JNI Environment == %p, java functor object == %p",
env, m_functor);
return false;
}
}
~RunFunctorBase() {
JNIEnv *env = qtjambi_current_environment();
if (env != 0) {
if (m_declaring_class != 0)
env->DeleteGlobalRef(m_declaring_class);
jint *a = m_conversion_scheme != 0 ? env->GetIntArrayElements(m_conversion_scheme, 0) : 0;
for (int i=0; i<m_arguments.size(); ++i) {
if (a != 0 && a[i] == 'L')
env->DeleteGlobalRef(m_arguments[i].l);
}
env->ReleaseIntArrayElements(m_conversion_scheme, a, JNI_ABORT);
if (m_conversion_scheme != 0)
env->DeleteGlobalRef(m_conversion_scheme);
}
}
static bool compare(const QVariant::Private *a, const QVariant::Private *b)
{
Q_ASSERT(a->type == b->type);
const JObjectWrapper *wrapper_a = cast_to_object_wrapper(a);
if (wrapper_a) {
const JObjectWrapper *wrapper_b = cast_to_object_wrapper(b);
JNIEnv *env = qtjambi_current_environment();
StaticCache *sc = StaticCache::instance();
return env->CallBooleanMethod(wrapper_a->object, sc->Object.equals, wrapper_b->object);
}
if (QtJambiVariant::getLastHandler())
return QtJambiVariant::getLastHandler()->compare(a, b);
else if (qcoreVariantHandler())
return qcoreVariantHandler()->compare(a, b);
return false;
}
JObjectWrapper operator ()(const JObjectWrapper &wrapper)
{
JNIEnv *env = qtjambi_current_environment();
if (env != 0 && m_functor) {
jobject javaObject = qtjambi_from_jobjectwrapper(env, wrapper);
StaticCache *sc = StaticCache::instance();
sc->resolveQtConcurrent_MappedFunctor();
jobject javaResult = env->CallObjectMethod(m_functor, sc->QtConcurrent_MappedFunctor.map, javaObject);
return qtjambi_to_jobjectwrapper(env, javaResult);
} else {
qWarning("Mapped functor called with invalid data. JNI Environment == %p, java functor object == %p",
env, m_functor);
return JObjectWrapper();
}
}
static void streamDebug(QDebug dbg, const QVariant &v)
{
if((uint)v.userType() == JOBJECTWRAPPER_TYPE) {
const JObjectWrapper wrapper = v.value<JObjectWrapper>();
JNIEnv *env = qtjambi_current_environment();
StaticCache *sc = StaticCache::instance();
sc->resolveObject();
jobject java_object = wrapper.object;
dbg << qtjambi_to_qstring(env, static_cast<jstring>(env->CallObjectMethod(java_object, sc->Object.toString)));
return;
}
else if (QtJambiVariant::getLastHandler()) {
QtJambiVariant::getLastHandler()->debugStream(dbg, v);
return;
}
else if (qcoreVariantHandler()) {
qcoreVariantHandler()->debugStream(dbg, v);
return;
}
}
void operator()(JObjectWrapper &result, const JObjectWrapper &wrapper)
{
JNIEnv *env = qtjambi_current_environment();
if (env != 0 && m_functor != 0) {
StaticCache *sc = StaticCache::instance();
sc->resolveQtConcurrent_ReducedFunctor();
// reduce() is synchronous, so while this data is static in terms
// of the map/reduce operation, it does not need to be protected
if (m_first_call) {
m_first_call = false;
result = JObjectWrapper(env, env->CallObjectMethod(m_functor, sc->QtConcurrent_ReducedFunctor.defaultResult));
}
jobject javaObject = qtjambi_from_jobjectwrapper(env, wrapper);
jobject javaResult = qtjambi_from_jobjectwrapper(env, result);
env->CallVoidMethod(m_functor, sc->QtConcurrent_ReducedFunctor.reduce, javaResult, javaObject);
} else {
qWarning("Reduce functor called with invalid data. JNI Environment == %p, java functor object == %p",
env, m_functor);
}
}
static bool convert(const QVariant::Private *d, QVariant::Type t,
void *result, bool *ok)
{
const JObjectWrapper *wrapper = cast_to_object_wrapper(d);
if(wrapper != 0) {
JNIEnv *env = qtjambi_current_environment();
StaticCache *sc = StaticCache::instance();
jobject java_object = wrapper->object;
switch (t) {
case QVariant::Int :
sc->resolveQtEnumerator();
if (env->IsInstanceOf(java_object, sc->QtEnumerator.class_ref)) {
*((int*)result) = env->CallIntMethod(java_object, sc->QtEnumerator.value);
return true;
}
break;
case QVariant::String :
sc->resolveObject();
*((QString*)result) = qtjambi_to_qstring(env, static_cast<jstring>(env->CallObjectMethod(java_object, sc->Object.toString)));
return true;
break;
default :
return false;
}
}
if (QtJambiVariant::getLastHandler())
return QtJambiVariant::getLastHandler()->convert(d, t, result, ok);
else if (qcoreVariantHandler())
return qcoreVariantHandler()->convert(d, t, result, ok);
return false;
}
void init(jobject functor) {
JNIEnv *env = qtjambi_current_environment();
if (env != 0)
m_functor = env->NewGlobalRef(functor);
}
virtual ~Functor()
{
JNIEnv *env = qtjambi_current_environment();
if (env != 0)
env->DeleteGlobalRef(m_functor);
}
