type_converter.h

Go to the documentation of this file.

/*
 * Copyright (c) 2010-2014:  Steinbeis Forschungszentrum (STZ Ölbronn)
 * Author: Michael Hoffer
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 */
 
#ifndef TYPE_CONVERTER_H
#define TYPE_CONVERTER_H
 
#include <jni.h>
#include <string>
#include <vector>
#include "registry/class.h"
#include "registry/registry.h"
#include "messaging.h"
 
 
// we are not sure whether NULL is equivalent to null object in Java.
// thus, we use this define that allows us to change that easily in the future
#define JNULL NULL;
 
namespace ug {
namespace vrl {
 
//  added by Christian Poliwoda
//  christian.poliwoda@gcsc.uni-frankfurt.de
//  y 13 m 10 d 31
struct TypeAndArray {
  ug::Variant::Type type;
  bool isArray;
};
 
jstring stringC2J(JNIEnv *env, const char* s);
 
std::string stringJ2C(JNIEnv *env, jstring const& s);
 
jobjectArray stringArrayC2J(JNIEnv *env, const std::string* strings);
 
jobjectArray stringArrayC2J(
    JNIEnv *env,
    std::vector<std::string> const& strings);
 
std::vector<std::string> stringArrayJ2C(
    JNIEnv *env, jobjectArray const& array);
 
inline bool boolJ2C(jboolean b) {
  return b == JNI_TRUE;
}
 
inline jboolean boolC2J(bool b) {
  return b ? JNI_TRUE : JNI_FALSE;
}
 
jobject boolean2JObject(JNIEnv *env, jboolean value);
 
jboolean jObject2Boolean(JNIEnv *env, jobject obj);
 
jobject int2JObject(JNIEnv *env, jint value);
 
jint jObject2Int(JNIEnv *env, jobject obj);
 
jobject double2JObject(JNIEnv *env, jdouble value);
 
jdouble jObject2Double(JNIEnv *env, jobject obj);
 
jobject string2JObject(JNIEnv *env, const char* value);
 
std::string jObject2String(JNIEnv *env, jobject obj);
 
jobject pointer2JObject(JNIEnv *env, void* value);
 
jobject constPointer2JObject(JNIEnv *env, const void* value);
 
jobject smartPointer2JObject(JNIEnv *env, SmartPtr<void> value);
 
jobject constSmartPointer2JObject(JNIEnv *env, ConstSmartPtr<void> value);
 
bool isJSmartPointerConst(JNIEnv *env, jobject ptr);
 
void invalidateJSmartPointer(JNIEnv *env, jobject obj);
 
void invalidateJConstSmartPointer(JNIEnv *env, jobject obj);
 
bool isConstJPtr(JNIEnv* env, jobject obj);
 
void* jObject2Pointer(JNIEnv *env, jobject obj);
 
std::string jPointerGetName(JNIEnv *env, jobject obj);
 
 
//  added by Christian Poliwoda
//  christian.poliwoda@gcsc.uni-frankfurt.de
//  y 13 m 05 d 28
bool isJObjectAnArray(JNIEnv *env, jobject value);
 
void jObject2BoolVector(JNIEnv *env, jobject object, std::vector<bool>& bv);
void jObject2IntVector(JNIEnv *env, jobject object, std::vector<int>& iv);
void jObject2SizetVector(JNIEnv *env, jobject object, std::vector<size_t>& stv);
void jObject2NumberVector(JNIEnv *env, jobject object, std::vector<number>& nv);
void jObject2stdStringVector(JNIEnv *env, jobject object, std::vector<std::string>& sv);
void jObject2PtrVector
(
  JNIEnv *env,
  jobject object,
  ug::Variant::Type jo_type,
  ug::bridge::Registry* reg,
  std::vector<std::pair<void*, const ug::bridge::ClassNameNode*> >& pv
);
void jObject2SmartPtrVector
(
  JNIEnv *env,
  jobject object,
  ug::bridge::Registry* reg,
  std::vector<std::pair<SmartPtr<void>, const ug::bridge::ClassNameNode*> >& pv
);
void jObject2ConstSmartPtrVector
(
  JNIEnv *env,
  jobject object,
  ug::Variant::Type jo_type,
  ug::bridge::Registry* reg,
  std::vector<std::pair<ConstSmartPtr<void>, const ug::bridge::ClassNameNode*> >& pv
);
 
jobject boolVector2JObject(JNIEnv* env, const std::vector<bool>& bv);
 
jobject intVector2JObject(JNIEnv* env, const std::vector<int>& iv);
 
jobject sizetVector2JObject(JNIEnv* env, const std::vector<size_t>& iv);
 
jobject numberVector2JObject(JNIEnv* env, const std::vector<number>& nv);
 
jobject cStringVector2JObject(JNIEnv* env, const std::vector<const char*>& sv);
 
jobject stdStringVector2JObject(JNIEnv* env, const std::vector<std::string>& sv);
 
jobject ptrVector2JObject(JNIEnv* env, const std::vector<void*>& pv);
 
jobject constPtrVector2JObject(JNIEnv* env, const std::vector<const void*>& pv);
 
jobject smartPtrVector2JObject(JNIEnv* env, const std::vector<SmartPtr<void> >& pv);
 
jobject constSmartPtrVector2JObject(JNIEnv* env, const std::vector<ConstSmartPtr<void> >& pv);
 
void jobjectArray2ParamStack(JNIEnv *env,
    ug::bridge::Registry* reg,
    ug::bridge::ParameterStack& paramsOut,
    const ug::bridge::ParameterInfo& paramsTemplate,
    jobjectArray const& array);
 
jobjectArray createEmptyJavaArray(
    JNIEnv *env, std::string className);
 
jobjectArray createEmptyJavaArray(
    JNIEnv *env, jclass elementClass);
 
jobject param2JObject(JNIEnv *env,
    ug::bridge::ParameterStack& params, size_t index);
 
jobject getClass(JNIEnv *env, jobject obj);
 
std::string getClassName(JNIEnv *env, jobject obj);
 
std::string getParamClassName(JNIEnv *env, jobject obj);
 
TypeAndArray paramClass2ParamType(JNIEnv *env, jobject obj);
 
bool compareParamTypes(JNIEnv *env, jobjectArray params,
        ug::bridge::Registry *reg,
    const ug::bridge::ParameterInfo& paramStack,
                bool allowSmartToRawPtrConversion = false);
 
const std::vector<const ug::bridge::IExportedClass*> getParentClasses(
    ug::bridge::Registry* reg,
    const ug::bridge::IExportedClass* clazz);
 
 
jobject registry2NativeAPI(JNIEnv *env, ug::bridge::Registry* reg);
 
std::vector<const char*> getBaseClassNames(const ug::bridge::ClassNameNode* node);
 
std::string getParamTypeAsString(const uint type);
 
std::string getParamTypesAsString(JNIEnv *env, jobjectArray const& array);
 
void throwUgErrorAsJavaException(JNIEnv *env, ug::UGError error);
 
void throwUgErrorAsJavaException(JNIEnv *env, std::string error);
 
}// end vrl::
}// end ug::
 
#endif  /* TYPE_CONVERTER_H */