jobjectArray rho_cast_helper<jobjectArray, VALUE>::operator()(JNIEnv *env, VALUE value)
{
RAWTRACE("rho_cast<jobjectArray, VALUE>");
if (!initConvertor(env))
return 0;
if (NIL_P(value))
return 0;
if(TYPE(value) == T_ARRAY)
{
int size = RARRAY_LEN(value);
jobjectArray jArray = env->NewObjectArray(size, clsString, 0);
if (!jArray)
return 0;
for (int i = 0; i < size; ++i)
{
jhstring jhElement = rho_cast<jstring>(env, rb_ary_entry(value, i));
env->SetObjectArrayElement(jArray, i, jhElement.get());
}
return jArray;
}
RAWLOG_ERROR1("rho_cast<jobjectArray, VALUE>: wrong type of VALUE: %d", TYPE(value));
return 0;
}
jobjectArray rho_cast_helper<jobjectArray, VALUE>::operator()(JNIEnv *env, VALUE value)
{
RAWTRACE("rho_cast<jobjectArray, VALUE>");
if (!initConvertor(env))
return 0;
if (NIL_P(value))
return 0;
if(TYPE(value) == RUBY_T_ARRAY)
{
int size = RARRAY_LEN(value);
jobjectArray jArray = env->NewObjectArray(size, clsString, 0);
if(env->ExceptionCheck() == JNI_TRUE)
{
rho::String message = rho::common::clearException(env);
RAWLOG_ERROR(message.c_str());
return 0;
}
for (int i = 0; i < size; ++i)
{
jhstring jhElement = rho_cast<jstring>(env, rb_ary_entry(value, i));
env->SetObjectArrayElement(jArray, i, jhElement.get());
}
return jArray;
}
RAWLOG_ERROR1("rho_cast<jobjectArray, VALUE>: wrong type of VALUE: %d", TYPE(value));
return 0;
}
VALUE rho_cast_helper<VALUE, jobject>::operator()(JNIEnv *env, jobject obj)
{
if (env->IsSameObject(obj, NULL) == JNI_TRUE)
return Qnil;
if (!initConvertor(env))
{
env->ThrowNew(getJNIClass(RHODES_JAVA_CLASS_RUNTIME_EXCEPTION), "Java <=> Ruby conversion initialization failed");
return Qnil;
}
if (env->IsInstanceOf(obj, clsString))
{
const char *str = env->GetStringUTFChars(static_cast<jstring>(obj), JNI_FALSE);
VALUE res = rho_ruby_create_string(str);
env->ReleaseStringUTFChars(static_cast<jstring>(obj), str);
return res;
}
if (env->IsInstanceOf(obj, clsMap))
return convertJavaMapToRubyHash(env, obj);
RAWLOG_ERROR("rho_cast<VALUE, jobject>: unknown type of value");
return Qnil;
}
HStringMap
rho_cast_helper<HStringMap, jobject>::operator()(JNIEnv *env, jobject jObj)
{
RAWTRACE("rho_cast<HStringMap, jobject>");
value_type result(new value_type::element_type);
if (!initConvertor(env)) return value_type(0);
jhobject jSet = env->CallObjectMethod(jObj, midMapKeySet);
if (!jSet) return value_type(0);
jhobject jIterator = env->CallObjectMethod(jSet.get(), midSetIterator);
if (!jIterator) return value_type(0);
while(env->CallBooleanMethod(jIterator.get(), midIteratorHasNext))
{
jhstring jkey = static_cast<jstring>(env->CallObjectMethod(jIterator.get(), midIteratorNext));
jhstring jval = static_cast<jstring>(env->CallObjectMethod(jObj, midMapGet, jkey.get()));
std::string key = rho_cast<std::string>(env, jkey);
std::string val = rho_cast<std::string>(env, jval);
result->put(key, val);
}
return result;
}
jobject rho_cast_helper<jobject, rho::Vector<std::string> >::operator()(JNIEnv* env, const rho::Vector<std::string>& stringVector)
{
RAWTRACE("rho_cast<jobject, HStringVector>");
if (!initConvertor(env)) return 0;
jobject jArray = env->NewObject(clsArrayList, midArrayList);
if(!jArray) return 0;
for(std::vector<std::string>::const_iterator iter = stringVector.begin(); iter != stringVector.end(); ++iter)
{
jhstring jhItem = rho_cast<jstring>(env, *iter);
env->CallBooleanMethod(jArray, midArrayListAdd, jhItem.get());
}
return jArray;
}
jobject rho_cast_helper<jobject, VALUE>::operator()(JNIEnv *env, VALUE value)
{
RAWTRACE("rho_cast<jobject, VALUE>");
if (NIL_P(value))
return 0;
if (!initConvertor(env))
return 0;
switch(TYPE(value))
{
case RUBY_T_SYMBOL:
value = rb_funcall(value, rb_intern("to_s"), 0);
case RUBY_T_STRING:
RAWTRACE("Convert to String object");
return env->NewStringUTF(RSTRING_PTR(value));
case RUBY_T_ARRAY:
RAWTRACE("Convert to Collection object");
return convertRubyArrayToJavaCollection(value);
case RUBY_T_HASH:
RAWTRACE("Convert to Map object");
return convertRubyHashToJavaMap(value);
case RUBY_T_TRUE:
RAWTRACE("Convert to TRUE Boolean obeject");
return RhoJniConvertor::getBooleanObject(true);
case RUBY_T_FALSE:
RAWTRACE("Convert to FALSE Boolean object");
return RhoJniConvertor::getBooleanObject(false);
case RUBY_T_FIXNUM:
case RUBY_T_BIGNUM:
RAWTRACE("Convert to Integer object");
return RhoJniConvertor::getIntegerObject(NUM2LONG(value));
case RUBY_T_FLOAT:
case RUBY_T_RATIONAL:
RAWTRACE("Convert to Double object");
return RhoJniConvertor::getDoubleObject(NUM2DBL(value));
}
RAWLOG_ERROR1("rho_cast<jobject, VALUE>: wrong type of VALUE: %d", TYPE(value));
return 0;
}
jobject PropertyMapConvertor<VALUE>::convertToPropertyMap(JNIEnv *env, VALUE value)
{
if (NIL_P(value))
return 0;
if (!initConvertor(env))
return 0;
m_jObject = env->NewObject(clsHashMap, midHashMap);
if(env->ExceptionCheck() == JNI_TRUE)
{
rho::String message = rho::common::clearException(env);
RAWLOG_ERROR(message.c_str());
return 0;
}
rho_ruby_enum_hash(value, rubyHashElementToProperty, this);
return m_jObject;
}
HStringVector
rho_cast_helper<HStringVector, jobject>::operator ()(JNIEnv *env, jobject jList)
{
RAWTRACE("rho_cast<HStringVector, jobject>");
value_type result(new value_type::element_type);
if (!initConvertor(env)) return value_type(0);
jhobject jhIterator = env->CallObjectMethod(jList, midCollectionIterator);
if (!jhIterator) return value_type(0);
while(env->CallBooleanMethod(jhIterator.get(), midIteratorHasNext))
{
jhstring jhVal = static_cast<jstring>(env->CallObjectMethod(jhIterator.get(), midIteratorNext));
std::string val = rho_cast<std::string>(env, jhVal);
result->push_back(val);
}
return result;
}
