Merge branch 'master' into ignite-1786 # Conflicts: # modules/platforms/dotnet/Apache.Ignite.Core/Apache.Ignite.Core.csproj
Project: http://git-wip-us.apache.org/repos/asf/ignite/repo Commit: http://git-wip-us.apache.org/repos/asf/ignite/commit/b7450ef4 Tree: http://git-wip-us.apache.org/repos/asf/ignite/tree/b7450ef4 Diff: http://git-wip-us.apache.org/repos/asf/ignite/diff/b7450ef4 Branch: refs/heads/ignite-1786 Commit: b7450ef4ae2d242bbf240996e593e31116cd69a5 Parents: 72362d4 d081538 Author: vozerov-gridgain <[email protected]> Authored: Wed Apr 27 16:17:52 2016 +0300 Committer: vozerov-gridgain <[email protected]> Committed: Wed Apr 27 16:17:52 2016 +0300 ---------------------------------------------------------------------- .../configuration/CacheConfiguration.java | 2 + .../ignite/internal/IgniteEventsImpl.java | 11 +- .../ignite/internal/IgniteMessagingImpl.java | 7 +- .../org/apache/ignite/internal/IgnitionEx.java | 2 +- .../ignite/internal/binary/BinaryContext.java | 4 + .../internal/binary/GridBinaryMarshaller.java | 3 + .../continuous/CacheContinuousQueryManager.java | 1 + .../continuous/GridContinuousProcessor.java | 29 +- .../platform/PlatformContextImpl.java | 1 - .../PlatformDefaultJavaObjectFactory.java | 62 ++++ .../platform/PlatformJavaObjectFactoryEx.java | 36 +++ .../PlatformJavaObjectFactoryProxy.java | 192 +++++++++++ .../PlatformJavaObjectSingletonFactory.java | 48 +++ .../platform/PlatformNoopProcessor.java | 10 + .../processors/platform/PlatformProcessor.java | 19 ++ .../platform/PlatformProcessorImpl.java | 41 ++- .../query/PlatformContinuousQueryImpl.java | 50 ++- .../utils/PlatformConfigurationUtils.java | 93 +++++- .../platform/utils/PlatformUtils.java | 69 ++++ .../ignite/internal/util/IgniteUtils.java | 5 +- .../platform/PlatformJavaObjectFactory.java | 36 +++ .../ignite/spi/IgniteNodeValidationResult.java | 8 +- .../ignite/spi/discovery/tcp/ServerImpl.java | 250 ++++++++------ .../tcp/internal/TcpDiscoveryNode.java | 2 +- .../messages/TcpDiscoveryAbstractMessage.java | 4 +- .../TcpDiscoveryCustomEventMessage.java | 13 +- .../TcpDiscoveryJoinRequestMessage.java | 16 +- .../TcpDiscoveryStatusCheckMessage.java | 18 +- .../platform/PlatformCacheEntryEventFilter.java | 193 +++++++++++ .../PlatformCacheEntryEventFilterFactory.java | 59 ++++ ...latformDefaultJavaObjectFactorySelfTest.java | 185 +++++++++++ .../PlatformJavaObjectFactoryProxySelfTest.java | 220 +++++++++++++ .../platform/PlatformStartIgniteTask.java | 1 + .../ignite/platform/PlatformStopIgniteTask.java | 1 + .../platform/javaobject/TestJavaObject.java | 271 ++++++++++++++++ .../javaobject/TestJavaObjectNoDefaultCtor.java | 49 +++ .../TestJavaObjectNoDefaultCtorFactory.java | 68 ++++ .../ignite/testsuites/IgniteBasicTestSuite.java | 2 + .../testsuites/IgnitePlatformsTestSuite.java | 41 +++ .../common/include/ignite/common/concurrent.h | 176 ++++++++-- .../cpp/common/src/common/concurrent.cpp | 13 +- .../cpp/core-test/src/concurrent_test.cpp | 93 ++++++ .../cpp/jni/include/ignite/jni/exports.h | 2 + .../platforms/cpp/jni/include/ignite/jni/java.h | 5 + modules/platforms/cpp/jni/project/vs/module.def | 2 + modules/platforms/cpp/jni/src/exports.cpp | 8 + modules/platforms/cpp/jni/src/java.cpp | 30 ++ .../Apache.Ignite.Core.Tests.csproj | 2 + .../Cache/CacheConfigurationTest.cs | 49 +++ .../Cache/CacheNearTest.cs | 188 +++++++++++ .../Cache/Query/CacheLinqTest.cs | 2 - .../Continuous/ContinuousQueryJavaFilterTest.cs | 323 +++++++++++++++++++ .../Apache.Ignite.Core.Tests/EventsTest.cs | 4 +- .../dotnet/Apache.Ignite.Core.Tests/app.config | 4 + .../Apache.Ignite.Core.csproj | 16 +- .../Cache/Configuration/CacheConfiguration.cs | 15 + .../Configuration/NearCacheConfiguration.cs | 75 +++++ .../Cache/Eviction/EvictionPolicyBase.cs | 126 ++++++++ .../Cache/Eviction/FifoEvictionPolicy.cs | 39 +++ .../Cache/Eviction/IEvictionPolicy.cs | 32 ++ .../Cache/Eviction/LruEvictionPolicy.cs | 39 +++ .../Continuous/ContinuousQueryExtensions.cs | 42 +++ .../Apache.Ignite.Core/Events/CacheEvent.cs | 9 +- .../dotnet/Apache.Ignite.Core/IIgnite.cs | 42 +++ .../Impl/Binary/BinaryUtils.cs | 3 + .../Impl/Binary/Marshaller.cs | 2 + .../Cache/Event/JavaCacheEntryEventFilter.cs | 49 +++ .../Continuous/ContinuousQueryHandleImpl.cs | 17 +- .../Common/PlatformJavaObjectFactoryProxy.cs | 106 ++++++ .../dotnet/Apache.Ignite.Core/Impl/Ignite.cs | 62 ++++ .../Apache.Ignite.Core/Impl/IgniteProxy.cs | 25 ++ .../Impl/Unmanaged/IgniteJniNativeMethods.cs | 6 + .../Impl/Unmanaged/UnmanagedUtils.cs | 32 ++ .../Apache.Ignite.Core/Interop/JavaObject.cs | 80 +++++ .../ignite/schema/generator/CodeGenerator.java | 30 +- .../ignite/schema/generator/XmlGenerator.java | 2 +- 76 files changed, 3681 insertions(+), 191 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/ignite/blob/b7450ef4/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteBasicTestSuite.java ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/ignite/blob/b7450ef4/modules/platforms/cpp/common/include/ignite/common/concurrent.h ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/ignite/blob/b7450ef4/modules/platforms/cpp/common/src/common/concurrent.cpp ---------------------------------------------------------------------- diff --cc modules/platforms/cpp/common/src/common/concurrent.cpp index 3f85b65,0000000..5b62387 mode 100644,000000..100644 --- a/modules/platforms/cpp/common/src/common/concurrent.cpp +++ b/modules/platforms/cpp/common/src/common/concurrent.cpp @@@ -1,94 -1,0 +1,105 @@@ +/* + * 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) ++ SharedPointerImpl::SharedPointerImpl(void* ptr, DeleterType deleter) : ++ ptr(ptr), deleter(deleter), refCnt(1) + { + Memory::Fence(); + } + + void* SharedPointerImpl::Pointer() + { + return ptr; + } + ++ const void* SharedPointerImpl::Pointer() const ++ { ++ return ptr; ++ } ++ ++ SharedPointerImpl::DeleterType SharedPointerImpl::Deleter() ++ { ++ return deleter; ++ } ++ + void SharedPointerImpl::Increment() + { + Atomics::IncrementAndGet32(&refCnt); + } + + bool SharedPointerImpl::Decrement() + { + return Atomics::DecrementAndGet32(&refCnt) == 0; + } + } + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/b7450ef4/modules/platforms/cpp/jni/include/ignite/jni/exports.h ---------------------------------------------------------------------- diff --cc modules/platforms/cpp/jni/include/ignite/jni/exports.h index bcbf390,0000000..6b223a7 mode 100644,000000..100644 --- a/modules/platforms/cpp/jni/include/ignite/jni/exports.h +++ b/modules/platforms/cpp/jni/include/ignite/jni/exports.h @@@ -1,182 -1,0 +1,184 @@@ +/* + * 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_EXPORTS +#define _IGNITE_JNI_EXPORTS + +#include "ignite/jni/java.h" + +namespace gcj = ignite::jni::java; + +extern "C" { + int IGNITE_CALL IgniteReallocate(long long memPtr, int cap); + + void* IGNITE_CALL IgniteIgnitionStart(gcj::JniContext* ctx, char* cfgPath, char* name, int factoryId, long long dataPtr); + void* IGNITE_CALL IgniteIgnitionInstance(gcj::JniContext* ctx, char* name); + long long IGNITE_CALL IgniteIgnitionEnvironmentPointer(gcj::JniContext* ctx, char* name); + bool IGNITE_CALL IgniteIgnitionStop(gcj::JniContext* ctx, char* name, 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 IgniteProcessorCreateCacheFromConfig(gcj::JniContext* ctx, void* obj, long long memPtr); + void* IGNITE_CALL IgniteProcessorGetOrCreateCacheFromConfig(gcj::JniContext* ctx, void* obj, long long memPtr); ++ void* IGNITE_CALL IgniteProcessorCreateNearCache(gcj::JniContext* ctx, void* obj, char* name, long long memPtr); ++ void* IGNITE_CALL IgniteProcessorGetOrCreateNearCache(gcj::JniContext* ctx, void* obj, char* name, long long memPtr); + void IGNITE_CALL IgniteProcessorDestroyCache(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); + void* IGNITE_CALL IgniteProcessorAtomicLong(gcj::JniContext* ctx, void* obj, char* name, long long initVal, bool create); + void* IGNITE_CALL IgniteProcessorAtomicSequence(gcj::JniContext* ctx, void* obj, char* name, long long initVal, bool create); + void* IGNITE_CALL IgniteProcessorAtomicReference(gcj::JniContext* ctx, void* obj, char* name, long long memPtr, bool create); + void IGNITE_CALL IgniteProcessorGetIgniteConfiguration(gcj::JniContext* ctx, void* obj, long long memPtr); + + 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); + void* IGNITE_CALL IgniteTargetListenFutureAndGet(gcj::JniContext* ctx, void* obj, long long futId, int typ); + void* IGNITE_CALL IgniteTargetListenFutureForOperationAndGet(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); + + long long IGNITE_CALL IgniteAtomicLongGet(gcj::JniContext* ctx, void* obj); + long long IGNITE_CALL IgniteAtomicLongIncrementAndGet(gcj::JniContext* ctx, void* obj); + long long IGNITE_CALL IgniteAtomicLongGetAndIncrement(gcj::JniContext* ctx, void* obj); + long long IGNITE_CALL IgniteAtomicLongAddAndGet(gcj::JniContext* ctx, void* obj, long long value); + long long IGNITE_CALL IgniteAtomicLongGetAndAdd(gcj::JniContext* ctx, void* obj, long long value); + long long IGNITE_CALL IgniteAtomicLongDecrementAndGet(gcj::JniContext* ctx, void* obj); + long long IGNITE_CALL IgniteAtomicLongGetAndDecrement(gcj::JniContext* ctx, void* obj); + long long IGNITE_CALL IgniteAtomicLongGetAndSet(gcj::JniContext* ctx, void* obj, long long value); + long long IGNITE_CALL IgniteAtomicLongCompareAndSetAndGet(gcj::JniContext* ctx, void* obj, long long expVal, long long newVal); + bool IGNITE_CALL IgniteAtomicLongIsClosed(gcj::JniContext* ctx, void* obj); + void IGNITE_CALL IgniteAtomicLongClose(gcj::JniContext* ctx, void* obj); + + long long IGNITE_CALL IgniteAtomicSequenceGet(gcj::JniContext* ctx, void* obj); + long long IGNITE_CALL IgniteAtomicSequenceIncrementAndGet(gcj::JniContext* ctx, void* obj); + long long IGNITE_CALL IgniteAtomicSequenceGetAndIncrement(gcj::JniContext* ctx, void* obj); + long long IGNITE_CALL IgniteAtomicSequenceAddAndGet(gcj::JniContext* ctx, void* obj, long long l); + long long IGNITE_CALL IgniteAtomicSequenceGetAndAdd(gcj::JniContext* ctx, void* obj, long long l); + int IGNITE_CALL IgniteAtomicSequenceGetBatchSize(gcj::JniContext* ctx, void* obj); + void IGNITE_CALL IgniteAtomicSequenceSetBatchSize(gcj::JniContext* ctx, void* obj, int size); + bool IGNITE_CALL IgniteAtomicSequenceIsClosed(gcj::JniContext* ctx, void* obj); + void IGNITE_CALL IgniteAtomicSequenceClose(gcj::JniContext* ctx, void* obj); + + bool IGNITE_CALL IgniteAtomicReferenceIsClosed(gcj::JniContext* ctx, void* obj); + void IGNITE_CALL IgniteAtomicReferenceClose(gcj::JniContext* ctx, void* obj); + + bool IGNITE_CALL IgniteListenableCancel(gcj::JniContext* ctx, void* obj); + bool IGNITE_CALL IgniteListenableIsCancelled(gcj::JniContext* ctx, void* obj); +} + +#endif //_IGNITE_JNI_EXPORTS http://git-wip-us.apache.org/repos/asf/ignite/blob/b7450ef4/modules/platforms/cpp/jni/include/ignite/jni/java.h ---------------------------------------------------------------------- diff --cc modules/platforms/cpp/jni/include/ignite/jni/java.h index 867f46c,0000000..3acbce3 mode 100644,000000..100644 --- a/modules/platforms/cpp/jni/include/ignite/jni/java.h +++ b/modules/platforms/cpp/jni/include/ignite/jni/java.h @@@ -1,738 -1,0 +1,743 @@@ +/* + * 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_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); + + 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 http://git-wip-us.apache.org/repos/asf/ignite/blob/b7450ef4/modules/platforms/cpp/jni/project/vs/module.def ---------------------------------------------------------------------- diff --cc modules/platforms/cpp/jni/project/vs/module.def index 9b9f6dd,0000000..3579468 mode 100644,000000..100644 --- a/modules/platforms/cpp/jni/project/vs/module.def +++ b/modules/platforms/cpp/jni/project/vs/module.def @@@ -1,132 -1,0 +1,134 @@@ +LIBRARY ignite.jni.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 +IgniteProcessorAtomicLong @98 +IgniteAtomicLongGet @99 +IgniteAtomicLongIncrementAndGet @100 +IgniteAtomicLongGetAndIncrement @101 +IgniteAtomicLongAddAndGet @102 +IgniteAtomicLongGetAndAdd @103 +IgniteAtomicLongDecrementAndGet @104 +IgniteAtomicLongGetAndDecrement @105 +IgniteAtomicLongGetAndSet @106 +IgniteAtomicLongCompareAndSetAndGet @107 +IgniteAtomicLongIsClosed @108 +IgniteAtomicLongClose @109 +IgniteListenableCancel @110 +IgniteListenableIsCancelled @111 +IgniteTargetListenFutureAndGet @112 +IgniteTargetListenFutureForOperationAndGet @113 +IgniteProcessorCreateCacheFromConfig @114 +IgniteProcessorGetOrCreateCacheFromConfig @115 +IgniteProcessorGetIgniteConfiguration @116 +IgniteProcessorDestroyCache @117 +IgniteProcessorAtomicSequence @118 +IgniteAtomicSequenceGet @119 +IgniteAtomicSequenceIncrementAndGet @120 +IgniteAtomicSequenceGetAndIncrement @121 +IgniteAtomicSequenceAddAndGet @122 +IgniteAtomicSequenceGetAndAdd @123 +IgniteAtomicSequenceGetBatchSize @124 +IgniteAtomicSequenceSetBatchSize @125 +IgniteAtomicSequenceIsClosed @126 +IgniteAtomicSequenceClose @127 +IgniteProcessorAtomicReference @128 +IgniteAtomicReferenceIsClosed @129 +IgniteAtomicReferenceClose @130 ++IgniteProcessorCreateNearCache @131 ++IgniteProcessorGetOrCreateNearCache @132
