You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@reef.apache.org by mo...@apache.org on 2016/07/08 00:31:07 UTC
[2/2] reef git commit: [REEF-997] Fix spacing in C++ files
[REEF-997] Fix spacing in C++ files
This addressed the issue by
* Fixed the indentation in C++ files in REEF Bridge: tabs to double spaces
JIRA:
[REEF-997](https://issues.apache.org/jira/browse/REEF-997)
Project: http://git-wip-us.apache.org/repos/asf/reef/repo
Commit: http://git-wip-us.apache.org/repos/asf/reef/commit/8557f0f2
Tree: http://git-wip-us.apache.org/repos/asf/reef/tree/8557f0f2
Diff: http://git-wip-us.apache.org/repos/asf/reef/diff/8557f0f2
Branch: refs/heads/master
Commit: 8557f0f2ad163d703ac7fc4713d4e82b6a945d9f
Parents: 4f85dd7
Author: JiEun Lee <sm...@gmail.com>
Authored: Fri Jul 1 16:00:37 2016 +0900
Committer: Sergiy Matusevych <mo...@apache.org>
Committed: Thu Jul 7 17:29:28 2016 -0700
----------------------------------------------------------------------
.../ActiveContextClr2Java.cpp | 308 ++++++++---------
.../AllocatedEvaluatorClr2Java.cpp | 328 +++++++++----------
.../ClosedContextClr2Java.cpp | 188 +++++------
.../Org.Apache.REEF.Bridge/CommonUtilities.cpp | 54 +--
.../CompletedEvaluatorClr2Java.cpp | 90 ++---
.../CompletedTaskClr2Java.cpp | 134 ++++----
.../ContextMessageClr2Java.cpp | 130 ++++----
.../DriverRestartCompletedClr2Java.cpp | 96 +++---
.../DriverRestartedClr2Java.cpp | 118 +++----
.../EvaluatorRequestorClr2Java.cpp | 142 ++++----
.../FailedContextClr2Java.cpp | 188 +++++------
.../FailedEvaluatorClr2Java.cpp | 126 +++----
.../FailedTaskClr2Java.cpp | 124 +++----
.../HttpServerClr2Java.cpp | 252 +++++++-------
.../cs/Org.Apache.REEF.Bridge/InteropLogger.cpp | 58 ++--
lang/cs/Org.Apache.REEF.Bridge/InteropUtil.cpp | 8 +-
.../cs/Org.Apache.REEF.Bridge/JavaClrBridge.cpp | 148 ++++-----
.../RunningTaskClr2Java.cpp | 250 +++++++-------
.../SuspendedTaskClr2Java.cpp | 132 ++++----
.../TaskMessageClr2Java.cpp | 114 +++----
.../common/driver/DriverExceptionHandler.java | 1 +
21 files changed, 1495 insertions(+), 1494 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/reef/blob/8557f0f2/lang/cs/Org.Apache.REEF.Bridge/ActiveContextClr2Java.cpp
----------------------------------------------------------------------
diff --git a/lang/cs/Org.Apache.REEF.Bridge/ActiveContextClr2Java.cpp b/lang/cs/Org.Apache.REEF.Bridge/ActiveContextClr2Java.cpp
index b3e8685..58cf186 100644
--- a/lang/cs/Org.Apache.REEF.Bridge/ActiveContextClr2Java.cpp
+++ b/lang/cs/Org.Apache.REEF.Bridge/ActiveContextClr2Java.cpp
@@ -18,158 +18,158 @@
#include "Clr2JavaImpl.h"
namespace Org {
- namespace Apache {
- namespace REEF {
- namespace Driver {
- namespace Bridge {
- namespace Clr2java {
- private ref class ManagedLog {
- internal:
- static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
- };
-
- ActiveContextClr2Java::ActiveContextClr2Java(JNIEnv *env, jobject jobjectActiveContext) {
- ManagedLog::LOGGER->LogStart("ActiveContextClr2Java::ActiveContextClr2Java");
- pin_ptr<JavaVM*> pJavaVm = &_jvm;
- if (env->GetJavaVM(pJavaVm) != 0) {
- ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
- }
-
- _jobjectActiveContext = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectActiveContext));
-
- jclass jclassActiveContext = env->GetObjectClass(_jobjectActiveContext);
- jmethodID jmidGetContextId = env->GetMethodID(jclassActiveContext, "getContextId", "()Ljava/lang/String;");
- _jstringId = CommonUtilities::CallGetMethodNewGlobalRef<jstring>(env, _jobjectActiveContext, jmidGetContextId);
- jmethodID jmidGetParentContextId = env->GetMethodID(jclassActiveContext, "getParentContextId", "()Ljava/lang/String;");
- _jstringParentId = CommonUtilities::CallGetMethodNewGlobalRef<jstring>(env, _jobjectActiveContext, jmidGetParentContextId);
- _jstringEvaluatorId = CommonUtilities::GetJObjectEvaluatorId(env, _jobjectActiveContext, jclassActiveContext);
-
- ManagedLog::LOGGER->LogStop("ActiveContextClr2Java::ActiveContextClr2Java");
- }
-
- ActiveContextClr2Java::~ActiveContextClr2Java() {
- this->!ActiveContextClr2Java();
- }
-
- ActiveContextClr2Java::!ActiveContextClr2Java() {
- JNIEnv *env = RetrieveEnv(_jvm);
- if (_jobjectActiveContext != NULL) {
- env->DeleteGlobalRef(_jobjectActiveContext);
- }
-
- if (_jstringId != NULL) {
- env->DeleteGlobalRef(_jstringId);
- }
-
- if (_jstringEvaluatorId != NULL) {
- env->DeleteGlobalRef(_jstringEvaluatorId);
- }
- }
-
- void ActiveContextClr2Java::SubmitTask(String^ taskConfigStr) {
- ManagedLog::LOGGER->LogStart("ActiveContextClr2Java::SubmitTask");
- JNIEnv *env = RetrieveEnv(_jvm);
- jclass jclassActiveContext = env->GetObjectClass(_jobjectActiveContext);
- jmethodID jmidSubmitTask = env->GetMethodID(jclassActiveContext, "submitTaskString", "(Ljava/lang/String;)V");
-
- if (jmidSubmitTask == NULL) {
- ManagedLog::LOGGER->Log("jmidSubmitTask is NULL");
- return;
- }
- env->CallObjectMethod(
- _jobjectActiveContext,
- jmidSubmitTask,
- JavaStringFromManagedString(env, taskConfigStr));
- ManagedLog::LOGGER->LogStop("ActiveContextClr2Java::SubmitTask");
- }
-
- void ActiveContextClr2Java::SubmitContext(String^ contextConfigStr) {
- SubmitContextAndService(contextConfigStr, nullptr);
- }
-
- void ActiveContextClr2Java::SubmitContextAndService(String^ contextConfigStr, String^ serviceConfigStr) {
- JNIEnv *env = RetrieveEnv(_jvm);
- jclass jclassActiveContext = env->GetObjectClass(_jobjectActiveContext);
- jmethodID jmidSubmitContext =
- env->GetMethodID(jclassActiveContext, "submitContextStringAndServiceString", "(Ljava/lang/String;Ljava/lang/String;)V");
-
- if (jmidSubmitContext == NULL) {
- ManagedLog::LOGGER->Log("jmidSubmitContextStringAndServiceString is NULL");
- return;
- }
-
- const jstring serviceConfigJavaStr =
- serviceConfigStr == nullptr ? NULL : JavaStringFromManagedString(env, serviceConfigStr);
-
- env->CallObjectMethod(
- _jobjectActiveContext,
- jmidSubmitContext,
- JavaStringFromManagedString(env, contextConfigStr),
- serviceConfigJavaStr);
- }
-
- void ActiveContextClr2Java::OnError(String^ message) {
- JNIEnv *env = RetrieveEnv(_jvm);
- HandleClr2JavaError(env, message, _jobjectActiveContext);
- }
-
- void ActiveContextClr2Java::Close() {
- ManagedLog::LOGGER->LogStart("ActiveContextClr2Java::Close");
- JNIEnv *env = RetrieveEnv(_jvm);
- jclass jclassActiveContext = env->GetObjectClass(_jobjectActiveContext);
- jmethodID jmidClose = env->GetMethodID(jclassActiveContext, "close", "()V");
-
- if (jmidClose == NULL) {
- ManagedLog::LOGGER->Log("jmidClose is NULL");
- return;
- }
- env->CallObjectMethod(
- _jobjectActiveContext,
- jmidClose);
- ManagedLog::LOGGER->LogStop("ActiveContextClr2Java::Close");
- }
-
- String^ ActiveContextClr2Java::GetParentId() {
- JNIEnv *env = RetrieveEnv(_jvm);
- return ManagedStringFromJavaString(env, _jstringParentId);
- }
-
- String^ ActiveContextClr2Java::GetId() {
- JNIEnv *env = RetrieveEnv(_jvm);
- return ManagedStringFromJavaString(env, _jstringId);
- }
-
- String^ ActiveContextClr2Java::GetEvaluatorId() {
- JNIEnv *env = RetrieveEnv(_jvm);
- return ManagedStringFromJavaString(env, _jstringEvaluatorId);
- }
-
- IEvaluatorDescriptor^ ActiveContextClr2Java::GetEvaluatorDescriptor() {
- ManagedLog::LOGGER->LogStart("ActiveContextClr2Java::GetEvaluatorDescriptor");
- return CommonUtilities::RetrieveEvaluatorDescriptor(_jobjectActiveContext, _jvm);
- }
-
- void ActiveContextClr2Java::SendMessage(array<byte>^ message) {
- ManagedLog::LOGGER->LogStart("ActiveContextClr2Java::SendMessage");
- JNIEnv *env = RetrieveEnv(_jvm);
- jclass jclassActiveContext = env->GetObjectClass(_jobjectActiveContext);
- jmethodID jmidSendMessage = env->GetMethodID(jclassActiveContext, "sendMessage", "([B)V");
-
- if (jmidSendMessage == NULL) {
- ManagedLog::LOGGER->Log("jmidSendMessage is NULL");
- return;
- }
-
- env->CallObjectMethod(
- _jobjectActiveContext,
- jmidSendMessage,
- JavaByteArrayFromManagedByteArray(env, message));
-
- ManagedLog::LOGGER->LogStop("ActiveContextClr2Java::SendMessage");
- }
- }
- }
- }
- }
- }
+ namespace Apache {
+ namespace REEF {
+ namespace Driver {
+ namespace Bridge {
+ namespace Clr2java {
+ private ref class ManagedLog {
+ internal:
+ static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
+ };
+
+ ActiveContextClr2Java::ActiveContextClr2Java(JNIEnv *env, jobject jobjectActiveContext) {
+ ManagedLog::LOGGER->LogStart("ActiveContextClr2Java::ActiveContextClr2Java");
+ pin_ptr<JavaVM*> pJavaVm = &_jvm;
+ if (env->GetJavaVM(pJavaVm) != 0) {
+ ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
+ }
+
+ _jobjectActiveContext = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectActiveContext));
+
+ jclass jclassActiveContext = env->GetObjectClass(_jobjectActiveContext);
+ jmethodID jmidGetContextId = env->GetMethodID(jclassActiveContext, "getContextId", "()Ljava/lang/String;");
+ _jstringId = CommonUtilities::CallGetMethodNewGlobalRef<jstring>(env, _jobjectActiveContext, jmidGetContextId);
+ jmethodID jmidGetParentContextId = env->GetMethodID(jclassActiveContext, "getParentContextId", "()Ljava/lang/String;");
+ _jstringParentId = CommonUtilities::CallGetMethodNewGlobalRef<jstring>(env, _jobjectActiveContext, jmidGetParentContextId);
+ _jstringEvaluatorId = CommonUtilities::GetJObjectEvaluatorId(env, _jobjectActiveContext, jclassActiveContext);
+
+ ManagedLog::LOGGER->LogStop("ActiveContextClr2Java::ActiveContextClr2Java");
+ }
+
+ ActiveContextClr2Java::~ActiveContextClr2Java() {
+ this->!ActiveContextClr2Java();
+ }
+
+ ActiveContextClr2Java::!ActiveContextClr2Java() {
+ JNIEnv *env = RetrieveEnv(_jvm);
+ if (_jobjectActiveContext != NULL) {
+ env->DeleteGlobalRef(_jobjectActiveContext);
+ }
+
+ if (_jstringId != NULL) {
+ env->DeleteGlobalRef(_jstringId);
+ }
+
+ if (_jstringEvaluatorId != NULL) {
+ env->DeleteGlobalRef(_jstringEvaluatorId);
+ }
+ }
+
+ void ActiveContextClr2Java::SubmitTask(String^ taskConfigStr) {
+ ManagedLog::LOGGER->LogStart("ActiveContextClr2Java::SubmitTask");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ jclass jclassActiveContext = env->GetObjectClass(_jobjectActiveContext);
+ jmethodID jmidSubmitTask = env->GetMethodID(jclassActiveContext, "submitTaskString", "(Ljava/lang/String;)V");
+
+ if (jmidSubmitTask == NULL) {
+ ManagedLog::LOGGER->Log("jmidSubmitTask is NULL");
+ return;
+ }
+ env->CallObjectMethod(
+ _jobjectActiveContext,
+ jmidSubmitTask,
+ JavaStringFromManagedString(env, taskConfigStr));
+ ManagedLog::LOGGER->LogStop("ActiveContextClr2Java::SubmitTask");
+ }
+
+ void ActiveContextClr2Java::SubmitContext(String^ contextConfigStr) {
+ SubmitContextAndService(contextConfigStr, nullptr);
+ }
+
+ void ActiveContextClr2Java::SubmitContextAndService(String^ contextConfigStr, String^ serviceConfigStr) {
+ JNIEnv *env = RetrieveEnv(_jvm);
+ jclass jclassActiveContext = env->GetObjectClass(_jobjectActiveContext);
+ jmethodID jmidSubmitContext =
+ env->GetMethodID(jclassActiveContext, "submitContextStringAndServiceString", "(Ljava/lang/String;Ljava/lang/String;)V");
+
+ if (jmidSubmitContext == NULL) {
+ ManagedLog::LOGGER->Log("jmidSubmitContextStringAndServiceString is NULL");
+ return;
+ }
+
+ const jstring serviceConfigJavaStr =
+ serviceConfigStr == nullptr ? NULL : JavaStringFromManagedString(env, serviceConfigStr);
+
+ env->CallObjectMethod(
+ _jobjectActiveContext,
+ jmidSubmitContext,
+ JavaStringFromManagedString(env, contextConfigStr),
+ serviceConfigJavaStr);
+ }
+
+ void ActiveContextClr2Java::OnError(String^ message) {
+ JNIEnv *env = RetrieveEnv(_jvm);
+ HandleClr2JavaError(env, message, _jobjectActiveContext);
+ }
+
+ void ActiveContextClr2Java::Close() {
+ ManagedLog::LOGGER->LogStart("ActiveContextClr2Java::Close");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ jclass jclassActiveContext = env->GetObjectClass(_jobjectActiveContext);
+ jmethodID jmidClose = env->GetMethodID(jclassActiveContext, "close", "()V");
+
+ if (jmidClose == NULL) {
+ ManagedLog::LOGGER->Log("jmidClose is NULL");
+ return;
+ }
+ env->CallObjectMethod(
+ _jobjectActiveContext,
+ jmidClose);
+ ManagedLog::LOGGER->LogStop("ActiveContextClr2Java::Close");
+ }
+
+ String^ ActiveContextClr2Java::GetParentId() {
+ JNIEnv *env = RetrieveEnv(_jvm);
+ return ManagedStringFromJavaString(env, _jstringParentId);
+ }
+
+ String^ ActiveContextClr2Java::GetId() {
+ JNIEnv *env = RetrieveEnv(_jvm);
+ return ManagedStringFromJavaString(env, _jstringId);
+ }
+
+ String^ ActiveContextClr2Java::GetEvaluatorId() {
+ JNIEnv *env = RetrieveEnv(_jvm);
+ return ManagedStringFromJavaString(env, _jstringEvaluatorId);
+ }
+
+ IEvaluatorDescriptor^ ActiveContextClr2Java::GetEvaluatorDescriptor() {
+ ManagedLog::LOGGER->LogStart("ActiveContextClr2Java::GetEvaluatorDescriptor");
+ return CommonUtilities::RetrieveEvaluatorDescriptor(_jobjectActiveContext, _jvm);
+ }
+
+ void ActiveContextClr2Java::SendMessage(array<byte>^ message) {
+ ManagedLog::LOGGER->LogStart("ActiveContextClr2Java::SendMessage");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ jclass jclassActiveContext = env->GetObjectClass(_jobjectActiveContext);
+ jmethodID jmidSendMessage = env->GetMethodID(jclassActiveContext, "sendMessage", "([B)V");
+
+ if (jmidSendMessage == NULL) {
+ ManagedLog::LOGGER->Log("jmidSendMessage is NULL");
+ return;
+ }
+
+ env->CallObjectMethod(
+ _jobjectActiveContext,
+ jmidSendMessage,
+ JavaByteArrayFromManagedByteArray(env, message));
+
+ ManagedLog::LOGGER->LogStop("ActiveContextClr2Java::SendMessage");
+ }
+ }
+ }
+ }
+ }
+ }
}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/reef/blob/8557f0f2/lang/cs/Org.Apache.REEF.Bridge/AllocatedEvaluatorClr2Java.cpp
----------------------------------------------------------------------
diff --git a/lang/cs/Org.Apache.REEF.Bridge/AllocatedEvaluatorClr2Java.cpp b/lang/cs/Org.Apache.REEF.Bridge/AllocatedEvaluatorClr2Java.cpp
index 397f536..387888c 100644
--- a/lang/cs/Org.Apache.REEF.Bridge/AllocatedEvaluatorClr2Java.cpp
+++ b/lang/cs/Org.Apache.REEF.Bridge/AllocatedEvaluatorClr2Java.cpp
@@ -21,169 +21,169 @@ using namespace JavaClrBridge;
namespace Org {
namespace Apache {
- namespace REEF {
- namespace Driver {
- namespace Bridge {
- namespace Clr2java {
- ref class ManagedLog {
- internal:
- static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
- };
-
- AllocatedEvaluatorClr2Java::AllocatedEvaluatorClr2Java(JNIEnv *env, jobject jallocatedEvaluator) {
-
- ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::AllocatedEvaluatorClr2Java");
-
- pin_ptr<JavaVM*> pJavaVm = &_jvm;
- if (env->GetJavaVM(pJavaVm) != 0) {
- ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
- }
- _jobjectAllocatedEvaluator = reinterpret_cast<jobject>(env->NewGlobalRef(jallocatedEvaluator));
-
- jclass jclassAllocatedEvaluator = env->GetObjectClass(_jobjectAllocatedEvaluator);
- _jstringId = CommonUtilities::GetJObjectId(env, _jobjectAllocatedEvaluator, jclassAllocatedEvaluator);
-
- jmethodID jmidGetNameServerInfo = env->GetMethodID(jclassAllocatedEvaluator, "getNameServerInfo", "()Ljava/lang/String;");
- _jstringNameServerInfo = CommonUtilities::CallGetMethodNewGlobalRef<jstring>(env, _jobjectAllocatedEvaluator, jmidGetNameServerInfo);
-
- ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::AllocatedEvaluatorClr2Java");
- }
-
- AllocatedEvaluatorClr2Java::~AllocatedEvaluatorClr2Java() {
- this->!AllocatedEvaluatorClr2Java();
- }
-
- AllocatedEvaluatorClr2Java::!AllocatedEvaluatorClr2Java() {
- JNIEnv *env = RetrieveEnv(_jvm);
- if (_jobjectAllocatedEvaluator != NULL) {
- env->DeleteGlobalRef(_jobjectAllocatedEvaluator);
- }
-
- if (_jstringId != NULL) {
- env->DeleteGlobalRef(_jstringId);
- }
-
- if (_jstringNameServerInfo != NULL) {
- env->DeleteGlobalRef(_jstringNameServerInfo);
- }
- }
-
- void AllocatedEvaluatorClr2Java::SubmitContext(String^ evaluatorConfigStr, String^ contextConfigStr) {
- ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::SubmitContext");
- JNIEnv *env = RetrieveEnv(_jvm);
- jclass jclassAllocatedEvaluator = env->GetObjectClass(_jobjectAllocatedEvaluator);
- jmethodID jmidSubmitContext = env->GetMethodID(jclassAllocatedEvaluator, "submitContextString", "(Ljava/lang/String;Ljava/lang/String;)V");
-
- if (jmidSubmitContext == NULL) {
- ManagedLog::LOGGER->Log("jmidSubmitContext is NULL");
- return;
- }
- env->CallObjectMethod(
- _jobjectAllocatedEvaluator,
- jmidSubmitContext,
- JavaStringFromManagedString(env, evaluatorConfigStr),
- JavaStringFromManagedString(env, contextConfigStr));
- ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::SubmitContext");
- }
-
- void AllocatedEvaluatorClr2Java::SubmitContextAndTask(String^ evaluatorConfigStr, String^ contextConfigStr, String^ taskConfigStr) {
- ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::SubmitContextAndTask");
- JNIEnv *env = RetrieveEnv(_jvm);
- jclass jclassAllocatedEvaluator = env->GetObjectClass(_jobjectAllocatedEvaluator);
- jmethodID jmidSubmitContextAndTask = env->GetMethodID(jclassAllocatedEvaluator, "submitContextAndTaskString", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
-
- if (jmidSubmitContextAndTask == NULL) {
- ManagedLog::LOGGER->Log("jmidSubmitContextAndTask is NULL");
- return;
- }
- env->CallObjectMethod(
- _jobjectAllocatedEvaluator,
- jmidSubmitContextAndTask,
- JavaStringFromManagedString(env, evaluatorConfigStr),
- JavaStringFromManagedString(env, contextConfigStr),
- JavaStringFromManagedString(env, taskConfigStr));
- ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::SubmitContextAndTask");
- }
-
- void AllocatedEvaluatorClr2Java::SubmitContextAndService(String^ evaluatorConfigStr, String^ contextConfigStr, String^ serviceConfigStr) {
- ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::SubmitContextAndService");
- JNIEnv *env = RetrieveEnv(_jvm);
- jclass jclassAllocatedEvaluator = env->GetObjectClass(_jobjectAllocatedEvaluator);
- jmethodID jmidSubmitContextAndService = env->GetMethodID(jclassAllocatedEvaluator, "submitContextAndServiceString", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
-
- if (jmidSubmitContextAndService == NULL) {
- ManagedLog::LOGGER->Log("jmidSubmitContextAndService is NULL");
- return;
- }
- env->CallObjectMethod(
- _jobjectAllocatedEvaluator,
- jmidSubmitContextAndService,
- JavaStringFromManagedString(env, evaluatorConfigStr),
- JavaStringFromManagedString(env, contextConfigStr),
- JavaStringFromManagedString(env, serviceConfigStr));
- ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::SubmitContextAndService");
- }
-
- void AllocatedEvaluatorClr2Java::SubmitContextAndServiceAndTask(String^ evaluatorConfigStr, String^ contextConfigStr, String^ serviceConfigStr, String^ taskConfigStr) {
- ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::SubmitContextAndServiceAndTask");
- JNIEnv *env = RetrieveEnv(_jvm);
- jclass jclassAllocatedEvaluator = env->GetObjectClass(_jobjectAllocatedEvaluator);
- jmethodID jmidSubmitContextAndServiceAndTask = env->GetMethodID(jclassAllocatedEvaluator, "submitContextAndServiceAndTaskString", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
-
- if (jmidSubmitContextAndServiceAndTask == NULL) {
- ManagedLog::LOGGER->Log("jmidSubmitContextAndServiceAndTask is NULL");
- return;
- }
- env->CallObjectMethod(
- _jobjectAllocatedEvaluator,
- jmidSubmitContextAndServiceAndTask,
- JavaStringFromManagedString(env, evaluatorConfigStr),
- JavaStringFromManagedString(env, contextConfigStr),
- JavaStringFromManagedString(env, serviceConfigStr),
- JavaStringFromManagedString(env, taskConfigStr));
- ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::SubmitContextAndServiceAndTask");
- }
-
- void AllocatedEvaluatorClr2Java::OnError(String^ message) {
- JNIEnv *env = RetrieveEnv(_jvm);
- HandleClr2JavaError(env, message, _jobjectAllocatedEvaluator);
- }
-
- void AllocatedEvaluatorClr2Java::Close() {
- ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::Close");
- JNIEnv *env = RetrieveEnv(_jvm);
- jclass jclassAllocatedEvaluator = env->GetObjectClass(_jobjectAllocatedEvaluator);
- jmethodID jmidClose = env->GetMethodID(jclassAllocatedEvaluator, "close", "()V");
-
- if (jmidClose == NULL) {
- ManagedLog::LOGGER->Log("jmidClose is NULL");
- return;
- }
- env->CallObjectMethod(
- _jobjectAllocatedEvaluator,
- jmidClose);
- ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::Close");
- }
-
- String^ AllocatedEvaluatorClr2Java::GetId() {
- ManagedLog::LOGGER->Log("AllocatedEvaluatorClr2Java::GetId");
- JNIEnv *env = RetrieveEnv(_jvm);
- return ManagedStringFromJavaString(env, _jstringId);
- }
-
- String^ AllocatedEvaluatorClr2Java::GetNameServerInfo() {
- ManagedLog::LOGGER->Log("AllocatedEvaluatorClr2Java::GetNameServerInfo");
- JNIEnv *env = RetrieveEnv(_jvm);
- return ManagedStringFromJavaString(env, _jstringNameServerInfo);
- }
-
- IEvaluatorDescriptor^ AllocatedEvaluatorClr2Java::GetEvaluatorDescriptor() {
- ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::GetEvaluatorDescriptor");
- return CommonUtilities::RetrieveEvaluatorDescriptor(_jobjectAllocatedEvaluator, _jvm);
- }
- }
- }
- }
- }
+ namespace REEF {
+ namespace Driver {
+ namespace Bridge {
+ namespace Clr2java {
+ ref class ManagedLog {
+ internal:
+ static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
+ };
+
+ AllocatedEvaluatorClr2Java::AllocatedEvaluatorClr2Java(JNIEnv *env, jobject jallocatedEvaluator) {
+
+ ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::AllocatedEvaluatorClr2Java");
+
+ pin_ptr<JavaVM*> pJavaVm = &_jvm;
+ if (env->GetJavaVM(pJavaVm) != 0) {
+ ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
+ }
+ _jobjectAllocatedEvaluator = reinterpret_cast<jobject>(env->NewGlobalRef(jallocatedEvaluator));
+
+ jclass jclassAllocatedEvaluator = env->GetObjectClass(_jobjectAllocatedEvaluator);
+ _jstringId = CommonUtilities::GetJObjectId(env, _jobjectAllocatedEvaluator, jclassAllocatedEvaluator);
+
+ jmethodID jmidGetNameServerInfo = env->GetMethodID(jclassAllocatedEvaluator, "getNameServerInfo", "()Ljava/lang/String;");
+ _jstringNameServerInfo = CommonUtilities::CallGetMethodNewGlobalRef<jstring>(env, _jobjectAllocatedEvaluator, jmidGetNameServerInfo);
+
+ ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::AllocatedEvaluatorClr2Java");
+ }
+
+ AllocatedEvaluatorClr2Java::~AllocatedEvaluatorClr2Java() {
+ this->!AllocatedEvaluatorClr2Java();
+ }
+
+ AllocatedEvaluatorClr2Java::!AllocatedEvaluatorClr2Java() {
+ JNIEnv *env = RetrieveEnv(_jvm);
+ if (_jobjectAllocatedEvaluator != NULL) {
+ env->DeleteGlobalRef(_jobjectAllocatedEvaluator);
+ }
+
+ if (_jstringId != NULL) {
+ env->DeleteGlobalRef(_jstringId);
+ }
+
+ if (_jstringNameServerInfo != NULL) {
+ env->DeleteGlobalRef(_jstringNameServerInfo);
+ }
+ }
+
+ void AllocatedEvaluatorClr2Java::SubmitContext(String^ evaluatorConfigStr, String^ contextConfigStr) {
+ ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::SubmitContext");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ jclass jclassAllocatedEvaluator = env->GetObjectClass(_jobjectAllocatedEvaluator);
+ jmethodID jmidSubmitContext = env->GetMethodID(jclassAllocatedEvaluator, "submitContextString", "(Ljava/lang/String;Ljava/lang/String;)V");
+
+ if (jmidSubmitContext == NULL) {
+ ManagedLog::LOGGER->Log("jmidSubmitContext is NULL");
+ return;
+ }
+ env->CallObjectMethod(
+ _jobjectAllocatedEvaluator,
+ jmidSubmitContext,
+ JavaStringFromManagedString(env, evaluatorConfigStr),
+ JavaStringFromManagedString(env, contextConfigStr));
+ ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::SubmitContext");
+ }
+
+ void AllocatedEvaluatorClr2Java::SubmitContextAndTask(String^ evaluatorConfigStr, String^ contextConfigStr, String^ taskConfigStr) {
+ ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::SubmitContextAndTask");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ jclass jclassAllocatedEvaluator = env->GetObjectClass(_jobjectAllocatedEvaluator);
+ jmethodID jmidSubmitContextAndTask = env->GetMethodID(jclassAllocatedEvaluator, "submitContextAndTaskString", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
+
+ if (jmidSubmitContextAndTask == NULL) {
+ ManagedLog::LOGGER->Log("jmidSubmitContextAndTask is NULL");
+ return;
+ }
+ env->CallObjectMethod(
+ _jobjectAllocatedEvaluator,
+ jmidSubmitContextAndTask,
+ JavaStringFromManagedString(env, evaluatorConfigStr),
+ JavaStringFromManagedString(env, contextConfigStr),
+ JavaStringFromManagedString(env, taskConfigStr));
+ ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::SubmitContextAndTask");
+ }
+
+ void AllocatedEvaluatorClr2Java::SubmitContextAndService(String^ evaluatorConfigStr, String^ contextConfigStr, String^ serviceConfigStr) {
+ ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::SubmitContextAndService");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ jclass jclassAllocatedEvaluator = env->GetObjectClass(_jobjectAllocatedEvaluator);
+ jmethodID jmidSubmitContextAndService = env->GetMethodID(jclassAllocatedEvaluator, "submitContextAndServiceString", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
+
+ if (jmidSubmitContextAndService == NULL) {
+ ManagedLog::LOGGER->Log("jmidSubmitContextAndService is NULL");
+ return;
+ }
+ env->CallObjectMethod(
+ _jobjectAllocatedEvaluator,
+ jmidSubmitContextAndService,
+ JavaStringFromManagedString(env, evaluatorConfigStr),
+ JavaStringFromManagedString(env, contextConfigStr),
+ JavaStringFromManagedString(env, serviceConfigStr));
+ ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::SubmitContextAndService");
+ }
+
+ void AllocatedEvaluatorClr2Java::SubmitContextAndServiceAndTask(String^ evaluatorConfigStr, String^ contextConfigStr, String^ serviceConfigStr, String^ taskConfigStr) {
+ ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::SubmitContextAndServiceAndTask");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ jclass jclassAllocatedEvaluator = env->GetObjectClass(_jobjectAllocatedEvaluator);
+ jmethodID jmidSubmitContextAndServiceAndTask = env->GetMethodID(jclassAllocatedEvaluator, "submitContextAndServiceAndTaskString", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
+
+ if (jmidSubmitContextAndServiceAndTask == NULL) {
+ ManagedLog::LOGGER->Log("jmidSubmitContextAndServiceAndTask is NULL");
+ return;
+ }
+ env->CallObjectMethod(
+ _jobjectAllocatedEvaluator,
+ jmidSubmitContextAndServiceAndTask,
+ JavaStringFromManagedString(env, evaluatorConfigStr),
+ JavaStringFromManagedString(env, contextConfigStr),
+ JavaStringFromManagedString(env, serviceConfigStr),
+ JavaStringFromManagedString(env, taskConfigStr));
+ ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::SubmitContextAndServiceAndTask");
+ }
+
+ void AllocatedEvaluatorClr2Java::OnError(String^ message) {
+ JNIEnv *env = RetrieveEnv(_jvm);
+ HandleClr2JavaError(env, message, _jobjectAllocatedEvaluator);
+ }
+
+ void AllocatedEvaluatorClr2Java::Close() {
+ ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::Close");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ jclass jclassAllocatedEvaluator = env->GetObjectClass(_jobjectAllocatedEvaluator);
+ jmethodID jmidClose = env->GetMethodID(jclassAllocatedEvaluator, "close", "()V");
+
+ if (jmidClose == NULL) {
+ ManagedLog::LOGGER->Log("jmidClose is NULL");
+ return;
+ }
+ env->CallObjectMethod(
+ _jobjectAllocatedEvaluator,
+ jmidClose);
+ ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::Close");
+ }
+
+ String^ AllocatedEvaluatorClr2Java::GetId() {
+ ManagedLog::LOGGER->Log("AllocatedEvaluatorClr2Java::GetId");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ return ManagedStringFromJavaString(env, _jstringId);
+ }
+
+ String^ AllocatedEvaluatorClr2Java::GetNameServerInfo() {
+ ManagedLog::LOGGER->Log("AllocatedEvaluatorClr2Java::GetNameServerInfo");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ return ManagedStringFromJavaString(env, _jstringNameServerInfo);
+ }
+
+ IEvaluatorDescriptor^ AllocatedEvaluatorClr2Java::GetEvaluatorDescriptor() {
+ ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::GetEvaluatorDescriptor");
+ return CommonUtilities::RetrieveEvaluatorDescriptor(_jobjectAllocatedEvaluator, _jvm);
+ }
+ }
+ }
+ }
+ }
}
}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/reef/blob/8557f0f2/lang/cs/Org.Apache.REEF.Bridge/ClosedContextClr2Java.cpp
----------------------------------------------------------------------
diff --git a/lang/cs/Org.Apache.REEF.Bridge/ClosedContextClr2Java.cpp b/lang/cs/Org.Apache.REEF.Bridge/ClosedContextClr2Java.cpp
index 358e5e6..7faeac6 100644
--- a/lang/cs/Org.Apache.REEF.Bridge/ClosedContextClr2Java.cpp
+++ b/lang/cs/Org.Apache.REEF.Bridge/ClosedContextClr2Java.cpp
@@ -18,101 +18,101 @@
#include "Clr2JavaImpl.h"
namespace Org {
- namespace Apache {
- namespace REEF {
- namespace Driver {
- namespace Bridge {
- namespace Clr2java {
- ref class ManagedLog {
- internal:
- static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
- };
- ClosedContextClr2Java::ClosedContextClr2Java(JNIEnv *env, jobject jobjectClosedContext) {
- ManagedLog::LOGGER->LogStart("ClosedContextClr2Java::ClosedContextClr2Java");
-
- pin_ptr<JavaVM*> pJavaVm = &_jvm;
- if (env->GetJavaVM(pJavaVm) != 0) {
- ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
- }
-
- // Gets the Java closed context class to get its fields
- _jobjectClosedContext = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectClosedContext));
- jclass jclassClosedContext = env->GetObjectClass(_jobjectClosedContext);
-
- // Gets the Context ID and Evaluator ID of the closed context from the Java closed context object.
- _jstringContextId = CommonUtilities::GetJObjectId(env, _jobjectClosedContext, jclassClosedContext);
- _jstringEvaluatorId = CommonUtilities::GetJObjectEvaluatorId(env, _jobjectClosedContext, jclassClosedContext);
-
- jmethodID jmidGetParentContextMid = env->GetMethodID(
- jclassClosedContext, "getParentContextBridge", "()Lorg/apache/reef/javabridge/ActiveContextBridge;");
-
- jobject parentContext = env->CallObjectMethod(_jobjectClosedContext, jmidGetParentContextMid);
-
- _parentContext = gcnew ActiveContextClr2Java(env, parentContext);
-
- ManagedLog::LOGGER->LogStop("ClosedContextClr2Java::ClosedContextClr2Java");
- }
-
- ClosedContextClr2Java::~ClosedContextClr2Java() {
- this->!ClosedContextClr2Java();
- }
-
- ClosedContextClr2Java::!ClosedContextClr2Java() {
- JNIEnv *env = RetrieveEnv(_jvm);
- if (_jobjectClosedContext != NULL) {
- env->DeleteGlobalRef(_jobjectClosedContext);
- }
-
- if (_jstringContextId != NULL) {
- env->DeleteGlobalRef(_jstringContextId);
- }
-
- if (_jstringEvaluatorId != NULL) {
- env->DeleteGlobalRef(_jstringEvaluatorId);
- }
- }
-
- /**
- * Gets the Parent context of the closed context through a JNI call to Java.
- */
- IActiveContextClr2Java^ ClosedContextClr2Java::GetParentContext() {
- return _parentContext;
- }
-
- /**
- * Gets the ID of the closed context from Java.
- */
- String^ ClosedContextClr2Java::GetId() {
- ManagedLog::LOGGER->Log("ClosedContextClr2Java::GetId");
- JNIEnv *env = RetrieveEnv(_jvm);
- return ManagedStringFromJavaString(env, _jstringContextId);
- }
-
- /**
- * Gets the Evaluator ID of the Evaluator on which the Closed Context was active.
- */
- String^ ClosedContextClr2Java::GetEvaluatorId() {
- ManagedLog::LOGGER->Log("ClosedContextClr2Java::GetEvaluatorId");
- JNIEnv *env = RetrieveEnv(_jvm);
- return ManagedStringFromJavaString(env, _jstringEvaluatorId);
- }
-
- /**
- * Gets the EvaluatorDescriptor of the Evaluator on which the Closed Context was active.
- */
- IEvaluatorDescriptor^ ClosedContextClr2Java::GetEvaluatorDescriptor() {
- ManagedLog::LOGGER->LogStart("ClosedContextClr2Java::GetEvaluatorDescriptor");
- return CommonUtilities::RetrieveEvaluatorDescriptor(_jobjectClosedContext, _jvm);
- }
-
- void ClosedContextClr2Java::OnError(String^ message) {
- ManagedLog::LOGGER->Log("ClosedContextClr2Java::OnError");
- JNIEnv *env = RetrieveEnv(_jvm);
- HandleClr2JavaError(env, message, _jobjectClosedContext);
- }
- }
- }
+ namespace Apache {
+ namespace REEF {
+ namespace Driver {
+ namespace Bridge {
+ namespace Clr2java {
+ ref class ManagedLog {
+ internal:
+ static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
+ };
+ ClosedContextClr2Java::ClosedContextClr2Java(JNIEnv *env, jobject jobjectClosedContext) {
+ ManagedLog::LOGGER->LogStart("ClosedContextClr2Java::ClosedContextClr2Java");
+
+ pin_ptr<JavaVM*> pJavaVm = &_jvm;
+ if (env->GetJavaVM(pJavaVm) != 0) {
+ ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
+ }
+
+ // Gets the Java closed context class to get its fields
+ _jobjectClosedContext = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectClosedContext));
+ jclass jclassClosedContext = env->GetObjectClass(_jobjectClosedContext);
+
+ // Gets the Context ID and Evaluator ID of the closed context from the Java closed context object.
+ _jstringContextId = CommonUtilities::GetJObjectId(env, _jobjectClosedContext, jclassClosedContext);
+ _jstringEvaluatorId = CommonUtilities::GetJObjectEvaluatorId(env, _jobjectClosedContext, jclassClosedContext);
+
+ jmethodID jmidGetParentContextMid = env->GetMethodID(
+ jclassClosedContext, "getParentContextBridge", "()Lorg/apache/reef/javabridge/ActiveContextBridge;");
+
+ jobject parentContext = env->CallObjectMethod(_jobjectClosedContext, jmidGetParentContextMid);
+
+ _parentContext = gcnew ActiveContextClr2Java(env, parentContext);
+
+ ManagedLog::LOGGER->LogStop("ClosedContextClr2Java::ClosedContextClr2Java");
}
+
+ ClosedContextClr2Java::~ClosedContextClr2Java() {
+ this->!ClosedContextClr2Java();
+ }
+
+ ClosedContextClr2Java::!ClosedContextClr2Java() {
+ JNIEnv *env = RetrieveEnv(_jvm);
+ if (_jobjectClosedContext != NULL) {
+ env->DeleteGlobalRef(_jobjectClosedContext);
+ }
+
+ if (_jstringContextId != NULL) {
+ env->DeleteGlobalRef(_jstringContextId);
+ }
+
+ if (_jstringEvaluatorId != NULL) {
+ env->DeleteGlobalRef(_jstringEvaluatorId);
+ }
+ }
+
+ /**
+ * Gets the Parent context of the closed context through a JNI call to Java.
+ */
+ IActiveContextClr2Java^ ClosedContextClr2Java::GetParentContext() {
+ return _parentContext;
+ }
+
+ /**
+ * Gets the ID of the closed context from Java.
+ */
+ String^ ClosedContextClr2Java::GetId() {
+ ManagedLog::LOGGER->Log("ClosedContextClr2Java::GetId");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ return ManagedStringFromJavaString(env, _jstringContextId);
+ }
+
+ /**
+ * Gets the Evaluator ID of the Evaluator on which the Closed Context was active.
+ */
+ String^ ClosedContextClr2Java::GetEvaluatorId() {
+ ManagedLog::LOGGER->Log("ClosedContextClr2Java::GetEvaluatorId");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ return ManagedStringFromJavaString(env, _jstringEvaluatorId);
+ }
+
+ /**
+ * Gets the EvaluatorDescriptor of the Evaluator on which the Closed Context was active.
+ */
+ IEvaluatorDescriptor^ ClosedContextClr2Java::GetEvaluatorDescriptor() {
+ ManagedLog::LOGGER->LogStart("ClosedContextClr2Java::GetEvaluatorDescriptor");
+ return CommonUtilities::RetrieveEvaluatorDescriptor(_jobjectClosedContext, _jvm);
+ }
+
+ void ClosedContextClr2Java::OnError(String^ message) {
+ ManagedLog::LOGGER->Log("ClosedContextClr2Java::OnError");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ HandleClr2JavaError(env, message, _jobjectClosedContext);
+ }
+ }
}
+ }
}
+ }
}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/reef/blob/8557f0f2/lang/cs/Org.Apache.REEF.Bridge/CommonUtilities.cpp
----------------------------------------------------------------------
diff --git a/lang/cs/Org.Apache.REEF.Bridge/CommonUtilities.cpp b/lang/cs/Org.Apache.REEF.Bridge/CommonUtilities.cpp
index 2a206f4..677e901 100644
--- a/lang/cs/Org.Apache.REEF.Bridge/CommonUtilities.cpp
+++ b/lang/cs/Org.Apache.REEF.Bridge/CommonUtilities.cpp
@@ -18,37 +18,37 @@
#include "Clr2JavaImpl.h"
namespace Org {
- namespace Apache {
- namespace REEF {
- namespace Driver {
- namespace Bridge {
- namespace Clr2java {
- ref class ManagedLog {
- internal:
- static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>CommonUtilities");
- };
+ namespace Apache {
+ namespace REEF {
+ namespace Driver {
+ namespace Bridge {
+ namespace Clr2java {
+ ref class ManagedLog {
+ internal:
+ static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>CommonUtilities");
+ };
- IEvaluatorDescriptor^ CommonUtilities::RetrieveEvaluatorDescriptor(jobject object, JavaVM* jvm) {
- ManagedLog::LOGGER->LogStart("CommonUtilities::GetEvaluatorDescriptor");
- JNIEnv *env = RetrieveEnv(jvm);
- jclass jclassActiveContext = env->GetObjectClass(object);
- jmethodID jmidGetEvaluatorDescriptor = env->GetMethodID(jclassActiveContext, "getEvaluatorDescriptorString", "()Ljava/lang/String;");
+ IEvaluatorDescriptor^ CommonUtilities::RetrieveEvaluatorDescriptor(jobject object, JavaVM* jvm) {
+ ManagedLog::LOGGER->LogStart("CommonUtilities::GetEvaluatorDescriptor");
+ JNIEnv *env = RetrieveEnv(jvm);
+ jclass jclassActiveContext = env->GetObjectClass(object);
+ jmethodID jmidGetEvaluatorDescriptor = env->GetMethodID(jclassActiveContext, "getEvaluatorDescriptorString", "()Ljava/lang/String;");
- if (jmidGetEvaluatorDescriptor == NULL) {
- ManagedLog::LOGGER->Log("jmidGetEvaluatorDescriptor is NULL");
- return nullptr;
- }
- jstring jevaluatorDescriptorString = (jstring)env->CallObjectMethod(
- object,
- jmidGetEvaluatorDescriptor);
- String^ evaluatorDescriptorString = ManagedStringFromJavaString(env, jevaluatorDescriptorString);
- ManagedLog::LOGGER->LogStop("InteropUtil::GetEvaluatorDescriptor");
+ if (jmidGetEvaluatorDescriptor == NULL) {
+ ManagedLog::LOGGER->Log("jmidGetEvaluatorDescriptor is NULL");
+ return nullptr;
+ }
+ jstring jevaluatorDescriptorString = (jstring)env->CallObjectMethod(
+ object,
+ jmidGetEvaluatorDescriptor);
+ String^ evaluatorDescriptorString = ManagedStringFromJavaString(env, jevaluatorDescriptorString);
+ ManagedLog::LOGGER->LogStop("InteropUtil::GetEvaluatorDescriptor");
- return gcnew EvaluatorDescriptorImpl(evaluatorDescriptorString);
- }
- }
- }
+ return gcnew EvaluatorDescriptorImpl(evaluatorDescriptorString);
}
+ }
}
+ }
}
+ }
}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/reef/blob/8557f0f2/lang/cs/Org.Apache.REEF.Bridge/CompletedEvaluatorClr2Java.cpp
----------------------------------------------------------------------
diff --git a/lang/cs/Org.Apache.REEF.Bridge/CompletedEvaluatorClr2Java.cpp b/lang/cs/Org.Apache.REEF.Bridge/CompletedEvaluatorClr2Java.cpp
index 68732d4..3e70a63 100644
--- a/lang/cs/Org.Apache.REEF.Bridge/CompletedEvaluatorClr2Java.cpp
+++ b/lang/cs/Org.Apache.REEF.Bridge/CompletedEvaluatorClr2Java.cpp
@@ -19,57 +19,57 @@
namespace Org {
namespace Apache {
- namespace REEF {
- namespace Driver {
- namespace Bridge {
- namespace Clr2java {
- ref class ManagedLog {
- internal:
- static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
- };
+ namespace REEF {
+ namespace Driver {
+ namespace Bridge {
+ namespace Clr2java {
+ ref class ManagedLog {
+ internal:
+ static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
+ };
- CompletedEvaluatorClr2Java::CompletedEvaluatorClr2Java(JNIEnv *env, jobject jCompletedEvaluator) {
- ManagedLog::LOGGER->LogStart("CompletedEvaluatorClr2Java::CompletedEvaluatorClr2Java");
- pin_ptr<JavaVM*> pJavaVm = &_jvm;
- if (env->GetJavaVM(pJavaVm) != 0) {
- ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
- }
- _jobjectCompletedEvaluator = reinterpret_cast<jobject>(env->NewGlobalRef(jCompletedEvaluator));
+ CompletedEvaluatorClr2Java::CompletedEvaluatorClr2Java(JNIEnv *env, jobject jCompletedEvaluator) {
+ ManagedLog::LOGGER->LogStart("CompletedEvaluatorClr2Java::CompletedEvaluatorClr2Java");
+ pin_ptr<JavaVM*> pJavaVm = &_jvm;
+ if (env->GetJavaVM(pJavaVm) != 0) {
+ ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
+ }
+ _jobjectCompletedEvaluator = reinterpret_cast<jobject>(env->NewGlobalRef(jCompletedEvaluator));
- jclass jclassCompletedEvaluator = env->GetObjectClass(_jobjectCompletedEvaluator);
- _jstringId = CommonUtilities::GetJObjectId(env, _jobjectCompletedEvaluator, jclassCompletedEvaluator);
- ManagedLog::LOGGER->LogStop("CompletedEvaluatorClr2Java::CompletedEvaluatorClr2Java");
- }
+ jclass jclassCompletedEvaluator = env->GetObjectClass(_jobjectCompletedEvaluator);
+ _jstringId = CommonUtilities::GetJObjectId(env, _jobjectCompletedEvaluator, jclassCompletedEvaluator);
+ ManagedLog::LOGGER->LogStop("CompletedEvaluatorClr2Java::CompletedEvaluatorClr2Java");
+ }
- CompletedEvaluatorClr2Java::~CompletedEvaluatorClr2Java() {
- this->!CompletedEvaluatorClr2Java();
- }
+ CompletedEvaluatorClr2Java::~CompletedEvaluatorClr2Java() {
+ this->!CompletedEvaluatorClr2Java();
+ }
- CompletedEvaluatorClr2Java::!CompletedEvaluatorClr2Java() {
- JNIEnv *env = RetrieveEnv(_jvm);
- if (_jobjectCompletedEvaluator != NULL) {
- env->DeleteGlobalRef(_jobjectCompletedEvaluator);
- }
+ CompletedEvaluatorClr2Java::!CompletedEvaluatorClr2Java() {
+ JNIEnv *env = RetrieveEnv(_jvm);
+ if (_jobjectCompletedEvaluator != NULL) {
+ env->DeleteGlobalRef(_jobjectCompletedEvaluator);
+ }
- if (_jstringId != NULL) {
- env->DeleteGlobalRef(_jstringId);
- }
- }
+ if (_jstringId != NULL) {
+ env->DeleteGlobalRef(_jstringId);
+ }
+ }
- void CompletedEvaluatorClr2Java::OnError(String^ message) {
- ManagedLog::LOGGER->Log("CompletedEvaluatorClr2Java::OnError");
- JNIEnv *env = RetrieveEnv(_jvm);
- HandleClr2JavaError(env, message, _jobjectCompletedEvaluator);
- }
+ void CompletedEvaluatorClr2Java::OnError(String^ message) {
+ ManagedLog::LOGGER->Log("CompletedEvaluatorClr2Java::OnError");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ HandleClr2JavaError(env, message, _jobjectCompletedEvaluator);
+ }
- String^ CompletedEvaluatorClr2Java::GetId() {
- ManagedLog::LOGGER->Log("CompletedEvaluatorClr2Java::GetId");
- JNIEnv *env = RetrieveEnv(_jvm);
- return ManagedStringFromJavaString(env, _jstringId);
- }
- }
- }
- }
- }
+ String^ CompletedEvaluatorClr2Java::GetId() {
+ ManagedLog::LOGGER->Log("CompletedEvaluatorClr2Java::GetId");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ return ManagedStringFromJavaString(env, _jstringId);
+ }
+ }
+ }
+ }
+ }
}
}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/reef/blob/8557f0f2/lang/cs/Org.Apache.REEF.Bridge/CompletedTaskClr2Java.cpp
----------------------------------------------------------------------
diff --git a/lang/cs/Org.Apache.REEF.Bridge/CompletedTaskClr2Java.cpp b/lang/cs/Org.Apache.REEF.Bridge/CompletedTaskClr2Java.cpp
index c5fada1..33d1b9b 100644
--- a/lang/cs/Org.Apache.REEF.Bridge/CompletedTaskClr2Java.cpp
+++ b/lang/cs/Org.Apache.REEF.Bridge/CompletedTaskClr2Java.cpp
@@ -19,83 +19,83 @@
namespace Org {
namespace Apache {
- namespace REEF {
- namespace Driver {
- namespace Bridge {
- namespace Clr2java {
- ref class ManagedLog {
- internal:
- static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
- };
+ namespace REEF {
+ namespace Driver {
+ namespace Bridge {
+ namespace Clr2java {
+ ref class ManagedLog {
+ internal:
+ static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
+ };
- CompletedTaskClr2Java::CompletedTaskClr2Java(JNIEnv *env, jobject jobjectCompletedTask) {
- ManagedLog::LOGGER->LogStart("CompletedTaskClr2Java::CompletedTaskClr2Java");
- pin_ptr<JavaVM*> pJavaVm = &_jvm;
- if (env->GetJavaVM(pJavaVm) != 0) {
- ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
- }
- _jobjectCompletedTask = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectCompletedTask));
+ CompletedTaskClr2Java::CompletedTaskClr2Java(JNIEnv *env, jobject jobjectCompletedTask) {
+ ManagedLog::LOGGER->LogStart("CompletedTaskClr2Java::CompletedTaskClr2Java");
+ pin_ptr<JavaVM*> pJavaVm = &_jvm;
+ if (env->GetJavaVM(pJavaVm) != 0) {
+ ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
+ }
+ _jobjectCompletedTask = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectCompletedTask));
- jclass jclassCompletedTask = env->GetObjectClass(_jobjectCompletedTask);
- jmethodID jmidGetTaskId = env->GetMethodID(jclassCompletedTask, "getTaskId", "()Ljava/lang/String;");
- _jstringId = CommonUtilities::CallGetMethodNewGlobalRef<jstring>(env, _jobjectCompletedTask, jmidGetTaskId);
- ManagedLog::LOGGER->LogStop("CompletedTaskClr2Java::CompletedTaskClr2Java");
- }
+ jclass jclassCompletedTask = env->GetObjectClass(_jobjectCompletedTask);
+ jmethodID jmidGetTaskId = env->GetMethodID(jclassCompletedTask, "getTaskId", "()Ljava/lang/String;");
+ _jstringId = CommonUtilities::CallGetMethodNewGlobalRef<jstring>(env, _jobjectCompletedTask, jmidGetTaskId);
+ ManagedLog::LOGGER->LogStop("CompletedTaskClr2Java::CompletedTaskClr2Java");
+ }
- CompletedTaskClr2Java::~CompletedTaskClr2Java(){
- this->!CompletedTaskClr2Java();
- }
+ CompletedTaskClr2Java::~CompletedTaskClr2Java(){
+ this->!CompletedTaskClr2Java();
+ }
- CompletedTaskClr2Java::!CompletedTaskClr2Java() {
- JNIEnv *env = RetrieveEnv(_jvm);
- if (_jobjectCompletedTask != NULL) {
- env->DeleteGlobalRef(_jobjectCompletedTask);
- }
+ CompletedTaskClr2Java::!CompletedTaskClr2Java() {
+ JNIEnv *env = RetrieveEnv(_jvm);
+ if (_jobjectCompletedTask != NULL) {
+ env->DeleteGlobalRef(_jobjectCompletedTask);
+ }
- if (_jstringId != NULL) {
- env->DeleteGlobalRef(_jstringId);
- }
- }
+ if (_jstringId != NULL) {
+ env->DeleteGlobalRef(_jstringId);
+ }
+ }
- void CompletedTaskClr2Java::OnError(String^ message) {
- ManagedLog::LOGGER->Log("CompletedTaskClr2Java::OnError");
- JNIEnv *env = RetrieveEnv(_jvm);
- HandleClr2JavaError(env, message, _jobjectCompletedTask);
- }
+ void CompletedTaskClr2Java::OnError(String^ message) {
+ ManagedLog::LOGGER->Log("CompletedTaskClr2Java::OnError");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ HandleClr2JavaError(env, message, _jobjectCompletedTask);
+ }
- IActiveContextClr2Java^ CompletedTaskClr2Java::GetActiveContext() {
- ManagedLog::LOGGER->LogStart("CompletedTaskClr2Java::GetActiveContext");
- JNIEnv *env = RetrieveEnv(_jvm);
+ IActiveContextClr2Java^ CompletedTaskClr2Java::GetActiveContext() {
+ ManagedLog::LOGGER->LogStart("CompletedTaskClr2Java::GetActiveContext");
+ JNIEnv *env = RetrieveEnv(_jvm);
- jclass jclassCompletedTask = env->GetObjectClass(_jobjectCompletedTask);
- jmethodID jmidGetActiveContext = env->GetMethodID(jclassCompletedTask, "getActiveContext", "()Lorg/apache/reef/javabridge/ActiveContextBridge;");
- jobject jobjectActiveContext = env->CallObjectMethod(_jobjectCompletedTask, jmidGetActiveContext);
- ManagedLog::LOGGER->LogStop("CompletedTaskClr2Java::GetActiveContext");
- return gcnew ActiveContextClr2Java(env, jobjectActiveContext);
- }
+ jclass jclassCompletedTask = env->GetObjectClass(_jobjectCompletedTask);
+ jmethodID jmidGetActiveContext = env->GetMethodID(jclassCompletedTask, "getActiveContext", "()Lorg/apache/reef/javabridge/ActiveContextBridge;");
+ jobject jobjectActiveContext = env->CallObjectMethod(_jobjectCompletedTask, jmidGetActiveContext);
+ ManagedLog::LOGGER->LogStop("CompletedTaskClr2Java::GetActiveContext");
+ return gcnew ActiveContextClr2Java(env, jobjectActiveContext);
+ }
- String^ CompletedTaskClr2Java::GetId() {
- ManagedLog::LOGGER->Log("CompletedTaskClr2Java::GetId");
- JNIEnv *env = RetrieveEnv(_jvm);
- return ManagedStringFromJavaString(env, _jstringId);
- }
+ String^ CompletedTaskClr2Java::GetId() {
+ ManagedLog::LOGGER->Log("CompletedTaskClr2Java::GetId");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ return ManagedStringFromJavaString(env, _jstringId);
+ }
- array<byte>^ CompletedTaskClr2Java::Get() {
- ManagedLog::LOGGER->Log("CompletedTaskClr2Java::GetMessage");
- JNIEnv *env = RetrieveEnv(_jvm);
- jclass jclassCompletedTask = env->GetObjectClass(_jobjectCompletedTask);
- jmethodID jmidGet = env->GetMethodID(jclassCompletedTask, "get", "()[B");
+ array<byte>^ CompletedTaskClr2Java::Get() {
+ ManagedLog::LOGGER->Log("CompletedTaskClr2Java::GetMessage");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ jclass jclassCompletedTask = env->GetObjectClass(_jobjectCompletedTask);
+ jmethodID jmidGet = env->GetMethodID(jclassCompletedTask, "get", "()[B");
- if (jmidGet == NULL) {
- ManagedLog::LOGGER->Log("jmidGet is NULL");
- return nullptr;
- }
- jbyteArray jMessage = (jbyteArray)env->CallObjectMethod(_jobjectCompletedTask, jmidGet);
- return ManagedByteArrayFromJavaByteArray(env, jMessage);
- }
- }
- }
- }
- }
+ if (jmidGet == NULL) {
+ ManagedLog::LOGGER->Log("jmidGet is NULL");
+ return nullptr;
+ }
+ jbyteArray jMessage = (jbyteArray)env->CallObjectMethod(_jobjectCompletedTask, jmidGet);
+ return ManagedByteArrayFromJavaByteArray(env, jMessage);
+ }
+ }
+ }
+ }
+ }
}
}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/reef/blob/8557f0f2/lang/cs/Org.Apache.REEF.Bridge/ContextMessageClr2Java.cpp
----------------------------------------------------------------------
diff --git a/lang/cs/Org.Apache.REEF.Bridge/ContextMessageClr2Java.cpp b/lang/cs/Org.Apache.REEF.Bridge/ContextMessageClr2Java.cpp
index 5eff952..33f928e 100644
--- a/lang/cs/Org.Apache.REEF.Bridge/ContextMessageClr2Java.cpp
+++ b/lang/cs/Org.Apache.REEF.Bridge/ContextMessageClr2Java.cpp
@@ -19,82 +19,82 @@
namespace Org {
namespace Apache {
- namespace REEF {
- namespace Driver {
- namespace Bridge {
- namespace Clr2java {
- ref class ManagedLog {
- internal:
- static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
- };
- ContextMessageClr2Java::ContextMessageClr2Java(JNIEnv *env, jobject jobjectContextMessage) {
- ManagedLog::LOGGER->LogStart("ContextMessageClr2Java::ContextMessageClr2Java");
+ namespace REEF {
+ namespace Driver {
+ namespace Bridge {
+ namespace Clr2java {
+ ref class ManagedLog {
+ internal:
+ static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
+ };
+ ContextMessageClr2Java::ContextMessageClr2Java(JNIEnv *env, jobject jobjectContextMessage) {
+ ManagedLog::LOGGER->LogStart("ContextMessageClr2Java::ContextMessageClr2Java");
- pin_ptr<JavaVM*> pJavaVm = &_jvm;
- if (env->GetJavaVM(pJavaVm) != 0) {
- ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
- }
- _jobjectContextMessage = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectContextMessage));
- jclass jclassContextMessage = env->GetObjectClass(_jobjectContextMessage);
- jmethodID jmidGetSourceId = env->GetMethodID(jclassContextMessage, "getMessageSourceID", "()Ljava/lang/String;");
- jmethodID jmidGetMessage = env->GetMethodID(jclassContextMessage, "get", "()[B");
+ pin_ptr<JavaVM*> pJavaVm = &_jvm;
+ if (env->GetJavaVM(pJavaVm) != 0) {
+ ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
+ }
+ _jobjectContextMessage = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectContextMessage));
+ jclass jclassContextMessage = env->GetObjectClass(_jobjectContextMessage);
+ jmethodID jmidGetSourceId = env->GetMethodID(jclassContextMessage, "getMessageSourceID", "()Ljava/lang/String;");
+ jmethodID jmidGetMessage = env->GetMethodID(jclassContextMessage, "get", "()[B");
- _jstringId = CommonUtilities::GetJObjectId(env, _jobjectContextMessage, jclassContextMessage);
- _jstringSourceId = CommonUtilities::CallGetMethodNewGlobalRef<jstring>(env, _jobjectContextMessage, jmidGetSourceId);
- _jarrayMessage = CommonUtilities::CallGetMethodNewGlobalRef<jbyteArray>(env, _jobjectContextMessage, jmidGetMessage);
+ _jstringId = CommonUtilities::GetJObjectId(env, _jobjectContextMessage, jclassContextMessage);
+ _jstringSourceId = CommonUtilities::CallGetMethodNewGlobalRef<jstring>(env, _jobjectContextMessage, jmidGetSourceId);
+ _jarrayMessage = CommonUtilities::CallGetMethodNewGlobalRef<jbyteArray>(env, _jobjectContextMessage, jmidGetMessage);
- ManagedLog::LOGGER->LogStop("ContextMessageClr2Java::ContextMessageClr2Java");
- }
+ ManagedLog::LOGGER->LogStop("ContextMessageClr2Java::ContextMessageClr2Java");
+ }
- ContextMessageClr2Java::~ContextMessageClr2Java() {
- this->!ContextMessageClr2Java();
- }
+ ContextMessageClr2Java::~ContextMessageClr2Java() {
+ this->!ContextMessageClr2Java();
+ }
- ContextMessageClr2Java::!ContextMessageClr2Java() {
- JNIEnv *env = RetrieveEnv(_jvm);
- if (_jobjectContextMessage != NULL) {
- env->DeleteGlobalRef(_jobjectContextMessage);
- }
+ ContextMessageClr2Java::!ContextMessageClr2Java() {
+ JNIEnv *env = RetrieveEnv(_jvm);
+ if (_jobjectContextMessage != NULL) {
+ env->DeleteGlobalRef(_jobjectContextMessage);
+ }
- if (_jstringId != NULL) {
- env->DeleteGlobalRef(_jstringId);
- }
+ if (_jstringId != NULL) {
+ env->DeleteGlobalRef(_jstringId);
+ }
- if (_jstringSourceId != NULL) {
- env->DeleteGlobalRef(_jstringSourceId);
- }
+ if (_jstringSourceId != NULL) {
+ env->DeleteGlobalRef(_jstringSourceId);
+ }
- if (_jarrayMessage != NULL) {
- env->DeleteGlobalRef(_jarrayMessage);
- }
- }
+ if (_jarrayMessage != NULL) {
+ env->DeleteGlobalRef(_jarrayMessage);
+ }
+ }
- String^ ContextMessageClr2Java::GetId() {
- ManagedLog::LOGGER->Log("ContextMessageClr2Java::GetId");
- JNIEnv *env = RetrieveEnv(_jvm);
- return ManagedStringFromJavaString(env, _jstringId);
- }
+ String^ ContextMessageClr2Java::GetId() {
+ ManagedLog::LOGGER->Log("ContextMessageClr2Java::GetId");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ return ManagedStringFromJavaString(env, _jstringId);
+ }
- String^ ContextMessageClr2Java::GetMessageSourceId() {
- ManagedLog::LOGGER->Log("ContextMessageClr2Java::GetMessageSourceId");
- JNIEnv *env = RetrieveEnv(_jvm);
- return ManagedStringFromJavaString(env, _jstringSourceId);
- }
+ String^ ContextMessageClr2Java::GetMessageSourceId() {
+ ManagedLog::LOGGER->Log("ContextMessageClr2Java::GetMessageSourceId");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ return ManagedStringFromJavaString(env, _jstringSourceId);
+ }
- array<byte>^ ContextMessageClr2Java::Get() {
- ManagedLog::LOGGER->Log("ContextMessageClr2Java::Get");
- JNIEnv *env = RetrieveEnv(_jvm);
- return ManagedByteArrayFromJavaByteArray(env, _jarrayMessage);
- }
+ array<byte>^ ContextMessageClr2Java::Get() {
+ ManagedLog::LOGGER->Log("ContextMessageClr2Java::Get");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ return ManagedByteArrayFromJavaByteArray(env, _jarrayMessage);
+ }
- void ContextMessageClr2Java::OnError(String^ message) {
- ManagedLog::LOGGER->Log("ContextMessageClr2Java::OnError");
- JNIEnv *env = RetrieveEnv(_jvm);
- HandleClr2JavaError(env, message, _jobjectContextMessage);
- }
- }
- }
- }
- }
+ void ContextMessageClr2Java::OnError(String^ message) {
+ ManagedLog::LOGGER->Log("ContextMessageClr2Java::OnError");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ HandleClr2JavaError(env, message, _jobjectContextMessage);
+ }
+ }
+ }
+ }
+ }
}
}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/reef/blob/8557f0f2/lang/cs/Org.Apache.REEF.Bridge/DriverRestartCompletedClr2Java.cpp
----------------------------------------------------------------------
diff --git a/lang/cs/Org.Apache.REEF.Bridge/DriverRestartCompletedClr2Java.cpp b/lang/cs/Org.Apache.REEF.Bridge/DriverRestartCompletedClr2Java.cpp
index 94612ba..9e72be7 100644
--- a/lang/cs/Org.Apache.REEF.Bridge/DriverRestartCompletedClr2Java.cpp
+++ b/lang/cs/Org.Apache.REEF.Bridge/DriverRestartCompletedClr2Java.cpp
@@ -18,61 +18,61 @@
#include "Clr2JavaImpl.h"
namespace Org {
- namespace Apache {
- namespace REEF {
- namespace Driver {
- namespace Bridge {
- namespace Clr2java {
- ref class ManagedLog {
- internal:
- static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
- };
+ namespace Apache {
+ namespace REEF {
+ namespace Driver {
+ namespace Bridge {
+ namespace Clr2java {
+ ref class ManagedLog {
+ internal:
+ static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
+ };
- DriverRestartCompletedClr2Java::DriverRestartCompletedClr2Java(JNIEnv *env, jobject jdriverRestartCompleted) {
- ManagedLog::LOGGER->LogStart("DriverRestartCompletedClr2Java::DriverRestartCompletedClr2Java");
- pin_ptr<JavaVM*> pJavaVm = &_jvm;
- if (env->GetJavaVM(pJavaVm) != 0) {
- ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
- }
- _jobjectDriverRestartCompleted = reinterpret_cast<jobject>(env->NewGlobalRef(jdriverRestartCompleted));
+ DriverRestartCompletedClr2Java::DriverRestartCompletedClr2Java(JNIEnv *env, jobject jdriverRestartCompleted) {
+ ManagedLog::LOGGER->LogStart("DriverRestartCompletedClr2Java::DriverRestartCompletedClr2Java");
+ pin_ptr<JavaVM*> pJavaVm = &_jvm;
+ if (env->GetJavaVM(pJavaVm) != 0) {
+ ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
+ }
+ _jobjectDriverRestartCompleted = reinterpret_cast<jobject>(env->NewGlobalRef(jdriverRestartCompleted));
- jclass jclassDriverRestartCompleted = env->GetObjectClass(_jobjectDriverRestartCompleted);
- jmethodID jmidIsTimedOut = env->GetMethodID(jclassDriverRestartCompleted, "isTimedOut", "()Z");
+ jclass jclassDriverRestartCompleted = env->GetObjectClass(_jobjectDriverRestartCompleted);
+ jmethodID jmidIsTimedOut = env->GetMethodID(jclassDriverRestartCompleted, "isTimedOut", "()Z");
- jboolean jisTimedOut = env->CallBooleanMethod(_jobjectDriverRestartCompleted, jmidIsTimedOut);
- _restartCompletedTime = System::DateTime::Now;
- _isTimedOut = ClrBoolFromJavaBoolean(env, jisTimedOut);
+ jboolean jisTimedOut = env->CallBooleanMethod(_jobjectDriverRestartCompleted, jmidIsTimedOut);
+ _restartCompletedTime = System::DateTime::Now;
+ _isTimedOut = ClrBoolFromJavaBoolean(env, jisTimedOut);
- ManagedLog::LOGGER->LogStop("DriverRestartCompletedClr2Java::DriverRestartCompletedClr2Java");
- }
+ ManagedLog::LOGGER->LogStop("DriverRestartCompletedClr2Java::DriverRestartCompletedClr2Java");
+ }
- DriverRestartCompletedClr2Java::~DriverRestartCompletedClr2Java() {
- this->!DriverRestartCompletedClr2Java();
- }
+ DriverRestartCompletedClr2Java::~DriverRestartCompletedClr2Java() {
+ this->!DriverRestartCompletedClr2Java();
+ }
- DriverRestartCompletedClr2Java::!DriverRestartCompletedClr2Java() {
- if (_jobjectDriverRestartCompleted != NULL) {
- JNIEnv *env = RetrieveEnv(_jvm);
- env->DeleteGlobalRef(_jobjectDriverRestartCompleted);
- }
- }
+ DriverRestartCompletedClr2Java::!DriverRestartCompletedClr2Java() {
+ if (_jobjectDriverRestartCompleted != NULL) {
+ JNIEnv *env = RetrieveEnv(_jvm);
+ env->DeleteGlobalRef(_jobjectDriverRestartCompleted);
+ }
+ }
- bool DriverRestartCompletedClr2Java::IsTimedOut() {
- return _isTimedOut;
- }
+ bool DriverRestartCompletedClr2Java::IsTimedOut() {
+ return _isTimedOut;
+ }
- DateTime DriverRestartCompletedClr2Java::GetCompletedTime() {
- return _restartCompletedTime;
- }
+ DateTime DriverRestartCompletedClr2Java::GetCompletedTime() {
+ return _restartCompletedTime;
+ }
- void DriverRestartCompletedClr2Java::OnError(String^ message) {
- ManagedLog::LOGGER->Log("DriverRestartCompletedClr2Java::OnError");
- JNIEnv *env = RetrieveEnv(_jvm);
- HandleClr2JavaError(env, message, _jobjectDriverRestartCompleted);
- }
- }
- }
- }
- }
- }
+ void DriverRestartCompletedClr2Java::OnError(String^ message) {
+ ManagedLog::LOGGER->Log("DriverRestartCompletedClr2Java::OnError");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ HandleClr2JavaError(env, message, _jobjectDriverRestartCompleted);
+ }
+ }
+ }
+ }
+ }
+ }
}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/reef/blob/8557f0f2/lang/cs/Org.Apache.REEF.Bridge/DriverRestartedClr2Java.cpp
----------------------------------------------------------------------
diff --git a/lang/cs/Org.Apache.REEF.Bridge/DriverRestartedClr2Java.cpp b/lang/cs/Org.Apache.REEF.Bridge/DriverRestartedClr2Java.cpp
index e1228c3..21e8e13 100644
--- a/lang/cs/Org.Apache.REEF.Bridge/DriverRestartedClr2Java.cpp
+++ b/lang/cs/Org.Apache.REEF.Bridge/DriverRestartedClr2Java.cpp
@@ -18,75 +18,75 @@
#include "Clr2JavaImpl.h"
namespace Org {
- namespace Apache {
- namespace REEF {
- namespace Driver {
- namespace Bridge {
- namespace Clr2java {
- ref class ManagedLog {
- internal:
- static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
- };
+ namespace Apache {
+ namespace REEF {
+ namespace Driver {
+ namespace Bridge {
+ namespace Clr2java {
+ ref class ManagedLog {
+ internal:
+ static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
+ };
- DriverRestartedClr2Java::DriverRestartedClr2Java(JNIEnv *env, jobject jdriverRestarted) {
- ManagedLog::LOGGER->LogStart("DriverRestartedClr2Java::DriverRestartedClr2Java");
- pin_ptr<JavaVM*> pJavaVm = &_jvm;
- if (env->GetJavaVM(pJavaVm) != 0) {
- ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
- }
- _jobjectDriverRestarted = reinterpret_cast<jobject>(env->NewGlobalRef(jdriverRestarted));
+ DriverRestartedClr2Java::DriverRestartedClr2Java(JNIEnv *env, jobject jdriverRestarted) {
+ ManagedLog::LOGGER->LogStart("DriverRestartedClr2Java::DriverRestartedClr2Java");
+ pin_ptr<JavaVM*> pJavaVm = &_jvm;
+ if (env->GetJavaVM(pJavaVm) != 0) {
+ ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
+ }
+ _jobjectDriverRestarted = reinterpret_cast<jobject>(env->NewGlobalRef(jdriverRestarted));
- jclass jclassDriverRestarted = env->GetObjectClass(_jobjectDriverRestarted);
- jmethodID jmidGetExpectedEvaluatorIds = env->GetMethodID(jclassDriverRestarted, "getExpectedEvaluatorIds", "()[Ljava/lang/String;");
- jmethodID jmidGetResubmissionAttempts = env->GetMethodID(jclassDriverRestarted, "getResubmissionAttempts", "()I");
+ jclass jclassDriverRestarted = env->GetObjectClass(_jobjectDriverRestarted);
+ jmethodID jmidGetExpectedEvaluatorIds = env->GetMethodID(jclassDriverRestarted, "getExpectedEvaluatorIds", "()[Ljava/lang/String;");
+ jmethodID jmidGetResubmissionAttempts = env->GetMethodID(jclassDriverRestarted, "getResubmissionAttempts", "()I");
- _resubmissionAttempts = env->CallIntMethod(_jobjectDriverRestarted, jmidGetResubmissionAttempts);
- jobjectArray jevaluatorIds = CommonUtilities::CallGetMethodNewGlobalRef<jobjectArray>(env, _jobjectDriverRestarted, jmidGetExpectedEvaluatorIds);
- _startTime = System::DateTime::Now;
- int count = env->GetArrayLength(jevaluatorIds);
- _expectedEvaluatorIds = gcnew array<String^>(count);
+ _resubmissionAttempts = env->CallIntMethod(_jobjectDriverRestarted, jmidGetResubmissionAttempts);
+ jobjectArray jevaluatorIds = CommonUtilities::CallGetMethodNewGlobalRef<jobjectArray>(env, _jobjectDriverRestarted, jmidGetExpectedEvaluatorIds);
+ _startTime = System::DateTime::Now;
+ int count = env->GetArrayLength(jevaluatorIds);
+ _expectedEvaluatorIds = gcnew array<String^>(count);
- for (int i = 0; i < count; i++) {
- jstring string = (jstring)(*env).GetObjectArrayElement(jevaluatorIds, i);
- _expectedEvaluatorIds[i] = ManagedStringFromJavaString(env, string);
- }
+ for (int i = 0; i < count; i++) {
+ jstring string = (jstring)(*env).GetObjectArrayElement(jevaluatorIds, i);
+ _expectedEvaluatorIds[i] = ManagedStringFromJavaString(env, string);
+ }
- env->DeleteGlobalRef(jevaluatorIds);
+ env->DeleteGlobalRef(jevaluatorIds);
- ManagedLog::LOGGER->LogStop("DriverRestartedClr2Java::DriverRestartedClr2Java");
- }
+ ManagedLog::LOGGER->LogStop("DriverRestartedClr2Java::DriverRestartedClr2Java");
+ }
- DriverRestartedClr2Java::~DriverRestartedClr2Java() {
- this->!DriverRestartedClr2Java();
- }
+ DriverRestartedClr2Java::~DriverRestartedClr2Java() {
+ this->!DriverRestartedClr2Java();
+ }
- DriverRestartedClr2Java::!DriverRestartedClr2Java() {
- if (_jobjectDriverRestarted != NULL) {
- JNIEnv *env = RetrieveEnv(_jvm);
- env->DeleteGlobalRef(_jobjectDriverRestarted);
- }
- }
+ DriverRestartedClr2Java::!DriverRestartedClr2Java() {
+ if (_jobjectDriverRestarted != NULL) {
+ JNIEnv *env = RetrieveEnv(_jvm);
+ env->DeleteGlobalRef(_jobjectDriverRestarted);
+ }
+ }
- array<String^>^ DriverRestartedClr2Java::GetExpectedEvaluatorIds() {
- return _expectedEvaluatorIds;
- }
+ array<String^>^ DriverRestartedClr2Java::GetExpectedEvaluatorIds() {
+ return _expectedEvaluatorIds;
+ }
- DateTime DriverRestartedClr2Java::GetStartTime() {
- return _startTime;
- }
+ DateTime DriverRestartedClr2Java::GetStartTime() {
+ return _startTime;
+ }
- int DriverRestartedClr2Java::GetResubmissionAttempts() {
- return _resubmissionAttempts;
- }
+ int DriverRestartedClr2Java::GetResubmissionAttempts() {
+ return _resubmissionAttempts;
+ }
- void DriverRestartedClr2Java::OnError(String^ message) {
- ManagedLog::LOGGER->Log("DriverRestartedClr2Java::OnError");
- JNIEnv *env = RetrieveEnv(_jvm);
- HandleClr2JavaError(env, message, _jobjectDriverRestarted);
- }
- }
- }
- }
- }
- }
+ void DriverRestartedClr2Java::OnError(String^ message) {
+ ManagedLog::LOGGER->Log("DriverRestartedClr2Java::OnError");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ HandleClr2JavaError(env, message, _jobjectDriverRestarted);
+ }
+ }
+ }
+ }
+ }
+ }
}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/reef/blob/8557f0f2/lang/cs/Org.Apache.REEF.Bridge/EvaluatorRequestorClr2Java.cpp
----------------------------------------------------------------------
diff --git a/lang/cs/Org.Apache.REEF.Bridge/EvaluatorRequestorClr2Java.cpp b/lang/cs/Org.Apache.REEF.Bridge/EvaluatorRequestorClr2Java.cpp
index 0a4df03..7616c2c 100644
--- a/lang/cs/Org.Apache.REEF.Bridge/EvaluatorRequestorClr2Java.cpp
+++ b/lang/cs/Org.Apache.REEF.Bridge/EvaluatorRequestorClr2Java.cpp
@@ -19,86 +19,86 @@
namespace Org {
namespace Apache {
- namespace REEF {
- namespace Driver {
- namespace Bridge {
- namespace Clr2java {
- ref class ManagedLog {
- internal:
- static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
- };
+ namespace REEF {
+ namespace Driver {
+ namespace Bridge {
+ namespace Clr2java {
+ ref class ManagedLog {
+ internal:
+ static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
+ };
- EvaluatorRequestorClr2Java::EvaluatorRequestorClr2Java(JNIEnv *env, jobject jevaluatorRequestor) {
- ManagedLog::LOGGER->LogStart("EvaluatorRequestorClr2Java::EvaluatorRequestorClr2Java");
- pin_ptr<JavaVM*> pJavaVm = &_jvm;
- if (env->GetJavaVM(pJavaVm) != 0) {
- ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
- }
- _jobjectEvaluatorRequestor = reinterpret_cast<jobject>(env->NewGlobalRef(jevaluatorRequestor));
- ManagedLog::LOGGER->LogStop("EvaluatorRequestorClr2Java::EvaluatorRequestorClr2Java");
- }
+ EvaluatorRequestorClr2Java::EvaluatorRequestorClr2Java(JNIEnv *env, jobject jevaluatorRequestor) {
+ ManagedLog::LOGGER->LogStart("EvaluatorRequestorClr2Java::EvaluatorRequestorClr2Java");
+ pin_ptr<JavaVM*> pJavaVm = &_jvm;
+ if (env->GetJavaVM(pJavaVm) != 0) {
+ ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
+ }
+ _jobjectEvaluatorRequestor = reinterpret_cast<jobject>(env->NewGlobalRef(jevaluatorRequestor));
+ ManagedLog::LOGGER->LogStop("EvaluatorRequestorClr2Java::EvaluatorRequestorClr2Java");
+ }
- EvaluatorRequestorClr2Java::~EvaluatorRequestorClr2Java() {
- this->!EvaluatorRequestorClr2Java();
- }
+ EvaluatorRequestorClr2Java::~EvaluatorRequestorClr2Java() {
+ this->!EvaluatorRequestorClr2Java();
+ }
- EvaluatorRequestorClr2Java::!EvaluatorRequestorClr2Java() {
- if (_jobjectEvaluatorRequestor != NULL) {
- JNIEnv *env = RetrieveEnv(_jvm);
- env->DeleteGlobalRef(_jobjectEvaluatorRequestor);
- }
- }
+ EvaluatorRequestorClr2Java::!EvaluatorRequestorClr2Java() {
+ if (_jobjectEvaluatorRequestor != NULL) {
+ JNIEnv *env = RetrieveEnv(_jvm);
+ env->DeleteGlobalRef(_jobjectEvaluatorRequestor);
+ }
+ }
- void EvaluatorRequestorClr2Java::Submit(IEvaluatorRequest^ request) {
- ManagedLog::LOGGER->LogStart("EvaluatorRequestorClr2Java::Submit");
- JNIEnv *env = RetrieveEnv(_jvm);
- jclass jclassEvaluatorRequestor = env->GetObjectClass(_jobjectEvaluatorRequestor);
- jmethodID jmidSubmit = env->GetMethodID(jclassEvaluatorRequestor, "submit", "(IIILjava/lang/String;Ljava/lang/String;)V");
+ void EvaluatorRequestorClr2Java::Submit(IEvaluatorRequest^ request) {
+ ManagedLog::LOGGER->LogStart("EvaluatorRequestorClr2Java::Submit");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ jclass jclassEvaluatorRequestor = env->GetObjectClass(_jobjectEvaluatorRequestor);
+ jmethodID jmidSubmit = env->GetMethodID(jclassEvaluatorRequestor, "submit", "(IIILjava/lang/String;Ljava/lang/String;)V");
- if (jmidSubmit == NULL) {
- fprintf(stdout, " jmidSubmit is NULL\n");
- fflush(stdout);
- return;
- }
- env->CallObjectMethod(
- _jobjectEvaluatorRequestor,
- jmidSubmit,
- request->Number,
- request->MemoryMegaBytes,
- request->VirtualCore,
- JavaStringFromManagedString(env, request->Rack),
- JavaStringFromManagedString(env, request->RuntimeName));
- ManagedLog::LOGGER->LogStop("EvaluatorRequestorClr2Java::Submit");
- }
+ if (jmidSubmit == NULL) {
+ fprintf(stdout, " jmidSubmit is NULL\n");
+ fflush(stdout);
+ return;
+ }
+ env->CallObjectMethod(
+ _jobjectEvaluatorRequestor,
+ jmidSubmit,
+ request->Number,
+ request->MemoryMegaBytes,
+ request->VirtualCore,
+ JavaStringFromManagedString(env, request->Rack),
+ JavaStringFromManagedString(env, request->RuntimeName));
+ ManagedLog::LOGGER->LogStop("EvaluatorRequestorClr2Java::Submit");
+ }
- array<byte>^ EvaluatorRequestorClr2Java::GetDefinedRuntimes() {
- ManagedLog::LOGGER->LogStart("EvaluatorRequestorClr2Java::GetDefinedRuntimes");
- JNIEnv *env = RetrieveEnv(_jvm);
- jclass jclassEvaluatorRequestor = env->GetObjectClass(_jobjectEvaluatorRequestor);
- jmethodID jmidGetDefinedRuntimes = env->GetMethodID(jclassEvaluatorRequestor, "getDefinedRuntimes", "()[B");
+ array<byte>^ EvaluatorRequestorClr2Java::GetDefinedRuntimes() {
+ ManagedLog::LOGGER->LogStart("EvaluatorRequestorClr2Java::GetDefinedRuntimes");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ jclass jclassEvaluatorRequestor = env->GetObjectClass(_jobjectEvaluatorRequestor);
+ jmethodID jmidGetDefinedRuntimes = env->GetMethodID(jclassEvaluatorRequestor, "getDefinedRuntimes", "()[B");
- if (jmidGetDefinedRuntimes == NULL) {
- fprintf(stdout, " jmidGetDefinedRuntimes is NULL\n");
- fflush(stdout);
- return nullptr;
- }
+ if (jmidGetDefinedRuntimes == NULL) {
+ fprintf(stdout, " jmidGetDefinedRuntimes is NULL\n");
+ fflush(stdout);
+ return nullptr;
+ }
- jbyteArray jBytes = (jbyteArray)env->CallObjectMethod(
- _jobjectEvaluatorRequestor,
- jmidGetDefinedRuntimes);
+ jbyteArray jBytes = (jbyteArray)env->CallObjectMethod(
+ _jobjectEvaluatorRequestor,
+ jmidGetDefinedRuntimes);
- ManagedLog::LOGGER->LogStop("EvaluatorRequestorClr2Java::GetDefinedRuntimes");
- return ManagedByteArrayFromJavaByteArray(env, jBytes);
- }
+ ManagedLog::LOGGER->LogStop("EvaluatorRequestorClr2Java::GetDefinedRuntimes");
+ return ManagedByteArrayFromJavaByteArray(env, jBytes);
+ }
- void EvaluatorRequestorClr2Java::OnError(String^ message) {
- ManagedLog::LOGGER->Log("EvaluatorRequestorClr2Java::OnError");
- JNIEnv *env = RetrieveEnv(_jvm);
- HandleClr2JavaError(env, message, _jobjectEvaluatorRequestor);
- }
- }
- }
- }
- }
+ void EvaluatorRequestorClr2Java::OnError(String^ message) {
+ ManagedLog::LOGGER->Log("EvaluatorRequestorClr2Java::OnError");
+ JNIEnv *env = RetrieveEnv(_jvm);
+ HandleClr2JavaError(env, message, _jobjectEvaluatorRequestor);
+ }
+ }
+ }
+ }
+ }
}
}
\ No newline at end of file