ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From voze...@apache.org
Subject [1/3] ignite git commit: IGNITE-1364: GridError -> IgniteError.
Date Thu, 03 Sep 2015 11:09:35 GMT
Repository: ignite
Updated Branches:
  refs/heads/ignite-1364 a79962c59 -> 863189fdd


http://git-wip-us.apache.org/repos/asf/ignite/blob/863189fd/modules/platform/src/main/cpp/core/src/impl/cache/cache_impl.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core/src/impl/cache/cache_impl.cpp b/modules/platform/src/main/cpp/core/src/impl/cache/cache_impl.cpp
index 176ab93..bf7a126 100644
--- a/modules/platform/src/main/cpp/core/src/impl/cache/cache_impl.cpp
+++ b/modules/platform/src/main/cpp/core/src/impl/cache/cache_impl.cpp
@@ -136,165 +136,165 @@ namespace ignite
                 return name;
             }
 
-            bool CacheImpl::IsEmpty(GridError* err)
+            bool CacheImpl::IsEmpty(IgniteError* err)
             {
                 return Size(IGNITE_PEEK_MODE_ALL, err) == 0;
             }
 
-            bool CacheImpl::ContainsKey(InputOperation& inOp, GridError* err)
+            bool CacheImpl::ContainsKey(InputOperation& inOp, IgniteError* err)
             {
                 return OutOpInternal(OP_CONTAINS_KEY, inOp, err);
             }
 
-            bool CacheImpl::ContainsKeys(InputOperation& inOp, GridError* err)
+            bool CacheImpl::ContainsKeys(InputOperation& inOp, IgniteError* err)
             {
                 return OutOpInternal(OP_CONTAINS_KEYS, inOp, err);
             }
 
-            void CacheImpl::LocalPeek(InputOperation& inOp, OutputOperation& outOp,
int32_t peekModes, GridError* err)
+            void CacheImpl::LocalPeek(InputOperation& inOp, OutputOperation& outOp,
int32_t peekModes, IgniteError* err)
             {
                 OutInOpInternal(OP_LOCAL_PEEK, inOp, outOp, err);
             }
 
-            void CacheImpl::Get(InputOperation& inOp, OutputOperation& outOp, GridError*
err)
+            void CacheImpl::Get(InputOperation& inOp, OutputOperation& outOp, IgniteError*
err)
             {
                 OutInOpInternal(OP_GET, inOp, outOp, err);
             }
 
-            void CacheImpl::GetAll(InputOperation& inOp, OutputOperation& outOp,
GridError* err)
+            void CacheImpl::GetAll(InputOperation& inOp, OutputOperation& outOp,
IgniteError* err)
             {
                 OutInOpInternal(OP_GET_ALL, inOp, outOp, err);
             }
 
-            void CacheImpl::Put(InputOperation& inOp, GridError* err)
+            void CacheImpl::Put(InputOperation& inOp, IgniteError* err)
             {
                 OutOpInternal(OP_PUT, inOp, err);
             }
 
-            void CacheImpl::PutAll(ignite::impl::InputOperation& inOp, GridError* err)
+            void CacheImpl::PutAll(ignite::impl::InputOperation& inOp, IgniteError* err)
             {
                 OutOpInternal(OP_PUT_ALL, inOp, err);
             }
 
-            void CacheImpl::GetAndPut(InputOperation& inOp, OutputOperation& outOp,
GridError* err)
+            void CacheImpl::GetAndPut(InputOperation& inOp, OutputOperation& outOp,
IgniteError* err)
             {
                 OutInOpInternal(OP_GET_AND_PUT, inOp, outOp, err);
             }
 
-            void CacheImpl::GetAndReplace(InputOperation& inOp, OutputOperation&
outOp, GridError* err)
+            void CacheImpl::GetAndReplace(InputOperation& inOp, OutputOperation&
outOp, IgniteError* err)
             {
                 OutInOpInternal(OP_GET_AND_REPLACE, inOp, outOp, err);
             }
 
-            void CacheImpl::GetAndRemove(InputOperation& inOp, OutputOperation& outOp,
GridError* err)
+            void CacheImpl::GetAndRemove(InputOperation& inOp, OutputOperation& outOp,
IgniteError* err)
             {
                 OutInOpInternal(OP_GET_AND_REMOVE, inOp, outOp, err);
             }
 
-            bool CacheImpl::PutIfAbsent(InputOperation& inOp, GridError* err)
+            bool CacheImpl::PutIfAbsent(InputOperation& inOp, IgniteError* err)
             {
                 return OutOpInternal(OP_PUT_IF_ABSENT, inOp, err);
             }
 
-            void CacheImpl::GetAndPutIfAbsent(InputOperation& inOp, OutputOperation&
outOp, GridError* err)
+            void CacheImpl::GetAndPutIfAbsent(InputOperation& inOp, OutputOperation&
outOp, IgniteError* err)
             {
                 OutInOpInternal(OP_GET_AND_PUT_IF_ABSENT, inOp, outOp, err);
             }
 
-            bool CacheImpl::Replace(InputOperation& inOp, GridError* err)
+            bool CacheImpl::Replace(InputOperation& inOp, IgniteError* err)
             {
                 return OutOpInternal(OP_REPLACE_2, inOp, err);
             }
 
-            bool CacheImpl::ReplaceIfEqual(InputOperation& inOp, GridError* err)
+            bool CacheImpl::ReplaceIfEqual(InputOperation& inOp, IgniteError* err)
             {
                 return OutOpInternal(OP_REPLACE_3, inOp, err);
             }
 
-            void CacheImpl::LocalEvict(InputOperation& inOp, GridError* err)
+            void CacheImpl::LocalEvict(InputOperation& inOp, IgniteError* err)
             {
                 OutOpInternal(OP_LOCAL_EVICT, inOp, err);
             }
 
-            void CacheImpl::Clear(GridError* err)
+            void CacheImpl::Clear(IgniteError* err)
             {
                 JniErrorInfo jniErr;
 
                 env.Get()->Context()->CacheClear(javaRef, &jniErr);
 
-                GridError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
+                IgniteError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
             }
 
-            void CacheImpl::Clear(InputOperation& inOp, GridError* err)
+            void CacheImpl::Clear(InputOperation& inOp, IgniteError* err)
             {
                 OutOpInternal(OP_CLEAR, inOp, err);
             }
 
-            void CacheImpl::ClearAll(InputOperation& inOp, GridError* err)
+            void CacheImpl::ClearAll(InputOperation& inOp, IgniteError* err)
             {
                 OutOpInternal(OP_CLEAR_ALL, inOp, err);
             }
 
-            void CacheImpl::LocalClear(InputOperation& inOp, GridError* err)
+            void CacheImpl::LocalClear(InputOperation& inOp, IgniteError* err)
             {
                 OutOpInternal(OP_LOCAL_CLEAR, inOp, err);
             }
 
-            void CacheImpl::LocalClearAll(InputOperation& inOp, GridError* err)
+            void CacheImpl::LocalClearAll(InputOperation& inOp, IgniteError* err)
             {
                 OutOpInternal(OP_LOCAL_CLEAR_ALL, inOp, err);
             }
 
-            bool CacheImpl::Remove(InputOperation& inOp, GridError* err)
+            bool CacheImpl::Remove(InputOperation& inOp, IgniteError* err)
             {
                 return OutOpInternal(OP_REMOVE_1, inOp, err);
             }
 
-            bool CacheImpl::RemoveIfEqual(InputOperation& inOp, GridError* err)
+            bool CacheImpl::RemoveIfEqual(InputOperation& inOp, IgniteError* err)
             {
                 return OutOpInternal(OP_REMOVE_2, inOp, err);
             }
 
-            void CacheImpl::RemoveAll(InputOperation& inOp, GridError* err)
+            void CacheImpl::RemoveAll(InputOperation& inOp, IgniteError* err)
             {
                 OutOpInternal(OP_REMOVE_ALL, inOp, err);
             }
 
-            void CacheImpl::RemoveAll(GridError* err)
+            void CacheImpl::RemoveAll(IgniteError* err)
             {
                 JniErrorInfo jniErr;
 
                 env.Get()->Context()->CacheRemoveAll(javaRef, &jniErr);
 
-                GridError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
+                IgniteError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
             }
 
-            int32_t CacheImpl::Size(const int32_t peekModes, GridError* err)
+            int32_t CacheImpl::Size(const int32_t peekModes, IgniteError* err)
             {
                 return SizeInternal(peekModes, false, err);
             }
 
-            int32_t CacheImpl::LocalSize(const int32_t peekModes, GridError* err)
+            int32_t CacheImpl::LocalSize(const int32_t peekModes, IgniteError* err)
             {
                 return SizeInternal(peekModes, true, err);
             }
 
-            QueryCursorImpl* CacheImpl::QuerySql(const SqlQuery& qry, GridError* err)
+            QueryCursorImpl* CacheImpl::QuerySql(const SqlQuery& qry, IgniteError* err)
             {
                 return QueryInternal(qry, OP_QRY_SQL, err);
             }
 
-            QueryCursorImpl* CacheImpl::QueryText(const TextQuery& qry, GridError* err)
+            QueryCursorImpl* CacheImpl::QueryText(const TextQuery& qry, IgniteError*
err)
             {
                 return QueryInternal(qry, OP_QRY_TEXT, err);
             }
 
-            QueryCursorImpl* CacheImpl::QueryScan(const ScanQuery& qry, GridError* err)
+            QueryCursorImpl* CacheImpl::QueryScan(const ScanQuery& qry, IgniteError*
err)
             {
                 return QueryInternal(qry, OP_QRY_SCAN, err);
             }
 
-            int64_t CacheImpl::WriteTo(InteropMemory* mem, InputOperation& inOp, GridError*
err)
+            int64_t CacheImpl::WriteTo(InteropMemory* mem, InputOperation& inOp, IgniteError*
err)
             {
                 PortableMetadataManager* metaMgr = env.Get()->GetMetadataManager();
 
@@ -327,13 +327,13 @@ namespace ignite
                 outOp.ProcessOutput(reader);
             }
 
-            int CacheImpl::SizeInternal(const int32_t peekModes, const bool loc, GridError*
err)
+            int CacheImpl::SizeInternal(const int32_t peekModes, const bool loc, IgniteError*
err)
             {
                 JniErrorInfo jniErr;
 
                 int res = env.Get()->Context()->CacheSize(javaRef, peekModes, loc,
&jniErr);
 
-                GridError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
+                IgniteError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
 
                 if (jniErr.code == IGNITE_JNI_ERR_SUCCESS)
                     return res;
@@ -341,7 +341,7 @@ namespace ignite
                     return -1;
             }
 
-            bool CacheImpl::OutOpInternal(const int32_t opType, InputOperation& inOp,
GridError* err)
+            bool CacheImpl::OutOpInternal(const int32_t opType, InputOperation& inOp,
IgniteError* err)
             {
                 JniErrorInfo jniErr;
 
@@ -353,7 +353,7 @@ namespace ignite
                 {
                     long long res = env.Get()->Context()->TargetInStreamOutLong(javaRef,
opType, outPtr, &jniErr);
 
-                    GridError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
+                    IgniteError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
 
                     if (jniErr.code == IGNITE_JNI_ERR_SUCCESS)
                         return res == 1;
@@ -363,7 +363,7 @@ namespace ignite
             }
 
             void CacheImpl::OutInOpInternal(const int32_t opType, InputOperation& inOp,
OutputOperation& outOp, 
-                GridError* err)
+                IgniteError* err)
             {
                 JniErrorInfo jniErr;
 
@@ -377,7 +377,7 @@ namespace ignite
                     env.Get()->Context()->TargetInStreamOutStream(javaRef, opType,
WriteTo(outMem.Get(), inOp, err), 
                         inMem.Get()->PointerLong(), &jniErr);
 
-                    GridError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
+                    IgniteError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
 
                     if (jniErr.code == IGNITE_JNI_ERR_SUCCESS)
                         ReadFrom(inMem.Get(), outOp);

http://git-wip-us.apache.org/repos/asf/ignite/blob/863189fd/modules/platform/src/main/cpp/core/src/impl/cache/query/query_impl.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core/src/impl/cache/query/query_impl.cpp b/modules/platform/src/main/cpp/core/src/impl/cache/query/query_impl.cpp
index 6196902..eb42a3e 100644
--- a/modules/platform/src/main/cpp/core/src/impl/cache/query/query_impl.cpp
+++ b/modules/platform/src/main/cpp/core/src/impl/cache/query/query_impl.cpp
@@ -51,12 +51,12 @@ namespace ignite
                     JniContext::Release(javaRef);
                 }
 
-                bool QueryCursorImpl::HasNext(GridError* err)
+                bool QueryCursorImpl::HasNext(IgniteError* err)
                 {
                     // Check whether GetAll() was called earlier.
                     if (getAllCalled) 
                     {
-                        *err = GridError(GridError::IGNITE_ERR_GENERIC, 
+                        *err = IgniteError(IgniteError::IGNITE_ERR_GENERIC, 
                             "Cannot use HasNext() method because GetAll() was called.");
 
                         return false;
@@ -69,12 +69,12 @@ namespace ignite
                     return hasNext;
                 }
 
-                void QueryCursorImpl::GetNext(OutputOperation& op, GridError* err)
+                void QueryCursorImpl::GetNext(OutputOperation& op, IgniteError* err)
                 {
                     // Check whether GetAll() was called earlier.
                     if (getAllCalled) 
                     {
-                        *err = GridError(GridError::IGNITE_ERR_GENERIC, 
+                        *err = IgniteError(IgniteError::IGNITE_ERR_GENERIC, 
                             "Cannot use GetNext() method because GetAll() was called.");
 
                         return;
@@ -92,7 +92,7 @@ namespace ignite
 
                         env.Get()->Context()->TargetOutStream(javaRef, OP_GET_SINGLE,
inMem.Get()->PointerLong(), &jniErr);
 
-                        GridError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
+                        IgniteError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg,
err);
 
                         if (jniErr.code == IGNITE_JNI_ERR_SUCCESS)
                         {
@@ -108,17 +108,17 @@ namespace ignite
                     else
                     {
                         // Ensure we do not overwrite possible previous error.
-                        if (err->GetCode() == GridError::IGNITE_SUCCESS)
-                            *err = GridError(GridError::IGNITE_ERR_GENERIC, "No more elements
available.");
+                        if (err->GetCode() == IgniteError::IGNITE_SUCCESS)
+                            *err = IgniteError(IgniteError::IGNITE_ERR_GENERIC, "No more
elements available.");
                     }
                 }
 
-                void QueryCursorImpl::GetAll(OutputOperation& op, GridError* err)
+                void QueryCursorImpl::GetAll(OutputOperation& op, IgniteError* err)
                 {
                     // Check whether any of iterator methods were called.
                     if (iterCalled)
                     {
-                        *err = GridError(GridError::IGNITE_ERR_GENERIC,
+                        *err = IgniteError(IgniteError::IGNITE_ERR_GENERIC,
                             "Cannot use GetAll() method because an iteration method was called.");
 
                         return;
@@ -127,7 +127,7 @@ namespace ignite
                     // Check whether GetAll was called before.
                     if (getAllCalled)
                     {
-                        *err = GridError(GridError::IGNITE_ERR_GENERIC,
+                        *err = IgniteError(IgniteError::IGNITE_ERR_GENERIC,
                             "Cannot use GetNext() method because GetAll() was called.");
 
                         return;
@@ -140,7 +140,7 @@ namespace ignite
 
                     env.Get()->Context()->TargetOutStream(javaRef, OP_GET_ALL, inMem.Get()->PointerLong(),
&jniErr);
 
-                    GridError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
+                    IgniteError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
 
                     if (jniErr.code == IGNITE_JNI_ERR_SUCCESS)
                     {
@@ -154,7 +154,7 @@ namespace ignite
                     }
                 }
 
-                bool QueryCursorImpl::CreateIteratorIfNeeded(GridError* err)
+                bool QueryCursorImpl::CreateIteratorIfNeeded(IgniteError* err)
                 {
                     if (!iterCalled)
                     {
@@ -162,7 +162,7 @@ namespace ignite
 
                         env.Get()->Context()->QueryCursorIterator(javaRef, &jniErr);
 
-                        GridError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
+                        IgniteError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg,
err);
 
                         if (jniErr.code == IGNITE_JNI_ERR_SUCCESS)
                         {
@@ -177,13 +177,13 @@ namespace ignite
                     return true;
                 }
 
-                bool QueryCursorImpl::IteratorHasNext(GridError* err)
+                bool QueryCursorImpl::IteratorHasNext(IgniteError* err)
                 {
                     JniErrorInfo jniErr;
 
                     bool res = env.Get()->Context()->QueryCursorIteratorHasNext(javaRef,
&jniErr);
 
-                    GridError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
+                    IgniteError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
 
                     return jniErr.code == IGNITE_JNI_ERR_SUCCESS && res;
                 }

http://git-wip-us.apache.org/repos/asf/ignite/blob/863189fd/modules/platform/src/main/cpp/core/src/impl/interop/interop_input_stream.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core/src/impl/interop/interop_input_stream.cpp
b/modules/platform/src/main/cpp/core/src/impl/interop/interop_input_stream.cpp
index 551d3a5..72340ee 100644
--- a/modules/platform/src/main/cpp/core/src/impl/interop/interop_input_stream.cpp
+++ b/modules/platform/src/main/cpp/core/src/impl/interop/interop_input_stream.cpp
@@ -18,7 +18,7 @@
 #include <cstring>
 
 #include "ignite/impl/interop/interop_input_stream.h"
-#include "ignite/grid_error.h"
+#include "ignite/ignite_error.h"
 
 /**
  * Common macro to read a single value.
@@ -176,7 +176,7 @@ namespace ignite
             void InteropInputStream::Position(int32_t pos)
             {
                 if (pos > len) {
-                    IGNITE_ERROR_FORMATTED_3(GridError::IGNITE_ERR_MEMORY, "Requested input
stream position is out of bounds",
+                    IGNITE_ERROR_FORMATTED_3(IgniteError::IGNITE_ERR_MEMORY, "Requested input
stream position is out of bounds",
                         "memPtr", mem->PointerLong(), "len", len, "pos", pos);
                 }
 
@@ -192,7 +192,7 @@ namespace ignite
             void InteropInputStream::EnsureEnoughData(int32_t cnt)
             {
                 if (len - pos < cnt) {
-                    IGNITE_ERROR_FORMATTED_4(GridError::IGNITE_ERR_MEMORY, "Not enough data
in the stream",
+                    IGNITE_ERROR_FORMATTED_4(IgniteError::IGNITE_ERR_MEMORY, "Not enough
data in the stream",
                         "memPtr", mem->PointerLong(), "len", len, "pos", pos, "requested",
cnt);
                 }
             }

http://git-wip-us.apache.org/repos/asf/ignite/blob/863189fd/modules/platform/src/main/cpp/core/src/impl/interop/interop_memory.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core/src/impl/interop/interop_memory.cpp b/modules/platform/src/main/cpp/core/src/impl/interop/interop_memory.cpp
index 04af510..05ba8b6 100644
--- a/modules/platform/src/main/cpp/core/src/impl/interop/interop_memory.cpp
+++ b/modules/platform/src/main/cpp/core/src/impl/interop/interop_memory.cpp
@@ -18,7 +18,7 @@
 #include <ignite/common/java.h>
 
 #include "ignite/impl/interop/interop_memory.h"
-#include "ignite/grid_error.h"
+#include "ignite/ignite_error.h"
 
 using namespace ignite::common::java;
 
@@ -173,7 +173,7 @@ namespace ignite
             void InteropExternalMemory::Reallocate(int32_t cap)
             {
                 if (JniContext::Reallocate(reinterpret_cast<int64_t>(memPtr), cap)
== -1) {
-                    IGNITE_ERROR_FORMATTED_2(GridError::IGNITE_ERR_MEMORY, "Failed to reallocate
external memory", 
+                    IGNITE_ERROR_FORMATTED_2(IgniteError::IGNITE_ERR_MEMORY, "Failed to reallocate
external memory", 
                         "memPtr", PointerLong(), "requestedCapacity", cap)
                 }
             }

http://git-wip-us.apache.org/repos/asf/ignite/blob/863189fd/modules/platform/src/main/cpp/core/src/impl/interop/interop_output_stream.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core/src/impl/interop/interop_output_stream.cpp
b/modules/platform/src/main/cpp/core/src/impl/interop/interop_output_stream.cpp
index 56c428c..ecdfd42 100644
--- a/modules/platform/src/main/cpp/core/src/impl/interop/interop_output_stream.cpp
+++ b/modules/platform/src/main/cpp/core/src/impl/interop/interop_output_stream.cpp
@@ -18,7 +18,7 @@
 #include <cstring>
 
 #include "ignite/impl/interop/interop_output_stream.h"
-#include "ignite/grid_error.h"
+#include "ignite/ignite_error.h"
 
 /**
  * Common macro to write a single value.

http://git-wip-us.apache.org/repos/asf/ignite/blob/863189fd/modules/platform/src/main/cpp/core/src/impl/portable/portable_metadata_manager.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core/src/impl/portable/portable_metadata_manager.cpp
b/modules/platform/src/main/cpp/core/src/impl/portable/portable_metadata_manager.cpp
index 9ecf5ab..63e92a9 100644
--- a/modules/platform/src/main/cpp/core/src/impl/portable/portable_metadata_manager.cpp
+++ b/modules/platform/src/main/cpp/core/src/impl/portable/portable_metadata_manager.cpp
@@ -105,7 +105,7 @@ namespace ignite
                 return pendingVer > oldVer;
             }
 
-            bool PortableMetadataManager::ProcessPendingUpdates(PortableMetadataUpdater*
updater, GridError* err)
+            bool PortableMetadataManager::ProcessPendingUpdates(PortableMetadataUpdater*
updater, IgniteError* err)
             {
                 bool success = true; // Optimistically assume that all will be fine.
                 

http://git-wip-us.apache.org/repos/asf/ignite/blob/863189fd/modules/platform/src/main/cpp/core/src/impl/portable/portable_metadata_updater_impl.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core/src/impl/portable/portable_metadata_updater_impl.cpp
b/modules/platform/src/main/cpp/core/src/impl/portable/portable_metadata_updater_impl.cpp
index 472938d..acaa1fe 100644
--- a/modules/platform/src/main/cpp/core/src/impl/portable/portable_metadata_updater_impl.cpp
+++ b/modules/platform/src/main/cpp/core/src/impl/portable/portable_metadata_updater_impl.cpp
@@ -46,7 +46,7 @@ namespace ignite
                 // No-op.
             }
 
-            bool PortableMetadataUpdaterImpl::Update(Snap* snap, GridError* err)
+            bool PortableMetadataUpdaterImpl::Update(Snap* snap, IgniteError* err)
             {
                 JniErrorInfo jniErr;
 
@@ -82,7 +82,7 @@ namespace ignite
 
                 long long res = env.Get()->Context()->TargetInStreamOutLong(javaRef,
OP_METADATA, mem.Get()->PointerLong(), &jniErr);
 
-                GridError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
+                IgniteError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
 
                 if (jniErr.code == IGNITE_JNI_ERR_SUCCESS)
                     return res == 1;

http://git-wip-us.apache.org/repos/asf/ignite/blob/863189fd/modules/platform/src/main/cpp/core/src/impl/portable/portable_reader_impl.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core/src/impl/portable/portable_reader_impl.cpp
b/modules/platform/src/main/cpp/core/src/impl/portable/portable_reader_impl.cpp
index 386ccd3..753ec25 100644
--- a/modules/platform/src/main/cpp/core/src/impl/portable/portable_reader_impl.cpp
+++ b/modules/platform/src/main/cpp/core/src/impl/portable/portable_reader_impl.cpp
@@ -21,7 +21,7 @@
 #include "ignite/impl/portable/portable_reader_impl.h"
 #include "ignite/impl/portable/portable_utils.h"
 #include "ignite/portable/portable_type.h"
-#include "ignite/grid_error.h"
+#include "ignite/ignite_error.h"
 
 using namespace ignite::impl::interop;
 using namespace ignite::impl::portable;
@@ -551,7 +551,7 @@ namespace ignite
                 else {
                     int32_t pos = stream->Position() - 1;
 
-                    IGNITE_ERROR_FORMATTED_3(GridError::IGNITE_ERR_PORTABLE, "Invalid header",
"position", pos, "expected", IGNITE_TYPE_UUID, "actual", typeId)
+                    IGNITE_ERROR_FORMATTED_3(IgniteError::IGNITE_ERR_PORTABLE, "Invalid header",
"position", pos, "expected", IGNITE_TYPE_UUID, "actual", typeId)
                 }
             }
 
@@ -603,20 +603,20 @@ namespace ignite
             void PortableReaderImpl::CheckRawMode(bool expected)
             {
                 if (expected && !rawMode) {
-                    IGNITE_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Operation can be performed
only in raw mode.")
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_PORTABLE, "Operation can be performed
only in raw mode.")
                 }
                 else if (!expected && rawMode) {
-                    IGNITE_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Operation cannot be performed
in raw mode.")
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_PORTABLE, "Operation cannot be
performed in raw mode.")
                 }
             }
 
             void PortableReaderImpl::CheckSingleMode(bool expected)
             {
                 if (expected && elemId != 0) {
-                    IGNITE_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Operation cannot be performed
when container is being read.");
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_PORTABLE, "Operation cannot be
performed when container is being read.");
                 }
                 else if (!expected && elemId == 0) {
-                    IGNITE_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Operation can be performed
only when container is being read.");
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_PORTABLE, "Operation can be performed
only when container is being read.");
                 }
             }
 
@@ -663,13 +663,13 @@ namespace ignite
             void PortableReaderImpl::CheckSession(int32_t expSes)
             {
                 if (elemId != expSes) {
-                    IGNITE_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Containter read session
has been finished or is not started yet.");
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_PORTABLE, "Containter read session
has been finished or is not started yet.");
                 }
             }
 
             void PortableReaderImpl::ThrowOnInvalidHeader(int32_t pos, int8_t expHdr, int8_t
hdr)
             {
-                IGNITE_ERROR_FORMATTED_3(GridError::IGNITE_ERR_PORTABLE, "Invalid header",
"position", pos, "expected", expHdr, "actual", hdr)
+                IGNITE_ERROR_FORMATTED_3(IgniteError::IGNITE_ERR_PORTABLE, "Invalid header",
"position", pos, "expected", expHdr, "actual", hdr)
             }
 
             void PortableReaderImpl::ThrowOnInvalidHeader(int8_t expHdr, int8_t hdr)

http://git-wip-us.apache.org/repos/asf/ignite/blob/863189fd/modules/platform/src/main/cpp/core/src/impl/portable/portable_writer_impl.cpp
----------------------------------------------------------------------
diff --git a/modules/platform/src/main/cpp/core/src/impl/portable/portable_writer_impl.cpp
b/modules/platform/src/main/cpp/core/src/impl/portable/portable_writer_impl.cpp
index 5e39f54..93aacd9 100644
--- a/modules/platform/src/main/cpp/core/src/impl/portable/portable_writer_impl.cpp
+++ b/modules/platform/src/main/cpp/core/src/impl/portable/portable_writer_impl.cpp
@@ -16,7 +16,7 @@
  */
 
 #include "ignite/impl/portable/portable_writer_impl.h"
-#include "ignite/grid_error.h"
+#include "ignite/ignite_error.h"
 
 using namespace ignite::impl::interop;
 using namespace ignite::impl::portable;
@@ -479,20 +479,20 @@ namespace ignite
                 bool rawMode = rawPos != -1;
 
                 if (expected && !rawMode) {
-                    IGNITE_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Operation can be performed
only in raw mode.");
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_PORTABLE, "Operation can be performed
only in raw mode.");
                 }
                 else if (!expected && rawMode) {
-                    IGNITE_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Operation cannot be performed
in raw mode.");
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_PORTABLE, "Operation cannot be
performed in raw mode.");
                 }
             }
 
             void PortableWriterImpl::CheckSingleMode(bool expected)
             {
                 if (expected && elemId != 0) {
-                    IGNITE_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Operation cannot be performed
when container is being written.");
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_PORTABLE, "Operation cannot be
performed when container is being written.");
                 }
                 else if (!expected && elemId == 0) {
-                    IGNITE_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Operation can be performed
only when container is being written.");
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_PORTABLE, "Operation can be performed
only when container is being written.");
                 }
             }
 
@@ -509,7 +509,7 @@ namespace ignite
             {
                 if (elemId != expSes) 
                 {
-                    IGNITE_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Containter write session
has been finished or is not started yet.");
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_PORTABLE, "Containter write session
has been finished or is not started yet.");
                 }
             }
 


Mime
View raw message