You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by vo...@apache.org on 2015/09/01 09:38:55 UTC
[1/4] ignite git commit: IGNITE-1337: Moved "common" CPP project to
Ignite.
Repository: ignite
Updated Branches:
refs/heads/master 10e51d166 -> 7ca8cbc77
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/parent/pom.xml
----------------------------------------------------------------------
diff --git a/parent/pom.xml b/parent/pom.xml
index a9ebf84..7a2b41c 100644
--- a/parent/pom.xml
+++ b/parent/pom.xml
@@ -738,6 +738,11 @@
<exclude>src/main/dotnet/Apache.Ignite.sln</exclude>
<exclude>src/main/dotnet/Apache.Ignite.sln.DotSettings</exclude>
<exclude>src/test/dotnet/Apache.Ignite.Core.Tests/Apache.Ignite.Core.Tests.csproj</exclude>
+ <exclude>**/Makefile.am</exclude>
+ <exclude>**/configure.ac</exclude>
+ <exclude>**/*.vcsproj</exclude>
+ <exclude>**/*.vcsproj.filters</exclude>
+ <exclude>**/module.def</exclude>
</excludes>
</configuration>
</execution>
[4/4] ignite git commit: IGNITE-1337: Moved "common" CPP project to
Ignite.
Posted by vo...@apache.org.
IGNITE-1337: Moved "common" CPP project to Ignite.
Project: http://git-wip-us.apache.org/repos/asf/ignite/repo
Commit: http://git-wip-us.apache.org/repos/asf/ignite/commit/7ca8cbc7
Tree: http://git-wip-us.apache.org/repos/asf/ignite/tree/7ca8cbc7
Diff: http://git-wip-us.apache.org/repos/asf/ignite/diff/7ca8cbc7
Branch: refs/heads/master
Commit: 7ca8cbc774b0c23aca537b078898707a2ede3cbd
Parents: 10e51d1
Author: vozerov-gridgain <vo...@gridgain.com>
Authored: Tue Sep 1 10:39:17 2015 +0300
Committer: vozerov-gridgain <vo...@gridgain.com>
Committed: Tue Sep 1 10:39:17 2015 +0300
----------------------------------------------------------------------
.../platform/src/main/cpp/common/Makefile.am | 45 +
.../platform/src/main/cpp/common/configure.ac | 62 +
.../src/main/cpp/common/ignite-common.pc.in | 9 +
.../src/main/cpp/common/include/Makefile.am | 22 +
.../common/include/ignite/common/concurrent.h | 210 ++
.../cpp/common/include/ignite/common/exports.h | 145 ++
.../cpp/common/include/ignite/common/java.h | 652 ++++++
.../cpp/common/os/linux/include/Makefile.am | 21 +
.../os/linux/include/ignite/common/common.h | 81 +
.../linux/include/ignite/common/concurrent_os.h | 394 ++++
.../src/main/cpp/common/os/linux/src/common.cpp | 59 +
.../cpp/common/os/linux/src/concurrent_os.cpp | 175 ++
.../os/win/include/ignite/common/common.h | 56 +
.../win/include/ignite/common/concurrent_os.h | 406 ++++
.../src/main/cpp/common/os/win/src/common.cpp | 65 +
.../cpp/common/os/win/src/concurrent_os.cpp | 151 ++
.../src/main/cpp/common/project/README.TXT | 1 +
.../src/main/cpp/common/project/vs/README.TXT | 1 +
.../main/cpp/common/project/vs/common.vcxproj | 202 ++
.../common/project/vs/common.vcxproj.filters | 54 +
.../src/main/cpp/common/project/vs/module.def | 99 +
.../src/main/cpp/common/project/vs/targetver.h | 25 +
.../src/main/cpp/common/src/concurrent.cpp | 94 +
.../src/main/cpp/common/src/exports.cpp | 413 ++++
.../platform/src/main/cpp/common/src/java.cpp | 2204 ++++++++++++++++++
parent/pom.xml | 5 +
26 files changed, 5651 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/Makefile.am
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/Makefile.am b/modules/platform/src/main/cpp/common/Makefile.am
new file mode 100644
index 0000000..f5ca5dd
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/Makefile.am
@@ -0,0 +1,45 @@
+##
+## Licensed to the Apache Software Foundation (ASF) under one or more
+## contributor license agreements. See the NOTICE file distributed with
+## this work for additional information regarding copyright ownership.
+## The ASF licenses this file to You under the Apache License, Version 2.0
+## (the "License"); you may not use this file except in compliance with
+## the License. You may obtain a copy of the License at
+##
+## http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+ACLOCAL_AMFLAGS = "-Im4"
+
+SUBDIRS = . include os/linux/include
+DIST_SUBDIRS = . include os/linux/include
+
+AM_CPPFLAGS = -I$(srcdir)/include -I$(srcdir)/os/linux/include -I$(JAVA_HOME)/include -I$(JAVA_HOME)/include/linux -DIGNITE_IMPL
+AM_CXXFLAGS = -Wall -std=c++0x
+LIB_LDFLAGS = -no-undefined -version-info 1
+
+COMMON_SRC = os/linux/src/concurrent_os.cpp \
+ src/concurrent.cpp \
+ src/java.cpp \
+ src/exports.cpp \
+ os/linux/src/common.cpp
+
+lib_LTLIBRARIES = libignite-common.la
+libignite_common_la_SOURCES = $(COMMON_SRC)
+libignite_common_la_LIBADD = -L$(JAVA_HOME)/jre/lib/amd64/server
+libignite_common_la_LDFLAGS = $(LIB_LDFLAGS) -L/usr/local/lib -ljvm -version-info 0:0:0 -release $(PACKAGE_VERSION)
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = ignite-common.pc
+
+clean-local:
+ $(RM) *.gcno *.gcda
+
+clean-docs:
+ $(RM) $(DX_CLEANFILES)
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/configure.ac
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/configure.ac b/modules/platform/src/main/cpp/common/configure.ac
new file mode 100644
index 0000000..7706737
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/configure.ac
@@ -0,0 +1,62 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# -*- Autoconf -*-
+# Process this file with autoconf to produce a configure script.
+
+AC_PREREQ([2.69])
+AC_INIT([Ignite JNI bridge for C++], [7.4.1], [dev@ignite.apache.org], [ignite-common], [ignite.apache.org])
+AC_CONFIG_SRCDIR(src)
+
+AC_CANONICAL_SYSTEM
+AC_CONFIG_MACRO_DIR([m4])
+AC_LANG([C++])
+
+# Initialize automake
+AM_INIT_AUTOMAKE([-Wall foreign subdir-objects])
+AC_CONFIG_HEADER(config.h)
+
+AM_PROG_AR
+
+# Checks for programs.
+GXX="-g -O2"
+
+AC_PROG_CXX
+
+# Initialize Libtool
+LT_INIT
+
+# Checks for libraries.
+AC_CHECK_LIB([pthread], [pthread_mutex_lock])
+
+# Checks for header files.
+
+# Checks for typedefs, structures, and compiler characteristics.
+AC_C_INLINE
+AC_TYPE_INT16_T
+AC_TYPE_INT32_T
+AC_TYPE_INT64_T
+AC_TYPE_INT8_T
+AC_TYPE_PID_T
+AC_TYPE_SIZE_T
+
+# Checks for library functions.
+AC_FUNC_ERROR_AT_LINE
+
+AC_CONFIG_FILES(Makefile include/Makefile os/linux/include/Makefile ignite-common.pc)
+
+AC_OUTPUT
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/ignite-common.pc.in
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/ignite-common.pc.in b/modules/platform/src/main/cpp/common/ignite-common.pc.in
new file mode 100644
index 0000000..3cd3cec
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/ignite-common.pc.in
@@ -0,0 +1,9 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: ignite-common
+Description: Ignite JNI bridge for C++.
+Version: @PACKAGE_VERSION@
+Libs: -L${libdir} -lignite-common
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/include/Makefile.am
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/include/Makefile.am b/modules/platform/src/main/cpp/common/include/Makefile.am
new file mode 100644
index 0000000..5db1d4a
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/include/Makefile.am
@@ -0,0 +1,22 @@
+##
+## Licensed to the Apache Software Foundation (ASF) under one or more
+## contributor license agreements. See the NOTICE file distributed with
+## this work for additional information regarding copyright ownership.
+## The ASF licenses this file to You under the Apache License, Version 2.0
+## (the "License"); you may not use this file except in compliance with
+## the License. You may obtain a copy of the License at
+##
+## http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+ACLOCAL_AMFLAGS = "-Im4"
+
+nobase_include_HEADERS = ignite/common/concurrent.h \
+ ignite/common/java.h \
+ ignite/common/exports.h
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/include/ignite/common/concurrent.h
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/include/ignite/common/concurrent.h b/modules/platform/src/main/cpp/common/include/ignite/common/concurrent.h
new file mode 100644
index 0000000..1c9ab22
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/include/ignite/common/concurrent.h
@@ -0,0 +1,210 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _IGNITE_COMMON_CONCURRENT
+#define _IGNITE_COMMON_CONCURRENT
+
+#include "ignite/common/concurrent_os.h"
+
+namespace ignite
+{
+ namespace common
+ {
+ namespace concurrent
+ {
+ /**
+ * Default deleter implementation.
+ *
+ * @param obj Object to be deleted.
+ */
+ template<typename T>
+ IGNITE_IMPORT_EXPORT void SharedPointerDefaultDeleter(T* obj)
+ {
+ delete obj;
+ }
+
+ /**
+ * Holder of shared pointer data.
+ */
+ class IGNITE_IMPORT_EXPORT SharedPointerImpl
+ {
+ public:
+ /**
+ * Constructor.
+ *
+ * @param ptr Raw pointer.
+ */
+ SharedPointerImpl(void* ptr);
+
+ /**
+ * Get raw pointer.
+ *
+ * @return Raw pointer.
+ */
+ void* Pointer();
+
+ /**
+ * Increment usage counter.
+ */
+ void Increment();
+
+ /**
+ * Decrement usage counter.
+ *
+ * @return True if counter reached zero.
+ */
+ bool Decrement();
+ private:
+ /** Raw pointer. */
+ void* ptr;
+
+ /** Reference count. */
+ int32_t refCnt;
+
+ IGNITE_NO_COPY_ASSIGNMENT(SharedPointerImpl)
+ };
+
+ /**
+ * Shared pointer.
+ */
+ template<typename T>
+ class IGNITE_IMPORT_EXPORT SharedPointer
+ {
+ public:
+ /**
+ * Constructor.
+ */
+ SharedPointer() : impl(NULL), deleter(NULL)
+ {
+ // No-op.
+ }
+
+ /**
+ * Constructor.
+ *
+ * @param ptr Raw pointer.
+ */
+ explicit SharedPointer(T* ptr)
+ {
+ if (ptr)
+ {
+ impl = new SharedPointerImpl(ptr);
+ deleter = SharedPointerDefaultDeleter;
+ }
+ else
+ {
+ impl = NULL;
+ deleter = NULL;
+ }
+ }
+
+ /**
+ * Constructor.
+ *
+ * @param ptr Raw pointer.
+ * @param deleter Delete function.
+ */
+ SharedPointer(T* ptr, void(*deleter)(T*))
+ {
+ if (ptr)
+ {
+ this->impl = new SharedPointerImpl(ptr);
+ this->deleter = deleter;
+ }
+ else
+ {
+ this->impl = NULL;
+ this->deleter = NULL;
+ }
+ }
+
+ /**
+ * Copy constructor.
+ *
+ * @param other Instance to copy.
+ */
+ SharedPointer(const SharedPointer& other)
+ {
+ impl = other.impl;
+ deleter = other.deleter;
+
+ if (impl)
+ impl->Increment();
+ }
+
+ /**
+ * Assignment operator.
+ *
+ * @param other Other instance.
+ */
+ SharedPointer& operator=(const SharedPointer& other)
+ {
+ if (this != &other)
+ {
+ // 1. Create new instance.
+ SharedPointer tmp(other);
+
+ // 2. Swap with temp.
+ SharedPointerImpl* impl0 = impl;
+ void(*deleter0)(T*) = deleter;
+
+ impl = tmp.impl;
+ deleter = tmp.deleter;
+
+ tmp.impl = impl0;
+ tmp.deleter = deleter0;
+ }
+
+ return *this;
+ }
+
+ /**
+ * Destructor.
+ */
+ ~SharedPointer()
+ {
+ if (impl && impl->Decrement())
+ {
+ T* ptr = Get();
+
+ delete impl;
+
+ deleter(ptr);
+ }
+ }
+
+ /**
+ * Get raw pointer.
+ *
+ * @return Raw pointer.
+ */
+ T* Get()
+ {
+ return impl ? static_cast<T*>(impl->Pointer()) : NULL;
+ }
+ private:
+ /** Implementation. */
+ SharedPointerImpl* impl;
+
+ /** Delete function. */
+ void(*deleter)(T*);
+ };
+ }
+ }
+}
+
+#endif
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/include/ignite/common/exports.h
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/include/ignite/common/exports.h b/modules/platform/src/main/cpp/common/include/ignite/common/exports.h
new file mode 100644
index 0000000..48e86f0
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/include/ignite/common/exports.h
@@ -0,0 +1,145 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _IGNITE_COMMON_EXPORTS
+#define _IGNITE_COMMON_EXPORTS
+
+#include "ignite/common/java.h"
+
+namespace gcj = ignite::common::java;
+
+extern "C" {
+ int IGNITE_CALL IgniteReallocate(long long memPtr, int cap);
+
+ void* IGNITE_CALL IgniteIgnitionStart(gcj::JniContext* ctx, char* cfgPath, char* gridName, int factoryId, long long dataPtr);
+ void* IGNITE_CALL IgniteIgnitionInstance(gcj::JniContext* ctx, char* gridName);
+ long long IGNITE_CALL IgniteIgnitionEnvironmentPointer(gcj::JniContext* ctx, char* gridName);
+ bool IGNITE_CALL IgniteIgnitionStop(gcj::JniContext* ctx, char* gridName, bool cancel);
+ void IGNITE_CALL IgniteIgnitionStopAll(gcj::JniContext* ctx, bool cancel);
+
+ void IGNITE_CALL IgniteProcessorReleaseStart(gcj::JniContext* ctx, void* obj);
+ void* IGNITE_CALL IgniteProcessorProjection(gcj::JniContext* ctx, void* obj);
+ void* IGNITE_CALL IgniteProcessorCache(gcj::JniContext* ctx, void* obj, char* name);
+ void* IGNITE_CALL IgniteProcessorCreateCache(gcj::JniContext* ctx, void* obj, char* name);
+ void* IGNITE_CALL IgniteProcessorGetOrCreateCache(gcj::JniContext* ctx, void* obj, char* name);
+ void* IGNITE_CALL IgniteProcessorAffinity(gcj::JniContext* ctx, void* obj, char* name);
+ void* IGNITE_CALL IgniteProcessorDataStreamer(gcj::JniContext* ctx, void* obj, char* name, bool keepPortable);
+ void* IGNITE_CALL IgniteProcessorTransactions(gcj::JniContext* ctx, void* obj);
+ void* IGNITE_CALL IgniteProcessorCompute(gcj::JniContext* ctx, void* obj, void* prj);
+ void* IGNITE_CALL IgniteProcessorMessage(gcj::JniContext* ctx, void* obj, void* prj);
+ void* IGNITE_CALL IgniteProcessorEvents(gcj::JniContext* ctx, void* obj, void* prj);
+ void* IGNITE_CALL IgniteProcessorServices(gcj::JniContext* ctx, void* obj, void* prj);
+ void* IGNITE_CALL IgniteProcessorExtensions(gcj::JniContext* ctx, void* obj);
+
+ long long IGNITE_CALL IgniteTargetInStreamOutLong(gcj::JniContext* ctx, void* obj, int opType, long long memPtr);
+ void IGNITE_CALL IgniteTargetInStreamOutStream(gcj::JniContext* ctx, void* obj, int opType, long long inMemPtr, long long outMemPtr);
+ void* IGNITE_CALL IgniteTargetInStreamOutObject(gcj::JniContext* ctx, void* obj, int opType, long long memPtr);
+ void IGNITE_CALL IgniteTargetInObjectStreamOutStream(gcj::JniContext* ctx, void* obj, int opType, void* arg, long long inMemPtr, long long outMemPtr);
+ long long IGNITE_CALL IgniteTargetOutLong(gcj::JniContext* ctx, void* obj, int opType);
+ void IGNITE_CALL IgniteTargetOutStream(gcj::JniContext* ctx, void* obj, int opType, long long memPtr);
+ void* IGNITE_CALL IgniteTargetOutObject(gcj::JniContext* ctx, void* obj, int opType);
+ void IGNITE_CALL IgniteTargetListenFuture(gcj::JniContext* ctx, void* obj, long long futId, int typ);
+ void IGNITE_CALL IgniteTargetListenFutureForOperation(gcj::JniContext* ctx, void* obj, long long futId, int typ, int opId);
+
+ int IGNITE_CALL IgniteAffinityPartitions(gcj::JniContext* ctx, void* obj);
+
+ void* IGNITE_CALL IgniteCacheWithSkipStore(gcj::JniContext* ctx, void* obj);
+ void* IGNITE_CALL IgniteCacheWithNoRetries(gcj::JniContext* ctx, void* obj);
+ void* IGNITE_CALL IgniteCacheWithExpiryPolicy(gcj::JniContext* ctx, void* obj, long long create, long long update, long long access);
+ void* IGNITE_CALL IgniteCacheWithAsync(gcj::JniContext* ctx, void* obj);
+ void* IGNITE_CALL IgniteCacheWithKeepPortable(gcj::JniContext* ctx, void* obj);
+ void IGNITE_CALL IgniteCacheClear(gcj::JniContext* ctx, void* obj);
+ void IGNITE_CALL IgniteCacheRemoveAll(gcj::JniContext* ctx, void* obj);
+ void* IGNITE_CALL IgniteCacheOutOpQueryCursor(gcj::JniContext* ctx, void* obj, int type, long long memPtr);
+ void* IGNITE_CALL IgniteCacheOutOpContinuousQuery(gcj::JniContext* ctx, void* obj, int type, long long memPtr);
+ void* IGNITE_CALL IgniteCacheIterator(gcj::JniContext* ctx, void* obj);
+ void* IGNITE_CALL IgniteCacheLocalIterator(gcj::JniContext* ctx, void* obj, int peekModes);
+ void IGNITE_CALL IgniteCacheEnterLock(gcj::JniContext* ctx, void* obj, long long id);
+ void IGNITE_CALL IgniteCacheExitLock(gcj::JniContext* ctx, void* obj, long long id);
+ bool IGNITE_CALL IgniteCacheTryEnterLock(gcj::JniContext* ctx, void* obj, long long id, long long timeout);
+ void IGNITE_CALL IgniteCacheCloseLock(gcj::JniContext* ctx, void* obj, long long id);
+ void IGNITE_CALL IgniteCacheRebalance(gcj::JniContext* ctx, void* obj, long long futId);
+ int IGNITE_CALL IgniteCacheSize(gcj::JniContext* ctx, void* obj, int peekModes, bool loc);
+
+ void IGNITE_CALL IgniteCacheStoreCallbackInvoke(gcj::JniContext* ctx, void* obj, long long memPtr);
+
+ void IGNITE_CALL IgniteComputeWithNoFailover(gcj::JniContext* ctx, void* obj);
+ void IGNITE_CALL IgniteComputeWithTimeout(gcj::JniContext* ctx, void* obj, long long timeout);
+ void IGNITE_CALL IgniteComputeExecuteNative(gcj::JniContext* ctx, void* obj, long long taskPtr, long long topVer);
+
+ void IGNITE_CALL IgniteContinuousQueryClose(gcj::JniContext* ctx, void* obj);
+ void* IGNITE_CALL IgniteContinuousQueryGetInitialQueryCursor(gcj::JniContext* ctx, void* obj);
+
+ void IGNITE_CALL IgniteDataStreamerListenTopology(gcj::JniContext* ctx, void* obj, long long ptr);
+ bool IGNITE_CALL IgniteDataStreamerAllowOverwriteGet(gcj::JniContext* ctx, void* obj);
+ void IGNITE_CALL IgniteDataStreamerAllowOverwriteSet(gcj::JniContext* ctx, void* obj, bool val);
+ bool IGNITE_CALL IgniteDataStreamerSkipStoreGet(gcj::JniContext* ctx, void* obj);
+ void IGNITE_CALL IgniteDataStreamerSkipStoreSet(gcj::JniContext* ctx, void* obj, bool val);
+ int IGNITE_CALL IgniteDataStreamerPerNodeBufferSizeGet(gcj::JniContext* ctx, void* obj);
+ void IGNITE_CALL IgniteDataStreamerPerNodeBufferSizeSet(gcj::JniContext* ctx, void* obj, int val);
+ int IGNITE_CALL IgniteDataStreamerPerNodeParallelOperationsGet(gcj::JniContext* ctx, void* obj);
+ void IGNITE_CALL IgniteDataStreamerPerNodeParallelOperationsSet(gcj::JniContext* ctx, void* obj, int val);
+
+ void* IGNITE_CALL IgniteMessagingWithAsync(gcj::JniContext* ctx, void* obj);
+
+ void* IGNITE_CALL IgniteProjectionForOthers(gcj::JniContext* ctx, void* obj, void* prj);
+ void* IGNITE_CALL IgniteProjectionForRemotes(gcj::JniContext* ctx, void* obj);
+ void* IGNITE_CALL IgniteProjectionForDaemons(gcj::JniContext* ctx, void* obj);
+ void* IGNITE_CALL IgniteProjectionForRandom(gcj::JniContext* ctx, void* obj);
+ void* IGNITE_CALL IgniteProjectionForOldest(gcj::JniContext* ctx, void* obj);
+ void* IGNITE_CALL IgniteProjectionForYoungest(gcj::JniContext* ctx, void* obj);
+ void IGNITE_CALL IgniteProjectionResetMetrics(gcj::JniContext* ctx, void* obj);
+ void* IGNITE_CALL IgniteProjectionOutOpRet(gcj::JniContext* ctx, void* obj, int type, long long memPtr);
+
+ void IGNITE_CALL IgniteQueryCursorIterator(gcj::JniContext* ctx, void* obj);
+ void IGNITE_CALL IgniteQueryCursorClose(gcj::JniContext* ctx, void* obj);
+
+ long long IGNITE_CALL IgniteTransactionsStart(gcj::JniContext* ctx, void* obj, int concurrency, int isolation, long long timeout, int txSize);
+ int IGNITE_CALL IgniteTransactionsCommit(gcj::JniContext* ctx, void* obj, long long id);
+ void IGNITE_CALL IgniteTransactionsCommitAsync(gcj::JniContext* ctx, void* obj, long long id, long long futId);
+ int IGNITE_CALL IgniteTransactionsRollback(gcj::JniContext* ctx, void* obj, long long id);
+ void IGNITE_CALL IgniteTransactionsRollbackAsync(gcj::JniContext* ctx, void* obj, long long id, long long futId);
+ int IGNITE_CALL IgniteTransactionsClose(gcj::JniContext* ctx, void* obj, long long id);
+ int IGNITE_CALL IgniteTransactionsState(gcj::JniContext* ctx, void* obj, long long id);
+ bool IGNITE_CALL IgniteTransactionsSetRollbackOnly(gcj::JniContext* ctx, void* obj, long long id);
+ void IGNITE_CALL IgniteTransactionsResetMetrics(gcj::JniContext* ctx, void* obj);
+
+ void* IGNITE_CALL IgniteAcquire(gcj::JniContext* ctx, void* obj);
+ void IGNITE_CALL IgniteRelease(void* obj);
+
+ void IGNITE_CALL IgniteThrowToJava(gcj::JniContext* ctx, char* errMsg);
+
+ int IGNITE_CALL IgniteHandlersSize();
+
+ void* IGNITE_CALL IgniteCreateContext(char** opts, int optsLen, gcj::JniHandlers* cbs);
+ void IGNITE_CALL IgniteDeleteContext(gcj::JniContext* ctx);
+
+ void IGNITE_CALL IgniteDestroyJvm(gcj::JniContext* ctx);
+
+ void* IGNITE_CALL IgniteEventsWithAsync(gcj::JniContext* ctx, void* obj);
+ bool IGNITE_CALL IgniteEventsStopLocalListen(gcj::JniContext* ctx, void* obj, long long hnd);
+ void IGNITE_CALL IgniteEventsLocalListen(gcj::JniContext* ctx, void* obj, long long hnd, int type);
+ bool IGNITE_CALL IgniteEventsIsEnabled(gcj::JniContext* ctx, void* obj, int type);
+
+ void* IGNITE_CALL IgniteServicesWithAsync(gcj::JniContext* ctx, void* obj);
+ void* IGNITE_CALL IgniteServicesWithServerKeepPortable(gcj::JniContext* ctx, void* obj);
+ void IGNITE_CALL IgniteServicesCancel(gcj::JniContext* ctx, void* obj, char* name);
+ void IGNITE_CALL IgniteServicesCancelAll(gcj::JniContext* ctx, void* obj);
+ void* IGNITE_CALL IgniteServicesGetServiceProxy(gcj::JniContext* ctx, void* obj, char* name, bool sticky);
+}
+
+#endif
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/include/ignite/common/java.h
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/include/ignite/common/java.h b/modules/platform/src/main/cpp/common/include/ignite/common/java.h
new file mode 100644
index 0000000..426ac68
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/include/ignite/common/java.h
@@ -0,0 +1,652 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _IGNITE_COMMON_JVM
+#define _IGNITE_COMMON_JVM
+
+#include <jni.h>
+
+#include "ignite/common/common.h"
+
+namespace ignite
+{
+ namespace common
+ {
+ namespace java
+ {
+ /* Error constants. */
+ const int IGNITE_JNI_ERR_SUCCESS = 0;
+ const int IGNITE_JNI_ERR_GENERIC = 1;
+ const int IGNITE_JNI_ERR_JVM_INIT = 2;
+ const int IGNITE_JNI_ERR_JVM_ATTACH = 3;
+
+ /* Handlers for callbacks from Java. */
+ typedef long long(JNICALL *CacheStoreCreateHandler)(void* target, long long memPtr);
+ typedef int(JNICALL *CacheStoreInvokeHandler)(void* target, long long objPtr, long long memPtr, void* cb);
+ typedef void(JNICALL *CacheStoreDestroyHandler)(void* target, long long objPtr);
+ typedef long long(JNICALL *CacheStoreSessionCreateHandler)(void* target, long long storePtr);
+
+ typedef long long(JNICALL *CacheEntryFilterCreateHandler)(void* target, long long memPtr);
+ typedef int(JNICALL *CacheEntryFilterApplyHandler)(void* target, long long ptr, long long memPtr);
+ typedef void(JNICALL *CacheEntryFilterDestroyHandler)(void* target, long long ptr);
+
+ typedef void(JNICALL *CacheInvokeHandler)(void* target, long long inMemPtr, long long outMemPtr);
+
+ typedef void(JNICALL *ComputeTaskMapHandler)(void* target, long long taskPtr, long long inMemPtr, long long outMemPtr);
+ typedef int(JNICALL *ComputeTaskJobResultHandler)(void* target, long long taskPtr, long long jobPtr, long long memPtr);
+ typedef void(JNICALL *ComputeTaskReduceHandler)(void* target, long long taskPtr);
+ typedef void(JNICALL *ComputeTaskCompleteHandler)(void* target, long long taskPtr, long long memPtr);
+ typedef int(JNICALL *ComputeJobSerializeHandler)(void* target, long long jobPtr, long long memPtr);
+ typedef long long(JNICALL *ComputeJobCreateHandler)(void* target, long long memPtr);
+ typedef void(JNICALL *ComputeJobExecuteHandler)(void* target, long long jobPtr, int cancel, long long memPtr);
+ typedef void(JNICALL *ComputeJobCancelHandler)(void* target, long long jobPtr);
+ typedef void(JNICALL *ComputeJobDestroyHandler)(void* target, long long jobPtr);
+
+ typedef void(JNICALL *ContinuousQueryListenerApplyHandler)(void* target, long long lsnrPtr, long long memPtr);
+ typedef long long(JNICALL *ContinuousQueryFilterCreateHandler)(void* target, long long memPtr);
+ typedef int(JNICALL *ContinuousQueryFilterApplyHandler)(void* target, long long filterPtr, long long memPtr);
+ typedef void(JNICALL *ContinuousQueryFilterReleaseHandler)(void* target, long long filterPtr);
+
+ typedef void(JNICALL *DataStreamerTopologyUpdateHandler)(void* target, long long ldrPtr, long long topVer, int topSize);
+ typedef void(JNICALL *DataStreamerStreamReceiverInvokeHandler)(void* target, long long ptr, void* cache, long long memPtr, unsigned char keepPortable);
+
+ typedef void(JNICALL *FutureByteResultHandler)(void* target, long long futAddr, int res);
+ typedef void(JNICALL *FutureBoolResultHandler)(void* target, long long futAddr, int res);
+ typedef void(JNICALL *FutureShortResultHandler)(void* target, long long futAddr, int res);
+ typedef void(JNICALL *FutureCharResultHandler)(void* target, long long futAddr, int res);
+ typedef void(JNICALL *FutureIntResultHandler)(void* target, long long futAddr, int res);
+ typedef void(JNICALL *FutureFloatResultHandler)(void* target, long long futAddr, float res);
+ typedef void(JNICALL *FutureLongResultHandler)(void* target, long long futAddr, long long res);
+ typedef void(JNICALL *FutureDoubleResultHandler)(void* target, long long futAddr, double res);
+ typedef void(JNICALL *FutureObjectResultHandler)(void* target, long long futAddr, long long memPtr);
+ typedef void(JNICALL *FutureNullResultHandler)(void* target, long long futAddr);
+ typedef void(JNICALL *FutureErrorHandler)(void* target, long long futAddr, long long memPtr);
+
+ typedef void(JNICALL *LifecycleEventHandler)(void* target, long long ptr, int evt);
+
+ typedef void(JNICALL *MemoryReallocateHandler)(void* target, long long memPtr, int cap);
+
+ typedef long long(JNICALL *MessagingFilterCreateHandler)(void* target, long long memPtr);
+ typedef int(JNICALL *MessagingFilterApplyHandler)(void* target, long long ptr, long long memPtr);
+ typedef void(JNICALL *MessagingFilterDestroyHandler)(void* target, long long ptr);
+
+ typedef long long(JNICALL *EventFilterCreateHandler)(void* target, long long memPtr);
+ typedef int(JNICALL *EventFilterApplyHandler)(void* target, long long ptr, long long memPtr);
+ typedef void(JNICALL *EventFilterDestroyHandler)(void* target, long long ptr);
+
+ typedef long long(JNICALL *ServiceInitHandler)(void* target, long long memPtr);
+ typedef void(JNICALL *ServiceExecuteHandler)(void* target, long long svcPtr, long long memPtr);
+ typedef void(JNICALL *ServiceCancelHandler)(void* target, long long svcPtr, long long memPtr);
+ typedef void(JNICALL *ServiceInvokeMethodHandler)(void* target, long long svcPtr, long long inMemPtr, long long outMemPtr);
+ typedef int(JNICALL *ClusterNodeFilterApplyHandler)(void* target, long long memPtr);
+
+ typedef long long(JNICALL *NodeInfoHandler)(void* target, long long memPtr);
+
+ typedef void(JNICALL *OnStartHandler)(void* target, long long memPtr);
+ typedef void(JNICALL *OnStopHandler)(void* target);
+ typedef void(JNICALL *ErrorHandler)(void* target, int errCode, const char* errClsChars, int errClsCharsLen, const char* errMsgChars, int errMsgCharsLen, void* errData, int errDataLen);
+
+ typedef long long(JNICALL *ExtensionCallbackInLongOutLongHandler)(void* target, int typ, long long arg1);
+ typedef long long(JNICALL *ExtensionCallbackInLongLongOutLongHandler)(void* target, int typ, long long arg1, long long arg2);
+
+ /**
+ * JNI handlers holder.
+ */
+ struct JniHandlers {
+ void* target;
+
+ CacheStoreCreateHandler cacheStoreCreate;
+ CacheStoreInvokeHandler cacheStoreInvoke;
+ CacheStoreDestroyHandler cacheStoreDestroy;
+ CacheStoreSessionCreateHandler cacheStoreSessionCreate;
+
+ CacheEntryFilterCreateHandler cacheEntryFilterCreate;
+ CacheEntryFilterApplyHandler cacheEntryFilterApply;
+ CacheEntryFilterDestroyHandler cacheEntryFilterDestroy;
+
+ CacheInvokeHandler cacheInvoke;
+
+ ComputeTaskMapHandler computeTaskMap;
+ ComputeTaskJobResultHandler computeTaskJobRes;
+ ComputeTaskReduceHandler computeTaskReduce;
+ ComputeTaskCompleteHandler computeTaskComplete;
+ ComputeJobSerializeHandler computeJobSerialize;
+ ComputeJobCreateHandler computeJobCreate;
+ ComputeJobExecuteHandler computeJobExec;
+ ComputeJobCancelHandler computeJobCancel;
+ ComputeJobDestroyHandler computeJobDestroy;
+
+ ContinuousQueryListenerApplyHandler contQryLsnrApply;
+ ContinuousQueryFilterCreateHandler contQryFilterCreate;
+ ContinuousQueryFilterApplyHandler contQryFilterApply;
+ ContinuousQueryFilterReleaseHandler contQryFilterRelease;
+
+ DataStreamerTopologyUpdateHandler dataStreamerTopologyUpdate;
+ DataStreamerStreamReceiverInvokeHandler streamReceiverInvoke;
+
+ FutureByteResultHandler futByteRes;
+ FutureBoolResultHandler futBoolRes;
+ FutureShortResultHandler futShortRes;
+ FutureCharResultHandler futCharRes;
+ FutureIntResultHandler futIntRes;
+ FutureFloatResultHandler futFloatRes;
+ FutureLongResultHandler futLongRes;
+ FutureDoubleResultHandler futDoubleRes;
+ FutureObjectResultHandler futObjRes;
+ FutureNullResultHandler futNullRes;
+ FutureErrorHandler futErr;
+
+ LifecycleEventHandler lifecycleEvt;
+
+ MemoryReallocateHandler memRealloc;
+
+ MessagingFilterCreateHandler messagingFilterCreate;
+ MessagingFilterApplyHandler messagingFilterApply;
+ MessagingFilterDestroyHandler messagingFilterDestroy;
+
+ EventFilterCreateHandler eventFilterCreate;
+ EventFilterApplyHandler eventFilterApply;
+ EventFilterDestroyHandler eventFilterDestroy;
+
+ ServiceInitHandler serviceInit;
+ ServiceExecuteHandler serviceExecute;
+ ServiceCancelHandler serviceCancel;
+ ServiceInvokeMethodHandler serviceInvokeMethod;
+
+ ClusterNodeFilterApplyHandler clusterNodeFilterApply;
+
+ NodeInfoHandler nodeInfo;
+
+ OnStartHandler onStart;
+ OnStopHandler onStop;
+ ErrorHandler error;
+
+ ExtensionCallbackInLongOutLongHandler extensionCallbackInLongOutLong;
+ ExtensionCallbackInLongLongOutLongHandler extensionCallbackInLongLongOutLong;
+ };
+
+ /**
+ * JNI Java members.
+ */
+ struct JniJavaMembers {
+ jclass c_Class;
+ jmethodID m_Class_getName;
+
+ jclass c_Throwable;
+ jmethodID m_Throwable_getMessage;
+ jmethodID m_Throwable_printStackTrace;
+
+ /**
+ * Constructor.
+ */
+ void Initialize(JNIEnv* env);
+
+ /**
+ * Destroy members releasing all allocated classes.
+ */
+ void Destroy(JNIEnv* env);
+
+ /**
+ * Write error information.
+ */
+ bool WriteErrorInfo(JNIEnv* env, char** errClsName, int* errClsNameLen, char** errMsg, int* errMsgLen);
+ };
+
+ /**
+ * JNI members.
+ */
+ struct JniMembers {
+ jclass c_PlatformAbstractQryCursor;
+ jmethodID m_PlatformAbstractQryCursor_iter;
+ jmethodID m_PlatformAbstractQryCursor_iterHasNext;
+ jmethodID m_PlatformAbstractQryCursor_close;
+
+ jclass c_PlatformAffinity;
+ jmethodID m_PlatformAffinity_partitions;
+
+ jclass c_PlatformCache;
+ jmethodID m_PlatformCache_withSkipStore;
+ jmethodID m_PlatformCache_withNoRetries;
+ jmethodID m_PlatformCache_withExpiryPolicy;
+ jmethodID m_PlatformCache_withAsync;
+ jmethodID m_PlatformCache_withKeepPortable;
+ jmethodID m_PlatformCache_clear;
+ jmethodID m_PlatformCache_removeAll;
+ jmethodID m_PlatformCache_iterator;
+ jmethodID m_PlatformCache_localIterator;
+ jmethodID m_PlatformCache_enterLock;
+ jmethodID m_PlatformCache_exitLock;
+ jmethodID m_PlatformCache_tryEnterLock;
+ jmethodID m_PlatformCache_closeLock;
+ jmethodID m_PlatformCache_rebalance;
+ jmethodID m_PlatformCache_size;
+
+ jclass c_PlatformCacheStoreCallback;
+ jmethodID m_PlatformCacheStoreCallback_invoke;
+
+ jclass c_IgniteException;
+
+ jclass c_PlatformClusterGroup;
+ jmethodID m_PlatformClusterGroup_forOthers;
+ jmethodID m_PlatformClusterGroup_forRemotes;
+ jmethodID m_PlatformClusterGroup_forDaemons;
+ jmethodID m_PlatformClusterGroup_forRandom;
+ jmethodID m_PlatformClusterGroup_forOldest;
+ jmethodID m_PlatformClusterGroup_forYoungest;
+ jmethodID m_PlatformClusterGroup_resetMetrics;
+
+ jclass c_PlatformCompute;
+ jmethodID m_PlatformCompute_withNoFailover;
+ jmethodID m_PlatformCompute_withTimeout;
+ jmethodID m_PlatformCompute_executeNative;
+
+ jclass c_PlatformContinuousQuery;
+ jmethodID m_PlatformContinuousQuery_close;
+ jmethodID m_PlatformContinuousQuery_getInitialQueryCursor;
+
+ jclass c_PlatformDataStreamer;
+ jmethodID m_PlatformDataStreamer_listenTopology;
+ jmethodID m_PlatformDataStreamer_getAllowOverwrite;
+ jmethodID m_PlatformDataStreamer_setAllowOverwrite;
+ jmethodID m_PlatformDataStreamer_getSkipStore;
+ jmethodID m_PlatformDataStreamer_setSkipStore;
+ jmethodID m_PlatformDataStreamer_getPerNodeBufSize;
+ jmethodID m_PlatformDataStreamer_setPerNodeBufSize;
+ jmethodID m_PlatformDataStreamer_getPerNodeParallelOps;
+ jmethodID m_PlatformDataStreamer_setPerNodeParallelOps;
+
+ jclass c_PlatformEvents;
+ jmethodID m_PlatformEvents_withAsync;
+ jmethodID m_PlatformEvents_stopLocalListen;
+ jmethodID m_PlatformEvents_localListen;
+ jmethodID m_PlatformEvents_isEnabled;
+
+ jclass c_PlatformServices;
+ jmethodID m_PlatformServices_withAsync;
+ jmethodID m_PlatformServices_withServerKeepPortable;
+ jmethodID m_PlatformServices_cancel;
+ jmethodID m_PlatformServices_cancelAll;
+ jmethodID m_PlatformServices_serviceProxy;
+
+ jclass c_PlatformIgnition;
+ jmethodID m_PlatformIgnition_start;
+ jmethodID m_PlatformIgnition_instance;
+ jmethodID m_PlatformIgnition_environmentPointer;
+ jmethodID m_PlatformIgnition_stop;
+ jmethodID m_PlatformIgnition_stopAll;
+
+ jclass c_PlatformMessaging;
+ jmethodID m_PlatformMessaging_withAsync;
+
+ jclass c_PlatformProcessor;
+ jmethodID m_PlatformProcessor_releaseStart;
+ jmethodID m_PlatformProcessor_cache;
+ jmethodID m_PlatformProcessor_createCache;
+ jmethodID m_PlatformProcessor_getOrCreateCache;
+ jmethodID m_PlatformProcessor_affinity;
+ jmethodID m_PlatformProcessor_dataStreamer;
+ jmethodID m_PlatformProcessor_transactions;
+ jmethodID m_PlatformProcessor_projection;
+ jmethodID m_PlatformProcessor_compute;
+ jmethodID m_PlatformProcessor_message;
+ jmethodID m_PlatformProcessor_events;
+ jmethodID m_PlatformProcessor_services;
+ jmethodID m_PlatformProcessor_extensions;
+
+ jclass c_PlatformTarget;
+ jmethodID m_PlatformTarget_inStreamOutLong;
+ jmethodID m_PlatformTarget_inStreamOutObject;
+ jmethodID m_PlatformTarget_outLong;
+ jmethodID m_PlatformTarget_outStream;
+ jmethodID m_PlatformTarget_outObject;
+ jmethodID m_PlatformTarget_inStreamOutStream;
+ jmethodID m_PlatformTarget_inObjectStreamOutStream;
+ jmethodID m_PlatformTarget_listenFuture;
+ jmethodID m_PlatformTarget_listenFutureForOperation;
+
+ jclass c_PlatformTransactions;
+ jmethodID m_PlatformTransactions_txStart;
+ jmethodID m_PlatformTransactions_txCommit;
+ jmethodID m_PlatformTransactions_txCommitAsync;
+ jmethodID m_PlatformTransactions_txRollback;
+ jmethodID m_PlatformTransactions_txRollbackAsync;
+ jmethodID m_PlatformTransactions_txState;
+ jmethodID m_PlatformTransactions_txSetRollbackOnly;
+ jmethodID m_PlatformTransactions_txClose;
+ jmethodID m_PlatformTransactions_resetMetrics;
+
+ jclass c_PlatformUtils;
+ jmethodID m_PlatformUtils_reallocate;
+ jmethodID m_PlatformUtils_errData;
+
+ /**
+ * Constructor.
+ */
+ void Initialize(JNIEnv* env);
+
+ /**
+ * Destroy members releasing all allocated classes.
+ */
+ void Destroy(JNIEnv* env);
+ };
+
+ /**
+ * JNI JVM wrapper.
+ */
+ class IGNITE_IMPORT_EXPORT JniJvm {
+ public:
+ /**
+ * Default constructor for uninitialized JVM.
+ */
+ JniJvm();
+
+ /**
+ * Constructor.
+ *
+ * @param jvm JVM.
+ * @param javaMembers Java members.
+ * @param members Members.
+ */
+ JniJvm(JavaVM* jvm, JniJavaMembers javaMembers, JniMembers members);
+
+ /**
+ * Get JVM.
+ *
+ * @param JVM.
+ */
+ JavaVM* GetJvm();
+
+ /**
+ * Get Java members.
+ *
+ * @param Java members.
+ */
+ JniJavaMembers& GetJavaMembers();
+
+ /**
+ * Get members.
+ *
+ * @param Members.
+ */
+ JniMembers& GetMembers();
+ private:
+ /** JVM. */
+ JavaVM* jvm;
+
+ /** Java members. */
+ JniJavaMembers javaMembers;
+
+ /** Members. */
+ JniMembers members;
+ };
+
+ /**
+ * JNI error information.
+ */
+ struct IGNITE_IMPORT_EXPORT JniErrorInfo
+ {
+ int code;
+ char* errCls;
+ char* errMsg;
+
+ /**
+ * Default constructor. Creates empty error info.
+ */
+ JniErrorInfo();
+
+ /**
+ * Constructor.
+ *
+ * @param code Code.
+ * @param errCls Error class.
+ * @param errMsg Error message.
+ */
+ JniErrorInfo(int code, const char* errCls, const char* errMsg);
+
+ /**
+ * Copy constructor.
+ *
+ * @param other Other instance.
+ */
+ JniErrorInfo(const JniErrorInfo& other);
+
+ /**
+ * Assignment operator overload.
+ *
+ * @param other Other instance.
+ * @return This instance.
+ */
+ JniErrorInfo& operator=(const JniErrorInfo& other);
+
+ /**
+ * Destructor.
+ */
+ ~JniErrorInfo();
+ };
+
+ /**
+ * Unmanaged context.
+ */
+ class IGNITE_IMPORT_EXPORT JniContext {
+ public:
+ static JniContext* Create(char** opts, int optsLen, JniHandlers hnds);
+ static JniContext* Create(char** opts, int optsLen, JniHandlers hnds, JniErrorInfo* errInfo);
+ static int Reallocate(long long memPtr, int cap);
+ static void Detach();
+ static void Release(jobject obj);
+
+ jobject IgnitionStart(char* cfgPath, char* gridName, int factoryId, long long dataPtr);
+ jobject IgnitionStart(char* cfgPath, char* gridName, int factoryId, long long dataPtr, JniErrorInfo* errInfo);
+ jobject IgnitionInstance(char* gridName);
+ jobject IgnitionInstance(char* gridName, JniErrorInfo* errInfo);
+ long long IgnitionEnvironmentPointer(char* gridName);
+ long long IgnitionEnvironmentPointer(char* gridName, JniErrorInfo* errInfo);
+ bool IgnitionStop(char* gridName, bool cancel);
+ bool IgnitionStop(char* gridName, bool cancel, JniErrorInfo* errInfo);
+ void IgnitionStopAll(bool cancel);
+ void IgnitionStopAll(bool cancel, JniErrorInfo* errInfo);
+
+ void ProcessorReleaseStart(jobject obj);
+ jobject ProcessorProjection(jobject obj);
+ jobject ProcessorCache(jobject obj, const char* name);
+ jobject ProcessorCache(jobject obj, const char* name, JniErrorInfo* errInfo);
+ jobject ProcessorCreateCache(jobject obj, const char* name);
+ jobject ProcessorCreateCache(jobject obj, const char* name, JniErrorInfo* errInfo);
+ jobject ProcessorGetOrCreateCache(jobject obj, const char* name);
+ jobject ProcessorGetOrCreateCache(jobject obj, const char* name, JniErrorInfo* errInfo);
+ jobject ProcessorAffinity(jobject obj, const char* name);
+ jobject ProcessorDataStreamer(jobject obj, const char* name, bool keepPortable);
+ jobject ProcessorTransactions(jobject obj);
+ jobject ProcessorCompute(jobject obj, jobject prj);
+ jobject ProcessorMessage(jobject obj, jobject prj);
+ jobject ProcessorEvents(jobject obj, jobject prj);
+ jobject ProcessorServices(jobject obj, jobject prj);
+ jobject ProcessorExtensions(jobject obj);
+
+ long long TargetInStreamOutLong(jobject obj, int type, long long memPtr, JniErrorInfo* errInfo = NULL);
+ void TargetInStreamOutStream(jobject obj, int opType, long long inMemPtr, long long outMemPtr, JniErrorInfo* errInfo = NULL);
+ jobject TargetInStreamOutObject(jobject obj, int type, long long memPtr, JniErrorInfo* errInfo = NULL);
+ void TargetInObjectStreamOutStream(jobject obj, int opType, void* arg, long long inMemPtr, long long outMemPtr, JniErrorInfo* errInfo = NULL);
+ long long TargetOutLong(jobject obj, int opType, JniErrorInfo* errInfo = NULL);
+ void TargetOutStream(jobject obj, int opType, long long memPtr, JniErrorInfo* errInfo = NULL);
+ jobject TargetOutObject(jobject obj, int opType, JniErrorInfo* errInfo = NULL);
+ void TargetListenFuture(jobject obj, long long futId, int typ);
+ void TargetListenFutureForOperation(jobject obj, long long futId, int typ, int opId);
+
+ int AffinityPartitions(jobject obj);
+
+ jobject CacheWithSkipStore(jobject obj);
+ jobject CacheWithNoRetries(jobject obj);
+ jobject CacheWithExpiryPolicy(jobject obj, long long create, long long update, long long access);
+ jobject CacheWithAsync(jobject obj);
+ jobject CacheWithKeepPortable(jobject obj);
+ void CacheClear(jobject obj, JniErrorInfo* errInfo = NULL);
+ void CacheRemoveAll(jobject obj, JniErrorInfo* errInfo = NULL);
+ jobject CacheOutOpQueryCursor(jobject obj, int type, long long memPtr, JniErrorInfo* errInfo = NULL);
+ jobject CacheOutOpContinuousQuery(jobject obj, int type, long long memPtr);
+ jobject CacheIterator(jobject obj);
+ jobject CacheLocalIterator(jobject obj, int peekModes);
+ void CacheEnterLock(jobject obj, long long id);
+ void CacheExitLock(jobject obj, long long id);
+ bool CacheTryEnterLock(jobject obj, long long id, long long timeout);
+ void CacheCloseLock(jobject obj, long long id);
+ void CacheRebalance(jobject obj, long long futId);
+ int CacheSize(jobject obj, int peekModes, bool loc, JniErrorInfo* errInfo = NULL);
+
+ void CacheStoreCallbackInvoke(jobject obj, long long memPtr);
+
+ void ComputeWithNoFailover(jobject obj);
+ void ComputeWithTimeout(jobject obj, long long timeout);
+ void ComputeExecuteNative(jobject obj, long long taskPtr, long long topVer);
+
+ void ContinuousQueryClose(jobject obj);
+ void* ContinuousQueryGetInitialQueryCursor(jobject obj);
+
+ void DataStreamerListenTopology(jobject obj, long long ptr);
+ bool DataStreamerAllowOverwriteGet(jobject obj);
+ void DataStreamerAllowOverwriteSet(jobject obj, bool val);
+ bool DataStreamerSkipStoreGet(jobject obj);
+ void DataStreamerSkipStoreSet(jobject obj, bool val);
+ int DataStreamerPerNodeBufferSizeGet(jobject obj);
+ void DataStreamerPerNodeBufferSizeSet(jobject obj, int val);
+ int DataStreamerPerNodeParallelOperationsGet(jobject obj);
+ void DataStreamerPerNodeParallelOperationsSet(jobject obj, int val);
+
+ jobject MessagingWithAsync(jobject obj);
+
+ jobject ProjectionForOthers(jobject obj, jobject prj);
+ jobject ProjectionForRemotes(jobject obj);
+ jobject ProjectionForDaemons(jobject obj);
+ jobject ProjectionForRandom(jobject obj);
+ jobject ProjectionForOldest(jobject obj);
+ jobject ProjectionForYoungest(jobject obj);
+ void ProjectionResetMetrics(jobject obj);
+ jobject ProjectionOutOpRet(jobject obj, int type, long long memPtr);
+
+ void QueryCursorIterator(jobject obj, JniErrorInfo* errInfo = NULL);
+ bool QueryCursorIteratorHasNext(jobject obj, JniErrorInfo* errInfo = NULL);
+ void QueryCursorClose(jobject obj, JniErrorInfo* errInfo = NULL);
+
+ long long TransactionsStart(jobject obj, int concurrency, int isolation, long long timeout, int txSize);
+ int TransactionsCommit(jobject obj, long long id);
+ void TransactionsCommitAsync(jobject obj, long long id, long long futId);
+ int TransactionsRollback(jobject obj, long long id);
+ void TransactionsRollbackAsync(jobject obj, long long id, long long futId);
+ int TransactionsClose(jobject obj, long long id);
+ int TransactionsState(jobject obj, long long id);
+ bool TransactionsSetRollbackOnly(jobject obj, long long id);
+ void TransactionsResetMetrics(jobject obj);
+
+ jobject EventsWithAsync(jobject obj);
+ bool EventsStopLocalListen(jobject obj, long long hnd);
+ void EventsLocalListen(jobject obj, long long hnd, int type);
+ bool EventsIsEnabled(jobject obj, int type);
+
+ jobject ServicesWithAsync(jobject obj);
+ jobject ServicesWithServerKeepPortable(jobject obj);
+ void ServicesCancel(jobject obj, char* name);
+ void ServicesCancelAll(jobject obj);
+ void* ServicesGetServiceProxy(jobject obj, char* name, bool sticky);
+
+ jobject Acquire(jobject obj);
+
+ void DestroyJvm();
+ void ThrowToJava(char* errMsg);
+ private:
+ JniJvm* jvm;
+ JniHandlers hnds;
+
+ JniContext(JniJvm* jvm, JniHandlers hnds);
+
+ JNIEnv* Attach();
+ void ExceptionCheck(JNIEnv* env);
+ void ExceptionCheck(JNIEnv* env, JniErrorInfo* errInfo);
+ jobject LocalToGlobal(JNIEnv* env, jobject obj);
+ jobject ProcessorCache0(jobject proc, const char* name, jmethodID mthd, JniErrorInfo* errInfo);
+ };
+
+ JNIEXPORT jlong JNICALL JniCacheStoreCreate(JNIEnv *env, jclass cls, jlong envPtr, jlong memPtr);
+ JNIEXPORT jint JNICALL JniCacheStoreInvoke(JNIEnv *env, jclass cls, jlong envPtr, jlong objPtr, jlong memPtr, jobject cb);
+ JNIEXPORT void JNICALL JniCacheStoreDestroy(JNIEnv *env, jclass cls, jlong envPtr, jlong objPtr);
+ JNIEXPORT jlong JNICALL JniCacheStoreSessionCreate(JNIEnv *env, jclass cls, jlong envPtr, jlong storePtr);
+
+ JNIEXPORT jlong JNICALL JniCacheEntryFilterCreate(JNIEnv *env, jclass cls, jlong envPtr, jlong memPtr);
+ JNIEXPORT jint JNICALL JniCacheEntryFilterApply(JNIEnv *env, jclass cls, jlong envPtr, jlong objPtr, jlong memPtr);
+ JNIEXPORT void JNICALL JniCacheEntryFilterDestroy(JNIEnv *env, jclass cls, jlong envPtr, jlong objPtr);
+
+ JNIEXPORT void JNICALL JniCacheInvoke(JNIEnv *env, jclass cls, jlong envPtr, jlong inMemPtr, jlong outMemPtr);
+
+ JNIEXPORT void JNICALL JniComputeTaskMap(JNIEnv *env, jclass cls, jlong envPtr, jlong taskPtr, jlong inMemPtr, jlong outMemPtr);
+ JNIEXPORT jint JNICALL JniComputeTaskJobResult(JNIEnv *env, jclass cls, jlong envPtr, jlong taskPtr, jlong jobPtr, jlong memPtr);
+ JNIEXPORT void JNICALL JniComputeTaskReduce(JNIEnv *env, jclass cls, jlong envPtr, jlong taskPtr);
+ JNIEXPORT void JNICALL JniComputeTaskComplete(JNIEnv *env, jclass cls, jlong envPtr, jlong taskPtr, jlong memPtr);
+ JNIEXPORT jint JNICALL JniComputeJobSerialize(JNIEnv *env, jclass cls, jlong envPtr, jlong jobPtr, jlong memPtr);
+ JNIEXPORT jlong JNICALL JniComputeJobCreate(JNIEnv *env, jclass cls, jlong envPtr, jlong memPtr);
+ JNIEXPORT void JNICALL JniComputeJobExecute(JNIEnv *env, jclass cls, jlong envPtr, jlong jobPtr, jint cancel, jlong memPtr);
+ JNIEXPORT void JNICALL JniComputeJobCancel(JNIEnv *env, jclass cls, jlong envPtr, jlong jobPtr);
+ JNIEXPORT void JNICALL JniComputeJobDestroy(JNIEnv *env, jclass cls, jlong envPtr, jlong jobPtr);
+
+ JNIEXPORT void JNICALL JniContinuousQueryListenerApply(JNIEnv *env, jclass cls, jlong envPtr, jlong cbPtr, jlong memPtr);
+ JNIEXPORT jlong JNICALL JniContinuousQueryFilterCreate(JNIEnv *env, jclass cls, jlong envPtr, jlong memPtr);
+ JNIEXPORT jint JNICALL JniContinuousQueryFilterApply(JNIEnv *env, jclass cls, jlong envPtr, jlong filterPtr, jlong memPtr);
+ JNIEXPORT void JNICALL JniContinuousQueryFilterRelease(JNIEnv *env, jclass cls, jlong envPtr, jlong filterPtr);
+
+ JNIEXPORT void JNICALL JniDataStreamerTopologyUpdate(JNIEnv *env, jclass cls, jlong envPtr, jlong ldrPtr, jlong topVer, jint topSize);
+ JNIEXPORT void JNICALL JniDataStreamerStreamReceiverInvoke(JNIEnv *env, jclass cls, jlong envPtr, jlong ptr, jobject cache, jlong memPtr, jboolean keepPortable);
+
+ JNIEXPORT void JNICALL JniFutureByteResult(JNIEnv *env, jclass cls, jlong envPtr, jlong futPtr, jint res);
+ JNIEXPORT void JNICALL JniFutureBoolResult(JNIEnv *env, jclass cls, jlong envPtr, jlong futPtr, jint res);
+ JNIEXPORT void JNICALL JniFutureShortResult(JNIEnv *env, jclass cls, jlong envPtr, jlong futPtr, jint res);
+ JNIEXPORT void JNICALL JniFutureCharResult(JNIEnv *env, jclass cls, jlong envPtr, jlong futPtr, jint res);
+ JNIEXPORT void JNICALL JniFutureIntResult(JNIEnv *env, jclass cls, jlong envPtr, jlong futPtr, jint res);
+ JNIEXPORT void JNICALL JniFutureFloatResult(JNIEnv *env, jclass cls, jlong envPtr, jlong futPtr, jfloat res);
+ JNIEXPORT void JNICALL JniFutureLongResult(JNIEnv *env, jclass cls, jlong envPtr, jlong futPtr, jlong res);
+ JNIEXPORT void JNICALL JniFutureDoubleResult(JNIEnv *env, jclass cls, jlong envPtr, jlong futPtr, jdouble res);
+ JNIEXPORT void JNICALL JniFutureObjectResult(JNIEnv *env, jclass cls, jlong envPtr, jlong futPtr, jlong memPtr);
+ JNIEXPORT void JNICALL JniFutureNullResult(JNIEnv *env, jclass cls, jlong envPtr, jlong futPtr);
+ JNIEXPORT void JNICALL JniFutureError(JNIEnv *env, jclass cls, jlong envPtr, jlong futPtr, jlong memPtr);
+
+ JNIEXPORT void JNICALL JniLifecycleEvent(JNIEnv *env, jclass cls, jlong envPtr, jlong ptr, jint evt);
+
+ JNIEXPORT void JNICALL JniMemoryReallocate(JNIEnv *env, jclass cls, jlong envPtr, jlong memPtr, jint cap);
+
+ JNIEXPORT jlong JNICALL JniMessagingFilterCreate(JNIEnv *env, jclass cls, jlong envPtr, jlong memPtr);
+ JNIEXPORT jint JNICALL JniMessagingFilterApply(JNIEnv *env, jclass cls, jlong envPtr, jlong ptr, jlong memPtr);
+ JNIEXPORT void JNICALL JniMessagingFilterDestroy(JNIEnv *env, jclass cls, jlong envPtr, jlong ptr);
+
+ JNIEXPORT jlong JNICALL JniEventFilterCreate(JNIEnv *env, jclass cls, jlong envPtr, jlong memPtr);
+ JNIEXPORT jint JNICALL JniEventFilterApply(JNIEnv *env, jclass cls, jlong envPtr, jlong ptr, jlong memPtr);
+ JNIEXPORT void JNICALL JniEventFilterDestroy(JNIEnv *env, jclass cls, jlong envPtr, jlong ptr);
+
+ JNIEXPORT jlong JNICALL JniServiceInit(JNIEnv *env, jclass cls, jlong envPtr, jlong memPtr);
+ JNIEXPORT void JNICALL JniServiceExecute(JNIEnv *env, jclass cls, jlong envPtr, jlong svcPtr, jlong memPtr);
+ JNIEXPORT void JNICALL JniServiceCancel(JNIEnv *env, jclass cls, jlong envPtr, jlong svcPtr, jlong memPtr);
+ JNIEXPORT void JNICALL JniServiceInvokeMethod(JNIEnv *env, jclass cls, jlong envPtr, jlong svcPtr, jlong inMemPtr, jlong outMemPtr);
+ JNIEXPORT jint JNICALL JniClusterNodeFilterApply(JNIEnv *env, jclass cls, jlong envPtr, jlong memPtr);
+
+ JNIEXPORT jlong JNICALL JniNodeInfo(JNIEnv *env, jclass cls, jlong envPtr, jlong memPtr);
+
+ JNIEXPORT void JNICALL JniOnStart(JNIEnv *env, jclass cls, jlong envPtr, jlong memPtr);
+ JNIEXPORT void JNICALL JniOnStop(JNIEnv *env, jclass cls, jlong envPtr);
+
+ JNIEXPORT jlong JNICALL JniExtensionCallbackInLongOutLong(JNIEnv *env, jclass cls, jlong envPtr, jint typ, jlong arg1);
+ JNIEXPORT jlong JNICALL JniExtensionCallbackInLongLongOutLong(JNIEnv *env, jclass cls, jlong envPtr, jint typ, jlong arg1, jlong arg2);
+ }
+ }
+}
+
+#endif
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/os/linux/include/Makefile.am
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/os/linux/include/Makefile.am b/modules/platform/src/main/cpp/common/os/linux/include/Makefile.am
new file mode 100644
index 0000000..68e45e6
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/os/linux/include/Makefile.am
@@ -0,0 +1,21 @@
+##
+## Licensed to the Apache Software Foundation (ASF) under one or more
+## contributor license agreements. See the NOTICE file distributed with
+## this work for additional information regarding copyright ownership.
+## The ASF licenses this file to You under the Apache License, Version 2.0
+## (the "License"); you may not use this file except in compliance with
+## the License. You may obtain a copy of the License at
+##
+## http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+
+ACLOCAL_AMFLAGS = "-Im4"
+
+nobase_include_HEADERS = ignite/common/common.h \
+ ignite/common/concurrent_os.h
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/os/linux/include/ignite/common/common.h
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/os/linux/include/ignite/common/common.h b/modules/platform/src/main/cpp/common/os/linux/include/ignite/common/common.h
new file mode 100644
index 0000000..6577ad8
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/os/linux/include/ignite/common/common.h
@@ -0,0 +1,81 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _IGNITE_COMMON_OS
+#define _IGNITE_COMMON_OS
+
+#ifndef __has_attribute
+ #define __has_attribute(x) 0
+#endif
+
+#if (defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4) && (__GNUC_MINOR__ > 2))) || __has_attribute(visibility)
+ #define IGNITE_EXPORT __attribute__((visibility("default")))
+ #define IGNITE_IMPORT __attribute__((visibility("default")))
+#else
+ #define IGNITE_EXPORT
+ #define IGNITE_IMPORT
+#endif
+
+#define IGNITE_CALL
+
+#ifdef IGNITE_IMPL
+ #define IGNITE_IMPORT_EXPORT IGNITE_EXPORT
+#else
+ #define IGNITE_IMPORT_EXPORT IGNITE_IMPORT
+#endif
+
+/**
+ * Common construction to disable copy constructor and assignment for class.
+ */
+#define IGNITE_NO_COPY_ASSIGNMENT(cls) \
+ cls(const cls& src); \
+ cls& operator= (const cls& other);
+
+namespace ignite
+{
+ namespace common
+ {
+ /**
+ * Helper class to manage attached threads.
+ */
+ class AttachHelper
+ {
+ public:
+ /**
+ * Destructor.
+ */
+ ~AttachHelper();
+
+ /**
+ * Callback invoked on successful thread attach ot JVM.
+ */
+ static void OnThreadAttach();
+ private:
+ /**
+ * Helper method to allocate attach key.
+ */
+ static void AllocateAttachKey();
+
+ /**
+ * Attach key destructor.
+ */
+ static void DestroyAttachKey(void* key);
+ };
+ }
+}
+
+#endif
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/os/linux/include/ignite/common/concurrent_os.h
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/os/linux/include/ignite/common/concurrent_os.h b/modules/platform/src/main/cpp/common/os/linux/include/ignite/common/concurrent_os.h
new file mode 100644
index 0000000..63798b1
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/os/linux/include/ignite/common/concurrent_os.h
@@ -0,0 +1,394 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _IGNITE_COMMON_CONCURRENT_OS
+#define _IGNITE_COMMON_CONCURRENT_OS
+
+#include <map>
+#include <stdint.h>
+#include <pthread.h>
+
+#include "ignite/common/common.h"
+
+namespace ignite
+{
+ namespace common
+ {
+ namespace concurrent
+ {
+ /**
+ * Static class to manage memory visibility semantics.
+ */
+ class IGNITE_IMPORT_EXPORT Memory {
+ public:
+ /**
+ * Full fence.
+ */
+ static void Fence();
+ };
+
+ /**
+ * Critical section.
+ */
+ class IGNITE_IMPORT_EXPORT CriticalSection {
+ public:
+ /**
+ * Constructor.
+ */
+ CriticalSection();
+
+ /**
+ * Destructor.
+ */
+ ~CriticalSection();
+
+ /**
+ * Enter critical section.
+ */
+ void Enter();
+
+ /**
+ * Leave critical section.
+ */
+ void Leave();
+ private:
+ pthread_mutex_t mux;
+
+ IGNITE_NO_COPY_ASSIGNMENT(CriticalSection)
+ };
+
+ /**
+ * Special latch with count = 1.
+ */
+ class IGNITE_IMPORT_EXPORT SingleLatch
+ {
+ public:
+ /**
+ * Constructor.
+ */
+ SingleLatch();
+
+ /**
+ * Destructor.
+ */
+ ~SingleLatch();
+
+ /**
+ * Perform the countdown.
+ */
+ void CountDown();
+
+ /**
+ * Await the countdown.
+ */
+ void Await();
+ private:
+ /** Mutex. */
+ pthread_mutex_t mux;
+
+ /** Condition. */
+ pthread_cond_t cond;
+
+ /** Ready flag. */
+ bool ready;
+
+ IGNITE_NO_COPY_ASSIGNMENT(SingleLatch)
+ };
+
+ /**
+ * Primitives for atomic access.
+ */
+ class IGNITE_IMPORT_EXPORT Atomics
+ {
+ public:
+ /**
+ * Update the 32-bit integer value if it is equal to expected value.
+ *
+ * @param ptr Pointer.
+ * @param expVal Expected value.
+ * @param newVal New value.
+ * @return True if update occurred as a result of this call, false otherwise.
+ */
+ static bool CompareAndSet32(int32_t* ptr, int32_t expVal, int32_t newVal);
+
+ /**
+ * Update the 32-bit integer value if it is equal to expected value.
+ *
+ * @param ptr Pointer.
+ * @param expVal Expected value.
+ * @param newVal New value.
+ * @return Value which were observed during CAS attempt.
+ */
+ static int32_t CompareAndSet32Val(int32_t* ptr, int32_t expVal, int32_t newVal);
+
+ /**
+ * Increment 32-bit integer and return new value.
+ *
+ * @param ptr Pointer.
+ * @return Value after increment.
+ */
+ static int32_t IncrementAndGet32(int32_t* ptr);
+
+ /**
+ * Decrement 32-bit integer and return new value.
+ *
+ * @param ptr Pointer.
+ * @return Value after decrement.
+ */
+ static int32_t DecrementAndGet32(int32_t* ptr);
+
+ /**
+ * Update the 64-bit integer value if it is equal to expected value.
+ *
+ * @param ptr Pointer.
+ * @param expVal Expected value.
+ * @param newVal New value.
+ * @return True if update occurred as a result of this call, false otherwise.
+ */
+ static bool CompareAndSet64(int64_t* ptr, int64_t expVal, int64_t newVal);
+
+ /**
+ * Update the 64-bit integer value if it is equal to expected value.
+ *
+ * @param ptr Pointer.
+ * @param expVal Expected value.
+ * @param newVal New value.
+ * @return Value which were observed during CAS attempt.
+ */
+ static int64_t CompareAndSet64Val(int64_t* ptr, int64_t expVal, int64_t newVal);
+
+ /**
+ * Increment 64-bit integer and return new value.
+ *
+ * @param ptr Pointer.
+ * @return Value after increment.
+ */
+ static int64_t IncrementAndGet64(int64_t* ptr);
+
+ /**
+ * Decrement 64-bit integer and return new value.
+ *
+ * @param ptr Pointer.
+ * @return Value after decrement.
+ */
+ static int64_t DecrementAndGet64(int64_t* ptr);
+ };
+
+ /**
+ * Thread-local entry.
+ */
+ class IGNITE_IMPORT_EXPORT ThreadLocalEntry
+ {
+ public:
+ /**
+ * Virtual destructor to allow for correct typed entries cleanup.
+ */
+ virtual ~ThreadLocalEntry()
+ {
+ // No-op.
+ }
+ };
+
+ /**
+ * Typed thread-local entry.
+ */
+ template<typename T>
+ class IGNITE_IMPORT_EXPORT ThreadLocalTypedEntry : public ThreadLocalEntry
+ {
+ public:
+ /**
+ * Constructor.
+ *
+ * @param val Value.
+ */
+ ThreadLocalTypedEntry(T val) : val(val)
+ {
+ // No-op.
+ }
+
+ ~ThreadLocalTypedEntry()
+ {
+ // No-op.
+ }
+
+ /**
+ * Get value.
+ *
+ * @return Value.
+ */
+ T Get()
+ {
+ return val;
+ }
+ private:
+ /** Value. */
+ T val;
+ };
+
+ /**
+ * Thread-local abstraction.
+ */
+ class IGNITE_IMPORT_EXPORT ThreadLocal
+ {
+ public:
+ /**
+ * Get next available index to be used in thread-local storage.
+ *
+ * @return Index.
+ */
+ static int32_t NextIndex();
+
+ /**
+ * Get value by index.
+ *
+ * @param idx Index.
+ * @return Value associated with the index or NULL.
+ */
+ template<typename T>
+ static T Get(int32_t idx)
+ {
+ void* linuxVal = Get0();
+
+ if (linuxVal)
+ {
+ std::map<int32_t, ThreadLocalEntry*>* map =
+ static_cast<std::map<int32_t, ThreadLocalEntry*>*>(linuxVal);
+
+ ThreadLocalTypedEntry<T>* entry = static_cast<ThreadLocalTypedEntry<T>*>((*map)[idx]);
+
+ if (entry)
+ return entry->Get();
+ }
+
+ return T();
+ }
+
+ /**
+ * Set value at the given index.
+ *
+ * @param idx Index.
+ * @param val Value to be associated with the index.
+ */
+ template<typename T>
+ static void Set(int32_t idx, const T& val)
+ {
+ void* linuxVal = Get0();
+
+ if (linuxVal)
+ {
+ std::map<int32_t, ThreadLocalEntry*>* map =
+ static_cast<std::map<int32_t, ThreadLocalEntry*>*>(linuxVal);
+
+ ThreadLocalEntry* appVal = (*map)[idx];
+
+ if (appVal)
+ delete appVal;
+
+ (*map)[idx] = new ThreadLocalTypedEntry<T>(val);
+ }
+ else
+ {
+ std::map<int32_t, ThreadLocalEntry*>* map = new std::map<int32_t, ThreadLocalEntry*>();
+
+ Set0(map);
+
+ (*map)[idx] = new ThreadLocalTypedEntry<T>(val);
+ }
+ }
+
+ /**
+ * Remove value at the given index.
+ *
+ * @param idx Index.
+ */
+ static void Remove(int32_t idx);
+
+ /**
+ * Internal thread-local map clear routine.
+ *
+ * @param mapPtr Pointer to map.
+ */
+ static void Clear0(void* mapPtr);
+
+ private:
+ /**
+ * Internal get routine.
+ *
+ * @param Associated value.
+ */
+ static void* Get0();
+
+ /**
+ * Internal set routine.
+ *
+ * @param ptr Pointer.
+ */
+ static void Set0(void* ptr);
+ };
+
+ /**
+ * Thread-local instance. Simplifies API avoiding direct index allocations.
+ */
+ template<typename T>
+ class IGNITE_IMPORT_EXPORT ThreadLocalInstance
+ {
+ public:
+ /**
+ * Constructor.
+ */
+ ThreadLocalInstance() : idx(ThreadLocal::NextIndex())
+ {
+ // No-op.
+ }
+
+ /**
+ * Get value.
+ *
+ * @return Value.
+ */
+ T Get()
+ {
+ return ThreadLocal::Get<T>(idx);
+ }
+
+ /**
+ * Set instance.
+ *
+ * @param val Value.
+ */
+ void Set(const T& val)
+ {
+ ThreadLocal::Set<T>(idx, val);
+ }
+
+ /**
+ * Remove instance.
+ */
+ void Remove()
+ {
+ ThreadLocal::Remove(idx);
+ }
+
+ private:
+ /** Index. */
+ int32_t idx;
+ };
+ }
+ }
+}
+
+#endif
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/os/linux/src/common.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/os/linux/src/common.cpp b/modules/platform/src/main/cpp/common/os/linux/src/common.cpp
new file mode 100644
index 0000000..c0cccdc
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/os/linux/src/common.cpp
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <pthread.h>
+
+#include "ignite/common/common.h"
+#include "ignite/common/java.h"
+
+using namespace ignite::common::java;
+
+namespace ignite
+{
+ namespace common
+ {
+ /** Key indicating that the thread is attached. */
+ static pthread_key_t attachKey;
+
+ /** Helper to ensure that attach key is allocated only once. */
+ static pthread_once_t attachKeyInit = PTHREAD_ONCE_INIT;
+
+ AttachHelper::~AttachHelper()
+ {
+ JniContext::Detach();
+ }
+
+ void AttachHelper::OnThreadAttach()
+ {
+ pthread_once(&attachKeyInit, AllocateAttachKey);
+
+ void* val = pthread_getspecific(attachKey);
+
+ if (!val)
+ pthread_setspecific(attachKey, new AttachHelper());
+ }
+
+ void AttachHelper::AllocateAttachKey()
+ {
+ pthread_key_create(&attachKey, DestroyAttachKey);
+ }
+
+ void AttachHelper::DestroyAttachKey(void* key)
+ {
+ delete reinterpret_cast<AttachHelper*>(key);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/os/linux/src/concurrent_os.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/os/linux/src/concurrent_os.cpp b/modules/platform/src/main/cpp/common/os/linux/src/concurrent_os.cpp
new file mode 100644
index 0000000..44f0b22
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/os/linux/src/concurrent_os.cpp
@@ -0,0 +1,175 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ignite/common/concurrent_os.h"
+
+namespace ignite
+{
+ namespace common
+ {
+ namespace concurrent
+ {
+ /** Key indicating that the thread is attached. */
+ static pthread_key_t tlsKey;
+
+ /** Helper to ensure that attach key is allocated only once. */
+ static pthread_once_t tlsKeyInit = PTHREAD_ONCE_INIT;
+
+ /**
+ * Routine to destroy TLS key.
+ *
+ * @param key Key.
+ */
+ void DestroyTlsKey(void* key) {
+ ThreadLocal::Clear0(key);
+ }
+
+ /**
+ * Routine to allocate TLS key.
+ */
+ void AllocateTlsKey() {
+ pthread_key_create(&tlsKey, DestroyTlsKey);
+ }
+
+ void Memory::Fence() {
+ __asm__ volatile ("" ::: "memory");
+ }
+
+ CriticalSection::CriticalSection() {
+ pthread_mutex_init(&mux, NULL);
+
+ Memory::Fence();
+ }
+
+ CriticalSection::~CriticalSection() {
+ Memory::Fence();
+
+ pthread_mutex_destroy(&mux);
+ }
+
+ void CriticalSection::Enter() {
+ Memory::Fence();
+
+ pthread_mutex_lock(&mux);
+ }
+
+ void CriticalSection::Leave() {
+ Memory::Fence();
+
+ pthread_mutex_unlock(&mux);
+ }
+
+ SingleLatch::SingleLatch()
+ {
+ pthread_mutex_init(&mux, NULL);
+ pthread_cond_init(&cond, NULL);
+ ready = false;
+
+ Memory::Fence();
+ }
+
+ SingleLatch::~SingleLatch()
+ {
+ Memory::Fence();
+
+ pthread_cond_destroy(&cond);
+ pthread_mutex_destroy(&mux);
+ }
+
+ void SingleLatch::CountDown()
+ {
+ pthread_mutex_lock(&mux);
+
+ if (!ready) {
+ ready = true;
+
+ pthread_cond_broadcast(&cond);
+ }
+
+ pthread_mutex_unlock(&mux);
+
+ Memory::Fence();
+ }
+
+ void SingleLatch::Await()
+ {
+ pthread_mutex_lock(&mux);
+
+ while (!ready)
+ pthread_cond_wait(&cond, &mux);
+
+ pthread_mutex_unlock(&mux);
+
+ Memory::Fence();
+ }
+
+ bool Atomics::CompareAndSet32(int32_t* ptr, int32_t expVal, int32_t newVal)
+ {
+ return __sync_bool_compare_and_swap(ptr, expVal, newVal);
+ }
+
+ int32_t Atomics::CompareAndSet32Val(int32_t* ptr, int32_t expVal, int32_t newVal)
+ {
+ return __sync_val_compare_and_swap(ptr, expVal, newVal);
+ }
+
+ int32_t Atomics::IncrementAndGet32(int32_t* ptr)
+ {
+ return __sync_fetch_and_add(ptr, 1) + 1;
+ }
+
+ int32_t Atomics::DecrementAndGet32(int32_t* ptr)
+ {
+ return __sync_fetch_and_sub(ptr, 1) - 1;
+ }
+
+ bool Atomics::CompareAndSet64(int64_t* ptr, int64_t expVal, int64_t newVal)
+ {
+ return __sync_bool_compare_and_swap(ptr, expVal, newVal);
+ }
+
+ int64_t Atomics::CompareAndSet64Val(int64_t* ptr, int64_t expVal, int64_t newVal)
+ {
+ return __sync_val_compare_and_swap(ptr, expVal, newVal);
+ }
+
+ int64_t Atomics::IncrementAndGet64(int64_t* ptr)
+ {
+ return __sync_fetch_and_add(ptr, 1) + 1;
+ }
+
+ int64_t Atomics::DecrementAndGet64(int64_t* ptr)
+ {
+ return __sync_fetch_and_sub(ptr, 1) - 1;
+ }
+
+ void* ThreadLocal::Get0()
+ {
+ pthread_once(&tlsKeyInit, AllocateTlsKey);
+
+ return pthread_getspecific(tlsKey);
+ }
+
+ void ThreadLocal::Set0(void* ptr)
+ {
+ pthread_once(&tlsKeyInit, AllocateTlsKey);
+
+ pthread_setspecific(tlsKey, ptr);
+ }
+ }
+ }
+}
\ No newline at end of file
[3/4] ignite git commit: IGNITE-1337: Moved "common" CPP project to
Ignite.
Posted by vo...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/os/win/include/ignite/common/common.h
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/os/win/include/ignite/common/common.h b/modules/platform/src/main/cpp/common/os/win/include/ignite/common/common.h
new file mode 100644
index 0000000..9e57bde
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/os/win/include/ignite/common/common.h
@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef _IGNITE_COMMON_COMMON
+#define _IGNITE_COMMON_COMMON
+
+#define IGNITE_EXPORT __declspec(dllexport)
+#define IGNITE_IMPORT __declspec(dllimport)
+#define IGNITE_CALL __stdcall
+
+#define IGNITE_IMPORT_EXPORT IGNITE_EXPORT
+
+#include <iostream>
+
+#define IGNITE_TRACE_ALLOC(addr) \
+ std::cout << "ALLOC " << __FILE__ << "(" << __LINE__ << "): 0x" << (void*)addr << std::endl;
+
+/**
+ * Common construction to disable copy constructor and assignment for class.
+ */
+#define IGNITE_NO_COPY_ASSIGNMENT(cls) \
+ cls(const cls& src); \
+ cls& operator= (const cls& other);
+
+namespace ignite
+{
+ namespace common
+ {
+ /**
+ * Helper class to manage attached threads.
+ */
+ class AttachHelper
+ {
+ public:
+ /**
+ * Callback invoked on successful thread attach ot JVM.
+ */
+ static void OnThreadAttach();
+ };
+ }
+}
+
+#endif
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/os/win/include/ignite/common/concurrent_os.h
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/os/win/include/ignite/common/concurrent_os.h b/modules/platform/src/main/cpp/common/os/win/include/ignite/common/concurrent_os.h
new file mode 100644
index 0000000..0a47beb
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/os/win/include/ignite/common/concurrent_os.h
@@ -0,0 +1,406 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _IGNITE_COMMON_CONCURRENT_OS
+#define _IGNITE_COMMON_CONCURRENT_OS
+
+#include <map>
+#include <stdint.h>
+#include <windows.h>
+
+#include "ignite/common/common.h"
+
+namespace ignite
+{
+ namespace common
+ {
+ namespace concurrent
+ {
+ /**
+ * Static class to manage memory visibility semantics.
+ */
+ class IGNITE_IMPORT_EXPORT Memory {
+ public:
+ /**
+ * Full fence.
+ */
+ static void Fence();
+ };
+
+ /**
+ * Critical section.
+ */
+ class IGNITE_IMPORT_EXPORT CriticalSection {
+ public:
+ /**
+ * Constructor.
+ */
+ CriticalSection();
+
+ /**
+ * Destructor.
+ */
+ ~CriticalSection();
+
+ /**
+ * Enter critical section.
+ */
+ void Enter();
+
+ /**
+ * Leave critical section.
+ */
+ void Leave();
+ private:
+ /** Handle. */
+ CRITICAL_SECTION* hnd;
+
+ IGNITE_NO_COPY_ASSIGNMENT(CriticalSection)
+ };
+
+ /**
+ * Special latch with count = 1.
+ */
+ class IGNITE_IMPORT_EXPORT SingleLatch
+ {
+ public:
+ /**
+ * Constructor.
+ */
+ SingleLatch();
+
+ /**
+ * Destructor.
+ */
+ ~SingleLatch();
+
+ /**
+ * Perform the countdown.
+ */
+ void CountDown();
+
+ /**
+ * Await the countdown.
+ */
+ void Await();
+ private:
+ /** Handle. */
+ void* hnd;
+
+ IGNITE_NO_COPY_ASSIGNMENT(SingleLatch)
+ };
+
+ /**
+ * Primitives for atomic access.
+ */
+ class IGNITE_IMPORT_EXPORT Atomics
+ {
+ public:
+ /**
+ * Update the 32-bit integer value if it is equal to expected value.
+ *
+ * @param ptr Pointer.
+ * @param expVal Expected value.
+ * @param newVal New value.
+ * @return True if update occurred as a result of this call, false otherwise.
+ */
+ static bool CompareAndSet32(int32_t* ptr, int32_t expVal, int32_t newVal);
+
+ /**
+ * Update the 32-bit integer value if it is equal to expected value.
+ *
+ * @param ptr Pointer.
+ * @param expVal Expected value.
+ * @param newVal New value.
+ * @return Value which were observed during CAS attempt.
+ */
+ static int32_t CompareAndSet32Val(int32_t* ptr, int32_t expVal, int32_t newVal);
+
+ /**
+ * Increment 32-bit integer and return new value.
+ *
+ * @param ptr Pointer.
+ * @return Value after increment.
+ */
+ static int32_t IncrementAndGet32(int32_t* ptr);
+
+ /**
+ * Decrement 32-bit integer and return new value.
+ *
+ * @param ptr Pointer.
+ * @return Value after decrement.
+ */
+ static int32_t DecrementAndGet32(int32_t* ptr);
+
+ /**
+ * Update the 64-bit integer value if it is equal to expected value.
+ *
+ * @param ptr Pointer.
+ * @param expVal Expected value.
+ * @param newVal New value.
+ * @return True if update occurred as a result of this call, false otherwise.
+ */
+ static bool CompareAndSet64(int64_t* ptr, int64_t expVal, int64_t newVal);
+
+ /**
+ * Update the 64-bit integer value if it is equal to expected value.
+ *
+ * @param ptr Pointer.
+ * @param expVal Expected value.
+ * @param newVal New value.
+ * @return Value which were observed during CAS attempt.
+ */
+ static int64_t CompareAndSet64Val(int64_t* ptr, int64_t expVal, int64_t newVal);
+
+ /**
+ * Increment 64-bit integer and return new value.
+ *
+ * @param ptr Pointer.
+ * @return Value after increment.
+ */
+ static int64_t IncrementAndGet64(int64_t* ptr);
+
+ /**
+ * Decrement 64-bit integer and return new value.
+ *
+ * @param ptr Pointer.
+ * @return Value after decrement.
+ */
+ static int64_t DecrementAndGet64(int64_t* ptr);
+ };
+
+ /**
+ * Thread-local entry.
+ */
+ class IGNITE_IMPORT_EXPORT ThreadLocalEntry
+ {
+ public:
+ /**
+ * Virtual destructor to allow for correct typed entries cleanup.
+ */
+ virtual ~ThreadLocalEntry()
+ {
+ // No-op.
+ }
+ };
+
+ /**
+ * Typed thread-local entry.
+ */
+ template<typename T>
+ class IGNITE_IMPORT_EXPORT ThreadLocalTypedEntry : public ThreadLocalEntry
+ {
+ public:
+ /**
+ * Constructor.
+ *
+ * @param val Value.
+ */
+ ThreadLocalTypedEntry(T val) : val(val)
+ {
+ // No-op.
+ }
+
+ ~ThreadLocalTypedEntry()
+ {
+ // No-op.
+ }
+
+ /**
+ * Get value.
+ *
+ * @return Value.
+ */
+ T Get()
+ {
+ return val;
+ }
+ private:
+ /** Value. */
+ T val;
+ };
+
+ /**
+ * Thread-local abstraction.
+ */
+ class IGNITE_IMPORT_EXPORT ThreadLocal
+ {
+ public:
+ /**
+ * Allocate thread-local index. Invoked once on DLL process attach.
+ *
+ * @return True if allocation was successful.
+ */
+ static bool OnProcessAttach();
+
+ /**
+ * Release thread-local entry. Invoked on DLL thread detach.
+ */
+ static void OnThreadDetach();
+
+ /**
+ * Release thread-local index. Invoked once on DLL process detach.
+ */
+ static void OnProcessDetach();
+
+ /**
+ * Get next available index to be used in thread-local storage.
+ *
+ * @return Index.
+ */
+ static int32_t NextIndex();
+
+ /**
+ * Get value by index.
+ *
+ * @param idx Index.
+ * @return Value associated with the index or NULL.
+ */
+ template<typename T>
+ static T Get(int32_t idx)
+ {
+ void* winVal = Get0();
+
+ if (winVal)
+ {
+ std::map<int32_t, ThreadLocalEntry*>* map =
+ static_cast<std::map<int32_t, ThreadLocalEntry*>*>(winVal);
+
+ ThreadLocalTypedEntry<T>* entry = static_cast<ThreadLocalTypedEntry<T>*>((*map)[idx]);
+
+ if (entry)
+ return entry->Get();
+ }
+
+ return T();
+ }
+
+ /**
+ * Set value at the given index.
+ *
+ * @param idx Index.
+ * @param val Value to be associated with the index.
+ */
+ template<typename T>
+ static void Set(int32_t idx, const T& val)
+ {
+ void* winVal = Get0();
+
+ if (winVal)
+ {
+ std::map<int32_t, ThreadLocalEntry*>* map =
+ static_cast<std::map<int32_t, ThreadLocalEntry*>*>(winVal);
+
+ ThreadLocalEntry* appVal = (*map)[idx];
+
+ if (appVal)
+ delete appVal;
+
+ (*map)[idx] = new ThreadLocalTypedEntry<T>(val);
+ }
+ else
+ {
+ std::map<int32_t, ThreadLocalEntry*>* map = new std::map<int32_t, ThreadLocalEntry*>();
+
+ Set0(map);
+
+ (*map)[idx] = new ThreadLocalTypedEntry<T>(val);
+ }
+ }
+
+ /**
+ * Remove value at the given index.
+ *
+ * @param idx Index.
+ */
+ static void Remove(int32_t idx);
+
+ private:
+ /**
+ * Internal get routine.
+ *
+ * @param Associated value.
+ */
+ static void* Get0();
+
+ /**
+ * Internal set routine.
+ *
+ * @param ptr Pointer.
+ */
+ static void Set0(void* ptr);
+
+ /**
+ * Internal thread-local map clear routine.
+ *
+ * @param mapPtr Pointer to map.
+ */
+ static void Clear0(void* mapPtr);
+ };
+
+ /**
+ * Thread-local instance. Simplifies API avoiding direct index allocations.
+ */
+ template<typename T>
+ class IGNITE_IMPORT_EXPORT ThreadLocalInstance
+ {
+ public:
+ /**
+ * Constructor.
+ */
+ ThreadLocalInstance() : idx(ThreadLocal::NextIndex())
+ {
+ // No-op.
+ }
+
+ /**
+ * Get value.
+ *
+ * @return Value.
+ */
+ T Get()
+ {
+ return ThreadLocal::Get<T>(idx);
+ }
+
+ /**
+ * Set instance.
+ *
+ * @param val Value.
+ */
+ void Set(const T& val)
+ {
+ ThreadLocal::Set<T>(idx, val);
+ }
+
+ /**
+ * Remove instance.
+ */
+ void Remove()
+ {
+ ThreadLocal::Remove(idx);
+ }
+
+ private:
+ /** Index. */
+ int32_t idx;
+ };
+ }
+ }
+}
+
+#endif
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/os/win/src/common.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/os/win/src/common.cpp b/modules/platform/src/main/cpp/common/os/win/src/common.cpp
new file mode 100644
index 0000000..e83e736
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/os/win/src/common.cpp
@@ -0,0 +1,65 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <windows.h>
+
+#include "ignite/common/common.h"
+#include "ignite/common/concurrent.h"
+#include "ignite/common/java.h"
+
+using namespace ignite::common::concurrent;
+using namespace ignite::common::java;
+
+namespace ignite
+{
+ namespace common
+ {
+ void AttachHelper::OnThreadAttach()
+ {
+ // No-op.
+ }
+ }
+}
+
+BOOL WINAPI DllMain(_In_ HINSTANCE hinstDLL, _In_ DWORD fdwReason, _In_ LPVOID lpvReserved)
+{
+ switch (fdwReason)
+ {
+ case DLL_PROCESS_ATTACH:
+ if (!ThreadLocal::OnProcessAttach())
+ return FALSE;
+
+ break;
+
+ case DLL_THREAD_DETACH:
+ ThreadLocal::OnThreadDetach();
+
+ JniContext::Detach();
+
+ break;
+
+ case DLL_PROCESS_DETACH:
+ ThreadLocal::OnProcessDetach();
+
+ break;
+
+ default:
+ break;
+ }
+
+ return TRUE;
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/os/win/src/concurrent_os.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/os/win/src/concurrent_os.cpp b/modules/platform/src/main/cpp/common/os/win/src/concurrent_os.cpp
new file mode 100644
index 0000000..a21f7ec
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/os/win/src/concurrent_os.cpp
@@ -0,0 +1,151 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ignite/common/concurrent_os.h"
+
+namespace ignite
+{
+ namespace common
+ {
+ namespace concurrent
+ {
+ /** Thread-local index for Windows. */
+ DWORD winTlsIdx;
+
+ void Memory::Fence() {
+ MemoryBarrier();
+ }
+
+ CriticalSection::CriticalSection() : hnd(new CRITICAL_SECTION) {
+ InitializeCriticalSection(hnd);
+
+ Memory::Fence();
+ }
+
+ CriticalSection::~CriticalSection() {
+ Memory::Fence();
+
+ delete hnd;
+ }
+
+ void CriticalSection::Enter() {
+ Memory::Fence();
+
+ EnterCriticalSection(hnd);
+ }
+
+ void CriticalSection::Leave() {
+ Memory::Fence();
+
+ LeaveCriticalSection(hnd);
+ }
+
+ SingleLatch::SingleLatch() : hnd(CreateEvent(NULL, TRUE, FALSE, NULL))
+ {
+ Memory::Fence();
+ }
+
+ SingleLatch::~SingleLatch()
+ {
+ Memory::Fence();
+
+ CloseHandle(hnd);
+ }
+
+ void SingleLatch::CountDown()
+ {
+ SetEvent(hnd);
+ }
+
+ void SingleLatch::Await()
+ {
+ WaitForSingleObject(hnd, INFINITE);
+ }
+
+ bool Atomics::CompareAndSet32(int32_t* ptr, int32_t expVal, int32_t newVal)
+ {
+ return CompareAndSet32Val(ptr, expVal, newVal) == expVal;
+ }
+
+ int32_t Atomics::CompareAndSet32Val(int32_t* ptr, int32_t expVal, int32_t newVal)
+ {
+ return InterlockedCompareExchange(reinterpret_cast<LONG*>(ptr), newVal, expVal);
+ }
+
+ int32_t Atomics::IncrementAndGet32(int32_t* ptr)
+ {
+ return InterlockedIncrement(reinterpret_cast<LONG*>(ptr));
+ }
+
+ int32_t Atomics::DecrementAndGet32(int32_t* ptr)
+ {
+ return InterlockedDecrement(reinterpret_cast<LONG*>(ptr));
+ }
+
+ bool Atomics::CompareAndSet64(int64_t* ptr, int64_t expVal, int64_t newVal)
+ {
+ return CompareAndSet64Val(ptr, expVal, newVal) == expVal;
+ }
+
+ int64_t Atomics::CompareAndSet64Val(int64_t* ptr, int64_t expVal, int64_t newVal)
+ {
+ return InterlockedCompareExchange64(reinterpret_cast<LONG64*>(ptr), newVal, expVal);
+ }
+
+ int64_t Atomics::IncrementAndGet64(int64_t* ptr)
+ {
+ return InterlockedIncrement64(reinterpret_cast<LONG64*>(ptr));
+ }
+
+ int64_t Atomics::DecrementAndGet64(int64_t* ptr)
+ {
+ return InterlockedDecrement64(reinterpret_cast<LONG64*>(ptr));
+ }
+
+ bool ThreadLocal::OnProcessAttach()
+ {
+ return (winTlsIdx = TlsAlloc()) != TLS_OUT_OF_INDEXES;
+ }
+
+ void ThreadLocal::OnThreadDetach()
+ {
+ if (winTlsIdx != TLS_OUT_OF_INDEXES)
+ {
+ void* mapPtr = Get0();
+
+ Clear0(mapPtr);
+ }
+ }
+
+ void ThreadLocal::OnProcessDetach()
+ {
+ if (winTlsIdx != TLS_OUT_OF_INDEXES)
+ TlsFree(winTlsIdx);
+ }
+
+ void* ThreadLocal::Get0()
+ {
+ return TlsGetValue(winTlsIdx);
+ }
+
+ void ThreadLocal::Set0(void* ptr)
+ {
+ TlsSetValue(winTlsIdx, ptr);
+ }
+ }
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/project/README.TXT
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/project/README.TXT b/modules/platform/src/main/cpp/common/project/README.TXT
new file mode 100644
index 0000000..97f4c64
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/project/README.TXT
@@ -0,0 +1 @@
+Contains IDE projects artifacts.
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/project/vs/README.TXT
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/project/vs/README.TXT b/modules/platform/src/main/cpp/common/project/vs/README.TXT
new file mode 100644
index 0000000..f4fb456
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/project/vs/README.TXT
@@ -0,0 +1 @@
+Contains Visual Studio project artifacts.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/project/vs/common.vcxproj
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/project/vs/common.vcxproj b/modules/platform/src/main/cpp/common/project/vs/common.vcxproj
new file mode 100644
index 0000000..478932f
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/project/vs/common.vcxproj
@@ -0,0 +1,202 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup Label="ProjectConfigurations">
+ <ProjectConfiguration Include="Debug|Win32">
+ <Configuration>Debug</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Debug|x64">
+ <Configuration>Debug</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Release|Win32">
+ <Configuration>Release</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Release|x64">
+ <Configuration>Release</Configuration>
+ <Platform>x64</Platform>
+ </ProjectConfiguration>
+ </ItemGroup>
+ <PropertyGroup Label="Globals">
+ <ProjectGuid>{4F7E4917-4612-4B96-9838-025711ADE391}</ProjectGuid>
+ <Keyword>Win32Proj</Keyword>
+ <RootNamespace>common</RootNamespace>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+ <ConfigurationType>DynamicLibrary</ConfigurationType>
+ <UseDebugLibraries>true</UseDebugLibraries>
+ <PlatformToolset>v100</PlatformToolset>
+ <CharacterSet>Unicode</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+ <ConfigurationType>DynamicLibrary</ConfigurationType>
+ <UseDebugLibraries>true</UseDebugLibraries>
+ <PlatformToolset>v100</PlatformToolset>
+ <CharacterSet>Unicode</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+ <ConfigurationType>DynamicLibrary</ConfigurationType>
+ <UseDebugLibraries>false</UseDebugLibraries>
+ <PlatformToolset>v100</PlatformToolset>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+ <ConfigurationType>DynamicLibrary</ConfigurationType>
+ <UseDebugLibraries>false</UseDebugLibraries>
+ <PlatformToolset>v100</PlatformToolset>
+ <WholeProgramOptimization>true</WholeProgramOptimization>
+ <CharacterSet>Unicode</CharacterSet>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+ <ImportGroup Label="ExtensionSettings">
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <PropertyGroup Label="UserMacros" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+ <LinkIncremental>true</LinkIncremental>
+ <TargetName>ignite.common</TargetName>
+ <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>$(Platform)\$(Configuration)\</IntDir>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <TargetName>ignite.common</TargetName>
+ <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>$(Platform)\$(Configuration)\</IntDir>
+ <LinkIncremental>true</LinkIncremental>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+ <LinkIncremental>false</LinkIncremental>
+ <TargetName>ignite.common</TargetName>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <TargetName>ignite.common</TargetName>
+ <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+ <IntDir>$(Platform)\$(Configuration)\</IntDir>
+ <LinkIncremental>false</LinkIncremental>
+ </PropertyGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+ <ClCompile>
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ <WarningLevel>Level3</WarningLevel>
+ <Optimization>Disabled</Optimization>
+ <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;IGNITEJVM_EXPORTS;_CRT_SECURE_NO_WARNINGS;IGNITE_IMPL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <AdditionalIncludeDirectories>$(JAVA_HOME)\include;$(JAVA_HOME)\include\win32;$(ProjectDir)\..\..\include;$(ProjectDir)\..\..\os\win\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ </ClCompile>
+ <Link>
+ <SubSystem>Windows</SubSystem>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <AdditionalDependencies>$(JAVA_HOME)\lib\jvm.lib;%(AdditionalDependencies)</AdditionalDependencies>
+ <AdditionalLibraryDirectories>$(JAVA_HOME)\lib\jvm.lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+ <DelayLoadDLLs>jvm.dll</DelayLoadDLLs>
+ <ModuleDefinitionFile>module.def</ModuleDefinitionFile>
+ <OptimizeReferences>false</OptimizeReferences>
+ <EnableCOMDATFolding>false</EnableCOMDATFolding>
+ <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+ </Link>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <ClCompile>
+ <WarningLevel>Level3</WarningLevel>
+ <SDLCheck>false</SDLCheck>
+ <AdditionalIncludeDirectories>$(JAVA_HOME)\include;$(JAVA_HOME)\include\win32;$(ProjectDir)\..\..\include;$(ProjectDir)\..\..\os\win\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;IGNITEJVM_EXPORTS;_CRT_SECURE_NO_WARNINGS;IGNITE_IMPL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+ </ClCompile>
+ <Link>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <AdditionalLibraryDirectories>$(JAVA_HOME)\lib\jvm.lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+ <AdditionalDependencies>$(JAVA_HOME)\lib\jvm.lib;%(AdditionalDependencies)</AdditionalDependencies>
+ <OptimizeReferences>true</OptimizeReferences>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <DelayLoadDLLs>jvm.dll</DelayLoadDLLs>
+ <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+ <ModuleDefinitionFile>module.def</ModuleDefinitionFile>
+ </Link>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+ <ClCompile>
+ <WarningLevel>Level3</WarningLevel>
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>
+ <Optimization>MaxSpeed</Optimization>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;IGNITEJVM_EXPORTS;_CRT_SECURE_NO_WARNINGS;IGNITE_IMPL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <AdditionalIncludeDirectories>$(JAVA_HOME)\include;$(JAVA_HOME)\include\win32;$(ProjectDir)\..\..\include;$(ProjectDir)\..\..\os\win\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+ <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+ <OmitFramePointers>true</OmitFramePointers>
+ <BufferSecurityCheck>false</BufferSecurityCheck>
+ <StringPooling>true</StringPooling>
+ </ClCompile>
+ <Link>
+ <SubSystem>Windows</SubSystem>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <OptimizeReferences>true</OptimizeReferences>
+ <AdditionalDependencies>$(JAVA_HOME)\lib\jvm.lib;%(AdditionalDependencies)</AdditionalDependencies>
+ <AdditionalLibraryDirectories>$(JAVA_HOME)\lib\jvm.lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+ <DelayLoadDLLs>jvm.dll</DelayLoadDLLs>
+ <ModuleDefinitionFile>module.def</ModuleDefinitionFile>
+ </Link>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <ClCompile>
+ <WarningLevel>Level3</WarningLevel>
+ <Optimization>Full</Optimization>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <SDLCheck>false</SDLCheck>
+ <AdditionalIncludeDirectories>$(JAVA_HOME)\include;$(JAVA_HOME)\include\win32;$(ProjectDir)\..\..\include;$(ProjectDir)\..\..\os\win\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+ <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+ <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+ <OmitFramePointers>true</OmitFramePointers>
+ <StringPooling>true</StringPooling>
+ <BufferSecurityCheck>false</BufferSecurityCheck>
+ <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;IGNITE_IMPL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ </ClCompile>
+ <Link>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <OptimizeReferences>true</OptimizeReferences>
+ <AdditionalLibraryDirectories>$(JAVA_HOME)\lib\jvm.lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+ <AdditionalDependencies>$(JAVA_HOME)\lib\jvm.lib;%(AdditionalDependencies)</AdditionalDependencies>
+ <DelayLoadDLLs>jvm.dll</DelayLoadDLLs>
+ <ModuleDefinitionFile>module.def</ModuleDefinitionFile>
+ </Link>
+ </ItemDefinitionGroup>
+ <ItemGroup>
+ <ClInclude Include="..\..\include\ignite\common\concurrent.h" />
+ <ClInclude Include="..\..\include\ignite\common\exports.h" />
+ <ClInclude Include="..\..\include\ignite\common\java.h" />
+ <ClInclude Include="..\..\os\win\include\ignite\common\common.h" />
+ <ClInclude Include="..\..\os\win\include\ignite\common\concurrent_os.h" />
+ <ClInclude Include="targetver.h" />
+ </ItemGroup>
+ <ItemGroup>
+ <ClCompile Include="..\..\os\win\src\common.cpp" />
+ <ClCompile Include="..\..\os\win\src\concurrent_os.cpp" />
+ <ClCompile Include="..\..\src\concurrent.cpp" />
+ <ClCompile Include="..\..\src\exports.cpp" />
+ <ClCompile Include="..\..\src\java.cpp" />
+ </ItemGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+ <ImportGroup Label="ExtensionTargets">
+ </ImportGroup>
+ <ItemGroup>
+ <None Include="module.def" />
+ </ItemGroup>
+</Project>
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/project/vs/common.vcxproj.filters
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/project/vs/common.vcxproj.filters b/modules/platform/src/main/cpp/common/project/vs/common.vcxproj.filters
new file mode 100644
index 0000000..3d4ae54
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/project/vs/common.vcxproj.filters
@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup>
+ <Filter Include="Misc">
+ <UniqueIdentifier>{1dbec2be-5cb4-4f70-aef6-b4627d39b99b}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="Code">
+ <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+ <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+ </Filter>
+ </ItemGroup>
+ <ItemGroup>
+ <ClInclude Include="..\..\os\win\include\ignite\common\common.h">
+ <Filter>Code</Filter>
+ </ClInclude>
+ <ClInclude Include="..\..\os\win\include\ignite\common\concurrent_os.h">
+ <Filter>Code</Filter>
+ </ClInclude>
+ <ClInclude Include="..\..\include\ignite\common\exports.h">
+ <Filter>Code</Filter>
+ </ClInclude>
+ <ClInclude Include="..\..\include\ignite\common\java.h">
+ <Filter>Code</Filter>
+ </ClInclude>
+ <ClInclude Include="..\..\include\ignite\common\concurrent.h">
+ <Filter>Code</Filter>
+ </ClInclude>
+ <ClInclude Include="targetver.h">
+ <Filter>Misc</Filter>
+ </ClInclude>
+ </ItemGroup>
+ <ItemGroup>
+ <ClCompile Include="..\..\os\win\src\common.cpp">
+ <Filter>Code</Filter>
+ </ClCompile>
+ <ClCompile Include="..\..\src\concurrent.cpp">
+ <Filter>Code</Filter>
+ </ClCompile>
+ <ClCompile Include="..\..\os\win\src\concurrent_os.cpp">
+ <Filter>Code</Filter>
+ </ClCompile>
+ <ClCompile Include="..\..\src\exports.cpp">
+ <Filter>Code</Filter>
+ </ClCompile>
+ <ClCompile Include="..\..\src\java.cpp">
+ <Filter>Code</Filter>
+ </ClCompile>
+ </ItemGroup>
+ <ItemGroup>
+ <None Include="module.def">
+ <Filter>Misc</Filter>
+ </None>
+ </ItemGroup>
+</Project>
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/project/vs/module.def
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/project/vs/module.def b/modules/platform/src/main/cpp/common/project/vs/module.def
new file mode 100644
index 0000000..d9e8d2b
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/project/vs/module.def
@@ -0,0 +1,99 @@
+LIBRARY ignite.common.dll
+EXPORTS
+IgniteReallocate @1
+IgniteIgnitionStart @2
+IgniteIgnitionInstance @3
+IgniteIgnitionEnvironmentPointer @4
+IgniteIgnitionStop @5
+IgniteIgnitionStopAll @6
+IgniteTargetOutLong @7
+IgniteProcessorReleaseStart @8
+IgniteProcessorProjection @9
+IgniteProcessorCache @10
+IgniteProcessorCreateCache @11
+IgniteProcessorGetOrCreateCache @12
+IgniteProcessorAffinity @13
+IgniteProcessorDataStreamer @14
+IgniteProcessorTransactions @15
+IgniteProcessorServices @16
+IgniteTargetInStreamOutObject @17
+IgniteTargetInStreamOutLong @18
+IgniteTargetOutStream @19
+IgniteTargetInStreamOutStream @20
+IgniteTargetInObjectStreamOutStream @21
+IgniteTargetListenFuture @22
+IgniteTargetListenFutureForOperation @23
+IgniteAffinityPartitions @24
+IgniteCacheWithSkipStore @25
+IgniteCacheWithNoRetries @26
+IgniteCacheWithExpiryPolicy @27
+IgniteCacheWithAsync @28
+IgniteCacheWithKeepPortable @29
+IgniteCacheClear @30
+IgniteCacheRemoveAll @31
+IgniteCacheOutOpQueryCursor @32
+IgniteCacheOutOpContinuousQuery @33
+IgniteCacheIterator @34
+IgniteCacheLocalIterator @35
+IgniteCacheEnterLock @36
+IgniteCacheExitLock @37
+IgniteCacheTryEnterLock @38
+IgniteCacheCloseLock @39
+IgniteCacheRebalance @40
+IgniteCacheSize @41
+IgniteCacheStoreCallbackInvoke @42
+IgniteComputeWithNoFailover @43
+IgniteComputeWithTimeout @44
+IgniteComputeExecuteNative @45
+IgniteContinuousQueryClose @46
+IgniteContinuousQueryGetInitialQueryCursor @47
+IgniteDataStreamerListenTopology @48
+IgniteDataStreamerAllowOverwriteGet @49
+IgniteDataStreamerAllowOverwriteSet @50
+IgniteDataStreamerSkipStoreGet @51
+IgniteDataStreamerSkipStoreSet @52
+IgniteDataStreamerPerNodeBufferSizeGet @53
+IgniteDataStreamerPerNodeBufferSizeSet @54
+IgniteDataStreamerPerNodeParallelOperationsGet @55
+IgniteDataStreamerPerNodeParallelOperationsSet @56
+IgniteMessagingWithAsync @57
+IgniteProjectionForOthers @58
+IgniteProjectionForRemotes @59
+IgniteProjectionForDaemons @60
+IgniteProjectionForRandom @61
+IgniteProjectionForOldest @62
+IgniteProjectionForYoungest @63
+IgniteProcessorCompute @64
+IgniteProcessorMessage @65
+IgniteProcessorEvents @66
+IgniteProjectionResetMetrics @67
+IgniteProjectionOutOpRet @68
+IgniteQueryCursorIterator @69
+IgniteQueryCursorClose @70
+IgniteTransactionsStart @71
+IgniteTransactionsCommit @72
+IgniteTransactionsCommitAsync @73
+IgniteTransactionsRollback @74
+IgniteTransactionsRollbackAsync @75
+IgniteTransactionsClose @76
+IgniteTransactionsState @77
+IgniteTransactionsSetRollbackOnly @78
+IgniteTransactionsResetMetrics @79
+IgniteAcquire @80
+IgniteRelease @81
+IgniteThrowToJava @82
+IgniteHandlersSize @83
+IgniteCreateContext @84
+IgniteDeleteContext @85
+IgniteDestroyJvm @86
+IgniteEventsWithAsync @87
+IgniteEventsStopLocalListen @88
+IgniteEventsLocalListen @89
+IgniteEventsIsEnabled @90
+IgniteTargetOutObject @91
+IgniteServicesWithAsync @92
+IgniteServicesWithServerKeepPortable @93
+IgniteServicesCancel @94
+IgniteServicesCancelAll @95
+IgniteServicesGetServiceProxy @96
+IgniteProcessorExtensions @97
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/project/vs/targetver.h
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/project/vs/targetver.h b/modules/platform/src/main/cpp/common/project/vs/targetver.h
new file mode 100644
index 0000000..4bea158
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/project/vs/targetver.h
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+// Including SDKDDKVer.h defines the highest available Windows platform.
+
+// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and
+// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.
+
+#include <SDKDDKVer.h>
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/src/concurrent.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/src/concurrent.cpp b/modules/platform/src/main/cpp/common/src/concurrent.cpp
new file mode 100644
index 0000000..3f85b65
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/src/concurrent.cpp
@@ -0,0 +1,94 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ignite/common/concurrent.h"
+
+namespace ignite
+{
+ namespace common
+ {
+ namespace concurrent
+ {
+ /** Thread-local index generator for application. */
+ int32_t appTlsIdxGen = 0;
+
+ int32_t ThreadLocal::NextIndex()
+ {
+ return Atomics::IncrementAndGet32(&appTlsIdxGen);
+ }
+
+ void ThreadLocal::Remove(int32_t idx)
+ {
+ void* val = Get0();
+
+ if (val)
+ {
+ std::map<int32_t, ThreadLocalEntry*>* map =
+ static_cast<std::map<int32_t, ThreadLocalEntry*>*>(val);
+
+ ThreadLocalEntry* appVal = (*map)[idx];
+
+ if (appVal)
+ delete appVal;
+
+ map->erase(idx);
+
+ if (map->size() == 0)
+ {
+ delete map;
+
+ Set0(NULL);
+ }
+ }
+ }
+
+ void ThreadLocal::Clear0(void* mapPtr)
+ {
+ if (mapPtr)
+ {
+ std::map<int32_t, ThreadLocalEntry*>* map =
+ static_cast<std::map<int32_t, ThreadLocalEntry*>*>(mapPtr);
+
+ for (std::map<int32_t, ThreadLocalEntry*>::iterator it = map->begin(); it != map->end(); ++it)
+ delete it->second;
+
+ delete map;
+ }
+ }
+
+ SharedPointerImpl::SharedPointerImpl(void* ptr) : ptr(ptr), refCnt(1)
+ {
+ Memory::Fence();
+ }
+
+ void* SharedPointerImpl::Pointer()
+ {
+ return ptr;
+ }
+
+ void SharedPointerImpl::Increment()
+ {
+ Atomics::IncrementAndGet32(&refCnt);
+ }
+
+ bool SharedPointerImpl::Decrement()
+ {
+ return Atomics::DecrementAndGet32(&refCnt) == 0;
+ }
+ }
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/src/exports.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/src/exports.cpp b/modules/platform/src/main/cpp/common/src/exports.cpp
new file mode 100644
index 0000000..10e4801
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/src/exports.cpp
@@ -0,0 +1,413 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ignite/common/exports.h"
+#include "ignite/common/java.h"
+
+namespace gcj = ignite::common::java;
+
+/* --- Target methods. --- */
+extern "C" {
+ int IGNITE_CALL IgniteReallocate(long long memPtr, int cap) {
+ return gcj::JniContext::Reallocate(memPtr, cap);
+ }
+
+ void* IGNITE_CALL IgniteIgnitionStart(gcj::JniContext* ctx, char* cfgPath, char* gridName, int factoryId, long long dataPtr) {
+ return ctx->IgnitionStart(cfgPath, gridName, factoryId, dataPtr);
+ }
+
+ void* IGNITE_CALL IgniteIgnitionInstance(gcj::JniContext* ctx, char* gridName) {
+ return ctx->IgnitionInstance(gridName);
+ }
+
+ long long IGNITE_CALL IgniteIgnitionEnvironmentPointer(gcj::JniContext* ctx, char* gridName) {
+ return ctx->IgnitionEnvironmentPointer(gridName);
+ }
+
+ bool IGNITE_CALL IgniteIgnitionStop(gcj::JniContext* ctx, char* gridName, bool cancel) {
+ return ctx->IgnitionStop(gridName, cancel);
+ }
+
+ void IGNITE_CALL IgniteIgnitionStopAll(gcj::JniContext* ctx, bool cancel) {
+ return ctx->IgnitionStopAll(cancel);
+ }
+
+ void IGNITE_CALL IgniteProcessorReleaseStart(gcj::JniContext* ctx, void* obj) {
+ return ctx->ProcessorReleaseStart(static_cast<jobject>(obj));
+ }
+
+ void* IGNITE_CALL IgniteProcessorProjection(gcj::JniContext* ctx, void* obj) {
+ return ctx->ProcessorProjection(static_cast<jobject>(obj));
+ }
+
+ void* IGNITE_CALL IgniteProcessorCache(gcj::JniContext* ctx, void* obj, char* name) {
+ return ctx->ProcessorCache(static_cast<jobject>(obj), name);
+ }
+
+ void* IGNITE_CALL IgniteProcessorCreateCache(gcj::JniContext* ctx, void* obj, char* name) {
+ return ctx->ProcessorCreateCache(static_cast<jobject>(obj), name);
+ }
+
+ void* IGNITE_CALL IgniteProcessorGetOrCreateCache(gcj::JniContext* ctx, void* obj, char* name) {
+ return ctx->ProcessorGetOrCreateCache(static_cast<jobject>(obj), name);
+ }
+
+ void* IGNITE_CALL IgniteProcessorAffinity(gcj::JniContext* ctx, void* obj, char* name) {
+ return ctx->ProcessorAffinity(static_cast<jobject>(obj), name);
+ }
+
+ void*IGNITE_CALL IgniteProcessorDataStreamer(gcj::JniContext* ctx, void* obj, char* name, bool keepPortable) {
+ return ctx->ProcessorDataStreamer(static_cast<jobject>(obj), name, keepPortable);
+ }
+
+ void* IGNITE_CALL IgniteProcessorTransactions(gcj::JniContext* ctx, void* obj) {
+ return ctx->ProcessorTransactions(static_cast<jobject>(obj));
+ }
+
+ void* IGNITE_CALL IgniteProcessorCompute(gcj::JniContext* ctx, void* obj, void* prj) {
+ return ctx->ProcessorCompute(static_cast<jobject>(obj), static_cast<jobject>(prj));
+ }
+
+ void* IGNITE_CALL IgniteProcessorMessage(gcj::JniContext* ctx, void* obj, void* prj) {
+ return ctx->ProcessorMessage(static_cast<jobject>(obj), static_cast<jobject>(prj));
+ }
+
+ void* IGNITE_CALL IgniteProcessorEvents(gcj::JniContext* ctx, void* obj, void* prj) {
+ return ctx->ProcessorEvents(static_cast<jobject>(obj), static_cast<jobject>(prj));
+ }
+
+ void* IGNITE_CALL IgniteProcessorServices(gcj::JniContext* ctx, void* obj, void* prj) {
+ return ctx->ProcessorServices(static_cast<jobject>(obj), static_cast<jobject>(prj));
+ }
+
+ void* IGNITE_CALL IgniteProcessorExtensions(gcj::JniContext* ctx, void* obj) {
+ return ctx->ProcessorExtensions(static_cast<jobject>(obj));
+ }
+
+ long long IGNITE_CALL IgniteTargetInStreamOutLong(gcj::JniContext* ctx, void* obj, int opType, long long memPtr) {
+ return ctx->TargetInStreamOutLong(static_cast<jobject>(obj), opType, memPtr);
+ }
+
+ void IGNITE_CALL IgniteTargetInStreamOutStream(gcj::JniContext* ctx, void* obj, int opType, long long inMemPtr, long long outMemPtr) {
+ ctx->TargetInStreamOutStream(static_cast<jobject>(obj), opType, inMemPtr, outMemPtr);
+ }
+
+ void* IGNITE_CALL IgniteTargetInStreamOutObject(gcj::JniContext* ctx, void* obj, int opType, long long memPtr) {
+ return ctx->TargetInStreamOutObject(static_cast<jobject>(obj), opType, memPtr);
+ }
+
+ void IGNITE_CALL IgniteTargetInObjectStreamOutStream(gcj::JniContext* ctx, void* obj, int opType, void* arg, long long inMemPtr, long long outMemPtr) {
+ ctx->TargetInObjectStreamOutStream(static_cast<jobject>(obj), opType, arg, inMemPtr, outMemPtr);
+ }
+
+ long long IGNITE_CALL IgniteTargetOutLong(gcj::JniContext* ctx, void* obj, int opType) {
+ return ctx->TargetOutLong(static_cast<jobject>(obj), opType);
+ }
+
+ void IGNITE_CALL IgniteTargetOutStream(gcj::JniContext* ctx, void* obj, int opType, long long memPtr) {
+ ctx->TargetOutStream(static_cast<jobject>(obj), opType, memPtr);
+ }
+
+ void* IGNITE_CALL IgniteTargetOutObject(gcj::JniContext* ctx, void* obj, int opType) {
+ return ctx->TargetOutObject(static_cast<jobject>(obj), opType);
+ }
+
+ void IGNITE_CALL IgniteTargetListenFuture(gcj::JniContext* ctx, void* obj, long long futId, int typ) {
+ ctx->TargetListenFuture(static_cast<jobject>(obj), futId, typ);
+ }
+
+ void IGNITE_CALL IgniteTargetListenFutureForOperation(gcj::JniContext* ctx, void* obj, long long futId, int typ, int opId) {
+ ctx->TargetListenFutureForOperation(static_cast<jobject>(obj), futId, typ, opId);
+ }
+
+ int IGNITE_CALL IgniteAffinityPartitions(gcj::JniContext* ctx, void* obj) {
+ return ctx->AffinityPartitions(static_cast<jobject>(obj));
+ }
+
+ void* IGNITE_CALL IgniteCacheWithSkipStore(gcj::JniContext* ctx, void* obj) {
+ return ctx->CacheWithSkipStore(static_cast<jobject>(obj));
+ }
+
+ void* IGNITE_CALL IgniteCacheWithNoRetries(gcj::JniContext* ctx, void* obj) {
+ return ctx->CacheWithNoRetries(static_cast<jobject>(obj));
+ }
+
+ void* IGNITE_CALL IgniteCacheWithExpiryPolicy(gcj::JniContext* ctx, void* obj, long long create, long long update, long long access) {
+ return ctx->CacheWithExpiryPolicy(static_cast<jobject>(obj), create, update, access);
+ }
+
+ void* IGNITE_CALL IgniteCacheWithAsync(gcj::JniContext* ctx, void* obj) {
+ return ctx->CacheWithAsync(static_cast<jobject>(obj));
+ }
+
+ void* IGNITE_CALL IgniteCacheWithKeepPortable(gcj::JniContext* ctx, void* obj)
+ {
+ return ctx->CacheWithKeepPortable(static_cast<jobject>(obj));
+ }
+
+ void IGNITE_CALL IgniteCacheClear(gcj::JniContext* ctx, void* obj) {
+ ctx->CacheClear(static_cast<jobject>(obj));
+ }
+
+ void IGNITE_CALL IgniteCacheRemoveAll(gcj::JniContext* ctx, void* obj) {
+ ctx->CacheRemoveAll(static_cast<jobject>(obj));
+ }
+
+ void* IGNITE_CALL IgniteCacheOutOpQueryCursor(gcj::JniContext* ctx, void* obj, int type, long long memPtr) {
+ return ctx->CacheOutOpQueryCursor(static_cast<jobject>(obj), type, memPtr);
+ }
+
+ void* IGNITE_CALL IgniteCacheOutOpContinuousQuery(gcj::JniContext* ctx, void* obj, int type, long long memPtr) {
+ return ctx->CacheOutOpContinuousQuery(static_cast<jobject>(obj), type, memPtr);
+ }
+
+ void* IGNITE_CALL IgniteCacheIterator(gcj::JniContext* ctx, void* obj) {
+ return ctx->CacheIterator(static_cast<jobject>(obj));
+ }
+
+ void* IGNITE_CALL IgniteCacheLocalIterator(gcj::JniContext* ctx, void* obj, int peekModes) {
+ return ctx->CacheLocalIterator(static_cast<jobject>(obj), peekModes);
+ }
+
+ void IGNITE_CALL IgniteCacheEnterLock(gcj::JniContext* ctx, void* obj, long long id) {
+ ctx->CacheEnterLock(static_cast<jobject>(obj), id);
+ }
+
+ void IGNITE_CALL IgniteCacheExitLock(gcj::JniContext* ctx, void* obj, long long id) {
+ ctx->CacheExitLock(static_cast<jobject>(obj), id);
+ }
+
+ bool IGNITE_CALL IgniteCacheTryEnterLock(gcj::JniContext* ctx, void* obj, long long id, long long timeout) {
+ return ctx->CacheTryEnterLock(static_cast<jobject>(obj), id, timeout);
+ }
+
+ void IGNITE_CALL IgniteCacheCloseLock(gcj::JniContext* ctx, void* obj, long long id) {
+ ctx->CacheCloseLock(static_cast<jobject>(obj), id);
+ }
+
+ void IGNITE_CALL IgniteCacheRebalance(gcj::JniContext* ctx, void* obj, long long futId) {
+ ctx->CacheRebalance(static_cast<jobject>(obj), futId);
+ }
+
+ int IGNITE_CALL IgniteCacheSize(gcj::JniContext* ctx, void* obj, int peekModes, bool loc) {
+ return ctx->CacheSize(static_cast<jobject>(obj), peekModes, loc);
+ }
+
+ void IGNITE_CALL IgniteComputeWithNoFailover(gcj::JniContext* ctx, void* obj) {
+ ctx->ComputeWithNoFailover(static_cast<jobject>(obj));
+ }
+
+ void IGNITE_CALL IgniteComputeWithTimeout(gcj::JniContext* ctx, void* obj, long long timeout) {
+ ctx->ComputeWithTimeout(static_cast<jobject>(obj), timeout);
+ }
+
+ void IGNITE_CALL IgniteComputeExecuteNative(gcj::JniContext* ctx, void* obj, long long taskPtr, long long topVer) {
+ ctx->ComputeExecuteNative(static_cast<jobject>(obj), taskPtr, topVer);
+ }
+
+ void IGNITE_CALL IgniteContinuousQueryClose(gcj::JniContext* ctx, void* obj) {
+ ctx->ContinuousQueryClose(static_cast<jobject>(obj));
+ }
+
+ void* IGNITE_CALL IgniteContinuousQueryGetInitialQueryCursor(gcj::JniContext* ctx, void* obj) {
+ return ctx->ContinuousQueryGetInitialQueryCursor(static_cast<jobject>(obj));
+ }
+
+ void IGNITE_CALL IgniteCacheStoreCallbackInvoke(gcj::JniContext* ctx, void* obj, long long memPtr) {
+ ctx->CacheStoreCallbackInvoke(static_cast<jobject>(obj), memPtr);
+ }
+
+ void IGNITE_CALL IgniteDataStreamerListenTopology(gcj::JniContext* ctx, void* obj, long long ptr) {
+ ctx->DataStreamerListenTopology(static_cast<jobject>(obj), ptr);
+ }
+
+ bool IGNITE_CALL IgniteDataStreamerAllowOverwriteGet(gcj::JniContext* ctx, void* obj) {
+ return ctx->DataStreamerAllowOverwriteGet(static_cast<jobject>(obj));
+ }
+
+ void IGNITE_CALL IgniteDataStreamerAllowOverwriteSet(gcj::JniContext* ctx, void* obj, bool val) {
+ ctx->DataStreamerAllowOverwriteSet(static_cast<jobject>(obj), val);
+ }
+
+ bool IGNITE_CALL IgniteDataStreamerSkipStoreGet(gcj::JniContext* ctx, void* obj) {
+ return ctx->DataStreamerSkipStoreGet(static_cast<jobject>(obj));
+ }
+
+ void IGNITE_CALL IgniteDataStreamerSkipStoreSet(gcj::JniContext* ctx, void* obj, bool val) {
+ ctx->DataStreamerSkipStoreSet(static_cast<jobject>(obj), val);
+ }
+
+ int IGNITE_CALL IgniteDataStreamerPerNodeBufferSizeGet(gcj::JniContext* ctx, void* obj) {
+ return ctx->DataStreamerPerNodeBufferSizeGet(static_cast<jobject>(obj));
+ }
+
+ void IGNITE_CALL IgniteDataStreamerPerNodeBufferSizeSet(gcj::JniContext* ctx, void* obj, int val) {
+ ctx->DataStreamerPerNodeBufferSizeSet(static_cast<jobject>(obj), val);
+ }
+
+ int IGNITE_CALL IgniteDataStreamerPerNodeParallelOperationsGet(gcj::JniContext* ctx, void* obj) {
+ return ctx->DataStreamerPerNodeParallelOperationsGet(static_cast<jobject>(obj));
+ }
+
+ void IGNITE_CALL IgniteDataStreamerPerNodeParallelOperationsSet(gcj::JniContext* ctx, void* obj, int val) {
+ ctx->DataStreamerPerNodeParallelOperationsSet(static_cast<jobject>(obj), val);
+ }
+
+ void* IGNITE_CALL IgniteMessagingWithAsync(gcj::JniContext* ctx, void* obj) {
+ return ctx->MessagingWithAsync(static_cast<jobject>(obj));
+ }
+
+ void* IGNITE_CALL IgniteProjectionForOthers(gcj::JniContext* ctx, void* obj, void* prj) {
+ return ctx->ProjectionForOthers(static_cast<jobject>(obj), static_cast<jobject>(prj));
+ }
+
+ void* IGNITE_CALL IgniteProjectionForRemotes(gcj::JniContext* ctx, void* obj) {
+ return ctx->ProjectionForRemotes(static_cast<jobject>(obj));
+ }
+
+ void* IGNITE_CALL IgniteProjectionForDaemons(gcj::JniContext* ctx, void* obj) {
+ return ctx->ProjectionForDaemons(static_cast<jobject>(obj));
+ }
+
+ void* IGNITE_CALL IgniteProjectionForRandom(gcj::JniContext* ctx, void* obj) {
+ return ctx->ProjectionForRandom(static_cast<jobject>(obj));
+ }
+
+ void* IGNITE_CALL IgniteProjectionForOldest(gcj::JniContext* ctx, void* obj) {
+ return ctx->ProjectionForOldest(static_cast<jobject>(obj));
+ }
+
+ void* IGNITE_CALL IgniteProjectionForYoungest(gcj::JniContext* ctx, void* obj) {
+ return ctx->ProjectionForYoungest(static_cast<jobject>(obj));
+ }
+
+ void IGNITE_CALL IgniteProjectionResetMetrics(gcj::JniContext* ctx, void* obj) {
+ ctx->ProjectionResetMetrics(static_cast<jobject>(obj));
+ }
+
+ void* IGNITE_CALL IgniteProjectionOutOpRet(gcj::JniContext* ctx, void* obj, int type, long long memPtr) {
+ return ctx->ProjectionOutOpRet(static_cast<jobject>(obj), type, memPtr);
+ }
+
+ void IGNITE_CALL IgniteQueryCursorIterator(gcj::JniContext* ctx, void* obj) {
+ ctx->QueryCursorIterator(static_cast<jobject>(obj));
+ }
+
+ void IGNITE_CALL IgniteQueryCursorClose(gcj::JniContext* ctx, void* obj) {
+ ctx->QueryCursorClose(static_cast<jobject>(obj));
+ }
+
+ long long IGNITE_CALL IgniteTransactionsStart(gcj::JniContext* ctx, void* obj, int concurrency, int isolation, long long timeout, int txSize) {
+ return ctx->TransactionsStart(static_cast<jobject>(obj), concurrency, isolation, timeout, txSize);
+ }
+
+ int IGNITE_CALL IgniteTransactionsCommit(gcj::JniContext* ctx, void* obj, long long id) {
+ return ctx->TransactionsCommit(static_cast<jobject>(obj), id);
+ }
+
+ void IGNITE_CALL IgniteTransactionsCommitAsync(gcj::JniContext* ctx, void* obj, long long id, long long futId) {
+ return ctx->TransactionsCommitAsync(static_cast<jobject>(obj), id, futId);
+ }
+
+ int IGNITE_CALL IgniteTransactionsRollback(gcj::JniContext* ctx, void* obj, long long id) {
+ return ctx->TransactionsRollback(static_cast<jobject>(obj), id);
+ }
+
+ void IGNITE_CALL IgniteTransactionsRollbackAsync(gcj::JniContext* ctx, void* obj, long long id, long long futId) {
+ return ctx->TransactionsRollbackAsync(static_cast<jobject>(obj), id, futId);
+ }
+
+ int IGNITE_CALL IgniteTransactionsClose(gcj::JniContext* ctx, void* obj, long long id) {
+ return ctx->TransactionsClose(static_cast<jobject>(obj), id);
+ }
+
+ int IGNITE_CALL IgniteTransactionsState(gcj::JniContext* ctx, void* obj, long long id) {
+ return ctx->TransactionsState(static_cast<jobject>(obj), id);
+ }
+
+ bool IGNITE_CALL IgniteTransactionsSetRollbackOnly(gcj::JniContext* ctx, void* obj, long long id) {
+ return ctx->TransactionsSetRollbackOnly(static_cast<jobject>(obj), id);
+ }
+
+ void IGNITE_CALL IgniteTransactionsResetMetrics(gcj::JniContext* ctx, void* obj) {
+ ctx->TransactionsResetMetrics(static_cast<jobject>(obj));
+ }
+
+ void* IGNITE_CALL IgniteAcquire(gcj::JniContext* ctx, void* obj) {
+ return ctx->Acquire(static_cast<jobject>(obj));
+ }
+
+ void IGNITE_CALL IgniteRelease(void* obj) {
+ gcj::JniContext::Release(static_cast<jobject>(obj));
+ }
+
+ void IGNITE_CALL IgniteThrowToJava(gcj::JniContext* ctx, char* err) {
+ ctx->ThrowToJava(err);
+ }
+
+ int IGNITE_CALL IgniteHandlersSize() {
+ return sizeof(gcj::JniHandlers);
+ }
+
+ void* IGNITE_CALL IgniteCreateContext(char** opts, int optsLen, gcj::JniHandlers* cbs) {
+ return gcj::JniContext::Create(opts, optsLen, *cbs);
+ }
+
+ void IGNITE_CALL IgniteDeleteContext(gcj::JniContext* ctx) {
+ delete ctx;
+ }
+
+ void IGNITE_CALL IgniteDestroyJvm(gcj::JniContext* ctx) {
+ ctx->DestroyJvm();
+ }
+
+ void* IGNITE_CALL IgniteEventsWithAsync(gcj::JniContext* ctx, void* obj) {
+ return ctx->EventsWithAsync(static_cast<jobject>(obj));
+ }
+
+ bool IGNITE_CALL IgniteEventsStopLocalListen(gcj::JniContext* ctx, void* obj, long long hnd) {
+ return ctx->EventsStopLocalListen(static_cast<jobject>(obj), hnd);
+ }
+
+ void IGNITE_CALL IgniteEventsLocalListen(gcj::JniContext* ctx, void* obj, long long hnd, int type) {
+ ctx->EventsLocalListen(static_cast<jobject>(obj), hnd, type);
+ }
+
+ bool IGNITE_CALL IgniteEventsIsEnabled(gcj::JniContext* ctx, void* obj, int type) {
+ return ctx->EventsIsEnabled(static_cast<jobject>(obj), type);
+ }
+
+ void* IGNITE_CALL IgniteServicesWithAsync(gcj::JniContext* ctx, void* obj) {
+ return ctx->ServicesWithAsync(static_cast<jobject>(obj));
+ }
+
+ void* IGNITE_CALL IgniteServicesWithServerKeepPortable(gcj::JniContext* ctx, void* obj) {
+ return ctx->ServicesWithServerKeepPortable(static_cast<jobject>(obj));
+ }
+
+ void IGNITE_CALL IgniteServicesCancel(gcj::JniContext* ctx, void* obj, char* name) {
+ ctx->ServicesCancel(static_cast<jobject>(obj), name);
+ }
+
+ void IGNITE_CALL IgniteServicesCancelAll(gcj::JniContext* ctx, void* obj) {
+ ctx->ServicesCancelAll(static_cast<jobject>(obj));
+ }
+
+ void* IGNITE_CALL IgniteServicesGetServiceProxy(gcj::JniContext* ctx, void* obj, char* name, bool sticky) {
+ return ctx->ServicesGetServiceProxy(static_cast<jobject>(obj), name, sticky);
+ }
+}
\ No newline at end of file
[2/4] ignite git commit: IGNITE-1337: Moved "common" CPP project to
Ignite.
Posted by vo...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/7ca8cbc7/modules/platform/src/main/cpp/common/src/java.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/common/src/java.cpp b/modules/platform/src/main/cpp/common/src/java.cpp
new file mode 100644
index 0000000..0c6524b
--- /dev/null
+++ b/modules/platform/src/main/cpp/common/src/java.cpp
@@ -0,0 +1,2204 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cstring>
+#include <string>
+#include <exception>
+
+#include "ignite/common/concurrent.h"
+#include "ignite/common/java.h"
+
+#define IGNITE_SAFE_PROC_NO_ARG(jniEnv, envPtr, type, field) { \
+ JniHandlers* hnds = reinterpret_cast<JniHandlers*>(envPtr); \
+ type hnd = hnds->field; \
+ if (hnd) \
+ hnd(hnds->target); \
+ else \
+ ThrowOnMissingHandler(jniEnv); \
+}
+
+#define IGNITE_SAFE_PROC(jniEnv, envPtr, type, field, ...) { \
+ JniHandlers* hnds = reinterpret_cast<JniHandlers*>(envPtr); \
+ type hnd = hnds->field; \
+ if (hnd) \
+ hnd(hnds->target, __VA_ARGS__); \
+ else \
+ ThrowOnMissingHandler(jniEnv); \
+}
+
+#define IGNITE_SAFE_FUNC(jniEnv, envPtr, type, field, ...) { \
+ JniHandlers* hnds = reinterpret_cast<JniHandlers*>(envPtr); \
+ type hnd = hnds->field; \
+ if (hnd) \
+ return hnd(hnds->target, __VA_ARGS__); \
+ else \
+ { \
+ ThrowOnMissingHandler(jniEnv); \
+ return 0; \
+ }\
+}
+
+namespace ignite
+{
+ namespace common
+ {
+ namespace java
+ {
+ namespace gcc = ignite::common::concurrent;
+
+ /* --- Startup exception. --- */
+ class JvmException : public std::exception {
+ // No-op.
+ };
+
+ /* --- JNI method definitions. --- */
+ struct JniMethod {
+ char* name;
+ char* sign;
+ bool isStatic;
+
+ JniMethod(const char* name, const char* sign, bool isStatic) {
+ this->name = const_cast<char*>(name);
+ this->sign = const_cast<char*>(sign);
+ this->isStatic = isStatic;
+ }
+ };
+
+ /*
+ * Heloper function to copy characters.
+ *
+ * @param src Source.
+ * @return Result.
+ */
+ char* CopyChars(const char* src)
+ {
+ if (src)
+ {
+ size_t len = strlen(src);
+ char* dest = new char[len + 1];
+ strcpy(dest, src);
+ *(dest + len) = 0;
+ return dest;
+ }
+ else
+ return NULL;
+ }
+
+ JniErrorInfo::JniErrorInfo() : code(IGNITE_JNI_ERR_SUCCESS), errCls(NULL), errMsg(NULL)
+ {
+ // No-op.
+ }
+
+ JniErrorInfo::JniErrorInfo(int code, const char* errCls, const char* errMsg) : code(code)
+ {
+ this->errCls = CopyChars(errCls);
+ this->errMsg = CopyChars(errMsg);
+ }
+
+ JniErrorInfo::JniErrorInfo(const JniErrorInfo& other) : code(other.code)
+ {
+ this->errCls = CopyChars(other.errCls);
+ this->errMsg = CopyChars(other.errMsg);
+ }
+
+ JniErrorInfo& JniErrorInfo::operator=(const JniErrorInfo& other)
+ {
+ if (this != &other)
+ {
+ // 1. Create new instance, exception could occur at this point.
+ JniErrorInfo tmp(other);
+
+ // 2. Swap with temp.
+ int code0 = code;
+ char* errCls0 = errCls;
+ char* errMsg0 = errMsg;
+
+ code = tmp.code;
+ errCls = tmp.errCls;
+ errMsg = tmp.errMsg;
+
+ tmp.code = code0;
+ tmp.errCls = errCls0;
+ tmp.errMsg = errMsg0;
+ }
+
+ return *this;
+ }
+
+ JniErrorInfo::~JniErrorInfo()
+ {
+ if (errCls)
+ delete[] errCls;
+
+ if (errMsg)
+ delete[] errMsg;
+ }
+
+ const char* C_THROWABLE = "java/lang/Throwable";
+ JniMethod M_THROWABLE_GET_MESSAGE = JniMethod("getMessage", "()Ljava/lang/String;", false);
+ JniMethod M_THROWABLE_PRINT_STACK_TRACE = JniMethod("printStackTrace", "()V", false);
+
+ const char* C_CLASS = "java/lang/Class";
+ JniMethod M_CLASS_GET_NAME = JniMethod("getName", "()Ljava/lang/String;", false);
+
+ const char* C_IGNITE_EXCEPTION = "org/apache/ignite/IgniteException";
+
+ const char* C_PLATFORM_NO_CALLBACK_EXCEPTION = "org/apache/ignite/internal/processors/platform/PlatformNoCallbackException";
+
+ const char* C_PLATFORM_PROCESSOR = "org/apache/ignite/internal/processors/platform/PlatformProcessor";
+ JniMethod M_PLATFORM_PROCESSOR_RELEASE_START = JniMethod("releaseStart", "()V", false);
+ JniMethod M_PLATFORM_PROCESSOR_PROJECTION = JniMethod("projection", "()Lorg/apache/ignite/internal/processors/platform/PlatformTarget;", false);
+ JniMethod M_PLATFORM_PROCESSOR_CACHE = JniMethod("cache", "(Ljava/lang/String;)Lorg/apache/ignite/internal/processors/platform/PlatformTarget;", false);
+ JniMethod M_PLATFORM_PROCESSOR_CREATE_CACHE = JniMethod("createCache", "(Ljava/lang/String;)Lorg/apache/ignite/internal/processors/platform/PlatformTarget;", false);
+ JniMethod M_PLATFORM_PROCESSOR_GET_OR_CREATE_CACHE = JniMethod("getOrCreateCache", "(Ljava/lang/String;)Lorg/apache/ignite/internal/processors/platform/PlatformTarget;", false);
+ JniMethod M_PLATFORM_PROCESSOR_AFFINITY = JniMethod("affinity", "(Ljava/lang/String;)Lorg/apache/ignite/internal/processors/platform/PlatformTarget;", false);
+ JniMethod M_PLATFORM_PROCESSOR_DATA_STREAMER = JniMethod("dataStreamer", "(Ljava/lang/String;Z)Lorg/apache/ignite/internal/processors/platform/PlatformTarget;", false);
+ JniMethod M_PLATFORM_PROCESSOR_TRANSACTIONS = JniMethod("transactions", "()Lorg/apache/ignite/internal/processors/platform/PlatformTarget;", false);
+ JniMethod M_PLATFORM_PROCESSOR_COMPUTE = JniMethod("compute", "(Lorg/apache/ignite/internal/processors/platform/PlatformTarget;)Lorg/apache/ignite/internal/processors/platform/PlatformTarget;", false);
+ JniMethod M_PLATFORM_PROCESSOR_MESSAGE = JniMethod("message", "(Lorg/apache/ignite/internal/processors/platform/PlatformTarget;)Lorg/apache/ignite/internal/processors/platform/PlatformTarget;", false);
+ JniMethod M_PLATFORM_PROCESSOR_EVENTS = JniMethod("events", "(Lorg/apache/ignite/internal/processors/platform/PlatformTarget;)Lorg/apache/ignite/internal/processors/platform/PlatformTarget;", false);
+ JniMethod M_PLATFORM_PROCESSOR_SERVICES = JniMethod("services", "(Lorg/apache/ignite/internal/processors/platform/PlatformTarget;)Lorg/apache/ignite/internal/processors/platform/PlatformTarget;", false);
+ JniMethod M_PLATFORM_PROCESSOR_EXTENSIONS = JniMethod("extensions", "()Lorg/apache/ignite/internal/processors/platform/PlatformTarget;", false);
+
+ const char* C_PLATFORM_TARGET = "org/apache/ignite/internal/processors/platform/PlatformTarget";
+ JniMethod M_PLATFORM_TARGET_IN_STREAM_OUT_LONG = JniMethod("inStreamOutLong", "(IJ)J", false);
+ JniMethod M_PLATFORM_TARGET_IN_STREAM_OUT_OBJECT = JniMethod("inStreamOutObject", "(IJ)Ljava/lang/Object;", false);
+ JniMethod M_PLATFORM_TARGET_IN_STREAM_OUT_STREAM = JniMethod("inStreamOutStream", "(IJJ)V", false);
+ JniMethod M_PLATFORM_TARGET_IN_OBJECT_STREAM_OUT_STREAM = JniMethod("inObjectStreamOutStream", "(ILjava/lang/Object;JJ)V", false);
+ JniMethod M_PLATFORM_TARGET_OUT_LONG = JniMethod("outLong", "(I)J", false);
+ JniMethod M_PLATFORM_TARGET_OUT_STREAM = JniMethod("outStream", "(IJ)V", false);
+ JniMethod M_PLATFORM_TARGET_OUT_OBJECT = JniMethod("outObject", "(I)Ljava/lang/Object;", false);
+ JniMethod M_PLATFORM_TARGET_LISTEN_FUTURE = JniMethod("listenFuture", "(JI)V", false);
+ JniMethod M_PLATFORM_TARGET_LISTEN_FOR_OPERATION = JniMethod("listenFutureForOperation", "(JII)V", false);
+
+ const char* C_PLATFORM_CLUSTER_GRP = "org/apache/ignite/internal/processors/platform/cluster/PlatformClusterGroup";
+ JniMethod M_PLATFORM_CLUSTER_GRP_FOR_OTHERS = JniMethod("forOthers", "(Lorg/apache/ignite/internal/processors/platform/cluster/PlatformClusterGroup;)Lorg/apache/ignite/internal/processors/platform/cluster/PlatformClusterGroup;", false);
+ JniMethod M_PLATFORM_CLUSTER_GRP_FOR_REMOTES = JniMethod("forRemotes", "()Lorg/apache/ignite/internal/processors/platform/cluster/PlatformClusterGroup;", false);
+ JniMethod M_PLATFORM_CLUSTER_GRP_FOR_DAEMONS = JniMethod("forDaemons", "()Lorg/apache/ignite/internal/processors/platform/cluster/PlatformClusterGroup;", false);
+ JniMethod M_PLATFORM_CLUSTER_GRP_FOR_RANDOM = JniMethod("forRandom", "()Lorg/apache/ignite/internal/processors/platform/cluster/PlatformClusterGroup;", false);
+ JniMethod M_PLATFORM_CLUSTER_GRP_FOR_OLDEST = JniMethod("forOldest", "()Lorg/apache/ignite/internal/processors/platform/cluster/PlatformClusterGroup;", false);
+ JniMethod M_PLATFORM_CLUSTER_GRP_FOR_YOUNGEST = JniMethod("forYoungest", "()Lorg/apache/ignite/internal/processors/platform/cluster/PlatformClusterGroup;", false);
+ JniMethod M_PLATFORM_CLUSTER_GRP_RESET_METRICS = JniMethod("resetMetrics", "()V", false);
+
+ const char* C_PLATFORM_MESSAGING = "org/apache/ignite/internal/processors/platform/messaging/PlatformMessaging";
+ JniMethod M_PLATFORM_MESSAGING_WITH_ASYNC = JniMethod("withAsync", "()Lorg/apache/ignite/internal/processors/platform/messaging/PlatformMessaging;", false);
+
+ const char* C_PLATFORM_COMPUTE = "org/apache/ignite/internal/processors/platform/compute/PlatformCompute";
+ JniMethod M_PLATFORM_COMPUTE_WITH_NO_FAILOVER = JniMethod("withNoFailover", "()V", false);
+ JniMethod M_PLATFORM_COMPUTE_WITH_TIMEOUT = JniMethod("withTimeout", "(J)V", false);
+ JniMethod M_PLATFORM_COMPUTE_EXECUTE_NATIVE = JniMethod("executeNative", "(JJ)V", false);
+
+ const char* C_PLATFORM_CACHE = "org/apache/ignite/internal/processors/platform/cache/PlatformCache";
+ JniMethod M_PLATFORM_CACHE_WITH_SKIP_STORE = JniMethod("withSkipStore", "()Lorg/apache/ignite/internal/processors/platform/cache/PlatformCache;", false);
+ JniMethod M_PLATFORM_CACHE_WITH_NO_RETRIES = JniMethod("withNoRetries", "()Lorg/apache/ignite/internal/processors/platform/cache/PlatformCache;", false);
+ JniMethod M_PLATFORM_CACHE_WITH_EXPIRY_PLC = JniMethod("withExpiryPolicy", "(JJJ)Lorg/apache/ignite/internal/processors/platform/cache/PlatformCache;", false);
+ JniMethod M_PLATFORM_CACHE_WITH_ASYNC = JniMethod("withAsync", "()Lorg/apache/ignite/internal/processors/platform/cache/PlatformCache;", false);
+ JniMethod M_PLATFORM_CACHE_WITH_KEEP_PORTABLE = JniMethod("withKeepPortable", "()Lorg/apache/ignite/internal/processors/platform/cache/PlatformCache;", false);
+ JniMethod M_PLATFORM_CACHE_CLEAR = JniMethod("clear", "()V", false);
+ JniMethod M_PLATFORM_CACHE_REMOVE_ALL = JniMethod("removeAll", "()V", false);
+ JniMethod M_PLATFORM_CACHE_ITERATOR = JniMethod("iterator", "()Lorg/apache/ignite/internal/processors/platform/cache/PlatformCacheIterator;", false);
+ JniMethod M_PLATFORM_CACHE_LOCAL_ITERATOR = JniMethod("localIterator", "(I)Lorg/apache/ignite/internal/processors/platform/cache/PlatformCacheIterator;", false);
+ JniMethod M_PLATFORM_CACHE_ENTER_LOCK = JniMethod("enterLock", "(J)V", false);
+ JniMethod M_PLATFORM_CACHE_EXIT_LOCK = JniMethod("exitLock", "(J)V", false);
+ JniMethod M_PLATFORM_CACHE_TRY_ENTER_LOCK = JniMethod("tryEnterLock", "(JJ)Z", false);
+ JniMethod M_PLATFORM_CACHE_CLOSE_LOCK = JniMethod("closeLock", "(J)V", false);
+ JniMethod M_PLATFORM_CACHE_REBALANCE = JniMethod("rebalance", "(J)V", false);
+ JniMethod M_PLATFORM_CACHE_SIZE = JniMethod("size", "(IZ)I", false);
+
+ const char* C_PLATFORM_AFFINITY = "org/apache/ignite/internal/processors/platform/cache/affinity/PlatformAffinity";
+ JniMethod C_PLATFORM_AFFINITY_PARTITIONS = JniMethod("partitions", "()I", false);
+
+ const char* C_PLATFORM_DATA_STREAMER = "org/apache/ignite/internal/processors/platform/datastreamer/PlatformDataStreamer";
+ JniMethod M_PLATFORM_DATA_STREAMER_LISTEN_TOPOLOGY = JniMethod("listenTopology", "(J)V", false);
+ JniMethod M_PLATFORM_DATA_STREAMER_GET_ALLOW_OVERWRITE = JniMethod("allowOverwrite", "()Z", false);
+ JniMethod M_PLATFORM_DATA_STREAMER_SET_ALLOW_OVERWRITE = JniMethod("allowOverwrite", "(Z)V", false);
+ JniMethod M_PLATFORM_DATA_STREAMER_GET_SKIP_STORE = JniMethod("skipStore", "()Z", false);
+ JniMethod M_PLATFORM_DATA_STREAMER_SET_SKIP_STORE = JniMethod("skipStore", "(Z)V", false);
+ JniMethod M_PLATFORM_DATA_STREAMER_GET_PER_NODE_BUFFER_SIZE = JniMethod("perNodeBufferSize", "()I", false);
+ JniMethod M_PLATFORM_DATA_STREAMER_SET_PER_NODE_BUFFER_SIZE = JniMethod("perNodeBufferSize", "(I)V", false);
+ JniMethod M_PLATFORM_DATA_STREAMER_GET_PER_NODE_PARALLEL_OPS = JniMethod("perNodeParallelOperations", "()I", false);
+ JniMethod M_PLATFORM_DATA_STREAMER_SET_PER_NODE_PARALLEL_OPS = JniMethod("perNodeParallelOperations", "(I)V", false);
+
+ const char* C_PLATFORM_TRANSACTIONS = "org/apache/ignite/internal/processors/platform/transactions/PlatformTransactions";
+ JniMethod M_PLATFORM_TRANSACTIONS_TX_START = JniMethod("txStart", "(IIJI)J", false);
+ JniMethod M_PLATFORM_TRANSACTIONS_TX_COMMIT = JniMethod("txCommit", "(J)I", false);
+ JniMethod M_PLATFORM_TRANSACTIONS_TX_ROLLBACK = JniMethod("txRollback", "(J)I", false);
+ JniMethod M_PLATFORM_TRANSACTIONS_TX_COMMIT_ASYNC = JniMethod("txCommitAsync", "(JJ)V", false);
+ JniMethod M_PLATFORM_TRANSACTIONS_TX_ROLLBACK_ASYNC = JniMethod("txRollbackAsync", "(JJ)V", false);
+ JniMethod M_PLATFORM_TRANSACTIONS_TX_STATE = JniMethod("txState", "(J)I", false);
+ JniMethod M_PLATFORM_TRANSACTIONS_TX_SET_ROLLBACK_ONLY = JniMethod("txSetRollbackOnly", "(J)Z", false);
+ JniMethod M_PLATFORM_TRANSACTIONS_TX_CLOSE = JniMethod("txClose", "(J)I", false);
+ JniMethod M_PLATFORM_TRANSACTIONS_RESET_METRICS = JniMethod("resetMetrics", "()V", false);
+
+ const char* C_PLATFORM_CACHE_STORE_CALLBACK = "org/apache/ignite/internal/processors/platform/cache/store/PlatformCacheStoreCallback";
+ JniMethod M_PLATFORM_CACHE_STORE_CALLBACK_INVOKE = JniMethod("invoke", "(J)V", false);
+
+ const char* C_PLATFORM_CALLBACK_UTILS = "org/apache/ignite/internal/processors/platform/callback/PlatformCallbackUtils";
+
+ JniMethod M_PLATFORM_CALLBACK_UTILS_CACHE_STORE_CREATE = JniMethod("cacheStoreCreate", "(JJ)J", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_CACHE_STORE_INVOKE = JniMethod("cacheStoreInvoke", "(JJJLjava/lang/Object;)I", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_CACHE_STORE_DESTROY = JniMethod("cacheStoreDestroy", "(JJ)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_CACHE_STORE_SESSION_CREATE = JniMethod("cacheStoreSessionCreate", "(JJ)J", true);
+
+ JniMethod M_PLATFORM_CALLBACK_UTILS_CACHE_ENTRY_FILTER_CREATE = JniMethod("cacheEntryFilterCreate", "(JJ)J", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_CACHE_ENTRY_FILTER_APPLY = JniMethod("cacheEntryFilterApply", "(JJJ)I", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_CACHE_ENTRY_FILTER_DESTROY = JniMethod("cacheEntryFilterDestroy", "(JJ)V", true);
+
+ JniMethod M_PLATFORM_CALLBACK_UTILS_CACHE_INVOKE = JniMethod("cacheInvoke", "(JJJ)V", true);
+
+ JniMethod M_PLATFORM_CALLBACK_UTILS_COMPUTE_TASK_MAP = JniMethod("computeTaskMap", "(JJJJ)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_COMPUTE_TASK_JOB_RESULT = JniMethod("computeTaskJobResult", "(JJJJ)I", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_COMPUTE_TASK_REDUCE = JniMethod("computeTaskReduce", "(JJ)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_COMPUTE_TASK_COMPLETE = JniMethod("computeTaskComplete", "(JJJ)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_COMPUTE_JOB_SERIALIZE = JniMethod("computeJobSerialize", "(JJJ)I", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_COMPUTE_JOB_CREATE = JniMethod("computeJobCreate", "(JJ)J", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_COMPUTE_JOB_EXECUTE = JniMethod("computeJobExecute", "(JJIJ)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_COMPUTE_JOB_DESTROY = JniMethod("computeJobDestroy", "(JJ)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_COMPUTE_JOB_CANCEL = JniMethod("computeJobCancel", "(JJ)V", true);
+
+ JniMethod M_PLATFORM_CALLBACK_UTILS_CONTINUOUS_QUERY_LSNR_APPLY = JniMethod("continuousQueryListenerApply", "(JJJ)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_CONTINUOUS_QUERY_FILTER_CREATE = JniMethod("continuousQueryFilterCreate", "(JJ)J", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_CONTINUOUS_QUERY_FILTER_EVAL = JniMethod("continuousQueryFilterApply", "(JJJ)I", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_CONTINUOUS_QUERY_FILTER_RELEASE = JniMethod("continuousQueryFilterRelease", "(JJ)V", true);
+
+ JniMethod M_PLATFORM_CALLBACK_UTILS_DATA_STREAMER_TOPOLOGY_UPDATE = JniMethod("dataStreamerTopologyUpdate", "(JJJI)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_DATA_STREAMER_STREAM_RECEIVER_INVOKE = JniMethod("dataStreamerStreamReceiverInvoke", "(JJLjava/lang/Object;JZ)V", true);
+
+ JniMethod M_PLATFORM_CALLBACK_UTILS_FUTURE_BYTE_RES = JniMethod("futureByteResult", "(JJI)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_FUTURE_BOOL_RES = JniMethod("futureBoolResult", "(JJI)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_FUTURE_SHORT_RES = JniMethod("futureShortResult", "(JJI)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_FUTURE_CHAR_RES = JniMethod("futureCharResult", "(JJI)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_FUTURE_INT_RES = JniMethod("futureIntResult", "(JJI)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_FUTURE_FLOAT_RES = JniMethod("futureFloatResult", "(JJF)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_FUTURE_LONG_RES = JniMethod("futureLongResult", "(JJJ)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_FUTURE_DOUBLE_RES = JniMethod("futureDoubleResult", "(JJD)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_FUTURE_OBJ_RES = JniMethod("futureObjectResult", "(JJJ)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_FUTURE_NULL_RES = JniMethod("futureNullResult", "(JJ)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_FUTURE_ERR = JniMethod("futureError", "(JJJ)V", true);
+
+ JniMethod M_PLATFORM_CALLBACK_UTILS_LIFECYCLE_EVENT = JniMethod("lifecycleEvent", "(JJI)V", true);
+
+ JniMethod M_PLATFORM_CALLBACK_UTILS_MESSAGING_FILTER_CREATE = JniMethod("messagingFilterCreate", "(JJ)J", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_MESSAGING_FILTER_APPLY = JniMethod("messagingFilterApply", "(JJJ)I", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_MESSAGING_FILTER_DESTROY = JniMethod("messagingFilterDestroy", "(JJ)V", true);
+
+ JniMethod M_PLATFORM_CALLBACK_UTILS_EVENT_FILTER_CREATE = JniMethod("eventFilterCreate", "(JJ)J", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_EVENT_FILTER_APPLY = JniMethod("eventFilterApply", "(JJJ)I", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_EVENT_FILTER_DESTROY = JniMethod("eventFilterDestroy", "(JJ)V", true);
+
+ JniMethod M_PLATFORM_CALLBACK_UTILS_SERVICE_INIT = JniMethod("serviceInit", "(JJ)J", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_SERVICE_EXECUTE = JniMethod("serviceExecute", "(JJJ)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_SERVICE_CANCEL = JniMethod("serviceCancel", "(JJJ)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_SERVICE_INVOKE_METHOD = JniMethod("serviceInvokeMethod", "(JJJJ)V", true);
+
+ JniMethod M_PLATFORM_CALLBACK_UTILS_CLUSTER_NODE_FILTER_APPLY = JniMethod("clusterNodeFilterApply", "(JJ)I", true);
+
+ JniMethod M_PLATFORM_CALLBACK_UTILS_NODE_INFO = JniMethod("nodeInfo", "(JJ)V", true);
+
+ JniMethod M_PLATFORM_CALLBACK_UTILS_MEMORY_REALLOCATE = JniMethod("memoryReallocate", "(JJI)V", true);
+
+ JniMethod M_PLATFORM_CALLBACK_UTILS_ON_START = JniMethod("onStart", "(JJ)V", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_ON_STOP = JniMethod("onStop", "(J)V", true);
+
+ JniMethod M_PLATFORM_CALLBACK_UTILS_EXTENSION_CALLBACK_IN_LONG_OUT_LONG = JniMethod("extensionCallbackInLongOutLong", "(JIJ)J", true);
+ JniMethod M_PLATFORM_CALLBACK_UTILS_EXTENSION_CALLBACK_IN_LONG_LONG_OUT_LONG = JniMethod("extensionCallbackInLongLongOutLong", "(JIJJ)J", true);
+
+ const char* C_PLATFORM_UTILS = "org/apache/ignite/internal/processors/platform/utils/PlatformUtils";
+ JniMethod M_PLATFORM_UTILS_REALLOC = JniMethod("reallocate", "(JI)V", true);
+ JniMethod M_PLATFORM_UTILS_ERR_DATA = JniMethod("errorData", "(Ljava/lang/Throwable;)[B", true);
+
+ const char* C_PLATFORM_IGNITION = "org/apache/ignite/internal/processors/platform/PlatformIgnition";
+ JniMethod M_PLATFORM_IGNITION_START = JniMethod("start", "(Ljava/lang/String;Ljava/lang/String;IJJ)Lorg/apache/ignite/internal/processors/platform/PlatformProcessor;", true);
+ JniMethod M_PLATFORM_IGNITION_INSTANCE = JniMethod("instance", "(Ljava/lang/String;)Lorg/apache/ignite/internal/processors/platform/PlatformProcessor;", true);
+ JniMethod M_PLATFORM_IGNITION_ENVIRONMENT_POINTER = JniMethod("environmentPointer", "(Ljava/lang/String;)J", true);
+ JniMethod M_PLATFORM_IGNITION_STOP = JniMethod("stop", "(Ljava/lang/String;Z)Z", true);
+ JniMethod M_PLATFORM_IGNITION_STOP_ALL = JniMethod("stopAll", "(Z)V", true);
+
+ const char* C_PLATFORM_ABSTRACT_QRY_CURSOR = "org/apache/ignite/internal/processors/platform/cache/query/PlatformAbstractQueryCursor";
+ JniMethod M_PLATFORM_ABSTRACT_QRY_CURSOR_ITER = JniMethod("iterator", "()V", false);
+ JniMethod M_PLATFORM_ABSTRACT_QRY_CURSOR_ITER_HAS_NEXT = JniMethod("iteratorHasNext", "()Z", false);
+ JniMethod M_PLATFORM_ABSTRACT_QRY_CURSOR_CLOSE = JniMethod("close", "()V", false);
+
+ const char* C_PLATFORM_CONT_QRY = "org/apache/ignite/internal/processors/platform/cache/query/PlatformContinuousQuery";
+ JniMethod M_PLATFORM_CONT_QRY_CLOSE = JniMethod("close", "()V", false);
+ JniMethod M_PLATFORM_CONT_QRY_GET_INITIAL_QUERY_CURSOR = JniMethod("getInitialQueryCursor", "()Lorg/apache/ignite/internal/processors/platform/PlatformTarget;", false);
+
+ const char* C_PLATFORM_EVENTS = "org/apache/ignite/internal/processors/platform/events/PlatformEvents";
+ JniMethod M_PLATFORM_EVENTS_WITH_ASYNC = JniMethod("withAsync", "()Lorg/apache/ignite/internal/processors/platform/events/PlatformEvents;", false);
+ JniMethod M_PLATFORM_EVENTS_STOP_LOCAL_LISTEN = JniMethod("stopLocalListen", "(J)Z", false);
+ JniMethod M_PLATFORM_EVENTS_LOCAL_LISTEN = JniMethod("localListen", "(JI)V", false);
+ JniMethod M_PLATFORM_EVENTS_IS_ENABLED = JniMethod("isEnabled", "(I)Z", false);
+
+ const char* C_PLATFORM_SERVICES = "org/apache/ignite/internal/processors/platform/services/PlatformServices";
+ JniMethod M_PLATFORM_SERVICES_WITH_ASYNC = JniMethod("withAsync", "()Lorg/apache/ignite/internal/processors/platform/services/PlatformServices;", false);
+ JniMethod M_PLATFORM_SERVICES_WITH_SERVER_KEEP_PORTABLE = JniMethod("withServerKeepPortable", "()Lorg/apache/ignite/internal/processors/platform/services/PlatformServices;", false);
+ JniMethod M_PLATFORM_SERVICES_CANCEL = JniMethod("cancel", "(Ljava/lang/String;)V", false);
+ JniMethod M_PLATFORM_SERVICES_CANCEL_ALL = JniMethod("cancelAll", "()V", false);
+ JniMethod M_PLATFORM_SERVICES_SERVICE_PROXY = JniMethod("dotNetServiceProxy", "(Ljava/lang/String;Z)Ljava/lang/Object;", false);
+
+ /* STATIC STATE. */
+ gcc::CriticalSection JVM_LOCK;
+ JniJvm JVM;
+ bool PRINT_EXCEPTION = false;
+
+ /* HELPER METHODS. */
+
+ /*
+ * Throw exception to Java in case of missing callback pointer. It means that callback is not implemented in
+ * native platform and Java -> platform operation cannot proceede further. As JniContext is not available at
+ * this point, we have to obtain exception details from scratch. This is not critical from performance
+ * perspective because missing handler usually denotes fatal condition.
+ *
+ * @param env JNI environment.
+ */
+ int ThrowOnMissingHandler(JNIEnv* env)
+ {
+ jclass cls = env->FindClass(C_PLATFORM_NO_CALLBACK_EXCEPTION);
+
+ env->ThrowNew(cls, "Callback handler is not set in native platform.");
+
+ return 0;
+ }
+
+ char* StringToChars(JNIEnv* env, jstring str, int* len) {
+ if (!str) {
+ *len = 0;
+ return NULL;
+ }
+
+ const char* strChars = env->GetStringUTFChars(str, 0);
+ const int strCharsLen = env->GetStringUTFLength(str);
+
+ char* strChars0 = new char[strCharsLen + 1];
+ std::strcpy(strChars0, strChars);
+ *(strChars0 + strCharsLen) = 0;
+
+ env->ReleaseStringUTFChars(str, strChars);
+
+ if (len)
+ *len = strCharsLen;
+
+ return strChars0;
+ }
+
+ std::string JavaStringToCString(JNIEnv* env, jstring str, int* len)
+ {
+ char* resChars = StringToChars(env, str, len);
+
+ if (resChars)
+ {
+ std::string res = std::string(resChars, *len);
+
+ delete[] resChars;
+
+ return res;
+ }
+ else
+ return std::string();
+ }
+
+ jclass FindClass(JNIEnv* env, const char *name) {
+ jclass res = env->FindClass(name);
+
+ if (!res)
+ throw JvmException();
+
+ jclass res0 = static_cast<jclass>(env->NewGlobalRef(res));
+
+ env->DeleteLocalRef(res);
+
+ return res0;
+ }
+
+ void DeleteClass(JNIEnv* env, jclass cls) {
+ if (cls)
+ env->DeleteGlobalRef(cls);
+ }
+
+ void CheckClass(JNIEnv* env, const char *name)
+ {
+ jclass res = env->FindClass(name);
+
+ if (!res)
+ throw JvmException();
+ }
+
+ jmethodID FindMethod(JNIEnv* env, jclass cls, JniMethod mthd) {
+ jmethodID mthd0 = mthd.isStatic ?
+ env->GetStaticMethodID(cls, mthd.name, mthd.sign) : env->GetMethodID(cls, mthd.name, mthd.sign);
+
+ if (!mthd0)
+ throw JvmException();
+
+ return mthd0;
+ }
+
+ void AddNativeMethod(JNINativeMethod* mthd, JniMethod jniMthd, void* fnPtr) {
+ mthd->name = jniMthd.name;
+ mthd->signature = jniMthd.sign;
+ mthd->fnPtr = fnPtr;
+ }
+
+ void JniJavaMembers::Initialize(JNIEnv* env) {
+ c_Class = FindClass(env, C_CLASS);
+ m_Class_getName = FindMethod(env, c_Class, M_CLASS_GET_NAME);
+
+ c_Throwable = FindClass(env, C_THROWABLE);
+ m_Throwable_getMessage = FindMethod(env, c_Throwable, M_THROWABLE_GET_MESSAGE);
+ m_Throwable_printStackTrace = FindMethod(env, c_Throwable, M_THROWABLE_PRINT_STACK_TRACE);
+ }
+
+ void JniJavaMembers::Destroy(JNIEnv* env) {
+ DeleteClass(env, c_Class);
+ DeleteClass(env, c_Throwable);
+ }
+
+ bool JniJavaMembers::WriteErrorInfo(JNIEnv* env, char** errClsName, int* errClsNameLen, char** errMsg, int* errMsgLen) {
+ if (env && env->ExceptionCheck()) {
+ if (m_Class_getName && m_Throwable_getMessage) {
+ jthrowable err = env->ExceptionOccurred();
+
+ env->ExceptionClear();
+
+ jclass errCls = env->GetObjectClass(err);
+
+ jstring clsName = static_cast<jstring>(env->CallObjectMethod(errCls, m_Class_getName));
+ *errClsName = StringToChars(env, clsName, errClsNameLen);
+
+ jstring msg = static_cast<jstring>(env->CallObjectMethod(err, m_Throwable_getMessage));
+ *errMsg = StringToChars(env, msg, errMsgLen);
+
+ if (errCls)
+ env->DeleteLocalRef(errCls);
+
+ if (clsName)
+ env->DeleteLocalRef(clsName);
+
+ if (msg)
+ env->DeleteLocalRef(msg);
+
+ return true;
+ }
+ else {
+ env->ExceptionClear();
+ }
+ }
+
+ return false;
+ }
+
+ void JniMembers::Initialize(JNIEnv* env) {
+ c_PlatformAbstractQryCursor = FindClass(env, C_PLATFORM_ABSTRACT_QRY_CURSOR);
+ m_PlatformAbstractQryCursor_iter = FindMethod(env, c_PlatformAbstractQryCursor, M_PLATFORM_ABSTRACT_QRY_CURSOR_ITER);
+ m_PlatformAbstractQryCursor_iterHasNext = FindMethod(env, c_PlatformAbstractQryCursor, M_PLATFORM_ABSTRACT_QRY_CURSOR_ITER_HAS_NEXT);
+ m_PlatformAbstractQryCursor_close = FindMethod(env, c_PlatformAbstractQryCursor, M_PLATFORM_ABSTRACT_QRY_CURSOR_CLOSE);
+
+ c_PlatformAffinity = FindClass(env, C_PLATFORM_AFFINITY);
+ m_PlatformAffinity_partitions = FindMethod(env, c_PlatformAffinity, C_PLATFORM_AFFINITY_PARTITIONS);
+
+ c_PlatformCache = FindClass(env, C_PLATFORM_CACHE);
+ m_PlatformCache_withSkipStore = FindMethod(env, c_PlatformCache, M_PLATFORM_CACHE_WITH_SKIP_STORE);
+ m_PlatformCache_withNoRetries = FindMethod(env, c_PlatformCache, M_PLATFORM_CACHE_WITH_NO_RETRIES);
+ m_PlatformCache_withExpiryPolicy = FindMethod(env, c_PlatformCache, M_PLATFORM_CACHE_WITH_EXPIRY_PLC);
+ m_PlatformCache_withAsync = FindMethod(env, c_PlatformCache, M_PLATFORM_CACHE_WITH_ASYNC);
+ m_PlatformCache_withKeepPortable = FindMethod(env, c_PlatformCache, M_PLATFORM_CACHE_WITH_KEEP_PORTABLE);
+ m_PlatformCache_clear = FindMethod(env, c_PlatformCache, M_PLATFORM_CACHE_CLEAR);
+ m_PlatformCache_removeAll = FindMethod(env, c_PlatformCache, M_PLATFORM_CACHE_REMOVE_ALL);
+ m_PlatformCache_iterator = FindMethod(env, c_PlatformCache, M_PLATFORM_CACHE_ITERATOR);
+ m_PlatformCache_localIterator = FindMethod(env, c_PlatformCache, M_PLATFORM_CACHE_LOCAL_ITERATOR);
+ m_PlatformCache_enterLock = FindMethod(env, c_PlatformCache, M_PLATFORM_CACHE_ENTER_LOCK);
+ m_PlatformCache_exitLock = FindMethod(env, c_PlatformCache, M_PLATFORM_CACHE_EXIT_LOCK);
+ m_PlatformCache_tryEnterLock = FindMethod(env, c_PlatformCache, M_PLATFORM_CACHE_TRY_ENTER_LOCK);
+ m_PlatformCache_closeLock = FindMethod(env, c_PlatformCache, M_PLATFORM_CACHE_CLOSE_LOCK);
+ m_PlatformCache_rebalance = FindMethod(env, c_PlatformCache, M_PLATFORM_CACHE_REBALANCE);
+ m_PlatformCache_size = FindMethod(env, c_PlatformCache, M_PLATFORM_CACHE_SIZE);
+
+ c_PlatformCacheStoreCallback = FindClass(env, C_PLATFORM_CACHE_STORE_CALLBACK);
+ m_PlatformCacheStoreCallback_invoke = FindMethod(env, c_PlatformCacheStoreCallback, M_PLATFORM_CACHE_STORE_CALLBACK_INVOKE);
+
+ c_IgniteException = FindClass(env, C_IGNITE_EXCEPTION);
+
+ c_PlatformClusterGroup = FindClass(env, C_PLATFORM_CLUSTER_GRP);
+ m_PlatformClusterGroup_forOthers = FindMethod(env, c_PlatformClusterGroup, M_PLATFORM_CLUSTER_GRP_FOR_OTHERS);
+ m_PlatformClusterGroup_forRemotes = FindMethod(env, c_PlatformClusterGroup, M_PLATFORM_CLUSTER_GRP_FOR_REMOTES);
+ m_PlatformClusterGroup_forDaemons = FindMethod(env, c_PlatformClusterGroup, M_PLATFORM_CLUSTER_GRP_FOR_DAEMONS);
+ m_PlatformClusterGroup_forRandom = FindMethod(env, c_PlatformClusterGroup, M_PLATFORM_CLUSTER_GRP_FOR_RANDOM);
+ m_PlatformClusterGroup_forOldest = FindMethod(env, c_PlatformClusterGroup, M_PLATFORM_CLUSTER_GRP_FOR_OLDEST);
+ m_PlatformClusterGroup_forYoungest = FindMethod(env, c_PlatformClusterGroup, M_PLATFORM_CLUSTER_GRP_FOR_YOUNGEST);
+ m_PlatformClusterGroup_resetMetrics = FindMethod(env, c_PlatformClusterGroup, M_PLATFORM_CLUSTER_GRP_RESET_METRICS);
+
+ c_PlatformCompute = FindClass(env, C_PLATFORM_COMPUTE);
+ m_PlatformCompute_withNoFailover = FindMethod(env, c_PlatformCompute, M_PLATFORM_COMPUTE_WITH_NO_FAILOVER);
+ m_PlatformCompute_withTimeout = FindMethod(env, c_PlatformCompute, M_PLATFORM_COMPUTE_WITH_TIMEOUT);
+ m_PlatformCompute_executeNative = FindMethod(env, c_PlatformCompute, M_PLATFORM_COMPUTE_EXECUTE_NATIVE);
+
+ c_PlatformContinuousQuery = FindClass(env, C_PLATFORM_CONT_QRY);
+ m_PlatformContinuousQuery_close = FindMethod(env, c_PlatformContinuousQuery, M_PLATFORM_CONT_QRY_CLOSE);
+ m_PlatformContinuousQuery_getInitialQueryCursor = FindMethod(env, c_PlatformContinuousQuery, M_PLATFORM_CONT_QRY_GET_INITIAL_QUERY_CURSOR);
+
+ c_PlatformDataStreamer = FindClass(env, C_PLATFORM_DATA_STREAMER);
+ m_PlatformDataStreamer_listenTopology = FindMethod(env, c_PlatformDataStreamer, M_PLATFORM_DATA_STREAMER_LISTEN_TOPOLOGY);
+ m_PlatformDataStreamer_getAllowOverwrite = FindMethod(env, c_PlatformDataStreamer, M_PLATFORM_DATA_STREAMER_GET_ALLOW_OVERWRITE);
+ m_PlatformDataStreamer_setAllowOverwrite = FindMethod(env, c_PlatformDataStreamer, M_PLATFORM_DATA_STREAMER_SET_ALLOW_OVERWRITE);
+ m_PlatformDataStreamer_getSkipStore = FindMethod(env, c_PlatformDataStreamer, M_PLATFORM_DATA_STREAMER_GET_SKIP_STORE);
+ m_PlatformDataStreamer_setSkipStore = FindMethod(env, c_PlatformDataStreamer, M_PLATFORM_DATA_STREAMER_SET_SKIP_STORE);
+ m_PlatformDataStreamer_getPerNodeBufSize = FindMethod(env, c_PlatformDataStreamer, M_PLATFORM_DATA_STREAMER_GET_PER_NODE_BUFFER_SIZE);
+ m_PlatformDataStreamer_setPerNodeBufSize = FindMethod(env, c_PlatformDataStreamer, M_PLATFORM_DATA_STREAMER_SET_PER_NODE_BUFFER_SIZE);
+ m_PlatformDataStreamer_getPerNodeParallelOps = FindMethod(env, c_PlatformDataStreamer, M_PLATFORM_DATA_STREAMER_GET_PER_NODE_PARALLEL_OPS);
+ m_PlatformDataStreamer_setPerNodeParallelOps = FindMethod(env, c_PlatformDataStreamer, M_PLATFORM_DATA_STREAMER_SET_PER_NODE_PARALLEL_OPS);
+
+ c_PlatformEvents = FindClass(env, C_PLATFORM_EVENTS);
+ m_PlatformEvents_withAsync = FindMethod(env, c_PlatformEvents, M_PLATFORM_EVENTS_WITH_ASYNC);
+ m_PlatformEvents_stopLocalListen = FindMethod(env, c_PlatformEvents, M_PLATFORM_EVENTS_STOP_LOCAL_LISTEN);
+ m_PlatformEvents_localListen = FindMethod(env, c_PlatformEvents, M_PLATFORM_EVENTS_LOCAL_LISTEN);
+ m_PlatformEvents_isEnabled = FindMethod(env, c_PlatformEvents, M_PLATFORM_EVENTS_IS_ENABLED);
+
+ c_PlatformServices = FindClass(env, C_PLATFORM_SERVICES);
+ m_PlatformServices_withAsync = FindMethod(env, c_PlatformServices, M_PLATFORM_SERVICES_WITH_ASYNC);
+ m_PlatformServices_withServerKeepPortable = FindMethod(env, c_PlatformServices, M_PLATFORM_SERVICES_WITH_SERVER_KEEP_PORTABLE);
+ m_PlatformServices_cancel = FindMethod(env, c_PlatformServices, M_PLATFORM_SERVICES_CANCEL);
+ m_PlatformServices_cancelAll = FindMethod(env, c_PlatformServices, M_PLATFORM_SERVICES_CANCEL_ALL);
+ m_PlatformServices_serviceProxy = FindMethod(env, c_PlatformServices, M_PLATFORM_SERVICES_SERVICE_PROXY);
+
+ c_PlatformIgnition = FindClass(env, C_PLATFORM_IGNITION);
+ m_PlatformIgnition_start = FindMethod(env, c_PlatformIgnition, M_PLATFORM_IGNITION_START);
+ m_PlatformIgnition_instance = FindMethod(env, c_PlatformIgnition, M_PLATFORM_IGNITION_INSTANCE);
+ m_PlatformIgnition_environmentPointer = FindMethod(env, c_PlatformIgnition, M_PLATFORM_IGNITION_ENVIRONMENT_POINTER);
+ m_PlatformIgnition_stop = FindMethod(env, c_PlatformIgnition, M_PLATFORM_IGNITION_STOP);
+ m_PlatformIgnition_stopAll = FindMethod(env, c_PlatformIgnition, M_PLATFORM_IGNITION_STOP_ALL);
+
+ c_PlatformMessaging = FindClass(env, C_PLATFORM_MESSAGING);
+ m_PlatformMessaging_withAsync = FindMethod(env, c_PlatformMessaging, M_PLATFORM_MESSAGING_WITH_ASYNC);
+
+ c_PlatformProcessor = FindClass(env, C_PLATFORM_PROCESSOR);
+ m_PlatformProcessor_releaseStart = FindMethod(env, c_PlatformProcessor, M_PLATFORM_PROCESSOR_RELEASE_START);
+ m_PlatformProcessor_cache = FindMethod(env, c_PlatformProcessor, M_PLATFORM_PROCESSOR_CACHE);
+ m_PlatformProcessor_createCache = FindMethod(env, c_PlatformProcessor, M_PLATFORM_PROCESSOR_CREATE_CACHE);
+ m_PlatformProcessor_getOrCreateCache = FindMethod(env, c_PlatformProcessor, M_PLATFORM_PROCESSOR_GET_OR_CREATE_CACHE);
+ m_PlatformProcessor_affinity = FindMethod(env, c_PlatformProcessor, M_PLATFORM_PROCESSOR_AFFINITY);
+ m_PlatformProcessor_dataStreamer = FindMethod(env, c_PlatformProcessor, M_PLATFORM_PROCESSOR_DATA_STREAMER);
+ m_PlatformProcessor_transactions = FindMethod(env, c_PlatformProcessor, M_PLATFORM_PROCESSOR_TRANSACTIONS);
+ m_PlatformProcessor_projection = FindMethod(env, c_PlatformProcessor, M_PLATFORM_PROCESSOR_PROJECTION);
+ m_PlatformProcessor_compute = FindMethod(env, c_PlatformProcessor, M_PLATFORM_PROCESSOR_COMPUTE);
+ m_PlatformProcessor_message = FindMethod(env, c_PlatformProcessor, M_PLATFORM_PROCESSOR_MESSAGE);
+ m_PlatformProcessor_events = FindMethod(env, c_PlatformProcessor, M_PLATFORM_PROCESSOR_EVENTS);
+ m_PlatformProcessor_services = FindMethod(env, c_PlatformProcessor, M_PLATFORM_PROCESSOR_SERVICES);
+ m_PlatformProcessor_extensions = FindMethod(env, c_PlatformProcessor, M_PLATFORM_PROCESSOR_EXTENSIONS);
+
+ c_PlatformTarget = FindClass(env, C_PLATFORM_TARGET);
+ m_PlatformTarget_inStreamOutLong = FindMethod(env, c_PlatformTarget, M_PLATFORM_TARGET_IN_STREAM_OUT_LONG);
+ m_PlatformTarget_inStreamOutObject = FindMethod(env, c_PlatformTarget, M_PLATFORM_TARGET_IN_STREAM_OUT_OBJECT);
+ m_PlatformTarget_outLong = FindMethod(env, c_PlatformTarget, M_PLATFORM_TARGET_OUT_LONG);
+ m_PlatformTarget_outStream = FindMethod(env, c_PlatformTarget, M_PLATFORM_TARGET_OUT_STREAM);
+ m_PlatformTarget_outObject = FindMethod(env, c_PlatformTarget, M_PLATFORM_TARGET_OUT_OBJECT);
+ m_PlatformTarget_inStreamOutStream = FindMethod(env, c_PlatformTarget, M_PLATFORM_TARGET_IN_STREAM_OUT_STREAM);
+ m_PlatformTarget_inObjectStreamOutStream = FindMethod(env, c_PlatformTarget, M_PLATFORM_TARGET_IN_OBJECT_STREAM_OUT_STREAM);
+ m_PlatformTarget_listenFuture = FindMethod(env, c_PlatformTarget, M_PLATFORM_TARGET_LISTEN_FUTURE);
+ m_PlatformTarget_listenFutureForOperation = FindMethod(env, c_PlatformTarget, M_PLATFORM_TARGET_LISTEN_FOR_OPERATION);
+
+ c_PlatformTransactions = FindClass(env, C_PLATFORM_TRANSACTIONS);
+ m_PlatformTransactions_txStart = FindMethod(env, c_PlatformTransactions, M_PLATFORM_TRANSACTIONS_TX_START);
+ m_PlatformTransactions_txCommit = FindMethod(env, c_PlatformTransactions, M_PLATFORM_TRANSACTIONS_TX_COMMIT);
+ m_PlatformTransactions_txRollback = FindMethod(env, c_PlatformTransactions, M_PLATFORM_TRANSACTIONS_TX_ROLLBACK);
+ m_PlatformTransactions_txCommitAsync = FindMethod(env, c_PlatformTransactions, M_PLATFORM_TRANSACTIONS_TX_COMMIT_ASYNC);
+ m_PlatformTransactions_txRollbackAsync = FindMethod(env, c_PlatformTransactions, M_PLATFORM_TRANSACTIONS_TX_ROLLBACK_ASYNC);
+ m_PlatformTransactions_txState = FindMethod(env, c_PlatformTransactions, M_PLATFORM_TRANSACTIONS_TX_STATE);
+ m_PlatformTransactions_txSetRollbackOnly = FindMethod(env, c_PlatformTransactions, M_PLATFORM_TRANSACTIONS_TX_SET_ROLLBACK_ONLY);
+ m_PlatformTransactions_txClose = FindMethod(env, c_PlatformTransactions, M_PLATFORM_TRANSACTIONS_TX_CLOSE);
+ m_PlatformTransactions_resetMetrics = FindMethod(env, c_PlatformTransactions, M_PLATFORM_TRANSACTIONS_RESET_METRICS);
+
+ c_PlatformUtils = FindClass(env, C_PLATFORM_UTILS);
+ m_PlatformUtils_reallocate = FindMethod(env, c_PlatformUtils, M_PLATFORM_UTILS_REALLOC);
+ m_PlatformUtils_errData = FindMethod(env, c_PlatformUtils, M_PLATFORM_UTILS_ERR_DATA);
+
+ // Find utility classes which are not used from context, but are still required in other places.
+ CheckClass(env, C_PLATFORM_NO_CALLBACK_EXCEPTION);
+ }
+
+ void JniMembers::Destroy(JNIEnv* env) {
+ DeleteClass(env, c_PlatformAbstractQryCursor);
+ DeleteClass(env, c_PlatformAffinity);
+ DeleteClass(env, c_PlatformCache);
+ DeleteClass(env, c_PlatformCacheStoreCallback);
+ DeleteClass(env, c_IgniteException);
+ DeleteClass(env, c_PlatformClusterGroup);
+ DeleteClass(env, c_PlatformCompute);
+ DeleteClass(env, c_PlatformContinuousQuery);
+ DeleteClass(env, c_PlatformDataStreamer);
+ DeleteClass(env, c_PlatformEvents);
+ DeleteClass(env, c_PlatformIgnition);
+ DeleteClass(env, c_PlatformMessaging);
+ DeleteClass(env, c_PlatformProcessor);
+ DeleteClass(env, c_PlatformTarget);
+ DeleteClass(env, c_PlatformTransactions);
+ DeleteClass(env, c_PlatformUtils);
+ }
+
+ JniJvm::JniJvm() : jvm(NULL), javaMembers(JniJavaMembers()), members(JniMembers())
+ {
+ // No-op.
+ }
+
+ JniJvm::JniJvm(JavaVM* jvm, JniJavaMembers javaMembers, JniMembers members) :
+ jvm(jvm), javaMembers(javaMembers), members(members)
+ {
+ // No-op.
+ }
+
+ JavaVM* JniJvm::GetJvm()
+ {
+ return jvm;
+ }
+
+ JniJavaMembers& JniJvm::GetJavaMembers()
+ {
+ return javaMembers;
+ }
+
+ JniMembers& JniJvm::GetMembers()
+ {
+ return members;
+ }
+
+ /*
+ * Create JVM.
+ */
+ void CreateJvm(char** opts, int optsLen, JavaVM** jvm, JNIEnv** env) {
+ JavaVMOption* opts0 = new JavaVMOption[optsLen];
+
+ for (int i = 0; i < optsLen; i++)
+ opts0[i].optionString = *(opts + i);
+
+ JavaVMInitArgs args;
+
+ args.version = JNI_VERSION_1_6;
+ args.nOptions = optsLen;
+ args.options = opts0;
+ args.ignoreUnrecognized = 0;
+
+ jint res = JNI_CreateJavaVM(jvm, reinterpret_cast<void**>(env), &args);
+
+ delete[] opts0;
+
+ if (res != JNI_OK)
+ throw JvmException();
+ }
+
+ void RegisterNatives(JNIEnv* env) {
+ {
+ JNINativeMethod methods[52];
+
+ int idx = 0;
+
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_CACHE_STORE_CREATE, reinterpret_cast<void*>(JniCacheStoreCreate));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_CACHE_STORE_INVOKE, reinterpret_cast<void*>(JniCacheStoreInvoke));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_CACHE_STORE_DESTROY, reinterpret_cast<void*>(JniCacheStoreDestroy));
+
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_CACHE_STORE_SESSION_CREATE, reinterpret_cast<void*>(JniCacheStoreSessionCreate));
+
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_CACHE_ENTRY_FILTER_CREATE, reinterpret_cast<void*>(JniCacheEntryFilterCreate));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_CACHE_ENTRY_FILTER_APPLY, reinterpret_cast<void*>(JniCacheEntryFilterApply));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_CACHE_ENTRY_FILTER_DESTROY, reinterpret_cast<void*>(JniCacheEntryFilterDestroy));
+
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_CACHE_INVOKE, reinterpret_cast<void*>(JniCacheInvoke));
+
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_COMPUTE_TASK_MAP, reinterpret_cast<void*>(JniComputeTaskMap));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_COMPUTE_TASK_JOB_RESULT, reinterpret_cast<void*>(JniComputeTaskJobResult));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_COMPUTE_TASK_REDUCE, reinterpret_cast<void*>(JniComputeTaskReduce));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_COMPUTE_TASK_COMPLETE, reinterpret_cast<void*>(JniComputeTaskComplete));
+
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_COMPUTE_JOB_SERIALIZE, reinterpret_cast<void*>(JniComputeJobSerialize));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_COMPUTE_JOB_CREATE, reinterpret_cast<void*>(JniComputeJobCreate));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_COMPUTE_JOB_EXECUTE, reinterpret_cast<void*>(JniComputeJobExecute));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_COMPUTE_JOB_DESTROY, reinterpret_cast<void*>(JniComputeJobDestroy));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_COMPUTE_JOB_CANCEL, reinterpret_cast<void*>(JniComputeJobCancel));
+
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_CONTINUOUS_QUERY_LSNR_APPLY, reinterpret_cast<void*>(JniContinuousQueryListenerApply));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_CONTINUOUS_QUERY_FILTER_CREATE, reinterpret_cast<void*>(JniContinuousQueryFilterCreate));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_CONTINUOUS_QUERY_FILTER_EVAL, reinterpret_cast<void*>(JniContinuousQueryFilterApply));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_CONTINUOUS_QUERY_FILTER_RELEASE, reinterpret_cast<void*>(JniContinuousQueryFilterRelease));
+
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_DATA_STREAMER_TOPOLOGY_UPDATE, reinterpret_cast<void*>(JniDataStreamerTopologyUpdate));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_DATA_STREAMER_STREAM_RECEIVER_INVOKE, reinterpret_cast<void*>(JniDataStreamerStreamReceiverInvoke));
+
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_FUTURE_BYTE_RES, reinterpret_cast<void*>(JniFutureByteResult));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_FUTURE_BOOL_RES, reinterpret_cast<void*>(JniFutureBoolResult));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_FUTURE_SHORT_RES, reinterpret_cast<void*>(JniFutureShortResult));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_FUTURE_CHAR_RES, reinterpret_cast<void*>(JniFutureCharResult));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_FUTURE_INT_RES, reinterpret_cast<void*>(JniFutureIntResult));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_FUTURE_FLOAT_RES, reinterpret_cast<void*>(JniFutureFloatResult));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_FUTURE_LONG_RES, reinterpret_cast<void*>(JniFutureLongResult));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_FUTURE_DOUBLE_RES, reinterpret_cast<void*>(JniFutureDoubleResult));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_FUTURE_OBJ_RES, reinterpret_cast<void*>(JniFutureObjectResult));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_FUTURE_NULL_RES, reinterpret_cast<void*>(JniFutureNullResult));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_FUTURE_ERR, reinterpret_cast<void*>(JniFutureError));
+
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_LIFECYCLE_EVENT, reinterpret_cast<void*>(JniLifecycleEvent));
+
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_MESSAGING_FILTER_CREATE, reinterpret_cast<void*>(JniMessagingFilterCreate));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_MESSAGING_FILTER_APPLY, reinterpret_cast<void*>(JniMessagingFilterApply));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_MESSAGING_FILTER_DESTROY, reinterpret_cast<void*>(JniMessagingFilterDestroy));
+
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_EVENT_FILTER_CREATE, reinterpret_cast<void*>(JniEventFilterCreate));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_EVENT_FILTER_APPLY, reinterpret_cast<void*>(JniEventFilterApply));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_EVENT_FILTER_DESTROY, reinterpret_cast<void*>(JniEventFilterDestroy));
+
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_SERVICE_INIT, reinterpret_cast<void*>(JniServiceInit));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_SERVICE_EXECUTE, reinterpret_cast<void*>(JniServiceExecute));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_SERVICE_CANCEL, reinterpret_cast<void*>(JniServiceCancel));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_SERVICE_INVOKE_METHOD, reinterpret_cast<void*>(JniServiceInvokeMethod));
+
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_CLUSTER_NODE_FILTER_APPLY, reinterpret_cast<void*>(JniClusterNodeFilterApply));
+
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_NODE_INFO, reinterpret_cast<void*>(JniNodeInfo));
+
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_MEMORY_REALLOCATE, reinterpret_cast<void*>(JniMemoryReallocate));
+
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_ON_START, reinterpret_cast<void*>(JniOnStart));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_ON_STOP, reinterpret_cast<void*>(JniOnStop));
+
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_EXTENSION_CALLBACK_IN_LONG_OUT_LONG, reinterpret_cast<void*>(JniExtensionCallbackInLongOutLong));
+ AddNativeMethod(methods + idx++, M_PLATFORM_CALLBACK_UTILS_EXTENSION_CALLBACK_IN_LONG_LONG_OUT_LONG, reinterpret_cast<void*>(JniExtensionCallbackInLongLongOutLong));
+
+ jint res = env->RegisterNatives(FindClass(env, C_PLATFORM_CALLBACK_UTILS), methods, idx);
+
+ if (res != JNI_OK)
+ throw JvmException();
+ }
+ }
+
+ JniContext::JniContext(JniJvm* jvm, JniHandlers hnds) : jvm(jvm), hnds(hnds) {
+ // No-op.
+ }
+
+ JniContext* JniContext::Create(char** opts, int optsLen, JniHandlers hnds) {
+ return Create(opts, optsLen, hnds, NULL);
+ }
+
+ JniContext* JniContext::Create(char** opts, int optsLen, JniHandlers hnds, JniErrorInfo* errInfo)
+ {
+ // Acquire global lock to instantiate the JVM.
+ JVM_LOCK.Enter();
+
+ // Define local variables.
+ JavaVM* jvm = NULL;
+ JNIEnv* env = NULL;
+
+ JniJavaMembers javaMembers;
+ memset(&javaMembers, 0, sizeof(javaMembers));
+
+ JniMembers members;
+ memset(&members, 0, sizeof(members));
+
+ JniContext* ctx = NULL;
+
+ std::string errClsName;
+ int errClsNameLen = 0;
+ std::string errMsg;
+ int errMsgLen = 0;
+
+ try {
+ if (!JVM.GetJvm()) {
+ // 1. Create JVM itself.
+ CreateJvm(opts, optsLen, &jvm, &env);
+
+ // 2. Populate members;
+ javaMembers.Initialize(env);
+ members.Initialize(env);
+
+ // 3. Register native functions.
+ RegisterNatives(env);
+
+ // 4. Create JNI JVM.
+ JVM = JniJvm(jvm, javaMembers, members);
+
+ char* printStack = getenv("IGNITE_CPP_PRINT_STACK");
+ PRINT_EXCEPTION = printStack && strcmp("true", printStack) == 0;
+ }
+
+ ctx = new JniContext(&JVM, hnds);
+ }
+ catch (JvmException)
+ {
+ char* errClsNameChars = NULL;
+ char* errMsgChars = NULL;
+
+ // Read error info if possible.
+ javaMembers.WriteErrorInfo(env, &errClsNameChars, &errClsNameLen, &errMsgChars, &errMsgLen);
+
+ if (errClsNameChars) {
+ errClsName = errClsNameChars;
+
+ delete[] errClsNameChars;
+ }
+
+ if (errMsgChars)
+ {
+ errMsg = errMsgChars;
+
+ delete[] errMsgChars;
+ }
+
+ // Destroy mmebers.
+ if (env) {
+ members.Destroy(env);
+ javaMembers.Destroy(env);
+ }
+
+ // Destroy faulty JVM.
+ if (jvm)
+ jvm->DestroyJavaVM();
+ }
+
+ // It safe to release the lock at this point.
+ JVM_LOCK.Leave();
+
+ // Notify err callback if needed.
+ if (!ctx) {
+ if (errInfo) {
+ JniErrorInfo errInfo0(IGNITE_JNI_ERR_JVM_INIT, errClsName.c_str(), errMsg.c_str());
+
+ *errInfo = errInfo0;
+ }
+
+ if (hnds.error)
+ hnds.error(hnds.target, IGNITE_JNI_ERR_JVM_INIT, errClsName.c_str(), errClsNameLen,
+ errMsg.c_str(), errMsgLen, NULL, 0);
+ }
+
+ return ctx;
+ }
+
+ int JniContext::Reallocate(long long memPtr, int cap) {
+ JavaVM* jvm = JVM.GetJvm();
+
+ JNIEnv* env;
+
+ int attachRes = jvm->AttachCurrentThread(reinterpret_cast<void**>(&env), NULL);
+
+ if (attachRes == JNI_OK)
+ AttachHelper::OnThreadAttach();
+ else
+ return -1;
+
+ env->CallStaticVoidMethod(JVM.GetMembers().c_PlatformUtils, JVM.GetMembers().m_PlatformUtils_reallocate, memPtr, cap);
+
+ if (env->ExceptionCheck()) {
+ env->ExceptionClear();
+
+ return -1;
+ }
+
+ return 0;
+ }
+
+ void JniContext::Detach() {
+ gcc::Memory::Fence();
+
+ if (JVM.GetJvm()) {
+ JNIEnv* env;
+
+ JVM.GetJvm()->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6);
+
+ if (env)
+ JVM.GetJvm()->DetachCurrentThread();
+ }
+ }
+
+ jobject JniContext::IgnitionStart(char* cfgPath, char* gridName, int factoryId, long long dataPtr) {
+ return IgnitionStart(cfgPath, gridName, factoryId, dataPtr, NULL);
+ }
+
+ jobject JniContext::IgnitionStart(char* cfgPath, char* gridName, int factoryId, long long dataPtr, JniErrorInfo* errInfo)
+ {
+ JNIEnv* env = Attach();
+
+ jstring cfgPath0 = env->NewStringUTF(cfgPath);
+ jstring gridName0 = env->NewStringUTF(gridName);
+
+ jobject interop = env->CallStaticObjectMethod(
+ jvm->GetMembers().c_PlatformIgnition,
+ jvm->GetMembers().m_PlatformIgnition_start,
+ cfgPath0,
+ gridName0,
+ factoryId,
+ reinterpret_cast<long long>(&hnds),
+ dataPtr
+ );
+
+ ExceptionCheck(env, errInfo);
+
+ return LocalToGlobal(env, interop);
+ }
+
+
+ jobject JniContext::IgnitionInstance(char* gridName)
+ {
+ return IgnitionInstance(gridName, NULL);
+ }
+
+ jobject JniContext::IgnitionInstance(char* gridName, JniErrorInfo* errInfo)
+ {
+ JNIEnv* env = Attach();
+
+ jstring gridName0 = env->NewStringUTF(gridName);
+
+ jobject interop = env->CallStaticObjectMethod(jvm->GetMembers().c_PlatformIgnition,
+ jvm->GetMembers().m_PlatformIgnition_instance, gridName0);
+
+ ExceptionCheck(env, errInfo);
+
+ return LocalToGlobal(env, interop);
+ }
+
+ long long JniContext::IgnitionEnvironmentPointer(char* gridName)
+ {
+ return IgnitionEnvironmentPointer(gridName, NULL);
+ }
+
+ long long JniContext::IgnitionEnvironmentPointer(char* gridName, JniErrorInfo* errInfo)
+ {
+ JNIEnv* env = Attach();
+
+ jstring gridName0 = env->NewStringUTF(gridName);
+
+ long long res = env->CallStaticLongMethod(jvm->GetMembers().c_PlatformIgnition,
+ jvm->GetMembers().m_PlatformIgnition_environmentPointer, gridName0);
+
+ ExceptionCheck(env, errInfo);
+
+ return res;
+ }
+
+ bool JniContext::IgnitionStop(char* gridName, bool cancel)
+ {
+ return IgnitionStop(gridName, cancel, NULL);
+ }
+
+ bool JniContext::IgnitionStop(char* gridName, bool cancel, JniErrorInfo* errInfo)
+ {
+ JNIEnv* env = Attach();
+
+ jstring gridName0 = env->NewStringUTF(gridName);
+
+ jboolean res = env->CallStaticBooleanMethod(jvm->GetMembers().c_PlatformIgnition, jvm->GetMembers().m_PlatformIgnition_stop,
+ gridName0, cancel);
+
+ ExceptionCheck(env, errInfo);
+
+ return res != 0;
+ }
+
+ void JniContext::IgnitionStopAll(bool cancel)
+ {
+ return IgnitionStopAll(cancel, NULL);
+ }
+
+ void JniContext::IgnitionStopAll(bool cancel, JniErrorInfo* errInfo)
+ {
+ JNIEnv* env = Attach();
+
+ env->CallStaticVoidMethod(jvm->GetMembers().c_PlatformIgnition, jvm->GetMembers().m_PlatformIgnition_stopAll, cancel);
+
+ ExceptionCheck(env, errInfo);
+ }
+
+ void JniContext::ProcessorReleaseStart(jobject obj) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformProcessor_releaseStart);
+
+ ExceptionCheck(env);
+ }
+
+ jobject JniContext::ProcessorProjection(jobject obj) {
+ JNIEnv* env = Attach();
+
+ jobject prj = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformProcessor_projection);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, prj);
+ }
+
+ jobject JniContext::ProcessorCache0(jobject obj, const char* name, jmethodID mthd, JniErrorInfo* errInfo)
+ {
+ JNIEnv* env = Attach();
+
+ jstring name0 = name != NULL ? env->NewStringUTF(name) : NULL;
+
+ jobject cache = env->CallObjectMethod(obj, mthd, name0);
+
+ if (name0)
+ env->DeleteLocalRef(name0);
+
+ ExceptionCheck(env, errInfo);
+
+ return LocalToGlobal(env, cache);
+ }
+
+ jobject JniContext::ProcessorCache(jobject obj, const char* name) {
+ return ProcessorCache(obj, name, NULL);
+ }
+
+ jobject JniContext::ProcessorCache(jobject obj, const char* name, JniErrorInfo* errInfo) {
+ return ProcessorCache0(obj, name, jvm->GetMembers().m_PlatformProcessor_cache, errInfo);
+ }
+
+ jobject JniContext::ProcessorCreateCache(jobject obj, const char* name) {
+ return ProcessorCreateCache(obj, name, NULL);
+ }
+
+ jobject JniContext::ProcessorCreateCache(jobject obj, const char* name, JniErrorInfo* errInfo)
+ {
+ return ProcessorCache0(obj, name, jvm->GetMembers().m_PlatformProcessor_createCache, errInfo);
+ }
+
+ jobject JniContext::ProcessorGetOrCreateCache(jobject obj, const char* name) {
+ return ProcessorGetOrCreateCache(obj, name, NULL);
+ }
+
+ jobject JniContext::ProcessorGetOrCreateCache(jobject obj, const char* name, JniErrorInfo* errInfo)
+ {
+ return ProcessorCache0(obj, name, jvm->GetMembers().m_PlatformProcessor_getOrCreateCache, errInfo);
+ }
+
+ jobject JniContext::ProcessorAffinity(jobject obj, const char* name) {
+ JNIEnv* env = Attach();
+
+ jstring name0 = name != NULL ? env->NewStringUTF(name) : NULL;
+
+ jobject aff = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformProcessor_affinity, name0);
+
+ if (name0)
+ env->DeleteLocalRef(name0);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, aff);
+ }
+
+ jobject JniContext::ProcessorDataStreamer(jobject obj, const char* name, bool keepPortable) {
+ JNIEnv* env = Attach();
+
+ jstring name0 = name != NULL ? env->NewStringUTF(name) : NULL;
+
+ jobject ldr = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformProcessor_dataStreamer, name0,
+ keepPortable);
+
+ if (name0)
+ env->DeleteLocalRef(name0);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, ldr);
+ }
+
+ jobject JniContext::ProcessorTransactions(jobject obj) {
+ JNIEnv* env = Attach();
+
+ jobject tx = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformProcessor_transactions);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, tx);
+ }
+
+ jobject JniContext::ProcessorCompute(jobject obj, jobject prj) {
+ JNIEnv* env = Attach();
+
+ jobject res = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformProcessor_compute, prj);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, res);
+ }
+
+ jobject JniContext::ProcessorMessage(jobject obj, jobject prj) {
+ JNIEnv* env = Attach();
+
+ jobject res = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformProcessor_message, prj);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, res);
+ }
+
+ jobject JniContext::ProcessorEvents(jobject obj, jobject prj) {
+ JNIEnv* env = Attach();
+
+ jobject res = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformProcessor_events, prj);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, res);
+ }
+
+ jobject JniContext::ProcessorServices(jobject obj, jobject prj) {
+ JNIEnv* env = Attach();
+
+ jobject res = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformProcessor_services, prj);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, res);
+ }
+
+ jobject JniContext::ProcessorExtensions(jobject obj)
+ {
+ JNIEnv* env = Attach();
+
+ jobject res = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformProcessor_extensions);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, res);
+ }
+
+ long long JniContext::TargetInStreamOutLong(jobject obj, int opType, long long memPtr, JniErrorInfo* err) {
+ JNIEnv* env = Attach();
+
+ long long res = env->CallLongMethod(obj, jvm->GetMembers().m_PlatformTarget_inStreamOutLong, opType, memPtr);
+
+ ExceptionCheck(env, err);
+
+ return res;
+ }
+
+ void JniContext::TargetInStreamOutStream(jobject obj, int opType, long long inMemPtr, long long outMemPtr, JniErrorInfo* err) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformTarget_inStreamOutStream, opType, inMemPtr, outMemPtr);
+
+ ExceptionCheck(env, err);
+ }
+
+ jobject JniContext::TargetInStreamOutObject(jobject obj, int opType, long long memPtr, JniErrorInfo* err) {
+ JNIEnv* env = Attach();
+
+ jobject res = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformTarget_inStreamOutObject, opType, memPtr);
+
+ ExceptionCheck(env, err);
+
+ return LocalToGlobal(env, res);
+ }
+
+ void JniContext::TargetInObjectStreamOutStream(jobject obj, int opType, void* arg, long long inMemPtr, long long outMemPtr, JniErrorInfo* err) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformTarget_inObjectStreamOutStream, opType, arg, inMemPtr, outMemPtr);
+
+ ExceptionCheck(env, err);
+ }
+
+ long long JniContext::TargetOutLong(jobject obj, int opType, JniErrorInfo* err)
+ {
+ JNIEnv* env = Attach();
+
+ jlong res = env->CallLongMethod(obj, jvm->GetMembers().m_PlatformTarget_outLong, opType);
+
+ ExceptionCheck(env, err);
+
+ return res;
+ }
+
+ void JniContext::TargetOutStream(jobject obj, int opType, long long memPtr, JniErrorInfo* err) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformTarget_outStream, opType, memPtr);
+
+ ExceptionCheck(env, err);
+ }
+
+ jobject JniContext::TargetOutObject(jobject obj, int opType, JniErrorInfo* err)
+ {
+ JNIEnv* env = Attach();
+
+ jobject res = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformTarget_outObject, opType);
+
+ ExceptionCheck(env, err);
+
+ return LocalToGlobal(env, res);
+ }
+
+ void JniContext::TargetListenFuture(jobject obj, long long futId, int typ) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformTarget_listenFuture, futId, typ);
+
+ ExceptionCheck(env);
+ }
+
+ void JniContext::TargetListenFutureForOperation(jobject obj, long long futId, int typ, int opId) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformTarget_listenFutureForOperation, futId, typ, opId);
+
+ ExceptionCheck(env);
+ }
+
+ int JniContext::AffinityPartitions(jobject obj) {
+ JNIEnv* env = Attach();
+
+ jint parts = env->CallIntMethod(obj, jvm->GetMembers().m_PlatformAffinity_partitions);
+
+ ExceptionCheck(env);
+
+ return parts;
+ }
+
+ jobject JniContext::CacheWithSkipStore(jobject obj) {
+ JNIEnv* env = Attach();
+
+ jobject cache = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformCache_withSkipStore);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, cache);
+ }
+
+ jobject JniContext::CacheWithNoRetries(jobject obj) {
+ JNIEnv* env = Attach();
+
+ jobject cache = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformCache_withNoRetries);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, cache);
+ }
+
+ jobject JniContext::CacheWithExpiryPolicy(jobject obj, long long create, long long update, long long access) {
+ JNIEnv* env = Attach();
+
+ jobject cache = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformCache_withExpiryPolicy,
+ create, update, access);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, cache);
+ }
+
+ jobject JniContext::CacheWithAsync(jobject obj) {
+ JNIEnv* env = Attach();
+
+ jobject cache = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformCache_withAsync);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, cache);
+ }
+
+ jobject JniContext::CacheWithKeepPortable(jobject obj) {
+ JNIEnv* env = Attach();
+
+ jobject cache = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformCache_withKeepPortable);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, cache);
+ }
+
+ void JniContext::CacheClear(jobject obj, JniErrorInfo* err) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformCache_clear);
+
+ ExceptionCheck(env, err);
+ }
+
+ void JniContext::CacheRemoveAll(jobject obj, JniErrorInfo* err) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformCache_removeAll);
+
+ ExceptionCheck(env, err);
+ }
+
+ jobject JniContext::CacheOutOpQueryCursor(jobject obj, int type, long long memPtr, JniErrorInfo* err) {
+ JNIEnv* env = Attach();
+
+ jobject res = env->CallObjectMethod(
+ obj, jvm->GetMembers().m_PlatformTarget_inStreamOutObject, type, memPtr);
+
+ ExceptionCheck(env, err);
+
+ return LocalToGlobal(env, res);
+ }
+
+ jobject JniContext::CacheOutOpContinuousQuery(jobject obj, int type, long long memPtr) {
+ JNIEnv* env = Attach();
+
+ jobject res = env->CallObjectMethod(
+ obj, jvm->GetMembers().m_PlatformTarget_inStreamOutObject, type, memPtr);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, res);
+ }
+
+ jobject JniContext::CacheIterator(jobject obj) {
+ JNIEnv* env = Attach();
+
+ jobject res = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformCache_iterator);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, res);
+ }
+
+ jobject JniContext::CacheLocalIterator(jobject obj, int peekModes) {
+ JNIEnv*env = Attach();
+
+ jobject res = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformCache_localIterator, peekModes);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, res);
+ }
+
+ void JniContext::CacheEnterLock(jobject obj, long long id) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformCache_enterLock, id);
+
+ ExceptionCheck(env);
+ }
+
+ void JniContext::CacheExitLock(jobject obj, long long id) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformCache_exitLock, id);
+
+ ExceptionCheck(env);
+ }
+
+ bool JniContext::CacheTryEnterLock(jobject obj, long long id, long long timeout) {
+ JNIEnv* env = Attach();
+
+ jboolean res = env->CallBooleanMethod(obj, jvm->GetMembers().m_PlatformCache_tryEnterLock, id, timeout);
+
+ ExceptionCheck(env);
+
+ return res != 0;
+ }
+
+ void JniContext::CacheCloseLock(jobject obj, long long id) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformCache_closeLock, id);
+
+ ExceptionCheck(env);
+ }
+
+ void JniContext::CacheRebalance(jobject obj, long long futId) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformCache_rebalance, futId);
+
+ ExceptionCheck(env);
+ }
+
+ int JniContext::CacheSize(jobject obj, int peekModes, bool loc, JniErrorInfo* err) {
+ JNIEnv* env = Attach();
+
+ jint res = env->CallIntMethod(obj, jvm->GetMembers().m_PlatformCache_size, peekModes, loc);
+
+ ExceptionCheck(env, err);
+
+ return res;
+ }
+
+ void JniContext::CacheStoreCallbackInvoke(jobject obj, long long memPtr) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformCacheStoreCallback_invoke, memPtr);
+
+ ExceptionCheck(env);
+ }
+
+ void JniContext::ComputeWithNoFailover(jobject obj) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformCompute_withNoFailover);
+
+ ExceptionCheck(env);
+ }
+
+ void JniContext::ComputeWithTimeout(jobject obj, long long timeout) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformCompute_withTimeout, timeout);
+
+ ExceptionCheck(env);
+ }
+
+ void JniContext::ComputeExecuteNative(jobject obj, long long taskPtr, long long topVer) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformCompute_executeNative, taskPtr, topVer);
+
+ ExceptionCheck(env);
+ }
+
+ void JniContext::ContinuousQueryClose(jobject obj) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformContinuousQuery_close);
+
+ ExceptionCheck(env);
+ }
+
+ void* JniContext::ContinuousQueryGetInitialQueryCursor(jobject obj) {
+ JNIEnv* env = Attach();
+
+ jobject res = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformContinuousQuery_getInitialQueryCursor);
+
+ ExceptionCheck(env);
+
+ return res;
+ }
+
+ void JniContext::DataStreamerListenTopology(jobject obj, long long ptr) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformDataStreamer_listenTopology, ptr);
+
+ ExceptionCheck(env);
+ }
+
+ bool JniContext::DataStreamerAllowOverwriteGet(jobject obj) {
+ JNIEnv* env = Attach();
+
+ jboolean res = env->CallBooleanMethod(obj, jvm->GetMembers().m_PlatformDataStreamer_getAllowOverwrite);
+
+ ExceptionCheck(env);
+
+ return res != 0;
+ }
+
+ void JniContext::DataStreamerAllowOverwriteSet(jobject obj, bool val) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformDataStreamer_setAllowOverwrite, val);
+
+ ExceptionCheck(env);
+ }
+
+ bool JniContext::DataStreamerSkipStoreGet(jobject obj) {
+ JNIEnv* env = Attach();
+
+ jboolean res = env->CallBooleanMethod(obj, jvm->GetMembers().m_PlatformDataStreamer_getSkipStore);
+
+ ExceptionCheck(env);
+
+ return res != 0;
+ }
+
+ void JniContext::DataStreamerSkipStoreSet(jobject obj, bool val) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformDataStreamer_setSkipStore, val);
+
+ ExceptionCheck(env);
+ }
+
+ int JniContext::DataStreamerPerNodeBufferSizeGet(jobject obj) {
+ JNIEnv* env = Attach();
+
+ jint res = env->CallIntMethod(obj, jvm->GetMembers().m_PlatformDataStreamer_getPerNodeBufSize);
+
+ ExceptionCheck(env);
+
+ return res;
+ }
+
+ void JniContext::DataStreamerPerNodeBufferSizeSet(jobject obj, int val) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformDataStreamer_setPerNodeBufSize, val);
+
+ ExceptionCheck(env);
+ }
+
+ int JniContext::DataStreamerPerNodeParallelOperationsGet(jobject obj) {
+ JNIEnv* env = Attach();
+
+ jint res = env->CallIntMethod(obj, jvm->GetMembers().m_PlatformDataStreamer_getPerNodeParallelOps);
+
+ ExceptionCheck(env);
+
+ return res;
+ }
+
+ void JniContext::DataStreamerPerNodeParallelOperationsSet(jobject obj, int val) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformDataStreamer_setPerNodeParallelOps, val);
+
+ ExceptionCheck(env);
+ }
+
+ jobject JniContext::MessagingWithAsync(jobject obj) {
+ JNIEnv* env = Attach();
+
+ jobject msg = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformMessaging_withAsync);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, msg);
+ }
+
+ jobject JniContext::ProjectionForOthers(jobject obj, jobject prj) {
+ JNIEnv* env = Attach();
+
+ jobject newPrj = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformClusterGroup_forOthers, prj);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, newPrj);
+ }
+
+ jobject JniContext::ProjectionForRemotes(jobject obj) {
+ JNIEnv* env = Attach();
+
+ jobject newPrj = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformClusterGroup_forRemotes);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, newPrj);
+ }
+
+ jobject JniContext::ProjectionForDaemons(jobject obj) {
+ JNIEnv* env = Attach();
+
+ jobject newPrj = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformClusterGroup_forDaemons);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, newPrj);
+ }
+
+ jobject JniContext::ProjectionForRandom(jobject obj) {
+ JNIEnv* env = Attach();
+
+ jobject newPrj = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformClusterGroup_forRandom);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, newPrj);
+ }
+
+ jobject JniContext::ProjectionForOldest(jobject obj) {
+ JNIEnv* env = Attach();
+
+ jobject newPrj = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformClusterGroup_forOldest);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, newPrj);
+ }
+
+ jobject JniContext::ProjectionForYoungest(jobject obj) {
+ JNIEnv* env = Attach();
+
+ jobject newPrj = env->CallObjectMethod(obj, jvm->GetMembers().m_PlatformClusterGroup_forYoungest);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, newPrj);
+ }
+
+ void JniContext::ProjectionResetMetrics(jobject obj) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformClusterGroup_resetMetrics);
+
+ ExceptionCheck(env);
+ }
+
+ jobject JniContext::ProjectionOutOpRet(jobject obj, int type, long long memPtr) {
+ JNIEnv* env = Attach();
+
+ jobject res = env->CallObjectMethod(
+ obj, jvm->GetMembers().m_PlatformTarget_inStreamOutObject, type, memPtr);
+
+ ExceptionCheck(env);
+
+ return LocalToGlobal(env, res);
+ }
+
+
+ void JniContext::QueryCursorIterator(jobject obj, JniErrorInfo* errInfo) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformAbstractQryCursor_iter);
+
+ ExceptionCheck(env, errInfo);
+ }
+
+ bool JniContext::QueryCursorIteratorHasNext(jobject obj, JniErrorInfo* errInfo)
+ {
+ JNIEnv* env = Attach();
+
+ jboolean res = env->CallBooleanMethod(obj, jvm->GetMembers().m_PlatformAbstractQryCursor_iterHasNext);
+
+ ExceptionCheck(env, errInfo);
+
+ return res != 0;
+ }
+
+ void JniContext::QueryCursorClose(jobject obj, JniErrorInfo* errInfo) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformAbstractQryCursor_close);
+
+ ExceptionCheck(env, errInfo);
+ }
+
+ long long JniContext::TransactionsStart(jobject obj, int concurrency, int isolation, long long timeout, int txSize) {
+ JNIEnv* env = Attach();
+
+ long long id = env->CallLongMethod(obj, jvm->GetMembers().m_PlatformTransactions_txStart, concurrency, isolation, timeout, txSize);
+
+ ExceptionCheck(env);
+
+ return id;
+ }
+
+ int JniContext::TransactionsCommit(jobject obj, long long id) {
+ JNIEnv* env = Attach();
+
+ int res = env->CallIntMethod(obj, jvm->GetMembers().m_PlatformTransactions_txCommit, id);
+
+ ExceptionCheck(env);
+
+ return res;
+ }
+
+ void JniContext::TransactionsCommitAsync(jobject obj, long long id, long long futId) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformTransactions_txCommitAsync, id, futId);
+
+ ExceptionCheck(env);
+ }
+
+ int JniContext::TransactionsRollback(jobject obj, long long id) {
+ JNIEnv* env = Attach();
+
+ int res = env->CallIntMethod(obj, jvm->GetMembers().m_PlatformTransactions_txRollback, id);
+
+ ExceptionCheck(env);
+
+ return res;
+ }
+
+ void JniContext::TransactionsRollbackAsync(jobject obj, long long id, long long futId) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformTransactions_txRollbackAsync, id, futId);
+
+ ExceptionCheck(env);
+ }
+
+ int JniContext::TransactionsClose(jobject obj, long long id) {
+ JNIEnv* env = Attach();
+
+ jint state = env->CallIntMethod(obj, jvm->GetMembers().m_PlatformTransactions_txClose, id);
+
+ ExceptionCheck(env);
+
+ return state;
+ }
+
+ int JniContext::TransactionsState(jobject obj, long long id) {
+ JNIEnv* env = Attach();
+
+ jint state = env->CallIntMethod(obj, jvm->GetMembers().m_PlatformTransactions_txState, id);
+
+ ExceptionCheck(env);
+
+ return state;
+ }
+
+ bool JniContext::TransactionsSetRollbackOnly(jobject obj, long long id) {
+ JNIEnv* env = Attach();
+
+ jboolean res = env->CallBooleanMethod(obj, jvm->GetMembers().m_PlatformTransactions_txSetRollbackOnly, id);
+
+ ExceptionCheck(env);
+
+ return res != 0;
+ }
+
+ void JniContext::TransactionsResetMetrics(jobject obj) {
+ JNIEnv* env = Attach();
+
+ env->CallVoidMethod(obj, jvm->GetMembers().m_PlatformTransactions_resetMetrics);
+
+ ExceptionCheck(env);
+ }
+
+ jobject JniContext::EventsWithAsync(jobject obj) {
+ JNIEnv * env = Attach();
+
+ jobject res = env->CallObjectMethod(
<TRUNCATED>