ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From voze...@apache.org
Subject [05/18] ignite git commit: IGNITE-1846: CPP: "portable" -> "binary", "metadata" -> "type".
Date Mon, 09 Nov 2015 11:48:37 GMT
http://git-wip-us.apache.org/repos/asf/ignite/blob/303d79eb/modules/platforms/cpp/core/src/impl/binary/binary_reader_impl.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/core/src/impl/binary/binary_reader_impl.cpp b/modules/platforms/cpp/core/src/impl/binary/binary_reader_impl.cpp
new file mode 100644
index 0000000..e189273
--- /dev/null
+++ b/modules/platforms/cpp/core/src/impl/binary/binary_reader_impl.cpp
@@ -0,0 +1,760 @@
+/*
+ * 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/impl/interop/interop.h"
+#include "ignite/impl/binary/binary_common.h"
+#include "ignite/impl/binary/binary_id_resolver.h"
+#include "ignite/impl/binary/binary_reader_impl.h"
+#include "ignite/impl/binary/binary_utils.h"
+#include "ignite/binary/binary_type.h"
+#include "ignite/ignite_error.h"
+#include "ignite/impl/interop/interop_stream_position_guard.h"
+
+using namespace ignite::impl::interop;
+using namespace ignite::impl::binary;
+using namespace ignite::binary;
+
+namespace ignite
+{
+    namespace impl
+    {
+        namespace binary
+        {
+            BinaryReaderImpl::BinaryReaderImpl(InteropInputStream* stream, BinaryIdResolver* idRslvr,
+                int32_t pos, bool usrType, int32_t typeId, int32_t hashCode, int32_t len, int32_t rawOff,
+                int32_t footerBegin, int32_t footerEnd, BinaryOffsetType schemaType) :
+                stream(stream), idRslvr(idRslvr), pos(pos), usrType(usrType), typeId(typeId), 
+                hashCode(hashCode), len(len), rawOff(rawOff), rawMode(false), elemIdGen(0), elemId(0),
+                elemCnt(-1), elemRead(0), footerBegin(footerBegin), footerEnd(footerEnd), schemaType(schemaType)
+            {
+                // No-op.
+            }
+
+            BinaryReaderImpl::BinaryReaderImpl(InteropInputStream* stream) :
+                stream(stream), idRslvr(NULL), pos(0), usrType(false), typeId(0), hashCode(0), len(0),
+                rawOff(0), rawMode(true), elemIdGen(0), elemId(0), elemCnt(-1), elemRead(0), footerBegin(-1),
+                footerEnd(-1), schemaType(OFFSET_TYPE_4_BYTE)
+            {
+                // No-op.
+            }
+
+            int8_t BinaryReaderImpl::ReadInt8()
+            {
+                return ReadRaw<int8_t>(BinaryUtils::ReadInt8);                
+            }
+            
+            int32_t BinaryReaderImpl::ReadInt8Array(int8_t* res, const int32_t len)
+            {
+                return ReadRawArray<int8_t>(res, len, BinaryUtils::ReadInt8Array, IGNITE_TYPE_ARRAY_BYTE);
+            }
+
+            int8_t BinaryReaderImpl::ReadInt8(const char* fieldName)
+            {
+                return Read(fieldName, BinaryUtils::ReadInt8, IGNITE_TYPE_BYTE, static_cast<int8_t>(0));
+            }
+
+            int32_t BinaryReaderImpl::ReadInt8Array(const char* fieldName, int8_t* res, const int32_t len)
+            {
+                return ReadArray<int8_t>(fieldName, res, len,BinaryUtils::ReadInt8Array, IGNITE_TYPE_ARRAY_BYTE);
+            }
+
+            bool BinaryReaderImpl::ReadBool()
+            {
+                return ReadRaw<bool>(BinaryUtils::ReadBool);
+            }
+
+            int32_t BinaryReaderImpl::ReadBoolArray(bool* res, const int32_t len)
+            {
+                return ReadRawArray<bool>(res, len, BinaryUtils::ReadBoolArray, IGNITE_TYPE_ARRAY_BOOL);
+            }
+
+            bool BinaryReaderImpl::ReadBool(const char* fieldName)
+            {
+                return Read(fieldName, BinaryUtils::ReadBool, IGNITE_TYPE_BOOL, static_cast<bool>(0));
+            }
+
+            int32_t BinaryReaderImpl::ReadBoolArray(const char* fieldName, bool* res, const int32_t len)
+            {
+                return ReadArray<bool>(fieldName, res, len,BinaryUtils::ReadBoolArray, IGNITE_TYPE_ARRAY_BOOL);
+            }
+
+            int16_t BinaryReaderImpl::ReadInt16()
+            {
+                return ReadRaw<int16_t>(BinaryUtils::ReadInt16);
+            }
+
+            int32_t BinaryReaderImpl::ReadInt16Array(int16_t* res, const int32_t len)
+            {
+                return ReadRawArray<int16_t>(res, len, BinaryUtils::ReadInt16Array, IGNITE_TYPE_ARRAY_SHORT);
+            }
+
+            int16_t BinaryReaderImpl::ReadInt16(const char* fieldName)
+            {
+                return Read(fieldName, BinaryUtils::ReadInt16, IGNITE_TYPE_SHORT, static_cast<int16_t>(0));
+            }
+
+            int32_t BinaryReaderImpl::ReadInt16Array(const char* fieldName, int16_t* res, const int32_t len)
+            {
+                return ReadArray<int16_t>(fieldName, res, len, BinaryUtils::ReadInt16Array, IGNITE_TYPE_ARRAY_SHORT);
+            }
+
+            uint16_t BinaryReaderImpl::ReadUInt16()
+            {
+                return ReadRaw<uint16_t>(BinaryUtils::ReadUInt16);
+            }
+
+            int32_t BinaryReaderImpl::ReadUInt16Array(uint16_t* res, const int32_t len)
+            {
+                return ReadRawArray<uint16_t>(res, len, BinaryUtils::ReadUInt16Array, IGNITE_TYPE_ARRAY_CHAR);
+            }
+
+            uint16_t BinaryReaderImpl::ReadUInt16(const char* fieldName)
+            {
+                return Read(fieldName, BinaryUtils::ReadUInt16, IGNITE_TYPE_CHAR, static_cast<uint16_t>(0));
+            }
+
+            int32_t BinaryReaderImpl::ReadUInt16Array(const char* fieldName, uint16_t* res, const int32_t len)
+            {
+                return ReadArray<uint16_t>(fieldName, res, len,BinaryUtils::ReadUInt16Array, IGNITE_TYPE_ARRAY_CHAR);
+            }
+
+            int32_t BinaryReaderImpl::ReadInt32()
+            {
+                return ReadRaw<int32_t>(BinaryUtils::ReadInt32);
+            }
+
+            int32_t BinaryReaderImpl::ReadInt32Array(int32_t* res, const int32_t len)
+            {
+                return ReadRawArray<int32_t>(res, len, BinaryUtils::ReadInt32Array, IGNITE_TYPE_ARRAY_INT);
+            }
+
+            int32_t BinaryReaderImpl::ReadInt32(const char* fieldName)
+            {
+                return Read(fieldName, BinaryUtils::ReadInt32, IGNITE_TYPE_INT, static_cast<int32_t>(0));
+            }
+
+            int32_t BinaryReaderImpl::ReadInt32Array(const char* fieldName, int32_t* res, const int32_t len)
+            {
+                return ReadArray<int32_t>(fieldName, res, len,BinaryUtils::ReadInt32Array, IGNITE_TYPE_ARRAY_INT);
+            }
+
+            int64_t BinaryReaderImpl::ReadInt64()
+            {
+                return ReadRaw<int64_t>(BinaryUtils::ReadInt64);
+            }
+
+            int32_t BinaryReaderImpl::ReadInt64Array(int64_t* res, const int32_t len)
+            {
+                return ReadRawArray<int64_t>(res, len, BinaryUtils::ReadInt64Array, IGNITE_TYPE_ARRAY_LONG);
+            }
+
+            int64_t BinaryReaderImpl::ReadInt64(const char* fieldName)
+            {
+                return Read(fieldName, BinaryUtils::ReadInt64, IGNITE_TYPE_LONG, static_cast<int64_t>(0));
+            }
+
+            int32_t BinaryReaderImpl::ReadInt64Array(const char* fieldName, int64_t* res, const int32_t len)
+            {
+                return ReadArray<int64_t>(fieldName, res, len,BinaryUtils::ReadInt64Array, IGNITE_TYPE_ARRAY_LONG);
+            }
+
+            float BinaryReaderImpl::ReadFloat()
+            {
+                return ReadRaw<float>(BinaryUtils::ReadFloat);
+            }
+
+            int32_t BinaryReaderImpl::ReadFloatArray(float* res, const int32_t len)
+            {
+                return ReadRawArray<float>(res, len, BinaryUtils::ReadFloatArray, IGNITE_TYPE_ARRAY_FLOAT);
+            }
+
+            float BinaryReaderImpl::ReadFloat(const char* fieldName)
+            {
+                return Read(fieldName, BinaryUtils::ReadFloat, IGNITE_TYPE_FLOAT, static_cast<float>(0));
+            }
+
+            int32_t BinaryReaderImpl::ReadFloatArray(const char* fieldName, float* res, const int32_t len)
+            {
+                return ReadArray<float>(fieldName, res, len,BinaryUtils::ReadFloatArray, IGNITE_TYPE_ARRAY_FLOAT);
+            }
+
+            double BinaryReaderImpl::ReadDouble()
+            {
+                return ReadRaw<double>(BinaryUtils::ReadDouble);
+            }
+
+            int32_t BinaryReaderImpl::ReadDoubleArray(double* res, const int32_t len)
+            {
+                return ReadRawArray<double>(res, len, BinaryUtils::ReadDoubleArray, IGNITE_TYPE_ARRAY_DOUBLE);
+            }
+
+            double BinaryReaderImpl::ReadDouble(const char* fieldName)
+            {
+                return Read(fieldName, BinaryUtils::ReadDouble, IGNITE_TYPE_DOUBLE, static_cast<double>(0));
+            }
+
+            int32_t BinaryReaderImpl::ReadDoubleArray(const char* fieldName, double* res, const int32_t len)
+            {
+                return ReadArray<double>(fieldName, res, len,BinaryUtils::ReadDoubleArray, IGNITE_TYPE_ARRAY_DOUBLE);
+            }
+
+            Guid BinaryReaderImpl::ReadGuid()
+            {
+                CheckRawMode(true);
+                CheckSingleMode(true);
+
+                return ReadNullable(stream, BinaryUtils::ReadGuid, IGNITE_TYPE_UUID);
+            }
+
+            int32_t BinaryReaderImpl::ReadGuidArray(Guid* res, const int32_t len)
+            {
+                CheckRawMode(true);
+                CheckSingleMode(true);
+
+                return ReadArrayInternal<Guid>(res, len, stream, ReadGuidArrayInternal, IGNITE_TYPE_ARRAY_UUID);
+            }
+
+            Guid BinaryReaderImpl::ReadGuid(const char* fieldName)
+            {
+                CheckRawMode(false);
+                CheckSingleMode(true);
+
+                int32_t fieldId = idRslvr->GetFieldId(typeId, fieldName);
+                int32_t fieldPos = FindField(fieldId);
+
+                if (fieldPos <= 0)
+                    return Guid();
+
+                stream->Position(fieldPos);
+
+                return ReadNullable(stream, BinaryUtils::ReadGuid, IGNITE_TYPE_UUID);
+            }
+
+            int32_t BinaryReaderImpl::ReadGuidArray(const char* fieldName, Guid* res, const int32_t len)
+            {
+                CheckRawMode(false);
+                CheckSingleMode(true);
+
+                int32_t fieldId = idRslvr->GetFieldId(typeId, fieldName);
+                int32_t fieldPos = FindField(fieldId);
+
+                if (fieldPos <= 0)
+                    return -1;
+
+                stream->Position(fieldPos);
+
+                int32_t realLen = ReadArrayInternal<Guid>(res, len, stream, ReadGuidArrayInternal, IGNITE_TYPE_ARRAY_UUID);
+
+                return realLen;
+            }
+
+            void BinaryReaderImpl::ReadGuidArrayInternal(InteropInputStream* stream, Guid* res, const int32_t len)
+            {
+                for (int i = 0; i < len; i++)
+                    *(res + i) = ReadNullable<Guid>(stream, BinaryUtils::ReadGuid, IGNITE_TYPE_UUID);
+            }
+
+            int32_t BinaryReaderImpl::ReadString(char* res, const int32_t len)
+            {
+                CheckRawMode(true);
+                CheckSingleMode(true);
+
+                return ReadStringInternal(res, len);
+            }
+
+            int32_t BinaryReaderImpl::ReadString(const char* fieldName, char* res, const int32_t len)
+            {
+                CheckRawMode(false);
+                CheckSingleMode(true);
+
+                int32_t fieldId = idRslvr->GetFieldId(typeId, fieldName);
+                int32_t fieldPos = FindField(fieldId);
+
+                if (fieldPos <= 0)
+                    return -1;
+
+                stream->Position(fieldPos);
+
+                int32_t realLen = ReadStringInternal(res, len);
+
+                return realLen;
+            }
+
+            int32_t BinaryReaderImpl::ReadStringArray(int32_t* size)
+            {
+                return StartContainerSession(true, IGNITE_TYPE_ARRAY_STRING, size);
+            }
+
+            int32_t BinaryReaderImpl::ReadStringArray(const char* fieldName, int32_t* size)
+            {
+                CheckRawMode(false);
+                CheckSingleMode(true);
+
+                int32_t fieldId = idRslvr->GetFieldId(typeId, fieldName);
+                int32_t fieldPos = FindField(fieldId);
+
+                if (fieldPos <= 0)
+                {
+                    *size = -1;
+
+                    return ++elemIdGen;
+                }
+
+                stream->Position(fieldPos);
+
+                return StartContainerSession(false, IGNITE_TYPE_ARRAY_STRING, size);
+            }
+
+            int32_t BinaryReaderImpl::ReadStringElement(int32_t id, char* res, const int32_t len)
+            {
+                CheckSession(id);
+
+                int32_t posBefore = stream->Position();
+
+                int32_t realLen = ReadStringInternal(res, len);
+
+                int32_t posAfter = stream->Position();
+
+                if (posAfter > posBefore && ++elemRead == elemCnt) {
+                    elemId = 0;
+                    elemCnt = -1;
+                    elemRead = 0;
+                }
+
+                return realLen;
+            }
+
+            int32_t BinaryReaderImpl::ReadStringInternal(char* res, const int32_t len)
+            {
+                int8_t hdr = stream->ReadInt8();
+
+                if (hdr == IGNITE_TYPE_STRING) {
+                    int32_t realLen = stream->ReadInt32();
+
+                    if (res && len >= realLen) {
+                        for (int i = 0; i < realLen; i++)
+                            *(res + i) = static_cast<char>(stream->ReadInt8());
+
+                        if (len > realLen)
+                            *(res + realLen) = 0; // Set NULL terminator if possible.
+                    }
+                    else
+                        stream->Position(stream->Position() - 4 - 1);
+
+                    return realLen;
+                }
+                else if (hdr != IGNITE_HDR_NULL)
+                    ThrowOnInvalidHeader(IGNITE_TYPE_ARRAY, hdr);
+
+                return -1;
+            }
+
+            int32_t BinaryReaderImpl::ReadArray(int32_t* size)
+            {
+                return StartContainerSession(true, IGNITE_TYPE_ARRAY, size);
+            }
+
+            int32_t BinaryReaderImpl::ReadArray(const char* fieldName, int32_t* size)
+            {
+                CheckRawMode(false);
+                CheckSingleMode(true);
+
+                int32_t fieldId = idRslvr->GetFieldId(typeId, fieldName);
+                int32_t fieldPos = FindField(fieldId);
+
+                if (fieldPos <= 0)
+                {
+                    *size = -1;
+
+                    return ++elemIdGen;
+                }
+
+                stream->Position(fieldPos);
+
+                return StartContainerSession(false, IGNITE_TYPE_ARRAY, size);
+            }
+
+            int32_t BinaryReaderImpl::ReadCollection(CollectionType* typ, int32_t* size)
+            {
+                int32_t id = StartContainerSession(true, IGNITE_TYPE_COLLECTION, size);
+
+                if (*size == -1)
+                    *typ = IGNITE_COLLECTION_UNDEFINED;
+                else
+                    *typ = static_cast<CollectionType>(stream->ReadInt8());
+
+                return id;
+            }
+
+            int32_t BinaryReaderImpl::ReadCollection(const char* fieldName, CollectionType* typ, int32_t* size)
+            {
+                CheckRawMode(false);
+                CheckSingleMode(true);
+
+                int32_t fieldId = idRslvr->GetFieldId(typeId, fieldName);
+                int32_t fieldPos = FindField(fieldId);
+
+                if (fieldPos <= 0)
+                {
+                    *typ = IGNITE_COLLECTION_UNDEFINED;
+                    *size = -1;
+
+                    return ++elemIdGen;
+                }
+
+                stream->Position(fieldPos);
+
+                int32_t id = StartContainerSession(false, IGNITE_TYPE_COLLECTION, size);
+
+                if (*size == -1)
+                    *typ = IGNITE_COLLECTION_UNDEFINED;
+                else
+                    *typ = static_cast<CollectionType>(stream->ReadInt8());
+
+                return id;
+            }
+
+            int32_t BinaryReaderImpl::ReadMap(MapType* typ, int32_t* size)
+            {
+                int32_t id = StartContainerSession(true, IGNITE_TYPE_MAP, size);
+
+                if (*size == -1)
+                    *typ = IGNITE_MAP_UNDEFINED;
+                else
+                    *typ = static_cast<MapType>(stream->ReadInt8());
+
+                return id;
+            }
+
+            int32_t BinaryReaderImpl::ReadMap(const char* fieldName, MapType* typ, int32_t* size)
+            {
+                CheckRawMode(false);
+                CheckSingleMode(true);
+
+                int32_t fieldId = idRslvr->GetFieldId(typeId, fieldName);
+                int32_t fieldPos = FindField(fieldId);
+
+                if (fieldPos <= 0)
+                {
+                    *typ = IGNITE_MAP_UNDEFINED;
+                    *size = -1;
+
+                    return ++elemIdGen;
+                }
+
+                stream->Position(fieldPos);
+
+                int32_t id = StartContainerSession(false, IGNITE_TYPE_MAP, size);
+
+                if (*size == -1)
+                    *typ = IGNITE_MAP_UNDEFINED;
+                else
+                    *typ = static_cast<MapType>(stream->ReadInt8());
+
+                return id;
+            }
+
+            CollectionType BinaryReaderImpl::ReadCollectionTypeUnprotected()
+            {
+                int32_t size = ReadCollectionSizeUnprotected();
+                if (size == -1)
+                    return IGNITE_COLLECTION_UNDEFINED;
+
+                CollectionType typ = static_cast<CollectionType>(stream->ReadInt8());
+
+                return typ;
+            }
+
+            CollectionType BinaryReaderImpl::ReadCollectionType()
+            {
+                InteropStreamPositionGuard<InteropInputStream> positionGuard(*stream);
+                
+                return ReadCollectionTypeUnprotected();
+            }
+
+            CollectionType BinaryReaderImpl::ReadCollectionType(const char* fieldName)
+            {
+                CheckRawMode(false);
+                CheckSingleMode(true);
+
+                InteropStreamPositionGuard<InteropInputStream> positionGuard(*stream);
+
+                int32_t fieldId = idRslvr->GetFieldId(typeId, fieldName);
+                int32_t fieldPos = FindField(fieldId);
+
+                if (fieldPos <= 0)
+                    return IGNITE_COLLECTION_UNDEFINED;
+
+                stream->Position(fieldPos);
+
+                return ReadCollectionTypeUnprotected();
+            }
+
+            int32_t BinaryReaderImpl::ReadCollectionSizeUnprotected()
+            {
+                int8_t hdr = stream->ReadInt8();
+
+                if (hdr != IGNITE_TYPE_COLLECTION)
+                {
+                    if (hdr != IGNITE_HDR_NULL)
+                        ThrowOnInvalidHeader(IGNITE_TYPE_COLLECTION, hdr);
+
+                    return -1;
+                }
+
+                int32_t size = stream->ReadInt32();
+
+                return size;
+            }
+
+            int32_t BinaryReaderImpl::ReadCollectionSize()
+            {
+                InteropStreamPositionGuard<InteropInputStream> positionGuard(*stream);
+
+                return ReadCollectionSizeUnprotected();
+            }
+
+            int32_t BinaryReaderImpl::ReadCollectionSize(const char* fieldName)
+            {
+                CheckRawMode(false);
+                CheckSingleMode(true);
+
+                InteropStreamPositionGuard<InteropInputStream> positionGuard(*stream);
+
+                int32_t fieldId = idRslvr->GetFieldId(typeId, fieldName);
+                int32_t fieldPos = FindField(fieldId);
+
+                if (fieldPos <= 0)
+                    return -1;
+
+                stream->Position(fieldPos);
+
+                return ReadCollectionSizeUnprotected();
+            }
+
+            bool BinaryReaderImpl::HasNextElement(int32_t id) const
+            {
+                return elemId == id && elemRead < elemCnt;
+            }
+
+            void BinaryReaderImpl::SetRawMode()
+            {
+                CheckRawMode(false);
+                CheckSingleMode(true);
+
+                stream->Position(pos + rawOff);
+                rawMode = true;
+            }
+
+            template <>
+            int8_t BinaryReaderImpl::ReadTopObject<int8_t>()
+            {
+                return ReadTopObject0(IGNITE_TYPE_BYTE, BinaryUtils::ReadInt8, static_cast<int8_t>(0));
+            }
+
+            template <>
+            bool BinaryReaderImpl::ReadTopObject<bool>()
+            {
+                return ReadTopObject0(IGNITE_TYPE_BOOL, BinaryUtils::ReadBool, static_cast<bool>(0));
+            }
+
+            template <>
+            int16_t BinaryReaderImpl::ReadTopObject<int16_t>()
+            {
+                return ReadTopObject0(IGNITE_TYPE_SHORT, BinaryUtils::ReadInt16, static_cast<int16_t>(0));
+            }
+
+            template <>
+            uint16_t BinaryReaderImpl::ReadTopObject<uint16_t>()
+            {
+                return ReadTopObject0(IGNITE_TYPE_CHAR, BinaryUtils::ReadUInt16, static_cast<uint16_t>(0));
+            }
+
+            template <>
+            int32_t BinaryReaderImpl::ReadTopObject<int32_t>()
+            {
+                return ReadTopObject0(IGNITE_TYPE_INT, BinaryUtils::ReadInt32, static_cast<int32_t>(0));
+            }
+
+            template <>
+            int64_t BinaryReaderImpl::ReadTopObject<int64_t>()
+            {
+                return ReadTopObject0(IGNITE_TYPE_LONG, BinaryUtils::ReadInt64, static_cast<int64_t>(0));
+            }
+
+            template <>
+            float BinaryReaderImpl::ReadTopObject<float>()
+            {
+                return ReadTopObject0(IGNITE_TYPE_FLOAT, BinaryUtils::ReadFloat, static_cast<float>(0));
+            }
+
+            template <>
+            double BinaryReaderImpl::ReadTopObject<double>()
+            {
+                return ReadTopObject0(IGNITE_TYPE_DOUBLE, BinaryUtils::ReadDouble, static_cast<double>(0));
+            }
+
+            template <>
+            Guid BinaryReaderImpl::ReadTopObject<Guid>()
+            {
+                int8_t typeId = stream->ReadInt8();
+
+                if (typeId == IGNITE_TYPE_UUID)
+                    return BinaryUtils::ReadGuid(stream);
+                else if (typeId == IGNITE_HDR_NULL)
+                    return Guid();
+                else {
+                    int32_t pos = stream->Position() - 1;
+
+                    IGNITE_ERROR_FORMATTED_3(IgniteError::IGNITE_ERR_BINARY, "Invalid header", "position", pos, "expected", IGNITE_TYPE_UUID, "actual", typeId)
+                }
+            }
+
+            InteropInputStream* BinaryReaderImpl::GetStream()
+            {
+                return stream;
+            }
+
+            int32_t BinaryReaderImpl::FindField(const int32_t fieldId)
+            {
+                InteropStreamPositionGuard<InteropInputStream> streamGuard(*stream);
+
+                stream->Position(footerBegin);
+
+                switch (schemaType)
+                {
+                    case OFFSET_TYPE_1_BYTE:
+                    {
+                        for (int32_t schemaPos = footerBegin; schemaPos < footerEnd; schemaPos += 5)
+                        {
+                            int32_t currentFieldId = stream->ReadInt32(schemaPos);
+
+                            if (fieldId == currentFieldId)
+                                return static_cast<uint8_t>(stream->ReadInt8(schemaPos + 4)) + pos;
+                        }
+                        break;
+                    }
+
+                    case OFFSET_TYPE_2_BYTE:
+                    {
+                        for (int32_t schemaPos = footerBegin; schemaPos < footerEnd; schemaPos += 6)
+                        {
+                            int32_t currentFieldId = stream->ReadInt32(schemaPos);
+
+                            if (fieldId == currentFieldId)
+                                return static_cast<uint16_t>(stream->ReadInt16(schemaPos + 4)) + pos;
+                        }
+                        break;
+                    }
+
+                    case OFFSET_TYPE_4_BYTE:
+                    {
+                        for (int32_t schemaPos = footerBegin; schemaPos < footerEnd; schemaPos += 8)
+                        {
+                            int32_t currentFieldId = stream->ReadInt32(schemaPos);
+
+                            if (fieldId == currentFieldId)
+                                return stream->ReadInt32(schemaPos + 4) + pos;
+                        }
+                        break;
+                    }
+                }
+
+                return -1;
+            }
+
+            void BinaryReaderImpl::CheckRawMode(bool expected) const
+            {
+                if (expected && !rawMode) {
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "Operation can be performed only in raw mode.")
+                }
+                else if (!expected && rawMode) {
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "Operation cannot be performed in raw mode.")
+                }
+            }
+
+            void BinaryReaderImpl::CheckSingleMode(bool expected) const
+            {
+                if (expected && elemId != 0) {
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "Operation cannot be performed when container is being read.");
+                }
+                else if (!expected && elemId == 0) {
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "Operation can be performed only when container is being read.");
+                }
+            }
+
+            int32_t BinaryReaderImpl::StartContainerSession(bool expRawMode, int8_t expHdr, int32_t* size)
+            {
+                CheckRawMode(expRawMode);
+                CheckSingleMode(true);
+
+                int8_t hdr = stream->ReadInt8();
+
+                if (hdr == expHdr)
+                {
+                    int32_t cnt = stream->ReadInt32();
+
+                    if (cnt != 0) 
+                    {
+                        elemId = ++elemIdGen;
+                        elemCnt = cnt;
+                        elemRead = 0;
+
+                        *size = cnt;
+
+                        return elemId;
+                    }
+                    else
+                    {
+                        *size = 0;
+
+                        return ++elemIdGen;
+                    }
+                }
+                else if (hdr == IGNITE_HDR_NULL) {
+                    *size = -1;
+
+                    return ++elemIdGen;
+                }
+                else {
+                    ThrowOnInvalidHeader(expHdr, hdr);
+
+                    return 0;
+                }
+            }
+
+            void BinaryReaderImpl::CheckSession(int32_t expSes) const
+            {
+                if (elemId != expSes) {
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "Containter read session has been finished or is not started yet.");
+                }
+            }
+
+            void BinaryReaderImpl::ThrowOnInvalidHeader(int32_t pos, int8_t expHdr, int8_t hdr)
+            {
+                IGNITE_ERROR_FORMATTED_3(IgniteError::IGNITE_ERR_BINARY, "Invalid header", "position", pos, "expected", expHdr, "actual", hdr)
+            }
+
+            void BinaryReaderImpl::ThrowOnInvalidHeader(int8_t expHdr, int8_t hdr) const
+            {
+                int32_t pos = stream->Position() - 1;
+
+                ThrowOnInvalidHeader(pos, expHdr, hdr);
+            }
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/303d79eb/modules/platforms/cpp/core/src/impl/binary/binary_schema.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/core/src/impl/binary/binary_schema.cpp b/modules/platforms/cpp/core/src/impl/binary/binary_schema.cpp
new file mode 100644
index 0000000..1596557
--- /dev/null
+++ b/modules/platforms/cpp/core/src/impl/binary/binary_schema.cpp
@@ -0,0 +1,135 @@
+/*
+* 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 <cassert>
+
+#include "ignite/impl/binary/binary_schema.h"
+#include "ignite/impl/binary/binary_writer_impl.h"
+
+/** FNV1 hash offset basis. */
+enum { FNV1_OFFSET_BASIS = 0x811C9DC5 };
+
+/** FNV1 hash prime. */
+enum { FNV1_PRIME = 0x01000193 };
+
+namespace ignite
+{
+    namespace impl
+    {
+        namespace binary
+        {
+            BinarySchema::BinarySchema(): id(0), fieldsInfo(new FieldContainer())
+            {
+                // No-op.
+            }
+
+            BinarySchema::~BinarySchema()
+            {
+                delete fieldsInfo;
+            }
+
+            void BinarySchema::AddField(int32_t fieldId, int32_t offset)
+            {
+                if (!id)
+                {
+                    // Initialize offset when the first field is written.
+                    id = FNV1_OFFSET_BASIS;
+                }
+
+                // Advance schema hash.
+                int32_t idAccumulator = id ^ (fieldId & 0xFF);
+                idAccumulator *= FNV1_PRIME;
+                idAccumulator ^= (fieldId >> 8) & 0xFF;
+                idAccumulator *= FNV1_PRIME;
+                idAccumulator ^= (fieldId >> 16) & 0xFF;
+                idAccumulator *= FNV1_PRIME;
+                idAccumulator ^= (fieldId >> 24) & 0xFF;
+                idAccumulator *= FNV1_PRIME;
+
+                id = idAccumulator;
+
+                BinarySchemaFieldInfo info = { fieldId, offset };
+                fieldsInfo->push_back(info);
+            }
+
+            void BinarySchema::Write(interop::InteropOutputStream& out) const
+            {
+                switch (GetType())
+                {
+                    case OFFSET_TYPE_1_BYTE:
+                    {
+                        for (FieldContainer::const_iterator i = fieldsInfo->begin(); i != fieldsInfo->end(); ++i)
+                        {
+                            out.WriteInt32(i->id);
+                            out.WriteInt8(static_cast<int8_t>(i->offset));
+                        }
+                        break;
+                    }
+
+                    case OFFSET_TYPE_2_BYTE:
+                    {
+                        for (FieldContainer::const_iterator i = fieldsInfo->begin(); i != fieldsInfo->end(); ++i)
+                        {
+                            out.WriteInt32(i->id);
+                            out.WriteInt16(static_cast<int16_t>(i->offset));
+                        }
+                        break;
+                    }
+
+                    case OFFSET_TYPE_4_BYTE:
+                    {
+                        for (FieldContainer::const_iterator i = fieldsInfo->begin(); i != fieldsInfo->end(); ++i)
+                        {
+                            out.WriteInt32(i->id);
+                            out.WriteInt32(i->offset);
+                        }
+                        break;
+                    }
+
+                    default:
+                    {
+                        assert(false);
+                        break;
+                    }
+                }
+            }
+
+            bool BinarySchema::Empty() const
+            {
+                return fieldsInfo->empty();
+            }
+
+            void BinarySchema::Clear()
+            {
+                id = 0;
+                fieldsInfo->clear();
+            }
+
+            BinaryOffsetType BinarySchema::GetType() const
+            {
+                int32_t maxOffset = fieldsInfo->back().offset;
+
+                if (maxOffset < 0x100)
+                    return OFFSET_TYPE_1_BYTE;
+                else if (maxOffset < 0x10000)
+                    return OFFSET_TYPE_2_BYTE;
+
+                return OFFSET_TYPE_4_BYTE;
+            }
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/303d79eb/modules/platforms/cpp/core/src/impl/binary/binary_type_handler.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/core/src/impl/binary/binary_type_handler.cpp b/modules/platforms/cpp/core/src/impl/binary/binary_type_handler.cpp
new file mode 100644
index 0000000..5e70707
--- /dev/null
+++ b/modules/platforms/cpp/core/src/impl/binary/binary_type_handler.cpp
@@ -0,0 +1,78 @@
+/*
+ * 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/impl/binary/binary_type_handler.h"
+
+using namespace ignite::common::concurrent;
+
+namespace ignite
+{    
+    namespace impl
+    {
+        namespace binary
+        {
+            BinaryTypeHandler::BinaryTypeHandler(SPSnap snap) : snap(snap), fieldIds(NULL), fields(NULL)
+            {
+                // No-op.
+            }
+            
+            BinaryTypeHandler::~BinaryTypeHandler()
+            {
+                if (fieldIds)
+                    delete fieldIds;
+
+                if (fields)
+                    delete fields;
+            }
+
+            void BinaryTypeHandler::OnFieldWritten(int32_t fieldId, std::string fieldName, int32_t fieldTypeId)
+            {
+                if (!snap.Get() || !snap.Get()->ContainsFieldId(fieldId))
+                {
+                    if (!HasDifference())
+                    {
+                        fieldIds = new std::set<int32_t>();
+                        fields = new std::map<std::string, int32_t>();
+                    }
+
+                    fieldIds->insert(fieldId);
+                    (*fields)[fieldName] = fieldTypeId;
+                }
+            }
+
+            SPSnap BinaryTypeHandler::GetSnapshot()
+            {
+                return snap;
+            }
+
+            bool BinaryTypeHandler::HasDifference()
+            {
+                return fieldIds ? true : false;
+            }
+
+            std::set<int32_t>* BinaryTypeHandler::GetFieldIds()
+            {
+                return fieldIds;
+            }
+
+            std::map<std::string, int32_t>* BinaryTypeHandler::GetFields()
+            {
+                return fields;
+            }
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/303d79eb/modules/platforms/cpp/core/src/impl/binary/binary_type_manager.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/core/src/impl/binary/binary_type_manager.cpp b/modules/platforms/cpp/core/src/impl/binary/binary_type_manager.cpp
new file mode 100644
index 0000000..9bd115c
--- /dev/null
+++ b/modules/platforms/cpp/core/src/impl/binary/binary_type_manager.cpp
@@ -0,0 +1,201 @@
+/*
+ * 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>
+
+#include "ignite/impl/binary/binary_type_manager.h"
+
+using namespace ignite::common::concurrent;
+
+namespace ignite
+{    
+    namespace impl
+    {
+        namespace binary
+        {
+            BinaryTypeManager::BinaryTypeManager() : 
+                snapshots(SharedPointer<std::map<int32_t, SPSnap>>(new std::map<int32_t, SPSnap>)),
+                pending(new std::vector<SPSnap>()), 
+                cs(new CriticalSection()), 
+                pendingVer(0), ver(0)
+            {
+                // No-op.
+            }
+
+            BinaryTypeManager::~BinaryTypeManager()
+            {
+                pending->erase(pending->begin(), pending->end());
+
+                delete pending;
+                delete cs;
+            }
+
+            SharedPointer<BinaryTypeHandler> BinaryTypeManager::GetHandler(int32_t typeId)
+            {
+                SharedPointer<std::map<int32_t, SPSnap>> snapshots0 = snapshots;
+
+                SPSnap snapshot = (*snapshots0.Get())[typeId];
+
+                return SharedPointer<BinaryTypeHandler>(new BinaryTypeHandler(snapshot));
+            }
+
+            void BinaryTypeManager::SubmitHandler(std::string typeName, int32_t typeId, 
+                BinaryTypeHandler* hnd)
+            {
+                Snap* snap = hnd->GetSnapshot().Get();
+
+                // If this is the very first write of a class or difference exists, 
+                // we need to enqueue it for write.
+                if (!snap || hnd->HasDifference())
+                {
+                    std::set<int32_t>* newFieldIds = new std::set<int32_t>();
+                    std::map<std::string, int32_t>* newFields = new std::map<std::string, int32_t>();
+                    
+                    CopyFields(snap, newFieldIds, newFields);
+
+                    if (hnd->HasDifference())
+                    {
+                        std::set<int32_t>* diffFieldIds = hnd->GetFieldIds();
+                        std::map<std::string, int32_t>* diffFields = hnd->GetFields();
+
+                        for (std::set<int32_t>::iterator it = diffFieldIds->begin(); it != diffFieldIds->end(); ++it)
+                            newFieldIds->insert(*it);
+
+                        for (std::map<std::string, int32_t>::iterator it = diffFields->begin(); it != diffFields->end(); ++it)
+                            (*newFields)[it->first] = it->second;
+                    }
+
+                    Snap* diffSnap = new Snap(typeName, typeId, newFieldIds, newFields);
+
+                    cs->Enter();
+
+                    pending->push_back(SPSnap(diffSnap));
+
+                    pendingVer++;
+
+                    cs->Leave();
+                }
+            }
+
+            int32_t BinaryTypeManager::GetVersion()
+            {
+                Memory::Fence();
+
+                return ver;
+            }
+
+            bool BinaryTypeManager::IsUpdatedSince(int32_t oldVer)
+            {
+                Memory::Fence();
+
+                return pendingVer > oldVer;
+            }
+
+            bool BinaryTypeManager::ProcessPendingUpdates(BinaryTypeUpdater* updater, IgniteError* err)
+            {
+                bool success = true; // Optimistically assume that all will be fine.
+                
+                cs->Enter();
+
+                for (std::vector<SPSnap>::iterator it = pending->begin(); it != pending->end(); ++it)
+                {
+                    Snap* pendingSnap = (*it).Get();
+
+                    if (updater->Update(pendingSnap, err))
+                    {
+                        // Perform copy-on-write update of snapshot collection.
+                        std::map<int32_t, SPSnap>* newSnapshots = new std::map<int32_t, SPSnap>();
+                        
+                        bool snapshotFound = false;
+
+                        for (std::map<int32_t, SPSnap>::iterator snapIt = snapshots.Get()->begin();
+                            snapIt != snapshots.Get()->end(); ++snapIt)
+                        {
+                            int32_t curTypeId = snapIt->first;
+                            Snap* curSnap = snapIt->second.Get();
+
+                            if (pendingSnap->GetTypeId() == curTypeId)
+                            {
+                                // Have to create snapshot with updated fields.
+                                std::set<int32_t>* newFieldIds = new std::set<int32_t>();
+                                std::map<std::string, int32_t>* newFields = new std::map<std::string, int32_t>();
+
+                                // Add old fields.
+                                CopyFields(curSnap, newFieldIds, newFields);
+
+                                // Add new fields.
+                                CopyFields(pendingSnap, newFieldIds, newFields);
+                                
+                                // Create new snapshot.
+                                Snap* newSnap = new Snap(pendingSnap->GetTypeName(), pendingSnap->GetTypeId(), 
+                                    newFieldIds, newFields);
+
+                                (*newSnapshots)[curTypeId] = SPSnap(newSnap);
+
+                                snapshotFound = true;
+                            }
+                            else 
+                                (*newSnapshots)[curTypeId] = snapIt->second; // Just transfer exising snapshot.
+                        }
+
+                        // Handle situation when completely new snapshot is found.
+                        if (!snapshotFound)
+                            (*newSnapshots)[pendingSnap->GetTypeId()] = *it;
+
+                        snapshots = SharedPointer<std::map<int32_t, SPSnap>>(newSnapshots);
+                    }
+                    else
+                    {
+                        // Stop as we cannot move further.
+                        success = false;
+
+                        break;
+                    }
+                }
+
+                if (success) 
+                {
+                    pending->erase(pending->begin(), pending->end());
+
+                    ver = pendingVer;
+                }
+
+                cs->Leave();
+
+                return success;
+            }
+
+            void BinaryTypeManager::CopyFields(Snap* snap, std::set<int32_t>* fieldIds, 
+                std::map<std::string, int32_t>* fields)
+            {
+                if (snap && snap->HasFields())
+                {
+                    std::set<int32_t>* snapFieldIds = snap->GetFieldIds();
+                    std::map<std::string, int32_t>* snapFields = snap->GetFields();
+
+                    for (std::set<int32_t>::iterator oldIt = snapFieldIds->begin();
+                        oldIt != snapFieldIds->end(); ++oldIt)
+                        fieldIds->insert(*oldIt);
+
+                    for (std::map<std::string, int32_t>::iterator newFieldsIt = snapFields->begin();
+                        newFieldsIt != snapFields->end(); ++newFieldsIt)
+                        (*fields)[newFieldsIt->first] = newFieldsIt->second;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/303d79eb/modules/platforms/cpp/core/src/impl/binary/binary_type_snapshot.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/core/src/impl/binary/binary_type_snapshot.cpp b/modules/platforms/cpp/core/src/impl/binary/binary_type_snapshot.cpp
new file mode 100644
index 0000000..f34732f
--- /dev/null
+++ b/modules/platforms/cpp/core/src/impl/binary/binary_type_snapshot.cpp
@@ -0,0 +1,70 @@
+/*
+ * 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/impl/binary/binary_type_snapshot.h"
+
+namespace ignite
+{    
+    namespace impl
+    {
+        namespace binary
+        {
+            BinaryTypeSnapshot::BinaryTypeSnapshot(std::string typeName, int32_t typeId, 
+                std::set<int32_t>* fieldIds, std::map<std::string, int32_t>* fields) : 
+                typeName(typeName), typeId(typeId), fieldIds(fieldIds), fields(fields)
+            {
+                // No-op.
+            }
+
+            BinaryTypeSnapshot::~BinaryTypeSnapshot()
+            {
+                delete fieldIds;
+                delete fields;
+            }
+
+            bool BinaryTypeSnapshot::ContainsFieldId(int32_t fieldId)
+            {
+                return fieldIds && fieldIds->count(fieldId) == 1;
+            }
+
+            std::string BinaryTypeSnapshot::GetTypeName()
+            {
+                return typeName;
+            }
+
+            int32_t BinaryTypeSnapshot::GetTypeId()
+            {
+                return typeId;
+            }
+
+            bool BinaryTypeSnapshot::HasFields()
+            {
+                return !fieldIds->empty();
+            }
+
+            std::set<int32_t>* BinaryTypeSnapshot::GetFieldIds()
+            {
+                return fieldIds;
+            }
+
+            std::map<std::string, int32_t>* BinaryTypeSnapshot::GetFields()
+            {
+                return fields;
+            }
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/303d79eb/modules/platforms/cpp/core/src/impl/binary/binary_type_updater.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/core/src/impl/binary/binary_type_updater.cpp b/modules/platforms/cpp/core/src/impl/binary/binary_type_updater.cpp
new file mode 100644
index 0000000..b3436e9
--- /dev/null
+++ b/modules/platforms/cpp/core/src/impl/binary/binary_type_updater.cpp
@@ -0,0 +1,32 @@
+/*
+ * 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/impl/binary/binary_type_updater.h"
+
+namespace ignite
+{    
+    namespace impl
+    {
+        namespace binary
+        {
+            BinaryTypeUpdater::~BinaryTypeUpdater()
+            {
+                // No-op.
+            }
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/303d79eb/modules/platforms/cpp/core/src/impl/binary/binary_type_updater_impl.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/core/src/impl/binary/binary_type_updater_impl.cpp b/modules/platforms/cpp/core/src/impl/binary/binary_type_updater_impl.cpp
new file mode 100644
index 0000000..2e86ccd
--- /dev/null
+++ b/modules/platforms/cpp/core/src/impl/binary/binary_type_updater_impl.cpp
@@ -0,0 +1,94 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ignite/impl/binary/binary_type_updater_impl.h"
+#include "ignite/impl/interop/interop_output_stream.h"
+#include "ignite/impl/binary/binary_writer_impl.h"
+#include "ignite/binary/binary_raw_writer.h"
+
+using namespace ignite::common::concurrent;
+using namespace ignite::common::java;
+using namespace ignite::impl;
+using namespace ignite::impl::interop;
+using namespace ignite::binary;
+
+namespace ignite
+{    
+    namespace impl
+    {
+        namespace binary
+        {
+            /** Operation: Clear. */
+            const int32_t OP_METADATA = -1;
+
+            BinaryTypeUpdaterImpl::BinaryTypeUpdaterImpl(SharedPointer<IgniteEnvironment> env,
+                jobject javaRef) :  env(env), javaRef(javaRef)
+            {
+                // No-op.
+            }
+
+            BinaryTypeUpdaterImpl::~BinaryTypeUpdaterImpl()
+            {
+                // No-op.
+            }
+
+            bool BinaryTypeUpdaterImpl::Update(Snap* snap, IgniteError* err)
+            {
+                JniErrorInfo jniErr;
+
+                SharedPointer<InteropMemory> mem = env.Get()->AllocateMemory();
+
+                InteropOutputStream out(mem.Get());
+                BinaryWriterImpl writer(&out, NULL);
+                BinaryRawWriter rawWriter(&writer);
+
+                // We always pass only one meta at a time in current implementation for simplicity.
+                rawWriter.WriteInt32(1);
+
+                rawWriter.WriteInt32(snap->GetTypeId());
+                rawWriter.WriteString(snap->GetTypeName());
+                rawWriter.WriteString(NULL); // Affinity key is not supported for now.
+                
+                if (snap->HasFields())
+                {
+                    std::map<std::string, int32_t>* fields = snap->GetFields();
+
+                    rawWriter.WriteInt32(static_cast<int32_t>(fields->size()));
+
+                    for (std::map<std::string, int32_t>::iterator it = fields->begin(); it != fields->end(); ++it)
+                    {
+                        rawWriter.WriteString(it->first);
+                        rawWriter.WriteInt32(it->second);
+                    }
+                }
+                else
+                    rawWriter.WriteInt32(0);
+
+                out.Synchronize();
+
+                long long res = env.Get()->Context()->TargetInStreamOutLong(javaRef, OP_METADATA, mem.Get()->PointerLong(), &jniErr);
+
+                IgniteError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
+
+                if (jniErr.code == IGNITE_JNI_ERR_SUCCESS)
+                    return res == 1;
+                else
+                    return false;
+            }
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/303d79eb/modules/platforms/cpp/core/src/impl/binary/binary_utils.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/core/src/impl/binary/binary_utils.cpp b/modules/platforms/cpp/core/src/impl/binary/binary_utils.cpp
new file mode 100644
index 0000000..8e26ea9
--- /dev/null
+++ b/modules/platforms/cpp/core/src/impl/binary/binary_utils.cpp
@@ -0,0 +1,211 @@
+/*
+ * 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/impl/interop/interop.h"
+#include "ignite/impl/binary/binary_utils.h"
+
+using namespace ignite::impl::interop;
+using namespace ignite::impl::binary;
+
+namespace ignite
+{
+    namespace impl
+    {
+        namespace binary
+        {
+            int8_t BinaryUtils::ReadInt8(InteropInputStream* stream)
+            {
+                return stream->ReadInt8();
+            }
+
+            void BinaryUtils::WriteInt8(InteropOutputStream* stream, int8_t val)
+            {
+                stream->WriteInt8(val); 
+            }
+
+            void BinaryUtils::ReadInt8Array(InteropInputStream* stream, int8_t* res, const int32_t len)
+            {
+                stream->ReadInt8Array(res, len);
+            }
+
+            void BinaryUtils::WriteInt8Array(InteropOutputStream* stream, const int8_t* val, const int32_t len)
+            {
+                stream->WriteInt8Array(val, len);
+            }
+
+            bool BinaryUtils::ReadBool(InteropInputStream* stream)
+            {
+                return stream->ReadBool();
+            }
+
+            void BinaryUtils::WriteBool(InteropOutputStream* stream, bool val)
+            {
+                stream->WriteBool(val);
+            }
+
+            void BinaryUtils::ReadBoolArray(InteropInputStream* stream, bool* res, const int32_t len)
+            {
+                stream->ReadBoolArray(res, len);
+            }
+
+            void BinaryUtils::WriteBoolArray(InteropOutputStream* stream, const bool* val, const int32_t len)
+            {
+                stream->WriteBoolArray(val, len);
+            }
+
+            int16_t BinaryUtils::ReadInt16(InteropInputStream* stream)
+            {
+                return stream->ReadInt16();
+            }
+
+            void BinaryUtils::WriteInt16(InteropOutputStream* stream, int16_t val)
+            {
+                stream->WriteInt16(val);
+            }
+
+            void BinaryUtils::ReadInt16Array(InteropInputStream* stream, int16_t* res, const int32_t len)
+            {
+                stream->ReadInt16Array(res, len);
+            }
+            
+            void BinaryUtils::WriteInt16Array(InteropOutputStream* stream, const int16_t* val, const int32_t len)
+            {
+                stream->WriteInt16Array(val, len);
+            }
+
+            uint16_t BinaryUtils::ReadUInt16(InteropInputStream* stream)
+            {
+                return stream->ReadUInt16();
+            }
+
+            void BinaryUtils::WriteUInt16(InteropOutputStream* stream, uint16_t val)
+            {
+                stream->WriteUInt16(val);
+            }
+
+            void BinaryUtils::ReadUInt16Array(InteropInputStream* stream, uint16_t* res, const int32_t len)
+            {
+                stream->ReadUInt16Array(res, len);
+            }
+
+            void BinaryUtils::WriteUInt16Array(InteropOutputStream* stream, const uint16_t* val, const int32_t len)
+            {
+                stream->WriteUInt16Array(val, len);
+            }
+
+            int32_t BinaryUtils::ReadInt32(InteropInputStream* stream)
+            {
+                return stream->ReadInt32();
+            }
+
+            void BinaryUtils::WriteInt32(InteropOutputStream* stream, int32_t val)
+            {
+                stream->WriteInt32(val);
+            }
+
+            void BinaryUtils::ReadInt32Array(InteropInputStream* stream, int32_t* res, const int32_t len)
+            {
+                stream->ReadInt32Array(res, len);
+            }
+
+            void BinaryUtils::WriteInt32Array(InteropOutputStream* stream, const int32_t* val, const int32_t len)
+            {
+                stream->WriteInt32Array(val, len);
+            }
+
+            int64_t BinaryUtils::ReadInt64(InteropInputStream* stream)
+            {
+                return stream->ReadInt64();
+            }
+
+            void BinaryUtils::WriteInt64(InteropOutputStream* stream, int64_t val)
+            {
+                stream->WriteInt64(val);
+            }
+
+            void BinaryUtils::ReadInt64Array(InteropInputStream* stream, int64_t* res, const int32_t len)
+            {
+                stream->ReadInt64Array(res, len);
+            }
+
+            void BinaryUtils::WriteInt64Array(InteropOutputStream* stream, const int64_t* val, const int32_t len)
+            {
+                stream->WriteInt64Array(val, len);
+            }
+
+            float BinaryUtils::ReadFloat(InteropInputStream* stream)
+            {
+                return stream->ReadFloat();
+            }
+
+            void BinaryUtils::WriteFloat(InteropOutputStream* stream, float val)
+            {
+                stream->WriteFloat(val);
+            }
+
+            void BinaryUtils::ReadFloatArray(InteropInputStream* stream, float* res, const int32_t len)
+            {
+                stream->ReadFloatArray(res, len);
+            }
+
+            void BinaryUtils::WriteFloatArray(InteropOutputStream* stream, const float* val, const int32_t len)
+            {
+                stream->WriteFloatArray(val, len);
+            }
+
+            double BinaryUtils::ReadDouble(InteropInputStream* stream)
+            {
+                return stream->ReadDouble();
+            }
+
+            void BinaryUtils::WriteDouble(InteropOutputStream* stream, double val)
+            {
+                stream->WriteDouble(val);
+            }
+
+            void BinaryUtils::ReadDoubleArray(InteropInputStream* stream, double* res, const int32_t len)
+            {
+                stream->ReadDoubleArray(res, len);
+            }
+
+            void BinaryUtils::WriteDoubleArray(InteropOutputStream* stream, const double* val, const int32_t len)
+            {
+                stream->WriteDoubleArray(val, len);
+            }
+
+            Guid BinaryUtils::ReadGuid(interop::InteropInputStream* stream)
+            {
+                int64_t most = stream->ReadInt64();
+                int64_t least = stream->ReadInt64();
+
+                return Guid(most, least);
+            }
+
+            void BinaryUtils::WriteGuid(interop::InteropOutputStream* stream, const Guid val)
+            {
+                stream->WriteInt64(val.GetMostSignificantBits());
+                stream->WriteInt64(val.GetLeastSignificantBits());
+            }
+
+            void BinaryUtils::WriteString(interop::InteropOutputStream* stream, const char* val, const int32_t len)
+            {
+                stream->WriteInt32(len);
+                stream->WriteInt8Array(reinterpret_cast<const int8_t*>(val), len);
+            }
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/303d79eb/modules/platforms/cpp/core/src/impl/binary/binary_writer_impl.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/core/src/impl/binary/binary_writer_impl.cpp b/modules/platforms/cpp/core/src/impl/binary/binary_writer_impl.cpp
new file mode 100644
index 0000000..47df19d
--- /dev/null
+++ b/modules/platforms/cpp/core/src/impl/binary/binary_writer_impl.cpp
@@ -0,0 +1,622 @@
+/*
+ * 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/impl/binary/binary_writer_impl.h"
+#include "ignite/impl/interop/interop_stream_position_guard.h"
+#include "ignite/ignite_error.h"
+
+using namespace ignite::impl::interop;
+using namespace ignite::impl::binary;
+using namespace ignite::binary;
+
+namespace ignite
+{
+    namespace impl
+    {
+        namespace binary
+        {
+            BinaryWriterImpl::BinaryWriterImpl(InteropOutputStream* stream, BinaryIdResolver* idRslvr, 
+                BinaryTypeManager* metaMgr, BinaryTypeHandler* metaHnd, int32_t start) :
+                stream(stream), idRslvr(idRslvr), metaMgr(metaMgr), metaHnd(metaHnd), typeId(idRslvr->GetTypeId()),
+                elemIdGen(0), elemId(0), elemCnt(0), elemPos(-1), rawPos(-1), start(start)
+            {
+                // No-op.
+            }
+            
+            BinaryWriterImpl::BinaryWriterImpl(InteropOutputStream* stream, BinaryTypeManager* metaMgr) :
+                stream(stream), idRslvr(NULL), metaMgr(metaMgr), metaHnd(NULL), typeId(0), 
+                elemIdGen(0), elemId(0), elemCnt(0), elemPos(-1), rawPos(0), start(stream->Position())
+            {
+                // No-op.
+            }
+
+            void BinaryWriterImpl::WriteInt8(const int8_t val)
+            {
+                WritePrimitiveRaw<int8_t>(val, BinaryUtils::WriteInt8);
+            }
+
+            void BinaryWriterImpl::WriteInt8Array(const int8_t* val, const int32_t len)
+            {
+                WritePrimitiveArrayRaw<int8_t>(val, len, BinaryUtils::WriteInt8Array, IGNITE_TYPE_ARRAY_BYTE);
+            }
+
+            void BinaryWriterImpl::WriteInt8(const char* fieldName, const int8_t val)
+            {
+                WritePrimitive<int8_t>(fieldName, val, BinaryUtils::WriteInt8, IGNITE_TYPE_BYTE, 1);
+            }
+
+            void BinaryWriterImpl::WriteInt8Array(const char* fieldName, const int8_t* val, const int32_t len)
+            {
+                WritePrimitiveArray<int8_t>(fieldName, val, len, BinaryUtils::WriteInt8Array, IGNITE_TYPE_ARRAY_BYTE, 0);
+            }
+
+            void BinaryWriterImpl::WriteBool(const bool val)
+            {
+                WritePrimitiveRaw<bool>(val, BinaryUtils::WriteBool);
+            }
+
+            void BinaryWriterImpl::WriteBoolArray(const bool* val, const int32_t len)
+            {
+                WritePrimitiveArrayRaw<bool>(val, len, BinaryUtils::WriteBoolArray, IGNITE_TYPE_ARRAY_BOOL);
+            }
+
+            void BinaryWriterImpl::WriteBool(const char* fieldName, const bool val)
+            {
+                WritePrimitive<bool>(fieldName, val, BinaryUtils::WriteBool, IGNITE_TYPE_BOOL, 1);
+            }
+
+            void BinaryWriterImpl::WriteBoolArray(const char* fieldName, const bool* val, const int32_t len)
+            {
+                WritePrimitiveArray<bool>(fieldName, val, len, BinaryUtils::WriteBoolArray, IGNITE_TYPE_ARRAY_BOOL, 0);
+            }
+
+            void BinaryWriterImpl::WriteInt16(const int16_t val)
+            {
+                WritePrimitiveRaw<int16_t>(val, BinaryUtils::WriteInt16);
+            }
+
+            void BinaryWriterImpl::WriteInt16Array(const int16_t* val, const int32_t len)
+            {
+                WritePrimitiveArrayRaw<int16_t>(val, len, BinaryUtils::WriteInt16Array, IGNITE_TYPE_ARRAY_SHORT);
+            }
+
+            void BinaryWriterImpl::WriteInt16(const char* fieldName, const int16_t val)
+            {
+                WritePrimitive<int16_t>(fieldName, val, BinaryUtils::WriteInt16, IGNITE_TYPE_SHORT, 2);
+            }
+
+            void BinaryWriterImpl::WriteInt16Array(const char* fieldName, const int16_t* val, const int32_t len)
+            {
+                WritePrimitiveArray<int16_t>(fieldName, val, len, BinaryUtils::WriteInt16Array, IGNITE_TYPE_ARRAY_SHORT, 1);
+            }
+
+            void BinaryWriterImpl::WriteUInt16(const uint16_t val)
+            {
+                WritePrimitiveRaw<uint16_t>(val, BinaryUtils::WriteUInt16);
+            }
+
+            void BinaryWriterImpl::WriteUInt16Array(const uint16_t* val, const int32_t len)
+            {
+                WritePrimitiveArrayRaw<uint16_t>(val, len, BinaryUtils::WriteUInt16Array, IGNITE_TYPE_ARRAY_CHAR);
+            }
+
+            void BinaryWriterImpl::WriteUInt16(const char* fieldName, const uint16_t val)
+            {
+                WritePrimitive<uint16_t>(fieldName, val, BinaryUtils::WriteUInt16, IGNITE_TYPE_CHAR, 2);
+            }
+
+            void BinaryWriterImpl::WriteUInt16Array(const char* fieldName, const uint16_t* val, const int32_t len)
+            {
+                WritePrimitiveArray<uint16_t>(fieldName, val, len, BinaryUtils::WriteUInt16Array, IGNITE_TYPE_ARRAY_CHAR, 1);
+            }
+
+            void BinaryWriterImpl::WriteInt32(const int32_t val)
+            {
+                WritePrimitiveRaw<int32_t>(val, BinaryUtils::WriteInt32);
+            }
+
+            void BinaryWriterImpl::WriteInt32Array(const int32_t* val, const int32_t len)
+            {
+                WritePrimitiveArrayRaw<int32_t>(val, len, BinaryUtils::WriteInt32Array, IGNITE_TYPE_ARRAY_INT);
+            }
+
+            void BinaryWriterImpl::WriteInt32(const char* fieldName, const int32_t val)
+            {
+                WritePrimitive<int32_t>(fieldName, val, BinaryUtils::WriteInt32, IGNITE_TYPE_INT, 4);
+            }
+
+            void BinaryWriterImpl::WriteInt32Array(const char* fieldName, const int32_t* val, const int32_t len)
+            {
+                WritePrimitiveArray<int32_t>(fieldName, val, len, BinaryUtils::WriteInt32Array, IGNITE_TYPE_ARRAY_INT, 2);
+            }
+
+            void BinaryWriterImpl::WriteInt64(const int64_t val)
+            {
+                WritePrimitiveRaw<int64_t>(val, BinaryUtils::WriteInt64);
+            }
+
+            void BinaryWriterImpl::WriteInt64Array(const int64_t* val, const int32_t len)
+            {
+                WritePrimitiveArrayRaw<int64_t>(val, len, BinaryUtils::WriteInt64Array, IGNITE_TYPE_ARRAY_LONG);
+            }
+
+            void BinaryWriterImpl::WriteInt64(const char* fieldName, const int64_t val)
+            {
+                WritePrimitive<int64_t>(fieldName, val, BinaryUtils::WriteInt64, IGNITE_TYPE_LONG, 8);
+            }
+
+            void BinaryWriterImpl::WriteInt64Array(const char* fieldName, const int64_t* val, const int32_t len)
+            {
+                WritePrimitiveArray<int64_t>(fieldName, val, len, BinaryUtils::WriteInt64Array, IGNITE_TYPE_ARRAY_LONG, 3);
+            }
+
+            void BinaryWriterImpl::WriteFloat(const float val)
+            {
+                WritePrimitiveRaw<float>(val, BinaryUtils::WriteFloat);
+            }
+
+            void BinaryWriterImpl::WriteFloatArray(const float* val, const int32_t len)
+            {
+                WritePrimitiveArrayRaw<float>(val, len, BinaryUtils::WriteFloatArray, IGNITE_TYPE_ARRAY_FLOAT);
+            }
+
+            void BinaryWriterImpl::WriteFloat(const char* fieldName, const float val)
+            {
+                WritePrimitive<float>(fieldName, val, BinaryUtils::WriteFloat, IGNITE_TYPE_FLOAT, 4);
+            }
+
+            void BinaryWriterImpl::WriteFloatArray(const char* fieldName, const float* val, const int32_t len)
+            {
+                WritePrimitiveArray<float>(fieldName, val, len, BinaryUtils::WriteFloatArray, IGNITE_TYPE_ARRAY_FLOAT, 2);
+            }
+
+            void BinaryWriterImpl::WriteDouble(const double val)
+            {
+                WritePrimitiveRaw<double>(val, BinaryUtils::WriteDouble);
+            }
+
+            void BinaryWriterImpl::WriteDoubleArray(const double* val, const int32_t len)
+            {
+                WritePrimitiveArrayRaw<double>(val, len, BinaryUtils::WriteDoubleArray, IGNITE_TYPE_ARRAY_DOUBLE);
+            }
+
+            void BinaryWriterImpl::WriteDouble(const char* fieldName, const double val)
+            {
+                WritePrimitive<double>(fieldName, val, BinaryUtils::WriteDouble, IGNITE_TYPE_DOUBLE, 8);
+            }
+
+            void BinaryWriterImpl::WriteDoubleArray(const char* fieldName, const double* val, const int32_t len)
+            {
+                WritePrimitiveArray<double>(fieldName, val, len, BinaryUtils::WriteDoubleArray, IGNITE_TYPE_ARRAY_DOUBLE, 3);
+            }
+
+            void BinaryWriterImpl::WriteGuid(const Guid val)
+            {                
+                CheckRawMode(true);
+                CheckSingleMode(true);
+
+                stream->WriteInt8(IGNITE_TYPE_UUID);
+
+                BinaryUtils::WriteGuid(stream, val);
+            }
+
+            void BinaryWriterImpl::WriteGuidArray(const Guid* val, const int32_t len)
+            {
+                CheckRawMode(true);
+                CheckSingleMode(true);
+                
+                if (val)
+                {
+                    stream->WriteInt8(IGNITE_TYPE_ARRAY_UUID);
+                    stream->WriteInt32(len);
+
+                    for (int i = 0; i < len; i++)
+                    {
+                        Guid elem = *(val + i);
+
+                        stream->WriteInt8(IGNITE_TYPE_UUID);
+                        BinaryUtils::WriteGuid(stream, elem);
+                    }
+                }
+                else
+                    stream->WriteInt8(IGNITE_HDR_NULL);
+            }
+
+            void BinaryWriterImpl::WriteGuid(const char* fieldName, const Guid val)
+            {
+                CheckRawMode(false);
+                CheckSingleMode(true);
+
+                WriteFieldId(fieldName, IGNITE_TYPE_UUID);
+
+                stream->WriteInt8(IGNITE_TYPE_UUID);
+
+                BinaryUtils::WriteGuid(stream, val);
+            }
+
+            void BinaryWriterImpl::WriteGuidArray(const char* fieldName, const Guid* val, const int32_t len)
+            {
+                CheckRawMode(false);
+                CheckSingleMode(true);
+
+                WriteFieldId(fieldName, IGNITE_TYPE_ARRAY_UUID);
+
+                if (val)
+                {
+                    stream->WriteInt8(IGNITE_TYPE_ARRAY_UUID);
+                    stream->WriteInt32(len);
+
+                    for (int i = 0; i < len; i++)
+                    {
+                        Guid elem = *(val + i);
+
+                        WriteTopObject(elem);
+                    }
+                }
+                else
+                {
+                    stream->WriteInt8(IGNITE_HDR_NULL);
+                }
+            }
+
+            void BinaryWriterImpl::WriteString(const char* val, const int32_t len)
+            {
+                CheckRawMode(true);
+                CheckSingleMode(true);
+
+                if (val) 
+                {
+                    stream->WriteInt8(IGNITE_TYPE_STRING);
+
+                    BinaryUtils::WriteString(stream, val, len);
+                }
+                else
+                    stream->WriteInt8(IGNITE_HDR_NULL);
+            }
+
+            void BinaryWriterImpl::WriteString(const char* fieldName, const char* val, const int32_t len)
+            {
+                CheckRawMode(false);
+                CheckSingleMode(true);
+
+                WriteFieldId(fieldName, IGNITE_TYPE_STRING);
+                
+                if (val)
+                {
+                    stream->WriteInt8(IGNITE_TYPE_STRING);
+
+                    BinaryUtils::WriteString(stream, val, len);
+                }
+                else
+                    stream->WriteInt8(IGNITE_HDR_NULL);
+            }
+
+            int32_t BinaryWriterImpl::WriteStringArray()
+            {
+                StartContainerSession(true);
+
+                stream->WriteInt8(IGNITE_TYPE_ARRAY_STRING);
+                stream->Position(stream->Position() + 4);
+
+                return elemId;
+            }
+
+            int32_t BinaryWriterImpl::WriteStringArray(const char* fieldName)
+            {
+                StartContainerSession(false);
+
+                WriteFieldId(fieldName, IGNITE_TYPE_ARRAY_STRING);
+
+                stream->WriteInt8(IGNITE_TYPE_ARRAY_STRING);
+                stream->Position(stream->Position() + 4);
+
+                return elemId;
+            }
+
+            void BinaryWriterImpl::WriteStringElement(int32_t id, const char* val, int32_t len)
+            {
+                CheckSession(id);
+
+                if (val)
+                {
+                    stream->WriteInt8(IGNITE_TYPE_STRING);
+
+                    BinaryUtils::WriteString(stream, val, len);
+                }
+                else
+                    stream->WriteInt8(IGNITE_HDR_NULL);
+
+                elemCnt++;
+            }
+
+            void BinaryWriterImpl::WriteNull()
+            {
+                CheckRawMode(true);
+                CheckSingleMode(true);
+
+                stream->WriteInt8(IGNITE_HDR_NULL);
+            }
+
+            void BinaryWriterImpl::WriteNull(const char* fieldName)
+            {
+                CheckRawMode(false);
+                CheckSingleMode(true);
+
+                WriteFieldId(fieldName, IGNITE_TYPE_OBJECT);
+                stream->WriteInt8(IGNITE_HDR_NULL);
+            }
+
+            int32_t BinaryWriterImpl::WriteArray()
+            {
+                StartContainerSession(true);
+                
+                stream->WriteInt8(IGNITE_TYPE_ARRAY);
+                stream->Position(stream->Position() + 4);
+
+                return elemId;
+            }
+
+            int32_t BinaryWriterImpl::WriteArray(const char* fieldName)
+            {
+                StartContainerSession(false);
+
+                WriteFieldId(fieldName, IGNITE_TYPE_ARRAY);
+
+                stream->WriteInt8(IGNITE_TYPE_ARRAY);
+                stream->Position(stream->Position() + 4);
+
+                return elemId;
+            }
+
+            int32_t BinaryWriterImpl::WriteCollection(CollectionType typ)
+            {
+                StartContainerSession(true);
+
+                stream->WriteInt8(IGNITE_TYPE_COLLECTION);
+                stream->Position(stream->Position() + 4);
+                stream->WriteInt8(typ);
+
+                return elemId;
+            }
+
+            int32_t BinaryWriterImpl::WriteCollection(const char* fieldName, CollectionType typ)
+            {
+                StartContainerSession(false);
+                
+                WriteFieldId(fieldName, IGNITE_TYPE_COLLECTION);
+
+                stream->WriteInt8(IGNITE_TYPE_COLLECTION);
+                stream->Position(stream->Position() + 4);
+                stream->WriteInt8(typ);
+
+                return elemId;
+            }
+
+            int32_t BinaryWriterImpl::WriteMap(ignite::binary::MapType typ)
+            {
+                StartContainerSession(true);
+
+                stream->WriteInt8(IGNITE_TYPE_MAP);
+                stream->Position(stream->Position() + 4);
+                stream->WriteInt8(typ);
+
+                return elemId;
+            }
+
+            int32_t BinaryWriterImpl::WriteMap(const char* fieldName, ignite::binary::MapType typ)
+            {
+                StartContainerSession(false);
+
+                WriteFieldId(fieldName, IGNITE_TYPE_MAP);
+                
+                stream->WriteInt8(IGNITE_TYPE_MAP);
+                stream->Position(stream->Position() + 4);
+                stream->WriteInt8(typ);
+
+                return elemId;
+            }
+
+            void BinaryWriterImpl::CommitContainer(int32_t id)
+            {
+                CheckSession(id);
+
+                stream->WriteInt32(elemPos + 1, elemCnt);
+
+                elemId = 0;
+                elemCnt = 0;
+                elemPos = -1;
+            }
+            
+            void BinaryWriterImpl::SetRawMode()
+            {
+                CheckRawMode(false);
+                CheckSingleMode(true);
+
+                rawPos = stream->Position();
+            }
+
+            int32_t BinaryWriterImpl::GetRawPosition() const
+            {
+                return rawPos == -1 ? stream->Position() : rawPos;
+            }
+
+            void BinaryWriterImpl::CheckRawMode(bool expected) const
+            {
+                bool rawMode = rawPos != -1;
+
+                if (expected && !rawMode) {
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "Operation can be performed only in raw mode.");
+                }
+                else if (!expected && rawMode) {
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "Operation cannot be performed in raw mode.");
+                }
+            }
+
+            void BinaryWriterImpl::CheckSingleMode(bool expected) const
+            {
+                if (expected && elemId != 0) {
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "Operation cannot be performed when container is being written.");
+                }
+                else if (!expected && elemId == 0) {
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "Operation can be performed only when container is being written.");
+                }
+            }
+
+            void BinaryWriterImpl::StartContainerSession(bool expRawMode)
+            {
+                CheckRawMode(expRawMode);
+                CheckSingleMode(true);
+
+                elemId = ++elemIdGen;
+                elemPos = stream->Position();
+            }
+
+            void BinaryWriterImpl::CheckSession(int32_t expSes) const
+            {
+                if (elemId != expSes) 
+                {
+                    IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "Containter write session has been finished or is not started yet.");
+                }
+            }
+
+            void BinaryWriterImpl::WriteFieldId(const char* fieldName, int32_t fieldTypeId)
+            {
+                int32_t fieldId = idRslvr->GetFieldId(typeId, fieldName);
+                int32_t fieldOff = stream->Position() - start;
+
+                schema.AddField(fieldId, fieldOff);
+
+                if (metaHnd)
+                    metaHnd->OnFieldWritten(fieldId, fieldName, fieldTypeId);
+            }
+
+            template <>
+            void BinaryWriterImpl::WriteTopObject<int8_t>(const int8_t& obj)
+            {
+                WriteTopObject0<int8_t>(obj, BinaryUtils::WriteInt8, IGNITE_TYPE_BYTE);
+            }
+
+            template <>
+            void BinaryWriterImpl::WriteTopObject<bool>(const bool& obj)
+            {
+                WriteTopObject0<bool>(obj, BinaryUtils::WriteBool, IGNITE_TYPE_BOOL);
+            }
+
+            template <>
+            void BinaryWriterImpl::WriteTopObject<int16_t>(const int16_t& obj)
+            {
+                WriteTopObject0<int16_t>(obj, BinaryUtils::WriteInt16, IGNITE_TYPE_SHORT);
+            }
+
+            template <>
+            void BinaryWriterImpl::WriteTopObject<uint16_t>(const uint16_t& obj)
+            {
+                WriteTopObject0<uint16_t>(obj, BinaryUtils::WriteUInt16, IGNITE_TYPE_CHAR);
+            }
+
+            template <>
+            void BinaryWriterImpl::WriteTopObject<int32_t>(const int32_t& obj)
+            {
+                WriteTopObject0<int32_t>(obj, BinaryUtils::WriteInt32, IGNITE_TYPE_INT);
+            }
+
+            template <>
+            void BinaryWriterImpl::WriteTopObject<int64_t>(const int64_t& obj)
+            {
+                WriteTopObject0<int64_t>(obj, BinaryUtils::WriteInt64, IGNITE_TYPE_LONG);
+            }
+
+            template <>
+            void BinaryWriterImpl::WriteTopObject<float>(const float& obj)
+            {
+                WriteTopObject0<float>(obj, BinaryUtils::WriteFloat, IGNITE_TYPE_FLOAT);
+            }
+
+            template <>
+            void BinaryWriterImpl::WriteTopObject<double>(const double& obj)
+            {
+                WriteTopObject0<double>(obj, BinaryUtils::WriteDouble, IGNITE_TYPE_DOUBLE);
+            }
+
+            template <>
+            void BinaryWriterImpl::WriteTopObject<Guid>(const Guid& obj)
+            {
+                WriteTopObject0<Guid>(obj, BinaryUtils::WriteGuid, IGNITE_TYPE_UUID);
+            }
+
+            void BinaryWriterImpl::PostWrite()
+            {
+                int32_t lenWithoutSchema = stream->Position() - start;
+
+                int32_t nonRawLen = rawPos == -1 ? lenWithoutSchema : rawPos - start;
+                
+                if (schema.Empty())
+                {
+                    stream->WriteInt16(start + IGNITE_OFFSET_FLAGS, IGNITE_BINARY_FLAG_USER_OBJECT | 
+                                                                    IGNITE_BINARY_FLAG_RAW_ONLY);
+                    stream->WriteInt32(start + IGNITE_OFFSET_LEN, lenWithoutSchema);
+                    stream->WriteInt32(start + IGNITE_OFFSET_SCHEMA_ID, 0);
+                    stream->WriteInt32(start + IGNITE_OFFSET_SCHEMA_OR_RAW_OFF, GetRawPosition() - start);
+                }
+                else
+                {
+                    int32_t schemaId = schema.GetId();
+                    BinaryOffsetType schemaType = schema.GetType();
+
+                    WriteAndClearSchema();
+
+                    if (rawPos > 0)
+                        stream->WriteInt32(rawPos - start);
+
+                    int32_t length = stream->Position() - start;
+
+                    if (schemaType == OFFSET_TYPE_1_BYTE)
+                    {
+                        stream->WriteInt16(start + IGNITE_OFFSET_FLAGS, 
+                            IGNITE_BINARY_FLAG_USER_OBJECT | IGNITE_BINARY_FLAG_OFFSET_1_BYTE);
+                    }
+                    else if (schemaType == OFFSET_TYPE_2_BYTE)
+                    {
+                        stream->WriteInt16(start + IGNITE_OFFSET_FLAGS, 
+                            IGNITE_BINARY_FLAG_USER_OBJECT | IGNITE_BINARY_FLAG_OFFSET_2_BYTE);
+                    }
+
+                    stream->WriteInt32(start + IGNITE_OFFSET_LEN, length);
+                    stream->WriteInt32(start + IGNITE_OFFSET_SCHEMA_ID, schemaId);
+                    stream->WriteInt32(start + IGNITE_OFFSET_SCHEMA_OR_RAW_OFF, lenWithoutSchema);
+                }
+            }
+
+            bool BinaryWriterImpl::HasSchema() const
+            {
+                return !schema.Empty();
+            }
+
+            void BinaryWriterImpl::WriteAndClearSchema()
+            {
+                schema.Write(*stream);
+
+                schema.Clear();
+            }
+
+            InteropOutputStream* BinaryWriterImpl::GetStream()
+            {
+                return stream;
+            }
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/303d79eb/modules/platforms/cpp/core/src/impl/cache/cache_impl.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/core/src/impl/cache/cache_impl.cpp b/modules/platforms/cpp/core/src/impl/cache/cache_impl.cpp
index 05c3e38..08526b5 100644
--- a/modules/platforms/cpp/core/src/impl/cache/cache_impl.cpp
+++ b/modules/platforms/cpp/core/src/impl/cache/cache_impl.cpp
@@ -18,10 +18,10 @@
 #include "ignite/cache/cache_peek_mode.h"
 #include "ignite/impl/cache/cache_impl.h"
 #include "ignite/impl/interop/interop.h"
-#include "ignite/impl/portable/portable_reader_impl.h"
+#include "ignite/impl/binary/binary_reader_impl.h"
 #include "ignite/impl/utils.h"
-#include "ignite/impl/portable/portable_metadata_updater_impl.h"
-#include "ignite/portable/portable.h"
+#include "ignite/impl/binary/binary_type_updater_impl.h"
+#include "ignite/binary/binary.h"
 
 using namespace ignite::common::concurrent;
 using namespace ignite::common::java;
@@ -30,9 +30,9 @@ using namespace ignite::cache::query;
 using namespace ignite::impl;
 using namespace ignite::impl::cache::query;
 using namespace ignite::impl::interop;
-using namespace ignite::impl::portable;
+using namespace ignite::impl::binary;
 using namespace ignite::impl::utils;
-using namespace ignite::portable;
+using namespace ignite::binary;
 
 namespace ignite
 {
@@ -301,12 +301,12 @@ namespace ignite
 
             int64_t CacheImpl::WriteTo(InteropMemory* mem, InputOperation& inOp, IgniteError* err)
             {
-                PortableMetadataManager* metaMgr = env.Get()->GetMetadataManager();
+                BinaryTypeManager* metaMgr = env.Get()->GetTypeManager();
 
                 int32_t metaVer = metaMgr->GetVersion();
 
                 InteropOutputStream out(mem);
-                PortableWriterImpl writer(&out, metaMgr);
+                BinaryWriterImpl writer(&out, metaMgr);
                 
                 inOp.ProcessInput(writer);
 
@@ -314,7 +314,7 @@ namespace ignite
 
                 if (metaMgr->IsUpdatedSince(metaVer))
                 {
-                    PortableMetadataUpdaterImpl metaUpdater(env, javaRef);
+                    BinaryTypeUpdaterImpl metaUpdater(env, javaRef);
 
                     if (!metaMgr->ProcessPendingUpdates(&metaUpdater, err))
                         return 0;
@@ -327,7 +327,7 @@ namespace ignite
             {
                 InteropInputStream in(mem);
 
-                PortableReaderImpl reader(&in);
+                BinaryReaderImpl reader(&in);
 
                 outOp.ProcessOutput(reader);
             }


Mime
View raw message