ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From voze...@apache.org
Subject [4/7] ignite git commit: IGNITE-1364: Renaming GG_ -> IGNITE_
Date Thu, 03 Sep 2015 10:10:31 GMT
http://git-wip-us.apache.org/repos/asf/ignite/blob/96245bfa/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 0bc2d56..16bd990 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
@@ -50,17 +50,17 @@ namespace gridgain
 
             void PortableWriterImpl::WriteInt8Array(const int8_t* val, const int32_t len)
             {
-                WritePrimitiveArrayRaw<int8_t>(val, len, PortableUtils::WriteInt8Array,
GG_TYPE_ARRAY_BYTE);
+                WritePrimitiveArrayRaw<int8_t>(val, len, PortableUtils::WriteInt8Array,
IGNITE_TYPE_ARRAY_BYTE);
             }
 
             void PortableWriterImpl::WriteInt8(const char* fieldName, const int8_t val)
             {
-                WritePrimitive<int8_t>(fieldName, val, PortableUtils::WriteInt8, GG_TYPE_BYTE,
1);
+                WritePrimitive<int8_t>(fieldName, val, PortableUtils::WriteInt8, IGNITE_TYPE_BYTE,
1);
             }
 
             void PortableWriterImpl::WriteInt8Array(const char* fieldName, const int8_t*
val, const int32_t len)
             {
-                WritePrimitiveArray<int8_t>(fieldName, val, len, PortableUtils::WriteInt8Array,
GG_TYPE_ARRAY_BYTE, 0);
+                WritePrimitiveArray<int8_t>(fieldName, val, len, PortableUtils::WriteInt8Array,
IGNITE_TYPE_ARRAY_BYTE, 0);
             }
 
             void PortableWriterImpl::WriteBool(const bool val)
@@ -70,17 +70,17 @@ namespace gridgain
 
             void PortableWriterImpl::WriteBoolArray(const bool* val, const int32_t len)
             {
-                WritePrimitiveArrayRaw<bool>(val, len, PortableUtils::WriteBoolArray,
GG_TYPE_ARRAY_BOOL);
+                WritePrimitiveArrayRaw<bool>(val, len, PortableUtils::WriteBoolArray,
IGNITE_TYPE_ARRAY_BOOL);
             }
 
             void PortableWriterImpl::WriteBool(const char* fieldName, const bool val)
             {
-                WritePrimitive<bool>(fieldName, val, PortableUtils::WriteBool, GG_TYPE_BOOL,
1);
+                WritePrimitive<bool>(fieldName, val, PortableUtils::WriteBool, IGNITE_TYPE_BOOL,
1);
             }
 
             void PortableWriterImpl::WriteBoolArray(const char* fieldName, const bool* val,
const int32_t len)
             {
-                WritePrimitiveArray<bool>(fieldName, val, len, PortableUtils::WriteBoolArray,
GG_TYPE_ARRAY_BOOL, 0);
+                WritePrimitiveArray<bool>(fieldName, val, len, PortableUtils::WriteBoolArray,
IGNITE_TYPE_ARRAY_BOOL, 0);
             }
 
             void PortableWriterImpl::WriteInt16(const int16_t val)
@@ -90,17 +90,17 @@ namespace gridgain
 
             void PortableWriterImpl::WriteInt16Array(const int16_t* val, const int32_t len)
             {
-                WritePrimitiveArrayRaw<int16_t>(val, len, PortableUtils::WriteInt16Array,
GG_TYPE_ARRAY_SHORT);
+                WritePrimitiveArrayRaw<int16_t>(val, len, PortableUtils::WriteInt16Array,
IGNITE_TYPE_ARRAY_SHORT);
             }
 
             void PortableWriterImpl::WriteInt16(const char* fieldName, const int16_t val)
             {
-                WritePrimitive<int16_t>(fieldName, val, PortableUtils::WriteInt16,
GG_TYPE_SHORT, 2);
+                WritePrimitive<int16_t>(fieldName, val, PortableUtils::WriteInt16,
IGNITE_TYPE_SHORT, 2);
             }
 
             void PortableWriterImpl::WriteInt16Array(const char* fieldName, const int16_t*
val, const int32_t len)
             {
-                WritePrimitiveArray<int16_t>(fieldName, val, len, PortableUtils::WriteInt16Array,
GG_TYPE_ARRAY_SHORT, 1);
+                WritePrimitiveArray<int16_t>(fieldName, val, len, PortableUtils::WriteInt16Array,
IGNITE_TYPE_ARRAY_SHORT, 1);
             }
 
             void PortableWriterImpl::WriteUInt16(const uint16_t val)
@@ -110,17 +110,17 @@ namespace gridgain
 
             void PortableWriterImpl::WriteUInt16Array(const uint16_t* val, const int32_t
len)
             {
-                WritePrimitiveArrayRaw<uint16_t>(val, len, PortableUtils::WriteUInt16Array,
GG_TYPE_ARRAY_CHAR);
+                WritePrimitiveArrayRaw<uint16_t>(val, len, PortableUtils::WriteUInt16Array,
IGNITE_TYPE_ARRAY_CHAR);
             }
 
             void PortableWriterImpl::WriteUInt16(const char* fieldName, const uint16_t val)
             {
-                WritePrimitive<uint16_t>(fieldName, val, PortableUtils::WriteUInt16,
GG_TYPE_CHAR, 2);
+                WritePrimitive<uint16_t>(fieldName, val, PortableUtils::WriteUInt16,
IGNITE_TYPE_CHAR, 2);
             }
 
             void PortableWriterImpl::WriteUInt16Array(const char* fieldName, const uint16_t*
val, const int32_t len)
             {
-                WritePrimitiveArray<uint16_t>(fieldName, val, len, PortableUtils::WriteUInt16Array,
GG_TYPE_ARRAY_CHAR, 1);
+                WritePrimitiveArray<uint16_t>(fieldName, val, len, PortableUtils::WriteUInt16Array,
IGNITE_TYPE_ARRAY_CHAR, 1);
             }
 
             void PortableWriterImpl::WriteInt32(const int32_t val)
@@ -130,17 +130,17 @@ namespace gridgain
 
             void PortableWriterImpl::WriteInt32Array(const int32_t* val, const int32_t len)
             {
-                WritePrimitiveArrayRaw<int32_t>(val, len, PortableUtils::WriteInt32Array,
GG_TYPE_ARRAY_INT);
+                WritePrimitiveArrayRaw<int32_t>(val, len, PortableUtils::WriteInt32Array,
IGNITE_TYPE_ARRAY_INT);
             }
 
             void PortableWriterImpl::WriteInt32(const char* fieldName, const int32_t val)
             {
-                WritePrimitive<int32_t>(fieldName, val, PortableUtils::WriteInt32,
GG_TYPE_INT, 4);
+                WritePrimitive<int32_t>(fieldName, val, PortableUtils::WriteInt32,
IGNITE_TYPE_INT, 4);
             }
 
             void PortableWriterImpl::WriteInt32Array(const char* fieldName, const int32_t*
val, const int32_t len)
             {
-                WritePrimitiveArray<int32_t>(fieldName, val, len, PortableUtils::WriteInt32Array,
GG_TYPE_ARRAY_INT, 2);
+                WritePrimitiveArray<int32_t>(fieldName, val, len, PortableUtils::WriteInt32Array,
IGNITE_TYPE_ARRAY_INT, 2);
             }
 
             void PortableWriterImpl::WriteInt64(const int64_t val)
@@ -150,17 +150,17 @@ namespace gridgain
 
             void PortableWriterImpl::WriteInt64Array(const int64_t* val, const int32_t len)
             {
-                WritePrimitiveArrayRaw<int64_t>(val, len, PortableUtils::WriteInt64Array,
GG_TYPE_ARRAY_LONG);
+                WritePrimitiveArrayRaw<int64_t>(val, len, PortableUtils::WriteInt64Array,
IGNITE_TYPE_ARRAY_LONG);
             }
 
             void PortableWriterImpl::WriteInt64(const char* fieldName, const int64_t val)
             {
-                WritePrimitive<int64_t>(fieldName, val, PortableUtils::WriteInt64,
GG_TYPE_LONG, 8);
+                WritePrimitive<int64_t>(fieldName, val, PortableUtils::WriteInt64,
IGNITE_TYPE_LONG, 8);
             }
 
             void PortableWriterImpl::WriteInt64Array(const char* fieldName, const int64_t*
val, const int32_t len)
             {
-                WritePrimitiveArray<int64_t>(fieldName, val, len, PortableUtils::WriteInt64Array,
GG_TYPE_ARRAY_LONG, 3);
+                WritePrimitiveArray<int64_t>(fieldName, val, len, PortableUtils::WriteInt64Array,
IGNITE_TYPE_ARRAY_LONG, 3);
             }
 
             void PortableWriterImpl::WriteFloat(const float val)
@@ -170,17 +170,17 @@ namespace gridgain
 
             void PortableWriterImpl::WriteFloatArray(const float* val, const int32_t len)
             {
-                WritePrimitiveArrayRaw<float>(val, len, PortableUtils::WriteFloatArray,
GG_TYPE_ARRAY_FLOAT);
+                WritePrimitiveArrayRaw<float>(val, len, PortableUtils::WriteFloatArray,
IGNITE_TYPE_ARRAY_FLOAT);
             }
 
             void PortableWriterImpl::WriteFloat(const char* fieldName, const float val)
             {
-                WritePrimitive<float>(fieldName, val, PortableUtils::WriteFloat, GG_TYPE_FLOAT,
4);
+                WritePrimitive<float>(fieldName, val, PortableUtils::WriteFloat, IGNITE_TYPE_FLOAT,
4);
             }
 
             void PortableWriterImpl::WriteFloatArray(const char* fieldName, const float*
val, const int32_t len)
             {
-                WritePrimitiveArray<float>(fieldName, val, len, PortableUtils::WriteFloatArray,
GG_TYPE_ARRAY_FLOAT, 2);
+                WritePrimitiveArray<float>(fieldName, val, len, PortableUtils::WriteFloatArray,
IGNITE_TYPE_ARRAY_FLOAT, 2);
             }
 
             void PortableWriterImpl::WriteDouble(const double val)
@@ -190,17 +190,17 @@ namespace gridgain
 
             void PortableWriterImpl::WriteDoubleArray(const double* val, const int32_t len)
             {
-                WritePrimitiveArrayRaw<double>(val, len, PortableUtils::WriteDoubleArray,
GG_TYPE_ARRAY_DOUBLE);
+                WritePrimitiveArrayRaw<double>(val, len, PortableUtils::WriteDoubleArray,
IGNITE_TYPE_ARRAY_DOUBLE);
             }
 
             void PortableWriterImpl::WriteDouble(const char* fieldName, const double val)
             {
-                WritePrimitive<double>(fieldName, val, PortableUtils::WriteDouble,
GG_TYPE_DOUBLE, 8);
+                WritePrimitive<double>(fieldName, val, PortableUtils::WriteDouble,
IGNITE_TYPE_DOUBLE, 8);
             }
 
             void PortableWriterImpl::WriteDoubleArray(const char* fieldName, const double*
val, const int32_t len)
             {
-                WritePrimitiveArray<double>(fieldName, val, len, PortableUtils::WriteDoubleArray,
GG_TYPE_ARRAY_DOUBLE, 3);
+                WritePrimitiveArray<double>(fieldName, val, len, PortableUtils::WriteDoubleArray,
IGNITE_TYPE_ARRAY_DOUBLE, 3);
             }
 
             void PortableWriterImpl::WriteGuid(const Guid val)
@@ -208,7 +208,7 @@ namespace gridgain
                 CheckRawMode(true);
                 CheckSingleMode(true);
 
-                stream->WriteInt8(GG_TYPE_UUID);
+                stream->WriteInt8(IGNITE_TYPE_UUID);
 
                 PortableUtils::WriteGuid(stream, val);
             }
@@ -220,19 +220,19 @@ namespace gridgain
                 
                 if (val)
                 {
-                    stream->WriteInt8(GG_TYPE_ARRAY_UUID);
+                    stream->WriteInt8(IGNITE_TYPE_ARRAY_UUID);
                     stream->WriteInt32(len);
 
                     for (int i = 0; i < len; i++)
                     {
                         Guid elem = *(val + i);
 
-                        stream->WriteInt8(GG_TYPE_UUID);
+                        stream->WriteInt8(IGNITE_TYPE_UUID);
                         PortableUtils::WriteGuid(stream, elem);
                     }
                 }
                 else
-                    stream->WriteInt8(GG_HDR_NULL);
+                    stream->WriteInt8(IGNITE_HDR_NULL);
             }
 
             void PortableWriterImpl::WriteGuid(const char* fieldName, const Guid val)
@@ -240,9 +240,9 @@ namespace gridgain
                 CheckRawMode(false);
                 CheckSingleMode(true);
 
-                WriteFieldIdAndLength(fieldName, GG_TYPE_UUID, 1 + 16);
+                WriteFieldIdAndLength(fieldName, IGNITE_TYPE_UUID, 1 + 16);
 
-                stream->WriteInt8(GG_TYPE_UUID);
+                stream->WriteInt8(IGNITE_TYPE_UUID);
 
                 PortableUtils::WriteGuid(stream, val);
             }
@@ -252,12 +252,12 @@ namespace gridgain
                 CheckRawMode(false);
                 CheckSingleMode(true);
 
-                WriteFieldId(fieldName, GG_TYPE_ARRAY_UUID);
+                WriteFieldId(fieldName, IGNITE_TYPE_ARRAY_UUID);
 
                 if (val)
                 {
                     stream->WriteInt32(5 + len * 17);
-                    stream->WriteInt8(GG_TYPE_ARRAY_UUID);
+                    stream->WriteInt8(IGNITE_TYPE_ARRAY_UUID);
                     stream->WriteInt32(len);
 
                     for (int i = 0; i < len; i++)
@@ -270,7 +270,7 @@ namespace gridgain
                 else
                 {
                     stream->WriteInt32(1);
-                    stream->WriteInt8(GG_HDR_NULL);
+                    stream->WriteInt8(IGNITE_HDR_NULL);
                 }
             }
 
@@ -281,12 +281,12 @@ namespace gridgain
 
                 if (val) 
                 {
-                    stream->WriteInt8(GG_TYPE_STRING);
+                    stream->WriteInt8(IGNITE_TYPE_STRING);
 
                     PortableUtils::WriteString(stream, val, len);
                 }
                 else
-                    stream->WriteInt8(GG_HDR_NULL);
+                    stream->WriteInt8(IGNITE_HDR_NULL);
             }
 
             void PortableWriterImpl::WriteString(const char* fieldName, const char* val,
const int32_t len)
@@ -294,14 +294,14 @@ namespace gridgain
                 CheckRawMode(false);
                 CheckSingleMode(true);
 
-                WriteFieldId(fieldName, GG_TYPE_STRING);
+                WriteFieldId(fieldName, IGNITE_TYPE_STRING);
                 
                 if (val)
                 {
                     int32_t lenPos = stream->Position();
                     stream->Position(lenPos + 4);
 
-                    stream->WriteInt8(GG_TYPE_STRING);
+                    stream->WriteInt8(IGNITE_TYPE_STRING);
                     stream->WriteBool(false);
                     stream->WriteInt32(len);
 
@@ -313,7 +313,7 @@ namespace gridgain
                 else
                 {
                     stream->WriteInt32(1);
-                    stream->WriteInt8(GG_HDR_NULL);
+                    stream->WriteInt8(IGNITE_HDR_NULL);
                 }
             }
 
@@ -321,7 +321,7 @@ namespace gridgain
             {
                 StartContainerSession(true);
 
-                stream->WriteInt8(GG_TYPE_ARRAY_STRING);
+                stream->WriteInt8(IGNITE_TYPE_ARRAY_STRING);
                 stream->Position(stream->Position() + 4);
 
                 return elemId;
@@ -331,9 +331,9 @@ namespace gridgain
             {
                 StartContainerSession(false);
 
-                WriteFieldIdSkipLength(fieldName, GG_TYPE_ARRAY_STRING);
+                WriteFieldIdSkipLength(fieldName, IGNITE_TYPE_ARRAY_STRING);
 
-                stream->WriteInt8(GG_TYPE_ARRAY_STRING);
+                stream->WriteInt8(IGNITE_TYPE_ARRAY_STRING);
                 stream->Position(stream->Position() + 4);
 
                 return elemId;
@@ -345,12 +345,12 @@ namespace gridgain
 
                 if (val)
                 {
-                    stream->WriteInt8(GG_TYPE_STRING);
+                    stream->WriteInt8(IGNITE_TYPE_STRING);
 
                     PortableUtils::WriteString(stream, val, len);
                 }
                 else
-                    stream->WriteInt8(GG_HDR_NULL);
+                    stream->WriteInt8(IGNITE_HDR_NULL);
 
                 elemCnt++;
             }
@@ -360,7 +360,7 @@ namespace gridgain
                 CheckRawMode(true);
                 CheckSingleMode(true);
 
-                stream->WriteInt8(GG_HDR_NULL);
+                stream->WriteInt8(IGNITE_HDR_NULL);
             }
 
             void PortableWriterImpl::WriteNull(const char* fieldName)
@@ -368,15 +368,15 @@ namespace gridgain
                 CheckRawMode(false);
                 CheckSingleMode(true);
 
-                WriteFieldIdAndLength(fieldName, GG_TYPE_OBJECT, 1);
-                stream->WriteInt8(GG_HDR_NULL);
+                WriteFieldIdAndLength(fieldName, IGNITE_TYPE_OBJECT, 1);
+                stream->WriteInt8(IGNITE_HDR_NULL);
             }
 
             int32_t PortableWriterImpl::WriteArray()
             {
                 StartContainerSession(true);
                 
-                stream->WriteInt8(GG_TYPE_ARRAY);
+                stream->WriteInt8(IGNITE_TYPE_ARRAY);
                 stream->Position(stream->Position() + 4);
 
                 return elemId;
@@ -386,9 +386,9 @@ namespace gridgain
             {
                 StartContainerSession(false);
 
-                WriteFieldIdSkipLength(fieldName, GG_TYPE_ARRAY);
+                WriteFieldIdSkipLength(fieldName, IGNITE_TYPE_ARRAY);
 
-                stream->WriteInt8(GG_TYPE_ARRAY);
+                stream->WriteInt8(IGNITE_TYPE_ARRAY);
                 stream->Position(stream->Position() + 4);
 
                 return elemId;
@@ -398,7 +398,7 @@ namespace gridgain
             {
                 StartContainerSession(true);
 
-                stream->WriteInt8(GG_TYPE_COLLECTION);
+                stream->WriteInt8(IGNITE_TYPE_COLLECTION);
                 stream->Position(stream->Position() + 4);
                 stream->WriteInt8(typ);
 
@@ -409,9 +409,9 @@ namespace gridgain
             {
                 StartContainerSession(false);
                 
-                WriteFieldIdSkipLength(fieldName, GG_TYPE_COLLECTION);
+                WriteFieldIdSkipLength(fieldName, IGNITE_TYPE_COLLECTION);
 
-                stream->WriteInt8(GG_TYPE_COLLECTION);
+                stream->WriteInt8(IGNITE_TYPE_COLLECTION);
                 stream->Position(stream->Position() + 4);
                 stream->WriteInt8(typ);
 
@@ -422,7 +422,7 @@ namespace gridgain
             {
                 StartContainerSession(true);
 
-                stream->WriteInt8(GG_TYPE_MAP);
+                stream->WriteInt8(IGNITE_TYPE_MAP);
                 stream->Position(stream->Position() + 4);
                 stream->WriteInt8(typ);
 
@@ -433,9 +433,9 @@ namespace gridgain
             {
                 StartContainerSession(false);
 
-                WriteFieldIdSkipLength(fieldName, GG_TYPE_MAP);
+                WriteFieldIdSkipLength(fieldName, IGNITE_TYPE_MAP);
                 
-                stream->WriteInt8(GG_TYPE_MAP);
+                stream->WriteInt8(IGNITE_TYPE_MAP);
                 stream->Position(stream->Position() + 4);
                 stream->WriteInt8(typ);
 
@@ -479,20 +479,20 @@ namespace gridgain
                 bool rawMode = rawPos != -1;
 
                 if (expected && !rawMode) {
-                    GG_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Operation can be performed
only in raw mode.");
+                    IGNITE_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Operation can be performed
only in raw mode.");
                 }
                 else if (!expected && rawMode) {
-                    GG_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Operation cannot be performed
in raw mode.");
+                    IGNITE_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Operation cannot be performed
in raw mode.");
                 }
             }
 
             void PortableWriterImpl::CheckSingleMode(bool expected)
             {
                 if (expected && elemId != 0) {
-                    GG_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Operation cannot be performed
when container is being written.");
+                    IGNITE_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Operation cannot be performed
when container is being written.");
                 }
                 else if (!expected && elemId == 0) {
-                    GG_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Operation can be performed
only when container is being written.");
+                    IGNITE_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Operation can be performed
only when container is being written.");
                 }
             }
 
@@ -509,7 +509,7 @@ namespace gridgain
             {
                 if (elemId != expSes) 
                 {
-                    GG_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Containter write session
has been finished or is not started yet.");
+                    IGNITE_ERROR_1(GridError::IGNITE_ERR_PORTABLE, "Containter write session
has been finished or is not started yet.");
                 }
             }
 
@@ -540,55 +540,55 @@ namespace gridgain
             template <>
             void PortableWriterImpl::WriteTopObject<int8_t>(const int8_t& obj)
             {
-                WriteTopObject0<int8_t>(obj, PortableUtils::WriteInt8, GG_TYPE_BYTE);
+                WriteTopObject0<int8_t>(obj, PortableUtils::WriteInt8, IGNITE_TYPE_BYTE);
             }
 
             template <>
             void PortableWriterImpl::WriteTopObject<bool>(const bool& obj)
             {
-                WriteTopObject0<bool>(obj, PortableUtils::WriteBool, GG_TYPE_BOOL);
+                WriteTopObject0<bool>(obj, PortableUtils::WriteBool, IGNITE_TYPE_BOOL);
             }
 
             template <>
             void PortableWriterImpl::WriteTopObject<int16_t>(const int16_t& obj)
             {
-                WriteTopObject0<int16_t>(obj, PortableUtils::WriteInt16, GG_TYPE_SHORT);
+                WriteTopObject0<int16_t>(obj, PortableUtils::WriteInt16, IGNITE_TYPE_SHORT);
             }
 
             template <>
             void PortableWriterImpl::WriteTopObject<uint16_t>(const uint16_t& obj)
             {
-                WriteTopObject0<uint16_t>(obj, PortableUtils::WriteUInt16, GG_TYPE_CHAR);
+                WriteTopObject0<uint16_t>(obj, PortableUtils::WriteUInt16, IGNITE_TYPE_CHAR);
             }
 
             template <>
             void PortableWriterImpl::WriteTopObject<int32_t>(const int32_t& obj)
             {
-                WriteTopObject0<int32_t>(obj, PortableUtils::WriteInt32, GG_TYPE_INT);
+                WriteTopObject0<int32_t>(obj, PortableUtils::WriteInt32, IGNITE_TYPE_INT);
             }
 
             template <>
             void PortableWriterImpl::WriteTopObject<int64_t>(const int64_t& obj)
             {
-                WriteTopObject0<int64_t>(obj, PortableUtils::WriteInt64, GG_TYPE_LONG);
+                WriteTopObject0<int64_t>(obj, PortableUtils::WriteInt64, IGNITE_TYPE_LONG);
             }
 
             template <>
             void PortableWriterImpl::WriteTopObject<float>(const float& obj)
             {
-                WriteTopObject0<float>(obj, PortableUtils::WriteFloat, GG_TYPE_FLOAT);
+                WriteTopObject0<float>(obj, PortableUtils::WriteFloat, IGNITE_TYPE_FLOAT);
             }
 
             template <>
             void PortableWriterImpl::WriteTopObject<double>(const double& obj)
             {
-                WriteTopObject0<double>(obj, PortableUtils::WriteDouble, GG_TYPE_DOUBLE);
+                WriteTopObject0<double>(obj, PortableUtils::WriteDouble, IGNITE_TYPE_DOUBLE);
             }
 
             template <>
             void PortableWriterImpl::WriteTopObject<Guid>(const Guid& obj)
             {
-                WriteTopObject0<Guid>(obj, PortableUtils::WriteGuid, GG_TYPE_UUID);
+                WriteTopObject0<Guid>(obj, PortableUtils::WriteGuid, IGNITE_TYPE_UUID);
             }
 
             InteropOutputStream* PortableWriterImpl::GetStream()


Mime
View raw message