/*
* Class: java_lang_VMClassRegistry
* Method: loadLibrary
* Signature: (Ljava/lang/String;Ljava/lang/ClassLoader;)V
*/
JNIEXPORT void JNICALL Java_java_lang_VMClassRegistry_loadLibrary
(JNIEnv *jenv, jclass, jstring filename, jobject classLoader)
{
// check filename
if (! filename)
{
jclass exc_class = FindClass(jenv, VM_Global_State::loader_env->JavaLangNullPointerException_String);
ThrowNew(jenv, exc_class, "null file name value.");
return;
}
// get filename char string
const char *str_filename = GetStringUTFChars(jenv, filename, NULL);
// load native library
Class_Loader_Handle loader;
if( classLoader ) {
loader = class_loader_lookup(classLoader);
} else {
// bootstrap class loader
loader = (Class_Loader_Handle)
jni_get_vm_env(jenv)->bootstrap_class_loader;
}
class_loader_load_native_lib(str_filename, loader);
// release char string
ReleaseStringUTFChars(jenv, filename, str_filename);
}
/*
* Class: java_lang_VMClassRegistry
* Method: defineClass
* Signature: (Ljava/lang/String;[BII)Ljava/lang/Class;
*/
JNIEXPORT jclass JNICALL Java_java_lang_ClassLoader_defineClass0
(JNIEnv *jenv, jobject cl, jstring name, jbyteArray data, jint offset, jint len)
{
const char* clssname = NULL;
// obtain char * for the name if provided
if(name) {
clssname = GetStringUTFChars(jenv, name, NULL);
}
// obtain raw classfile data data pointer
jboolean is_copy;
jbyte *bytes = GetByteArrayElements(jenv, data, &is_copy);
assert(bytes);
// define class
jclass clss = DefineClass(jenv, clssname, cl, bytes + offset, len);
// release JNI objects
ReleaseByteArrayElements(jenv, data, bytes, 0);
if(clssname)
ReleaseStringUTFChars(jenv, name, clssname);
return clss;
}
const char *
getClassName(JNIEnv *env, jclass klass, jboolean *isCopy)
{
const char *tmp;
jstring str = get_java_class_name(env, klass);
tmp = VMENV GetStringUTFChars(env, str, isCopy);
return(tmp);
}
std::string JObjectWrapper<jstring>::toStdString() const {
const auto env = internal::getEnv();
auto modified = env->GetStringUTFChars(self(), nullptr);
auto length = env->GetStringUTFLength(self());
auto string = detail::modifiedUTF8ToUTF8(reinterpret_cast<const uint8_t*>(modified), length);
env->ReleaseStringUTFChars(self(), modified);
return string;
}
/*
* Class: java_lang_VMClassRegistry
* Method: findLoadedClass
* Signature: (Ljava/lang/String;Ljava/lang/ClassLoader;)Ljava/lang/Class;
*/
JNIEXPORT jclass JNICALL Java_java_lang_ClassLoader_findLoadedClass
(JNIEnv *jenv, jobject cl, jstring name)
{
if (NULL == name) {
return NULL;
}
const char* buf = GetStringUTFChars(jenv, name, NULL);
Class_Loader_Handle loader = class_loader_lookup(cl);
Class_Handle clss = class_find_loaded(loader, buf);
ReleaseStringUTFChars(jenv, name, buf);
return clss ? jni_class_from_handle(jenv, clss) : NULL;
}
cinder::fs::path CinderNativeActivity::getPicturesDirectory()
{
cinder::fs::path result;
auto jniEnv = JniHelper::Get()->AttachCurrentThread();
if( jniEnv ) {
jstring jstr = (jstring)jniEnv->CallObjectMethod( getInstance()->getJavaObject(), Java::getPicturesDirectory );
const char * c_str = jniEnv->GetStringUTFChars( jstr, nullptr );
result = std::string( c_str );
jniEnv->ReleaseStringUTFChars( jstr, c_str );
}
return result;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
std::string CreateSTDStringFromJString(jstring in_jString)
{
if (in_jString == nullptr)
{
return "";
}
auto environment = JavaVirtualMachine::Get()->GetJNIEnvironment();
const char * cString = environment->GetStringUTFChars(in_jString, JNI_FALSE);
CS_ASSERT(cString != nullptr, "String returned from GetStringUTFChars() cannot be null.");
std::string output = std::string(cString);
environment->ReleaseStringUTFChars(in_jString, cString);
return output;
}
char* JniFirebase::GetKey()
{
if (!m_firebase) {
return NULL;
}
auto env = getEnv();
if (!GetMethod(env, s_firebaseClass, s_firebaseGetKeyName, s_firebaseGetKeySig, &s_firebaseGetKey)) {
return NULL;
}
JSTRING java_string = JSTRING(env, (jstring)env->CallObjectMethod(m_firebase, s_firebaseGetKey));
if((jstring)java_string == NULL){
return NULL;
}
const char* utf_string = env->GetStringUTFChars(java_string, NULL);
#if _WIN64
char* result = _strdup(utf_string);
#else
char* result = strdup(utf_string);
#endif
env->ReleaseStringUTFChars(java_string, utf_string);
return result;
}
JNIEXPORT jclass JNICALL Java_java_lang_VMClassRegistry_loadBootstrapClass
(JNIEnv *jenv, jclass, jstring name)
{
// obtain char* for the name
const char* buf = GetStringUTFChars(jenv, name, NULL);
// set flag to detect if the requested class is not on the bootclasspath
p_TLS_vmthread->class_not_found = true;
Class_Handle clss = class_find_class_from_loader(NULL, buf, FALSE);
ReleaseStringUTFChars(jenv, name, buf);
if (clss) {
// filter out primitive types for compatibility
return clss->is_primitive() ? NULL : jni_class_from_handle(jenv, clss);
} else {
assert(exn_raised());
if(p_TLS_vmthread->class_not_found)
{
// the requested class is not on the bootclasspath
// delegation model requires letting child loader(s) to continue
// with searching on their paths, so reset the exception
exn_clear();
}
return NULL;
}
}
USER_OBJECT_
RS_JAVA(MethodConverter)(jobject obj, jclass type, JNIEnv *env, RSFromJavaConverter *converter)
{
int i = 0, k, n;
int numSlots;
USER_OBJECT_ ans, names;
const char *tmp;
jboolean isCopy;
jstring jval;
jclass klass;
jobject jsig, jobj;
ReflectanceMethodIDs *mids;
boolean isMethod;
jint modifier;
if(ModifierStringID == NULL)
initReflectanceMethods(env);
/* Determine whether we have a constructor or method
and set the method identifiers and number of slots
appropriately.
*/
isMethod = VMENV IsSameObject(env, type, VMENV FindClass(env, "java/lang/reflect/Method")) == JNI_TRUE;
if(isMethod) {
mids = &MethodIDs;
numSlots = 6;
} else {
mids = &ConstructorIDs;
numSlots = 5; /* Drop out the */
}
PROTECT(ans = NEW_LIST(numSlots));
PROTECT(names = NEW_CHARACTER(numSlots));
SET_VECTOR_ELT(ans, i, NEW_CHARACTER(1));
jval = VMENV CallObjectMethod(env, obj, mids->getName);
tmp = VMENV GetStringUTFChars(env, jval, &isCopy);
SET_STRING_ELT(VECTOR_ELT(ans, i), 0, COPY_TO_USER_STRING(tmp));
if(isCopy)
VMENV ReleaseStringUTFChars(env, jval, tmp);
SET_STRING_ELT(names, i, COPY_TO_USER_STRING("name"));
i++;
SET_VECTOR_ELT(ans, i, NEW_CHARACTER(1));
klass = VMENV CallObjectMethod(env, obj, mids->getClass);
tmp = getClassName(env, klass, &isCopy);
SET_STRING_ELT(VECTOR_ELT(ans, i), 0, COPY_TO_USER_STRING(tmp));
SET_STRING_ELT(names, i, COPY_TO_USER_STRING("Declaring class"));
i++;
jsig = VMENV CallObjectMethod(env, obj, mids->getParameters);
n = VMENV GetArrayLength(env, jsig);
SET_VECTOR_ELT(ans, i, NEW_CHARACTER(n));
for(k = 0; k < n ; k++) {
jobj = VMENV GetObjectArrayElement(env, jsig, k);
tmp = getClassName(env, jobj, &isCopy);
SET_STRING_ELT(VECTOR_ELT(ans, i), k, COPY_TO_USER_STRING(tmp));
}
SET_STRING_ELT(names, i, COPY_TO_USER_STRING("Parameters"));
i++;
SET_VECTOR_ELT(ans, i, NEW_INTEGER(1));
modifier = VMENV CallIntMethod(env, obj, mids->getModifiers);
INTEGER_DATA(VECTOR_ELT(ans, i))[0] = modifier;
SET_STRING_ELT(names, i, COPY_TO_USER_STRING("Modifiers"));
{
/* Now get the string that represents the modifier value.
Do this by calling the static method toString(int)
in the java.lang.reflect.Modifier class.
We assume we have initialized the ModifierStringID
method id earlier when getting all the method ids
for the reflectance classes.
*/
USER_OBJECT_ tmpr;
const char *modName;
jstring jmodName;
PROTECT(tmpr = NEW_CHARACTER(1));
jmodName = VMENV CallStaticObjectMethod(env, (jclass)VMENV FindClass(env, "java/lang/reflect/Modifier"), ModifierStringID, modifier);
if(jmodName != NULL_JAVA_OBJECT) {
modName = VMENV GetStringUTFChars(env, jmodName, &isCopy);
SET_STRING_ELT(tmpr, 0, COPY_TO_USER_STRING(modName));
}
SET_NAMES(VECTOR_ELT(ans, i), tmpr);
UNPROTECT(1);
}
i++;
jsig = VMENV CallObjectMethod(env, obj, mids->getExceptions);
n = VMENV GetArrayLength(env, jsig);
SET_VECTOR_ELT(ans, i, NEW_CHARACTER(n));
for(k = 0; k < n ; k++) {
jobj = VMENV GetObjectArrayElement(env, jsig, k);
tmp = getClassName(env, jobj, &isCopy);
SET_STRING_ELT(VECTOR_ELT(ans, i), k, COPY_TO_USER_STRING(tmp));
}
SET_STRING_ELT(names, i, COPY_TO_USER_STRING("Exceptions"));
i++;
if(isMethod) {
SET_VECTOR_ELT(ans, i, NEW_CHARACTER(1));
klass = VMENV CallObjectMethod(env, obj, mids->getReturnType);
tmp = getClassName(env, klass, &isCopy);
SET_VECTOR_ELT(VECTOR_ELT(ans, i), 0, COPY_TO_USER_STRING(tmp));
SET_STRING_ELT(names, i, COPY_TO_USER_STRING("Return type"));
i++;
}
SET_NAMES(ans, names);
/* Now set the class to be "JavaMethod" */
UNPROTECT(2);
return(ans);
}
JNIEXPORT jobjectArray JNICALL Java_org_tmu_core_Nauty_canonize
(JNIEnv * env, jobject thisobj, jobjectArray arr, jint k){
int subgraph_size=0;
graph g[MAXN*MAXM];
graph canong[MAXN*MAXM];
int lab[MAXN],ptn[MAXN],orbits[MAXN];
static DEFAULTOPTIONS_DIGRAPH(options);
statsblk stats;
subgraph_size=k;
if (subgraph_size > MAXN)
{
printf("size of graph must be in the range 1..%d\n",MAXN);
return NULL;
}
options.defaultptn = TRUE;
options.getcanon = TRUE;
char bin_adj[BUFSIZE];
char zeroed_adj[BUFSIZE];
char str[BUFSIZE];
int n=subgraph_size;
int m=SETWORDSNEEDED(n);
nauty_check(WORDSIZE,m,n,NAUTYVERSIONID);
int stringCount = GetArrayLength(env, arr);
jobjectArray ret;
ret= (jobjectArray)env->NewObjectArray(stringCount,
env->FindClass("java/lang/String"),
env->NewStringUTF(""));
for (int i=0; i<stringCount; i++) {
jstring string = (jstring) GetObjectArrayElement(env, arr, i);
const char *rawString = GetStringUTFChars(env, string, 0);
strcpy(bin_adj,rawString);
ReleaseStringUTFChars(rawString);
int bin_len=strlen(bin_adj);
if(bin_len<subgraph_size*subgraph_size){
memset(zeroed_adj,'0',subgraph_size*subgraph_size-bin_len);
}
strcpy(zeroed_adj+subgraph_size*subgraph_size-bin_len,bin_adj);
EMPTYGRAPH(g,m,n);
for (int i = 0; i < subgraph_size; i++)
for (int j = 0; j < subgraph_size; j++)
if (i!=j&&zeroed_adj[i * subgraph_size + j] == '1')
ADDONEARC(g,i,j,m);
densenauty(g,lab,ptn,orbits,&options,&stats,m,n,canong);
memset(str,'0',subgraph_size*subgraph_size);
for (int i = 0; i < subgraph_size; i++) {
for(int j = 0; j < subgraph_size; j++) {
if(i!=j&&zeroed_adj[lab[i]*subgraph_size+lab[j]]=='1')
str[i*subgraph_size+j]='1';
}
}
str[subgraph_size*subgraph_size]=0;
env->SetObjectArrayElement(ret,i,env->NewStringUTF(str));
}
return ret;
}
