ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From voze...@apache.org
Subject [13/31] ignite git commit: IGNITE-1786: Implemented ODBC driver.
Date Thu, 05 May 2016 13:46:50 GMT
http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/jni/include/ignite/jni/java.h
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/jni/include/ignite/jni/java.h b/modules/platforms/cpp/jni/include/ignite/jni/java.h
new file mode 100644
index 0000000..5ffbb8a
--- /dev/null
+++ b/modules/platforms/cpp/jni/include/ignite/jni/java.h
@@ -0,0 +1,745 @@
+/*
+ * 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_JNI_JAVA
+#define _IGNITE_JNI_JAVA
+
+#include <jni.h>
+
+#include "ignite/common/common.h"
+#include "ignite/ignite_error.h"
+
+namespace ignite
+{
+    namespace jni
+    {
+        namespace java
+        {
+            /* 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, void* proc, 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);
+
+            typedef void(JNICALL *OnClientDisconnectedHandler)(void* target);
+            typedef void(JNICALL *OnClientReconnectedHandler)(void* target, unsigned char clusterRestarted);
+
+            /**
+             * 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;
+
+                OnClientDisconnectedHandler onClientDisconnected;
+                OnClientReconnectedHandler onClientReconnected;
+            };
+
+            /**
+             * 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_createCacheFromConfig;
+                jmethodID m_PlatformProcessor_getOrCreateCacheFromConfig;
+                jmethodID m_PlatformProcessor_createNearCache;
+                jmethodID m_PlatformProcessor_getOrCreateNearCache;
+                jmethodID m_PlatformProcessor_destroyCache;
+                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;
+                jmethodID m_PlatformProcessor_atomicLong;
+                jmethodID m_PlatformProcessor_getIgniteConfiguration;
+                jmethodID m_PlatformProcessor_getCacheNames;
+                jmethodID m_PlatformProcessor_atomicSequence;
+                jmethodID m_PlatformProcessor_atomicReference;
+
+                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;
+                jmethodID m_PlatformTarget_listenFutureAndGet;
+                jmethodID m_PlatformTarget_listenFutureForOperationAndGet;
+
+                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;
+
+                jclass c_PlatformAtomicLong;
+                jmethodID m_PlatformAtomicLong_get;
+                jmethodID m_PlatformAtomicLong_incrementAndGet;
+                jmethodID m_PlatformAtomicLong_getAndIncrement;
+                jmethodID m_PlatformAtomicLong_addAndGet;
+                jmethodID m_PlatformAtomicLong_getAndAdd;
+                jmethodID m_PlatformAtomicLong_decrementAndGet;
+                jmethodID m_PlatformAtomicLong_getAndDecrement;
+                jmethodID m_PlatformAtomicLong_getAndSet;
+                jmethodID m_PlatformAtomicLong_compareAndSetAndGet;
+                jmethodID m_PlatformAtomicLong_isClosed;
+                jmethodID m_PlatformAtomicLong_close;
+
+                jclass c_PlatformAtomicSequence;
+                jmethodID m_PlatformAtomicSequence_get;
+                jmethodID m_PlatformAtomicSequence_incrementAndGet;
+                jmethodID m_PlatformAtomicSequence_getAndIncrement;
+                jmethodID m_PlatformAtomicSequence_addAndGet;
+                jmethodID m_PlatformAtomicSequence_getAndAdd;
+                jmethodID m_PlatformAtomicSequence_getBatchSize;
+                jmethodID m_PlatformAtomicSequence_setBatchSize;
+                jmethodID m_PlatformAtomicSequence_isClosed;
+                jmethodID m_PlatformAtomicSequence_close;
+
+                jclass c_PlatformAtomicReference;
+                jmethodID m_PlatformAtomicReference_isClosed;
+                jmethodID m_PlatformAtomicReference_close;
+
+                jclass c_PlatformListenable;
+                jmethodID m_PlatformListenable_cancel;
+                jmethodID m_PlatformListenable_isCancelled;
+
+                /**
+                 * 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* name, int factoryId, long long dataPtr);
+                jobject IgnitionStart(char* cfgPath, char* name, int factoryId, long long dataPtr, JniErrorInfo* errInfo);
+                jobject IgnitionInstance(char* name);
+                jobject IgnitionInstance(char* name, JniErrorInfo* errInfo);
+                long long IgnitionEnvironmentPointer(char* name);
+                long long IgnitionEnvironmentPointer(char* name, JniErrorInfo* errInfo);
+                bool IgnitionStop(char* name, bool cancel);
+                bool IgnitionStop(char* name, 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 ProcessorCreateCacheFromConfig(jobject obj, long long memPtr);
+                jobject ProcessorCreateCacheFromConfig(jobject obj, long long memPtr, JniErrorInfo* errInfo);
+                jobject ProcessorGetOrCreateCacheFromConfig(jobject obj, long long memPtr);
+                jobject ProcessorGetOrCreateCacheFromConfig(jobject obj, long long memPtr, JniErrorInfo* errInfo);
+                jobject ProcessorCreateNearCache(jobject obj, const char* name, long long memPtr);
+                jobject ProcessorGetOrCreateNearCache(jobject obj, const char* name, long long memPtr);
+                void ProcessorDestroyCache(jobject obj, const char* name);
+                void ProcessorDestroyCache(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);
+                jobject ProcessorAtomicLong(jobject obj, char* name, long long initVal, bool create);
+                jobject ProcessorAtomicSequence(jobject obj, char* name, long long initVal, bool create);
+                jobject ProcessorAtomicReference(jobject obj, char* name, long long memPtr, bool create);
+				void ProcessorGetIgniteConfiguration(jobject obj, long long memPtr);
+				void ProcessorGetCacheNames(jobject obj, long long memPtr);
+                
+                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);
+                void* TargetListenFutureAndGet(jobject obj, long long futId, int typ);
+                void* TargetListenFutureForOperationAndGet(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);
+                jobject 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);
+
+                long long AtomicLongGet(jobject obj);
+                long long AtomicLongIncrementAndGet(jobject obj);
+                long long AtomicLongGetAndIncrement(jobject obj);
+                long long AtomicLongAddAndGet(jobject obj, long long value);
+                long long AtomicLongGetAndAdd(jobject obj, long long value);
+                long long AtomicLongDecrementAndGet(jobject obj);
+                long long AtomicLongGetAndDecrement(jobject obj);
+                long long AtomicLongGetAndSet(jobject obj, long long value);
+                long long AtomicLongCompareAndSetAndGet(jobject obj, long long expVal, long long newVal);
+                bool AtomicLongIsClosed(jobject obj);
+                void AtomicLongClose(jobject obj);
+
+                long long AtomicSequenceGet(jobject obj);
+                long long AtomicSequenceIncrementAndGet(jobject obj);
+                long long AtomicSequenceGetAndIncrement(jobject obj);
+                long long AtomicSequenceAddAndGet(jobject obj, long long l);
+                long long AtomicSequenceGetAndAdd(jobject obj, long long l);
+                int AtomicSequenceGetBatchSize(jobject obj);
+                void AtomicSequenceSetBatchSize(jobject obj, int size);
+                bool AtomicSequenceIsClosed(jobject obj);
+                void AtomicSequenceClose(jobject obj);
+
+                bool AtomicReferenceIsClosed(jobject obj);
+                void AtomicReferenceClose(jobject obj);
+
+                bool ListenableCancel(jobject obj);
+                bool ListenableIsCancelled(jobject obj);
+
+                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);
+                jobject ProcessorCacheFromConfig0(jobject proc, long long memPtr, jmethodID mthd, JniErrorInfo* errInfo);
+                jobject ProcessorGetOrCreateNearCache0(jobject obj, const char* name, long long memPtr, jmethodID methodID);
+            };
+
+            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, jobject proc, 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);
+
+            JNIEXPORT void JNICALL JniOnClientDisconnected(JNIEnv *env, jclass cls, jlong envPtr);
+            JNIEXPORT void JNICALL JniOnClientReconnected(JNIEnv *env, jclass cls, jlong envPtr, jboolean clusterRestarted);
+        }
+    }
+}
+
+#endif //_IGNITE_JNI_JAVA
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/jni/include/ignite/jni/utils.h
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/jni/include/ignite/jni/utils.h b/modules/platforms/cpp/jni/include/ignite/jni/utils.h
new file mode 100644
index 0000000..ee40248
--- /dev/null
+++ b/modules/platforms/cpp/jni/include/ignite/jni/utils.h
@@ -0,0 +1,101 @@
+/*
+ * 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_JNI_UTILS
+#define _IGNITE_JNI_UTILS
+
+#include <string>
+
+#include <ignite/common/common.h>
+
+namespace ignite
+{
+    namespace jni
+    {
+        /**
+         * Helper class to manage attached threads.
+         */
+        class AttachHelper 
+        {
+        public:
+            /**
+             * Destructor.
+             */
+            ~AttachHelper();
+			
+            /**
+             * Callback invoked on successful thread attach ot JVM.
+             */
+            static void OnThreadAttach();
+        };
+
+        /**
+         * Attempts to find JVM library to load it into the process later.
+         * First search is performed using the passed path argument (is not NULL).
+         * Then JRE_HOME is evaluated. Last, JAVA_HOME is evaluated.
+         *
+         * @param Explicitly defined path (optional).
+         * @param found Whether library was found.
+         * @return Path to the file.
+         */
+        IGNITE_IMPORT_EXPORT std::string FindJvmLibrary(const std::string* path, bool* found);
+
+        /**
+         * Load JVM library into the process.
+         *
+         * @param path Optional path to the library.
+         * @return Whether load was successful.
+         */
+        IGNITE_IMPORT_EXPORT bool LoadJvmLibrary(const std::string& path);
+
+        /**
+         * Create Ignite classpath based on user input and home directory.
+         *
+         * @param usrCp User's classpath.
+         * @param home Ignite home directory.
+         * @return Classpath.
+         */
+        IGNITE_IMPORT_EXPORT std::string CreateIgniteClasspath(const std::string* usrCp, const std::string* home);
+
+        /**
+         * Create Ignite classpath based on user input and home directory.
+         *
+         * @param usrCp User's classpath.
+         * @param home Ignite home directory.
+         * @param test Whether test classpath must be used.
+         * @return Classpath.
+         */
+        IGNITE_IMPORT_EXPORT std::string CreateIgniteClasspath(const std::string* usrCp, const std::string* home, bool test);
+
+        /**
+         * Resolve IGNITE_HOME directory. Resolution is performed in several
+         * steps:
+         * 1) Check for path provided as argument.
+         * 2) Check for environment variable.
+         * 3) Check for current working directory.
+         * Result of these 3 checks are evaluated based on existence of certain
+         * predefined folders inside possible GG home. If they are found, 
+         * IGNITE_HOME is considered resolved.
+         *
+         * @param path Optional path to evaluate.
+         * @param found Whether IGNITE_HOME home was found.
+         * @return Resolved GG home.
+         */
+        IGNITE_IMPORT_EXPORT std::string ResolveIgniteHome(const std::string* path, bool* found);
+    }
+}
+
+#endif //_IGNITE_JNI_UTILS
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/jni/os/linux/src/utils.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/jni/os/linux/src/utils.cpp b/modules/platforms/cpp/jni/os/linux/src/utils.cpp
new file mode 100644
index 0000000..a0f74ef
--- /dev/null
+++ b/modules/platforms/cpp/jni/os/linux/src/utils.cpp
@@ -0,0 +1,417 @@
+/*
+ * 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 <pthread.h>
+
+#include <sys/stat.h>
+#include <dirent.h>
+#include <dlfcn.h>
+
+#include "ignite/common/utils.h"
+#include "ignite/jni/utils.h"
+#include "ignite/jni/java.h"
+
+using namespace ignite::common;
+using namespace ignite::jni::java;
+
+namespace ignite
+{
+    namespace jni
+    {
+        const char* JAVA_HOME = "JAVA_HOME";
+        const char* JAVA_DLL = "/jre/lib/amd64/server/libjvm.so";
+
+        const char* IGNITE_HOME = "IGNITE_HOME";
+
+        const char* PROBE_BIN = "/bin";
+        const char* PROBE_EXAMPLES = "/examples";
+
+        const char* IGNITE_NATIVE_TEST_CLASSPATH = "IGNITE_NATIVE_TEST_CLASSPATH";
+
+        /** 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;
+        
+        void DestroyAttachKey(void* key)
+        {
+            delete reinterpret_cast<AttachHelper*>(key);
+        }
+        
+        void AllocateAttachKey()
+        {
+            pthread_key_create(&attachKey, DestroyAttachKey);
+        }
+		
+        AttachHelper::~AttachHelper()
+        {
+            JniContext::Detach();
+        }
+        
+        void AttachHelper::OnThreadAttach()
+        {
+            pthread_once(&attachKeyInit, AllocateAttachKey);
+            
+            void* val = pthread_getspecific(attachKey);
+            
+            if (!val)
+                pthread_setspecific(attachKey, new AttachHelper());
+        }
+		
+        /**
+         * Helper method to set boolean result to reference with proper NULL-check.
+         *
+         * @param res Result.
+         * @param outRes Where to set the result.
+         */
+        inline void SetBoolResult(bool res, bool* outRes)
+        {
+            if (outRes)
+                *outRes = res;
+        }
+		
+        /**
+         * Helper function for GG home resolution. Checks whether certain folders
+         * exist in the path. Optionally goes upwards in directory hierarchy.
+         *
+         * @param path Path to evaluate.
+         * @param up Whether to go upwards.
+         * @res Resolution result.
+         * @return Resolved directory.
+         */
+        std::string ResolveIgniteHome0(const std::string& path, bool up, bool* res)
+        {
+            struct stat pathStat;
+            
+            if (stat(path.c_str(), &pathStat) != -1 && S_ISDIR(pathStat.st_mode)) 
+            {
+                // Remove trailing slashes, otherwise we will have an infinite loop.
+                std::string path0 = path;
+
+                while (true) {
+                    char lastChar = *path0.rbegin();
+
+                    if (lastChar == '/' || lastChar == ' ') {
+                        size_t off = path0.find_last_of(lastChar);
+
+                        path0.erase(off, 1);
+                    }
+                    else
+                        break;
+                }
+
+                std::string binStr = path0 + PROBE_BIN;
+                struct stat binStat;
+
+                std::string examplesStr = path0 + PROBE_EXAMPLES;
+                struct stat examplesStat;
+
+                if (stat(binStr.c_str(), &binStat) != -1 && S_ISDIR(binStat.st_mode) &&
+                    stat(examplesStr.c_str(), &examplesStat) != -1 && S_ISDIR(examplesStat.st_mode))
+                {
+                    SetBoolResult(true, res);
+
+                    return std::string(path0);
+                }
+
+                if (up)
+                {
+                    // Evaluate parent directory.
+                    size_t slashPos = path0.find_last_of("/");
+
+                    if (slashPos != std::string::npos)
+                    {
+                        std::string parent = path0.substr(0, slashPos);
+
+                        return ResolveIgniteHome0(parent, true, res);
+                    }
+                }
+
+            }
+
+            SetBoolResult(false, res);
+
+            return std::string();
+        }
+
+        /**
+         * Create classpath picking JARs from the given path.
+         *
+         * @path Path.
+         * @return Classpath;
+         */
+        std::string ClasspathJars(const std::string& path)
+        {
+            std::string res = std::string();
+
+            DIR* dir = opendir(path.c_str());
+
+            if (dir)
+            {
+                struct dirent* entry;
+
+                while ((entry = readdir(dir)) != NULL)
+                {
+                    if (strstr(entry->d_name, ".jar"))
+                    {
+                        res.append(path);
+                        res.append("/");
+                        res.append(entry->d_name);
+                        res.append(":");
+                    }
+                }
+
+                closedir(dir);
+            }
+
+            return res;
+        }
+
+        /**
+         * Create classpath picking compiled classes from the given path.
+         *
+         * @path Path.
+         * @return Classpath;
+         */
+        std::string ClasspathExploded(const std::string& path, bool down)
+        {
+            std::string res;
+
+            if (FileExists(path))
+            {
+                // 1. Append "target\classes".
+                std::string classesPath = path + "/target/classes";
+
+                if (FileExists(classesPath)) {
+                    res += classesPath;
+                    res += ":";
+                }
+
+                // 2. Append "target\test-classes"
+                std::string testClassesPath = path + "/target/test-classes";
+
+                if (FileExists(testClassesPath)) {
+                    res += testClassesPath;
+                    res += ":";
+                }
+
+                // 3. Append "target\libs"
+                std::string libsPath = path + "/target/libs";
+
+                if (FileExists(libsPath)) {
+                    std::string libsCp = ClasspathJars(libsPath);
+                    res += libsCp;
+                }
+
+                // 4. Do the same for child if needed.
+                if (down)
+                {
+                    DIR* dir = opendir(path.c_str());
+
+                    if (dir)
+                    {
+                        struct dirent* entry;
+
+                        while ((entry = readdir(dir)) != NULL)
+                        {
+                            std::string entryPath = entry->d_name;
+
+                            if (entryPath.compare(".") != 0 && entryPath.compare("..") != 0)
+                            {
+                                std::string entryFullPath = path + "/" + entryPath;
+
+                                struct stat entryFullStat;
+
+                                if (stat(entryFullPath.c_str(), &entryFullStat) != -1 && S_ISDIR(entryFullStat.st_mode))
+                                {
+                                    std::string childCp = ClasspathExploded(entryFullPath, false);
+
+                                    res += childCp;
+                                }
+                            }
+                        }
+
+                        closedir(dir);
+                    }
+                }
+            }
+
+            return res;
+        }
+
+        /**
+         * Helper function to create classpath based on Ignite home directory.
+         *
+         * @param home Home directory; expected to be valid.
+         * @param forceTest Force test classpath.
+         */
+        std::string CreateIgniteHomeClasspath(const std::string& home, bool forceTest)
+        {
+            std::string res = std::string();
+
+            // 1. Add exploded test directories.
+            if (forceTest)
+            {
+                std::string examplesPath = home + "/examples";
+                std::string examplesCp = ClasspathExploded(examplesPath, true);
+                res.append(examplesCp);
+
+                std::string modulesPath = home + "/modules";
+                std::string modulesCp = ClasspathExploded(modulesPath, true);
+                res.append(modulesCp);
+            }
+
+            // 2. Add regular jars from "libs" folder excluding "optional".
+            std::string libsPath = home + "/libs";
+
+            if (FileExists(libsPath))
+            {
+                res.append(ClasspathJars(libsPath));
+
+                // Append inner directories.
+                DIR* dir = opendir(libsPath.c_str());
+
+                if (dir)
+                {
+                    struct dirent* entry;
+
+                    while ((entry = readdir(dir)) != NULL)
+                    {
+                        std::string entryPath = entry->d_name;
+
+                        if (entryPath.compare(".") != 0 && entryPath.compare("..") != 0 &&
+                            entryPath.compare("optional") != 0)
+                        {
+                            std::string entryFullPath = libsPath;
+
+                            entryFullPath.append("/");
+                            entryFullPath.append(entryPath);
+
+                            struct stat entryFullStat;
+
+                            if (stat(entryFullPath.c_str(), &entryFullStat) != -1 && 
+                                S_ISDIR(entryFullStat.st_mode)) 
+                                res.append(ClasspathJars(entryFullPath));
+                        }                                                              
+                    }
+
+                    closedir(dir);
+                }
+            }
+
+            // 3. Return.
+            return res;
+        }
+
+        std::string FindJvmLibrary(const std::string* path, bool* found)
+        {
+            SetBoolResult(true, found); // Optimistically assume that we will find it.
+
+            if (path) {
+                // If path is provided explicitly, then check only it.
+                if (FileExists(*path))                            
+                    return std::string(path->data());
+            }
+            else
+            {
+                bool javaEnvFound;
+                std::string javaEnv = GetEnv(JAVA_HOME, javaEnvFound);
+
+                if (javaEnvFound)
+                {
+                    std::string javaDll = javaEnv + JAVA_DLL;
+
+                    if (FileExists(javaDll))
+                        return std::string(javaDll);
+                }
+            }
+
+            SetBoolResult(false, found);
+
+            return std::string();
+        }
+
+        bool LoadJvmLibrary(const std::string& path)
+        {
+            void* hnd = dlopen(path.c_str(), RTLD_LAZY);
+            
+            return hnd != NULL;
+        }                
+
+        std::string ResolveIgniteHome(const std::string* path, bool* found)
+        {
+            if (path)
+                // 1. Check passed argument.
+                return ResolveIgniteHome0(*path, false, found);
+            else
+            {
+                // 2. Check environment variable.
+                bool envFound;
+                std::string env = GetEnv(IGNITE_HOME, envFound);
+
+                if (envFound)
+                    return ResolveIgniteHome0(env, false, found);
+            }
+
+            SetBoolResult(false, found);
+                    
+            return std::string();
+        }
+
+        std::string CreateIgniteClasspath(const std::string* usrCp, const std::string* home)
+        {
+            bool forceTest = false;
+
+            if (home)
+            {
+                bool envFound;
+                std::string env = GetEnv(IGNITE_NATIVE_TEST_CLASSPATH, envFound);
+
+                forceTest = envFound && env.compare("true") == 0;
+            }
+
+            return CreateIgniteClasspath(usrCp, home, forceTest);
+        }
+
+        std::string CreateIgniteClasspath(const std::string* usrCp, const std::string* home, bool forceTest)
+        {
+            // 1. Append user classpath if it exists.
+            std::string cp = std::string();
+
+            if (usrCp)
+            {
+                cp.append(*usrCp);
+
+                if (*cp.rbegin() != ':')
+                    cp.append(":");
+            }
+
+            // 2. Append home classpath if home is defined.
+            if (home)
+            {
+                std::string homeCp = CreateIgniteHomeClasspath(*home, forceTest);
+
+                cp.append(homeCp);
+            }
+
+            // 3. Return.
+            return cp;
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/jni/os/win/src/utils.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/jni/os/win/src/utils.cpp b/modules/platforms/cpp/jni/os/win/src/utils.cpp
new file mode 100644
index 0000000..0647aa3
--- /dev/null
+++ b/modules/platforms/cpp/jni/os/win/src/utils.cpp
@@ -0,0 +1,428 @@
+/*
+ * 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/concurrent.h"
+#include "ignite/common/utils.h"
+
+#include "ignite/jni/utils.h"
+#include "ignite/jni/java.h"
+
+using namespace ignite::common;
+using namespace ignite::common::concurrent;
+
+using namespace ignite::jni::java;
+
+namespace ignite
+{
+    namespace jni
+    {
+        AttachHelper::~AttachHelper()
+        {
+            // No-op.
+        }
+
+        void AttachHelper::OnThreadAttach()
+        {
+            // No-op.
+        }
+
+        const char* JAVA_HOME = "JAVA_HOME";
+        const char* JAVA_DLL = "\\jre\\bin\\server\\jvm.dll";
+
+        const char* IGNITE_HOME = "IGNITE_HOME";
+
+        const char* PROBE_BIN = "\\bin";
+        const char* PROBE_EXAMPLES = "\\examples";
+
+        const char* IGNITE_NATIVE_TEST_CLASSPATH = "IGNITE_NATIVE_TEST_CLASSPATH";
+
+        /**
+         * Helper method to set boolean result to pointer with proper NULL-check.
+         *
+         * @param res Result.
+         * @param outRes Where to set the result.
+         */
+        inline void SetBoolResult(bool res, bool* outRes)
+        {
+            if (outRes)
+                *outRes = res;
+        }
+
+        /**
+         * Helper function for GG home resolution. Checks whether certain folders
+         * exist in the path. Optionally goes upwards in directory hierarchy.
+         *
+         * @param path Path to evaluate.
+         * @param up Whether to go upwards.
+         * @res Resolution result.
+         * @return Resolved directory.
+         */
+        std::string ResolveIgniteHome0(const std::string& path, bool up, bool* res)
+        {
+            DWORD attrs = GetFileAttributesA(path.c_str());
+
+            if (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY))
+            {
+                // Remove trailing slashes, otherwise we will have an infinite loop.
+                std::string path0 = path;
+
+                while (true) {
+                    char lastChar = *path0.rbegin();
+
+                    if (lastChar == '/' || lastChar == '\\' || lastChar == ' ') {
+                        size_t off = path0.find_last_of(lastChar);
+
+                        path0.erase(off, 1);
+                    }
+                    else
+                        break;
+                }
+
+                std::string binStr = path0 + PROBE_BIN;
+                DWORD binAttrs = GetFileAttributesA(binStr.c_str());
+
+                std::string examplesStr = path0 + PROBE_EXAMPLES;
+                DWORD examplesAttrs = GetFileAttributesA(examplesStr.c_str());
+
+                if (binAttrs != INVALID_FILE_ATTRIBUTES && (binAttrs & FILE_ATTRIBUTE_DIRECTORY) &&
+                    examplesAttrs != INVALID_FILE_ATTRIBUTES && (examplesAttrs & FILE_ATTRIBUTE_DIRECTORY))
+                {
+                    SetBoolResult(true, res);
+                    return std::string(path0);
+                }
+
+                if (up)
+                {
+                    // Evaluate parent directory.
+                    size_t slashPos = path0.find_last_of("/\\");
+
+                    if (slashPos != std::string::npos)
+                    {
+                        std::string parent = path0.substr(0, slashPos);
+
+                        return ResolveIgniteHome0(parent, true, res);
+                    }
+                }
+            }
+
+            SetBoolResult(false, res);
+
+            return std::string();
+        }
+
+        /**
+         * Create classpath picking JARs from the given path.
+         *
+         * @path Path.
+         * @return Classpath;
+         */
+        std::string ClasspathJars(const std::string& path)
+        {
+            std::string searchPath = path + "\\*.jar";
+
+            std::string res = std::string();
+
+            WIN32_FIND_DATAA findData;
+
+            HANDLE hnd = FindFirstFileA(searchPath.c_str(), &findData);
+
+            if (hnd != INVALID_HANDLE_VALUE)
+            {
+                do
+                {
+                    res.append(path);
+                    res.append("\\");
+                    res.append(findData.cFileName);
+                    res.append(";");
+                } while (FindNextFileA(hnd, &findData) != 0);
+
+                FindClose(hnd);
+            }
+
+            return res;
+        }
+
+        /**
+         * Create classpath picking compiled classes from the given path.
+         *
+         * @path Path.
+         * @return Classpath;
+         */
+        std::string ClasspathExploded(const std::string& path, bool down)
+        {
+            std::string res;
+
+            if (FileExists(path))
+            {
+                // 1. Append "target\classes".
+                std::string classesPath = path + "\\target\\classes";
+
+                if (FileExists(classesPath)) {
+                    res.append(classesPath);
+                    res.append(";");
+                }
+
+                // 2. Append "target\test-classes"
+                std::string testClassesPath = path + "\\target\\test-classes";
+
+                if (FileExists(testClassesPath)) {
+                    res.append(testClassesPath);
+                    res.append(";");
+                }
+
+                // 3. Append "target\libs"
+                std::string libsPath = path + "\\target\\libs";
+
+                if (FileExists(libsPath)) {
+                    std::string libsCp = ClasspathJars(libsPath);
+                    res.append(libsCp);
+                }
+
+                // 4. Do the same for child if needed.
+                if (down)
+                {
+                    std::string searchPath = path + "\\*";
+
+                    WIN32_FIND_DATAA findData;
+
+                    HANDLE hnd = FindFirstFileA(searchPath.c_str(), &findData);
+
+                    if (hnd != INVALID_HANDLE_VALUE)
+                    {
+                        do
+                        {
+                            if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+                            {
+                                std::string childPath = findData.cFileName;
+
+                                if (childPath.compare(".") != 0 &&
+                                    childPath.compare("..") != 0)
+                                {
+                                    std::string childCp =
+                                        ClasspathExploded(path + "\\" + childPath, false);
+
+                                    res.append(childCp);
+                                }
+                            }
+                        } while (FindNextFileA(hnd, &findData) != 0);
+
+                        FindClose(hnd);
+                    }
+                }
+            }
+
+            return res;
+        }
+
+        /**
+         * Helper function to create classpath based on Ignite home directory.
+         *
+         * @param home Home directory; expected to be valid.
+         * @param forceTest Force test classpath.
+         */
+        std::string CreateIgniteHomeClasspath(const std::string& home, bool forceTest)
+        {
+            std::string res = std::string();
+
+            // 1. Add exploded test directories.
+            if (forceTest)
+            {
+                std::string examplesPath = home + "\\examples";
+                std::string examplesCp = ClasspathExploded(examplesPath, true);
+                res.append(examplesCp);
+
+                std::string modulesPath = home + "\\modules";
+                std::string modulesCp = ClasspathExploded(modulesPath, true);
+                res.append(modulesCp);
+            }
+
+            // 2. Add regular jars from "libs" folder excluding "optional".
+            std::string libsPath = home + "\\libs";
+
+            if (FileExists(libsPath))
+            {
+                res.append(ClasspathJars(libsPath));
+
+                // Append inner directories.
+                std::string libsSearchPath = libsPath + "\\*";
+
+                WIN32_FIND_DATAA libsFindData;
+
+                HANDLE libsHnd = FindFirstFileA(libsSearchPath.c_str(), &libsFindData);
+
+                if (libsHnd != INVALID_HANDLE_VALUE)
+                {
+                    do
+                    {
+                        if (libsFindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+                        {
+                            std::string libsChildPath = libsFindData.cFileName;
+
+                            if (libsChildPath.compare(".") != 0 &&
+                                libsChildPath.compare("..") != 0 &&
+                                libsChildPath.compare("optional") != 0) {
+                                std::string libsFolder = libsPath + "\\" + libsChildPath;
+
+                                res.append(ClasspathJars(libsFolder));
+                            }
+                        }
+                    } while (FindNextFileA(libsHnd, &libsFindData) != 0);
+
+                    FindClose(libsHnd);
+                }
+            }
+
+            // 3. Return.
+            return res;
+        }
+
+        std::string FindJvmLibrary(const std::string* path, bool* found)
+        {
+            SetBoolResult(true, found); // Optimistically assume that we will find it.
+
+            if (path) {
+                // If path is provided explicitly, then check only it.
+                if (FileExists(*path))
+                    return std::string(path->data());
+            }
+            else
+            {
+                bool javaEnvFound;
+                std::string javaEnv = GetEnv(JAVA_HOME, javaEnvFound);
+
+                if (javaEnvFound)
+                {
+                    std::string javaDll = javaEnv + JAVA_DLL;
+
+                    if (FileExists(javaDll))
+                        return std::string(javaDll);
+                }
+            }
+
+            *found = false;
+
+            return std::string();
+        }
+
+        bool LoadJvmLibrary(const std::string& path)
+        {
+            HMODULE mod = LoadLibraryA(path.c_str());
+
+            return mod != NULL;
+        }
+
+        std::string CreateIgniteClasspath(const std::string* usrCp, const std::string* home)
+        {
+            bool forceTest = false;
+
+            if (home)
+            {
+                bool envFound;
+                std::string env = GetEnv(IGNITE_NATIVE_TEST_CLASSPATH, envFound);
+
+                forceTest = envFound && env.compare("true") == 0;
+            }
+
+            return CreateIgniteClasspath(usrCp, home, forceTest);
+        }
+
+        std::string CreateIgniteClasspath(const std::string* usrCp, const std::string* home, bool forceTest)
+        {
+            // 1. Append user classpath if it exists.
+            std::string cp = std::string();
+
+            if (usrCp)
+            {
+                cp.append(*usrCp);
+
+                if (*cp.rbegin() != ';')
+                    cp.append(";");
+            }
+
+            // 2. Append home classpath if home is defined.
+            if (home)
+            {
+                std::string homeCp = CreateIgniteHomeClasspath(*home, forceTest);
+
+                cp.append(homeCp);
+            }
+
+            // 3. Return.
+            return cp;
+        }
+
+        std::string ResolveIgniteHome(const std::string* path, bool* found)
+        {
+            if (path)
+                // 1. Check passed argument.
+                return ResolveIgniteHome0(*path, false, found);
+            else
+            {
+                // 2. Check environment variable.
+                bool envFound;
+                std::string env = GetEnv(IGNITE_HOME, envFound);
+
+                if (envFound)
+                    return ResolveIgniteHome0(env, false, found);
+
+                // 3. Check current work dir.
+                const DWORD curDirLen = GetCurrentDirectory(0, NULL);
+
+                char* curDir = new char[curDirLen];
+
+                GetCurrentDirectoryA(curDirLen, curDir);
+
+                std::string curDirStr = curDir;
+
+                delete[] curDir;
+
+                return ResolveIgniteHome0(curDirStr, true, found);
+            }
+        }
+    }
+}
+
+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/764c97b9/modules/platforms/cpp/jni/project/README.TXT
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/jni/project/README.TXT b/modules/platforms/cpp/jni/project/README.TXT
new file mode 100644
index 0000000..97f4c64
--- /dev/null
+++ b/modules/platforms/cpp/jni/project/README.TXT
@@ -0,0 +1 @@
+Contains IDE projects artifacts.

http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/jni/project/vs/README.TXT
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/jni/project/vs/README.TXT b/modules/platforms/cpp/jni/project/vs/README.TXT
new file mode 100644
index 0000000..f4fb456
--- /dev/null
+++ b/modules/platforms/cpp/jni/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/764c97b9/modules/platforms/cpp/jni/project/vs/jni.vcxproj
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/jni/project/vs/jni.vcxproj b/modules/platforms/cpp/jni/project/vs/jni.vcxproj
new file mode 100644
index 0000000..ac17ad3
--- /dev/null
+++ b/modules/platforms/cpp/jni/project/vs/jni.vcxproj
@@ -0,0 +1,205 @@
+<?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>jni</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'">
+    <TargetName>ignite.jni</TargetName>
+    <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <TargetName>ignite.jni</TargetName>
+    <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <TargetName>ignite.jni</TargetName>
+    <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <TargetName>ignite.jni</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)\..\..\..\common\include;$(ProjectDir)\..\..\..\common\os\win\include;$(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)\..\..\..\common\include;$(ProjectDir)\..\..\..\common\os\win\include;$(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)\..\..\..\common\include;$(ProjectDir)\..\..\..\common\os\win\include;$(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)\..\..\..\common\include;$(ProjectDir)\..\..\..\common\os\win\include;$(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\jni\exports.h" />
+    <ClInclude Include="..\..\include\ignite\jni\java.h" />
+    <ClInclude Include="..\..\include\ignite\jni\utils.h" />
+    <ClInclude Include="targetver.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\os\win\src\utils.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>
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\common\project\vs\common.vcxproj">
+      <Project>{b63f2e01-5157-4719-8491-0e1c7cd3b701}</Project>
+    </ProjectReference>
+  </ItemGroup>
+</Project>
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/jni/project/vs/jni.vcxproj.filters
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/jni/project/vs/jni.vcxproj.filters b/modules/platforms/cpp/jni/project/vs/jni.vcxproj.filters
new file mode 100644
index 0000000..7bc8dfd
--- /dev/null
+++ b/modules/platforms/cpp/jni/project/vs/jni.vcxproj.filters
@@ -0,0 +1,42 @@
+<?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="..\..\include\ignite\jni\exports.h">
+      <Filter>Code</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\jni\java.h">
+      <Filter>Code</Filter>
+    </ClInclude>
+    <ClInclude Include="targetver.h">
+      <Filter>Misc</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\jni\utils.h">
+      <Filter>Code</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\exports.cpp">
+      <Filter>Code</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\java.cpp">
+      <Filter>Code</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\os\win\src\utils.cpp">
+      <Filter>Code</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="module.def">
+      <Filter>Misc</Filter>
+    </None>
+  </ItemGroup>
+</Project>
\ No newline at end of file


Mime
View raw message