ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From akuznet...@apache.org
Subject [27/60] [abbrv] ignite git commit: IGNITE-1786: Implemented ODBC driver.
Date Thu, 12 May 2016 06:42:21 GMT
http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/binary/project/vs/binary.vcxproj
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/binary/project/vs/binary.vcxproj b/modules/platforms/cpp/binary/project/vs/binary.vcxproj
new file mode 100644
index 0000000..212c554
--- /dev/null
+++ b/modules/platforms/cpp/binary/project/vs/binary.vcxproj
@@ -0,0 +1,233 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{4F15669B-92EB-49F0-B774-8F19BAE0B960}</ProjectGuid>
+    <RootNamespace>binary</RootNamespace>
+    <ProjectName>binary</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v100</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v100</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v100</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v100</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <TargetName>ignite.binary</TargetName>
+    <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <TargetName>ignite.binary</TargetName>
+    <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <TargetName>ignite.binary</TargetName>
+    <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <TargetName>ignite.binary</TargetName>
+    <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\</IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>false</SDLCheck>
+      <AdditionalIncludeDirectories>$(ProjectDir)\..\..\..\common\include;$(ProjectDir)\..\..\..\common\os\win\include;$(ProjectDir)\..\..\include</AdditionalIncludeDirectories>
+      <InlineFunctionExpansion>Disabled</InlineFunctionExpansion>
+      <IntrinsicFunctions>false</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
+      <OmitFramePointers>false</OmitFramePointers>
+      <StringPooling>true</StringPooling>
+      <MinimalRebuild>false</MinimalRebuild>
+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
+      <BufferSecurityCheck>true</BufferSecurityCheck>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;IGNITE_IMPL;IGNITE_FRIEND;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <WholeProgramOptimization>false</WholeProgramOptimization>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>false</SDLCheck>
+      <AdditionalIncludeDirectories>$(ProjectDir)\..\..\..\common\include;$(ProjectDir)\..\..\..\common\os\win\include;$(ProjectDir)\..\..\include</AdditionalIncludeDirectories>
+      <InlineFunctionExpansion>Disabled</InlineFunctionExpansion>
+      <IntrinsicFunctions>false</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
+      <OmitFramePointers>false</OmitFramePointers>
+      <StringPooling>true</StringPooling>
+      <MinimalRebuild>false</MinimalRebuild>
+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
+      <BufferSecurityCheck>true</BufferSecurityCheck>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;IGNITE_IMPL;IGNITE_FRIEND;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <WholeProgramOptimization>false</WholeProgramOptimization>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Full</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>false</SDLCheck>
+      <AdditionalIncludeDirectories>$(ProjectDir)\..\..\..\common\include;$(ProjectDir)\..\..\..\common\os\win\include;$(ProjectDir)\..\..\include</AdditionalIncludeDirectories>
+      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <StringPooling>true</StringPooling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;IGNITE_IMPL;IGNITE_FRIEND;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>false</SDLCheck>
+      <AdditionalIncludeDirectories>$(ProjectDir)\..\..\..\common\include;$(ProjectDir)\..\..\..\common\os\win\include;$(ProjectDir)\..\..\include</AdditionalIncludeDirectories>
+      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <StringPooling>true</StringPooling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;IGNITE_IMPL;IGNITE_FRIEND;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\include\ignite\binary\binary.h" />
+    <ClInclude Include="..\..\include\ignite\binary\binary_consts.h" />
+    <ClInclude Include="..\..\include\ignite\binary\binary_containers.h" />
+    <ClInclude Include="..\..\include\ignite\binary\binary_raw_reader.h" />
+    <ClInclude Include="..\..\include\ignite\binary\binary_raw_writer.h" />
+    <ClInclude Include="..\..\include\ignite\binary\binary_reader.h" />
+    <ClInclude Include="..\..\include\ignite\binary\binary_type.h" />
+    <ClInclude Include="..\..\include\ignite\binary\binary_writer.h" />
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_common.h" />
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_id_resolver.h" />
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_reader_impl.h" />
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_schema.h" />
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_type_handler.h" />
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_type_manager.h" />
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_type_snapshot.h" />
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_type_updater.h" />
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_utils.h" />
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_writer_impl.h" />
+    <ClInclude Include="..\..\include\ignite\impl\interop\interop.h" />
+    <ClInclude Include="..\..\include\ignite\impl\interop\interop_input_stream.h" />
+    <ClInclude Include="..\..\include\ignite\impl\interop\interop_memory.h" />
+    <ClInclude Include="..\..\include\ignite\impl\interop\interop_output_stream.h" />
+    <ClInclude Include="..\..\include\ignite\impl\interop\interop_stream_position_guard.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\binary\binary_containers.cpp" />
+    <ClCompile Include="..\..\src\binary\binary_raw_reader.cpp" />
+    <ClCompile Include="..\..\src\binary\binary_raw_writer.cpp" />
+    <ClCompile Include="..\..\src\binary\binary_reader.cpp" />
+    <ClCompile Include="..\..\src\binary\binary_type.cpp" />
+    <ClCompile Include="..\..\src\binary\binary_writer.cpp" />
+    <ClCompile Include="..\..\src\impl\binary\binary_reader_impl.cpp" />
+    <ClCompile Include="..\..\src\impl\binary\binary_schema.cpp" />
+    <ClCompile Include="..\..\src\impl\binary\binary_type_handler.cpp" />
+    <ClCompile Include="..\..\src\impl\binary\binary_type_manager.cpp" />
+    <ClCompile Include="..\..\src\impl\binary\binary_type_snapshot.cpp" />
+    <ClCompile Include="..\..\src\impl\binary\binary_type_updater.cpp" />
+    <ClCompile Include="..\..\src\impl\binary\binary_utils.cpp" />
+    <ClCompile Include="..\..\src\impl\binary\binary_writer_impl.cpp" />
+    <ClCompile Include="..\..\src\impl\interop\interop_input_stream.cpp" />
+    <ClCompile Include="..\..\src\impl\interop\interop_memory.cpp" />
+    <ClCompile Include="..\..\src\impl\interop\interop_output_stream.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\common\project\vs\common.vcxproj">
+      <Project>{b63f2e01-5157-4719-8491-0e1c7cd3b701}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/binary/project/vs/binary.vcxproj.filters
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/binary/project/vs/binary.vcxproj.filters b/modules/platforms/cpp/binary/project/vs/binary.vcxproj.filters
new file mode 100644
index 0000000..09aca58
--- /dev/null
+++ b/modules/platforms/cpp/binary/project/vs/binary.vcxproj.filters
@@ -0,0 +1,145 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Code">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Code\binary">
+      <UniqueIdentifier>{1815eb01-65f5-4142-b773-06abf2dcd0af}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Code\impl">
+      <UniqueIdentifier>{7cb1d41b-cf13-4c88-a663-3d74f0bd1b52}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Code\impl\binary">
+      <UniqueIdentifier>{12775752-54bd-4c9c-b890-0252b2f221b5}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Code\impl\interop">
+      <UniqueIdentifier>{d41f0ecd-360a-4a59-a5fb-98db54a3e170}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\include\ignite\binary\binary.h">
+      <Filter>Code\binary</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\binary\binary_consts.h">
+      <Filter>Code\binary</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\binary\binary_containers.h">
+      <Filter>Code\binary</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\binary\binary_raw_reader.h">
+      <Filter>Code\binary</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\binary\binary_raw_writer.h">
+      <Filter>Code\binary</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\binary\binary_reader.h">
+      <Filter>Code\binary</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\binary\binary_type.h">
+      <Filter>Code\binary</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\binary\binary_writer.h">
+      <Filter>Code\binary</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_common.h">
+      <Filter>Code\impl\binary</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_id_resolver.h">
+      <Filter>Code\impl\binary</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_reader_impl.h">
+      <Filter>Code\impl\binary</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_schema.h">
+      <Filter>Code\impl\binary</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_type_handler.h">
+      <Filter>Code\impl\binary</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_type_manager.h">
+      <Filter>Code\impl\binary</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_type_snapshot.h">
+      <Filter>Code\impl\binary</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_type_updater.h">
+      <Filter>Code\impl\binary</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_utils.h">
+      <Filter>Code\impl\binary</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\impl\binary\binary_writer_impl.h">
+      <Filter>Code\impl\binary</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\impl\interop\interop.h">
+      <Filter>Code\impl\interop</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\impl\interop\interop_input_stream.h">
+      <Filter>Code\impl\interop</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\impl\interop\interop_memory.h">
+      <Filter>Code\impl\interop</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\impl\interop\interop_output_stream.h">
+      <Filter>Code\impl\interop</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\ignite\impl\interop\interop_stream_position_guard.h">
+      <Filter>Code\impl\interop</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\binary\binary_containers.cpp">
+      <Filter>Code\binary</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\binary\binary_raw_reader.cpp">
+      <Filter>Code\binary</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\binary\binary_raw_writer.cpp">
+      <Filter>Code\binary</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\binary\binary_reader.cpp">
+      <Filter>Code\binary</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\binary\binary_type.cpp">
+      <Filter>Code\binary</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\binary\binary_writer.cpp">
+      <Filter>Code\binary</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\impl\binary\binary_reader_impl.cpp">
+      <Filter>Code\impl\binary</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\impl\binary\binary_schema.cpp">
+      <Filter>Code\impl\binary</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\impl\binary\binary_type_handler.cpp">
+      <Filter>Code\impl\binary</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\impl\binary\binary_type_manager.cpp">
+      <Filter>Code\impl\binary</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\impl\binary\binary_type_snapshot.cpp">
+      <Filter>Code\impl\binary</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\impl\binary\binary_type_updater.cpp">
+      <Filter>Code\impl\binary</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\impl\binary\binary_utils.cpp">
+      <Filter>Code\impl\binary</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\impl\binary\binary_writer_impl.cpp">
+      <Filter>Code\impl\binary</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\impl\interop\interop_input_stream.cpp">
+      <Filter>Code\impl\interop</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\impl\interop\interop_memory.cpp">
+      <Filter>Code\impl\interop</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\impl\interop\interop_output_stream.cpp">
+      <Filter>Code\impl\interop</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/binary/src/binary/binary_containers.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/binary/src/binary/binary_containers.cpp b/modules/platforms/cpp/binary/src/binary/binary_containers.cpp
new file mode 100644
index 0000000..91645cc
--- /dev/null
+++ b/modules/platforms/cpp/binary/src/binary/binary_containers.cpp
@@ -0,0 +1,76 @@
+/*
+ * 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/binary/binary_containers.h"
+
+using namespace ignite::impl::binary;
+
+namespace ignite
+{
+    namespace binary
+    {
+        BinaryStringArrayWriter::BinaryStringArrayWriter(BinaryWriterImpl* impl, int32_t id) : 
+            impl(impl), id(id)
+        {
+            // No-op.
+        }
+
+        void BinaryStringArrayWriter::Write(const char* val)
+        {
+            if (val)
+                Write(val, static_cast<int32_t>(strlen(val)));
+            else
+                Write(NULL, -1);
+        }
+
+        void BinaryStringArrayWriter::Write(const char* val, int32_t len)
+        {
+            impl->WriteStringElement(id, val, len);
+        }
+
+        void BinaryStringArrayWriter::Close()
+        {
+            impl->CommitContainer(id);
+        }
+
+        BinaryStringArrayReader::BinaryStringArrayReader(impl::binary::BinaryReaderImpl* impl, 
+            int32_t id, int32_t size) : impl(impl), id(id), size(size)
+        {
+            // No-op.
+        }
+
+        bool BinaryStringArrayReader::HasNext()
+        {
+            return impl->HasNextElement(id);
+        }
+
+        int32_t BinaryStringArrayReader::GetNext(char* res, int32_t len)
+        {
+            return impl->ReadStringElement(id, res, len);
+        }
+
+        int32_t BinaryStringArrayReader::GetSize() const
+        {
+            return size;
+        }
+
+        bool BinaryStringArrayReader::IsNull() const
+        {
+            return size == -1;
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/binary/src/binary/binary_raw_reader.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/binary/src/binary/binary_raw_reader.cpp b/modules/platforms/cpp/binary/src/binary/binary_raw_reader.cpp
new file mode 100644
index 0000000..e472588
--- /dev/null
+++ b/modules/platforms/cpp/binary/src/binary/binary_raw_reader.cpp
@@ -0,0 +1,166 @@
+/*
+ * 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/binary/binary_raw_reader.h"
+#include "ignite/impl/binary/binary_reader_impl.h"
+
+using namespace ignite::impl::binary;
+
+namespace ignite
+{
+    namespace binary
+    {        
+        BinaryRawReader::BinaryRawReader(BinaryReaderImpl* impl) : impl(impl)
+        {
+            // No-op.
+        }
+        
+        int8_t BinaryRawReader::ReadInt8()
+        {
+            return impl->ReadInt8();
+        }
+
+        int32_t BinaryRawReader::ReadInt8Array(int8_t* res, const int32_t len)
+        {
+            return impl->ReadInt8Array(res, len);
+        }
+        
+        bool BinaryRawReader::ReadBool()
+        {
+            return impl->ReadBool();
+        }
+
+        int32_t BinaryRawReader::ReadBoolArray(bool* res, const int32_t len)
+        {
+            return impl->ReadBoolArray(res, len);
+        }
+
+        int16_t BinaryRawReader::ReadInt16()
+        {
+            return impl->ReadInt16();
+        }
+        
+        int32_t BinaryRawReader::ReadInt16Array(int16_t* res, const int32_t len)
+        {
+            return impl->ReadInt16Array(res, len);
+        }
+
+        uint16_t BinaryRawReader::ReadUInt16()
+        {
+            return impl->ReadUInt16();
+        }
+
+        int32_t BinaryRawReader::ReadUInt16Array(uint16_t* res, const int32_t len)
+        {
+            return impl->ReadUInt16Array(res, len);
+        }
+
+        int32_t BinaryRawReader::ReadInt32()
+        {
+            return impl->ReadInt32();
+        }
+        
+        int32_t BinaryRawReader::ReadInt32Array(int32_t* res, const int32_t len)
+        {
+            return impl->ReadInt32Array(res, len);
+        }
+
+        int64_t BinaryRawReader::ReadInt64()
+        {
+            return impl->ReadInt64();
+        }
+
+        int32_t BinaryRawReader::ReadInt64Array(int64_t* res, const int32_t len)
+        {
+            return impl->ReadInt64Array(res, len);
+        }
+
+        float BinaryRawReader::ReadFloat()
+        {
+            return impl->ReadFloat();
+        }
+        
+        int32_t BinaryRawReader::ReadFloatArray(float* res, const int32_t len)
+        {
+            return impl->ReadFloatArray(res, len);
+        }
+
+        double BinaryRawReader::ReadDouble()
+        {
+            return impl->ReadDouble();
+        }
+        
+        int32_t BinaryRawReader::ReadDoubleArray(double* res, const int32_t len)
+        {
+            return impl->ReadDoubleArray(res, len);
+        }
+        
+        Guid BinaryRawReader::ReadGuid()
+        {
+            return impl->ReadGuid();
+        }
+
+        int32_t BinaryRawReader::ReadGuidArray(Guid* res, const int32_t len)
+        {
+            return impl->ReadGuidArray(res, len);
+        }
+
+        Date BinaryRawReader::ReadDate()
+        {
+            return impl->ReadDate();
+        }
+
+        int32_t BinaryRawReader::ReadDateArray(Date* res, int32_t len)
+        {
+            return impl->ReadDateArray(res, len);
+        }
+
+        Timestamp BinaryRawReader::ReadTimestamp()
+        {
+            return impl->ReadTimestamp();
+        }
+
+        int32_t BinaryRawReader::ReadTimestampArray(Timestamp * res, int32_t len)
+        {
+            return impl->ReadTimestampArray(res, len);
+        }
+
+        int32_t BinaryRawReader::ReadString(char* res, const int32_t len)
+        {
+            return impl->ReadString(res, len);
+        }
+
+        BinaryStringArrayReader BinaryRawReader::ReadStringArray()
+        {
+            int32_t size;
+
+            int32_t id = impl->ReadStringArray(&size);
+
+            return BinaryStringArrayReader(impl, id, size);
+        }
+
+        CollectionType BinaryRawReader::ReadCollectionType()
+        {
+            return impl->ReadCollectionType();
+        }
+
+        int32_t BinaryRawReader::ReadCollectionSize()
+        {
+            return impl->ReadCollectionSize();
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/binary/src/binary/binary_raw_writer.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/binary/src/binary/binary_raw_writer.cpp b/modules/platforms/cpp/binary/src/binary/binary_raw_writer.cpp
new file mode 100644
index 0000000..a83c74b
--- /dev/null
+++ b/modules/platforms/cpp/binary/src/binary/binary_raw_writer.cpp
@@ -0,0 +1,167 @@
+/*
+ * 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/binary/binary_raw_writer.h"
+
+using namespace ignite::impl::binary;
+
+namespace ignite
+{
+    namespace binary
+    {
+        BinaryRawWriter::BinaryRawWriter(BinaryWriterImpl* impl) : impl(impl)
+        {
+            // No-op.
+        }
+
+        void BinaryRawWriter::WriteInt8(int8_t val)
+        {
+            impl->WriteInt8(val);
+        }
+
+        void BinaryRawWriter::WriteInt8Array(const int8_t* val, int32_t len)
+        {
+            impl->WriteInt8Array(val, len);
+        }
+
+        void BinaryRawWriter::WriteBool(bool val)
+        {
+            impl->WriteBool(val);
+        }
+
+        void BinaryRawWriter::WriteBoolArray(const bool* val, int32_t len)
+        {            
+            impl->WriteBoolArray(val, len);
+        }
+
+        void BinaryRawWriter::WriteInt16(int16_t val)
+        {
+            impl->WriteInt16(val);
+        }
+
+        void BinaryRawWriter::WriteInt16Array(const int16_t* val, int32_t len)
+        {
+            impl->WriteInt16Array(val, len);
+        }
+
+        void BinaryRawWriter::WriteUInt16(uint16_t val)
+        {
+            impl->WriteUInt16(val);
+        }
+
+        void BinaryRawWriter::WriteUInt16Array(const uint16_t* val, int32_t len)
+        {
+            impl->WriteUInt16Array(val, len);
+        }
+
+        void BinaryRawWriter::WriteInt32(int32_t val)
+        {
+            impl->WriteInt32(val);
+        }
+
+        void BinaryRawWriter::WriteInt32Array(const int32_t* val, int32_t len)
+        {
+            impl->WriteInt32Array(val, len);
+        }
+
+        void BinaryRawWriter::WriteInt64(int64_t val)
+        {
+            impl->WriteInt64(val);
+        }
+
+        void BinaryRawWriter::WriteInt64Array(const int64_t* val, int32_t len)
+        {
+            impl->WriteInt64Array(val, len);
+        }
+
+        void BinaryRawWriter::WriteFloat(float val)
+        {
+            impl->WriteFloat(val);
+        }
+
+        void BinaryRawWriter::WriteFloatArray(const float* val, int32_t len)
+        {
+            impl->WriteFloatArray(val, len);
+        }
+
+        void BinaryRawWriter::WriteDouble(double val)
+        {
+            impl->WriteDouble(val);
+        }
+
+        void BinaryRawWriter::WriteDoubleArray(const double* val, int32_t len)
+        {
+            impl->WriteDoubleArray(val, len);
+        }
+
+        void BinaryRawWriter::WriteGuid(const Guid& val)
+        {
+            impl->WriteGuid(val);
+        }
+
+        void BinaryRawWriter::WriteGuidArray(const Guid* val, int32_t len)
+        {
+            impl->WriteGuidArray(val, len);
+        }
+
+        void BinaryRawWriter::WriteDate(const Date& val)
+        {
+            impl->WriteDate(val);
+        }
+
+        void BinaryRawWriter::WriteDateArray(const Date* val, int32_t len)
+        {
+            impl->WriteDateArray(val, len);
+        }
+
+        void BinaryRawWriter::WriteTimestamp(const Timestamp& val)
+        {
+            impl->WriteTimestamp(val);
+        }
+
+        void BinaryRawWriter::WriteTimestampArray(const Timestamp* val, int32_t len)
+        {
+            impl->WriteTimestampArray(val, len);
+        }
+
+        void BinaryRawWriter::WriteString(const char* val)
+        {
+            if (val)
+                WriteString(val, static_cast<int32_t>(strlen(val)));
+            else
+                WriteNull();
+        }
+
+        void BinaryRawWriter::WriteString(const char* val, int32_t len)
+        {
+            impl->WriteString(val, len);
+        }
+
+        BinaryStringArrayWriter BinaryRawWriter::WriteStringArray()
+        {
+            int32_t id = impl->WriteStringArray();
+
+            return BinaryStringArrayWriter(impl, id);
+        }
+
+        void BinaryRawWriter::WriteNull()
+        {
+            impl->WriteNull();
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/binary/src/binary/binary_reader.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/binary/src/binary/binary_reader.cpp b/modules/platforms/cpp/binary/src/binary/binary_reader.cpp
new file mode 100644
index 0000000..814db83
--- /dev/null
+++ b/modules/platforms/cpp/binary/src/binary/binary_reader.cpp
@@ -0,0 +1,173 @@
+/*
+ * 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/binary/binary_reader.h"
+#include "ignite/impl/binary/binary_reader_impl.h"
+
+using namespace ignite::impl::binary;
+
+namespace ignite
+{
+    namespace binary
+    {
+        BinaryReader::BinaryReader(BinaryReaderImpl* impl) : impl(impl)
+        {
+            // No-op.
+        }
+        
+        int8_t BinaryReader::ReadInt8(const char* fieldName)
+        {
+            return impl->ReadInt8(fieldName);
+        }
+
+        int32_t BinaryReader::ReadInt8Array(const char* fieldName, int8_t* res, int32_t len)
+        {
+            return impl->ReadInt8Array(fieldName, res, len);
+        }
+
+        bool BinaryReader::ReadBool(const char* fieldName)
+        {
+            return impl->ReadBool(fieldName);
+        }
+
+        int32_t BinaryReader::ReadBoolArray(const char* fieldName, bool* res, int32_t len)
+        {
+            return impl->ReadBoolArray(fieldName, res, len);
+        }
+
+        int16_t BinaryReader::ReadInt16(const char* fieldName)
+        {
+            return impl->ReadInt16(fieldName);
+        }
+
+        int32_t BinaryReader::ReadInt16Array(const char* fieldName, int16_t* res, int32_t len)
+        {
+            return impl->ReadInt16Array(fieldName, res, len);
+        }
+
+        uint16_t BinaryReader::ReadUInt16(const char* fieldName)
+        {
+            return impl->ReadUInt16(fieldName);
+        }
+
+        int32_t BinaryReader::ReadUInt16Array(const char* fieldName, uint16_t* res, int32_t len)
+        {
+            return impl->ReadUInt16Array(fieldName, res, len);
+        }
+
+        int32_t BinaryReader::ReadInt32(const char* fieldName)
+        {
+            return impl->ReadInt32(fieldName);
+        }
+
+        int32_t BinaryReader::ReadInt32Array(const char* fieldName, int32_t* res, int32_t len)
+        {
+            return impl->ReadInt32Array(fieldName, res, len);
+        }
+
+        int64_t BinaryReader::ReadInt64(const char* fieldName)
+        {
+            return impl->ReadInt64(fieldName);
+        }
+
+        int32_t BinaryReader::ReadInt64Array(const char* fieldName, int64_t* res, int32_t len)
+        {
+            return impl->ReadInt64Array(fieldName, res, len);
+        }
+
+        float BinaryReader::ReadFloat(const char* fieldName)
+        {
+            return impl->ReadFloat(fieldName);
+        }
+
+        int32_t BinaryReader::ReadFloatArray(const char* fieldName, float* res, int32_t len)
+        {
+            return impl->ReadFloatArray(fieldName, res, len);
+        }
+
+        double BinaryReader::ReadDouble(const char* fieldName)
+        {
+            return impl->ReadDouble(fieldName);
+        }
+
+        int32_t BinaryReader::ReadDoubleArray(const char* fieldName, double* res, int32_t len)
+        {
+            return impl->ReadDoubleArray(fieldName, res, len);
+        }
+
+        Guid BinaryReader::ReadGuid(const char* fieldName)
+        {
+            return impl->ReadGuid(fieldName);
+        }
+
+        int32_t BinaryReader::ReadGuidArray(const char* fieldName, Guid* res, int32_t len)
+        {
+            return impl->ReadGuidArray(fieldName, res, len);
+        }
+
+        Date BinaryReader::ReadDate(const char * fieldName)
+        {
+            return impl->ReadDate(fieldName);
+        }
+
+        int32_t BinaryReader::ReadDateArray(const char * fieldName, Date * res, const int32_t len)
+        {
+            return impl->ReadDateArray(fieldName, res, len);
+        }
+
+        Timestamp BinaryReader::ReadTimestamp(const char * fieldName)
+        {
+            return impl->ReadTimestamp(fieldName);
+        }
+
+        int32_t BinaryReader::ReadTimestampArray(const char * fieldName, Timestamp * res, const int32_t len)
+        {
+            return impl->ReadTimestampArray(fieldName, res, len);
+        }
+        
+        int32_t BinaryReader::ReadString(const char* fieldName, char* res, int32_t len)
+        {
+            return impl->ReadString(fieldName, res, len);
+        }
+
+        BinaryStringArrayReader BinaryReader::ReadStringArray(const char* fieldName)
+        {
+            int32_t size;
+
+            int32_t id = impl->ReadStringArray(fieldName, &size);
+
+            return BinaryStringArrayReader(impl, id, size);
+        }
+
+        CollectionType BinaryReader::ReadCollectionType(const char* fieldName)
+        {
+            return impl->ReadCollectionType(fieldName);
+        }
+
+        int32_t BinaryReader::ReadCollectionSize(const char* fieldName)
+        {
+            return impl->ReadCollectionSize(fieldName);
+        }
+
+        BinaryRawReader BinaryReader::RawReader()
+        {
+            impl->SetRawMode();
+
+            return BinaryRawReader(impl);
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/binary/src/binary/binary_type.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/binary/src/binary/binary_type.cpp b/modules/platforms/cpp/binary/src/binary/binary_type.cpp
new file mode 100644
index 0000000..19d906d
--- /dev/null
+++ b/modules/platforms/cpp/binary/src/binary/binary_type.cpp
@@ -0,0 +1,51 @@
+/*
+ * 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/binary/binary_type.h"
+
+namespace ignite
+{
+    namespace binary
+    {
+        int32_t GetBinaryStringHashCode(const char* val)
+        {
+            if (val)
+            {
+                int32_t hash = 0;
+
+                int i = 0;
+
+                while (true)
+                {
+                    char c = *(val + i++);
+
+                    if (c == '\0')
+                        break;
+
+                    if ('A' <= c && c <= 'Z')
+                        c = c | 0x20;
+
+                    hash = 31 * hash + c;
+                }
+
+                return hash;
+            }
+            else
+                return 0;
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/binary/src/binary/binary_writer.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/binary/src/binary/binary_writer.cpp b/modules/platforms/cpp/binary/src/binary/binary_writer.cpp
new file mode 100644
index 0000000..efbc0ce
--- /dev/null
+++ b/modules/platforms/cpp/binary/src/binary/binary_writer.cpp
@@ -0,0 +1,174 @@
+/*
+ * 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/binary/binary_writer.h"
+
+using namespace ignite::impl::binary;
+
+namespace ignite
+{
+    namespace binary
+    {
+        BinaryWriter::BinaryWriter(BinaryWriterImpl* impl) : impl(impl)
+        {
+            // No-op.
+        }
+
+        void BinaryWriter::WriteInt8(const char* fieldName, int8_t val)
+        {
+            impl->WriteInt8(fieldName, val);
+        }
+
+        void BinaryWriter::WriteInt8Array(const char* fieldName, const int8_t* val, int32_t len)
+        {
+            impl->WriteInt8Array(fieldName, val, len);
+        }
+
+        void BinaryWriter::WriteBool(const char* fieldName, bool val)
+        {
+            impl->WriteBool(fieldName, val);
+        }
+
+        void BinaryWriter::WriteBoolArray(const char* fieldName, const bool* val, int32_t len)
+        {
+            impl->WriteBoolArray(fieldName, val, len);
+        }
+
+        void BinaryWriter::WriteInt16(const char* fieldName, int16_t val)
+        {
+            impl->WriteInt16(fieldName, val);
+        }
+
+        void BinaryWriter::WriteInt16Array(const char* fieldName, const int16_t* val, int32_t len)
+        {
+            impl->WriteInt16Array(fieldName, val, len);
+        }
+
+        void BinaryWriter::WriteUInt16(const char* fieldName, uint16_t val)
+        {
+            impl->WriteUInt16(fieldName, val);
+        }
+
+        void BinaryWriter::WriteUInt16Array(const char* fieldName, const uint16_t* val, int32_t len)
+        {
+            impl->WriteUInt16Array(fieldName, val, len);
+        }
+
+        void BinaryWriter::WriteInt32(const char* fieldName, int32_t val)
+        {
+            impl->WriteInt32(fieldName, val);
+        }
+
+        void BinaryWriter::WriteInt32Array(const char* fieldName, const int32_t* val, int32_t len)
+        {
+            impl->WriteInt32Array(fieldName, val, len);
+        }
+
+        void BinaryWriter::WriteInt64(const char* fieldName, const int64_t val)
+        {
+            impl->WriteInt64(fieldName, val);
+        }
+
+        void BinaryWriter::WriteInt64Array(const char* fieldName, const int64_t* val, int32_t len)
+        {
+            impl->WriteInt64Array(fieldName, val, len);
+        }
+
+        void BinaryWriter::WriteFloat(const char* fieldName, float val)
+        {
+            impl->WriteFloat(fieldName, val);
+        }
+
+        void BinaryWriter::WriteFloatArray(const char* fieldName, const float* val, int32_t len)
+        {
+            impl->WriteFloatArray(fieldName, val, len);
+        }
+
+        void BinaryWriter::WriteDouble(const char* fieldName, double val)
+        {
+            impl->WriteDouble(fieldName, val);
+        }
+
+        void BinaryWriter::WriteDoubleArray(const char* fieldName, const double* val, int32_t len)
+        {
+            impl->WriteDoubleArray(fieldName, val, len);
+        }
+
+        void BinaryWriter::WriteGuid(const char* fieldName, const Guid& val)
+        {
+            impl->WriteGuid(fieldName, val);
+        }
+
+        void BinaryWriter::WriteGuidArray(const char* fieldName, const Guid* val, const int32_t len)
+        {
+            impl->WriteGuidArray(fieldName, val, len);
+        }
+
+        void BinaryWriter::WriteDate(const char * fieldName, const Date & val)
+        {
+            impl->WriteDate(fieldName, val);
+        }
+
+        void BinaryWriter::WriteDateArray(const char * fieldName, const Date * val, const int32_t len)
+        {
+            impl->WriteDateArray(fieldName, val, len);
+        }
+
+        void BinaryWriter::WriteTimestamp(const char * fieldName, const Timestamp & val)
+        {
+            impl->WriteTimestamp(fieldName, val);
+        }
+
+        void BinaryWriter::WriteTimestampArray(const char * fieldName, const Timestamp * val, const int32_t len)
+        {
+            impl->WriteTimestampArray(fieldName, val, len);
+        }
+
+        void BinaryWriter::WriteString(const char* fieldName, const char* val)
+        {
+            if (val)
+                WriteString(fieldName, val, static_cast<int32_t>(strlen(val)));
+            else
+                WriteNull(fieldName);
+        }
+
+        void BinaryWriter::WriteString(const char* fieldName, const char* val, int32_t len)
+        {
+            impl->WriteString(fieldName, val, len);
+        }
+
+        BinaryStringArrayWriter BinaryWriter::WriteStringArray(const char* fieldName)
+        {
+            int32_t id = impl->WriteStringArray(fieldName);
+
+            return BinaryStringArrayWriter(impl, id);
+        }
+
+        void BinaryWriter::WriteNull(const char* fieldName)
+        {
+            impl->WriteNull(fieldName);
+        }
+
+        BinaryRawWriter BinaryWriter::RawWriter()
+        {
+            impl->SetRawMode();
+
+            return BinaryRawWriter(impl);
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/binary/src/impl/binary/binary_reader_impl.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/binary/src/impl/binary/binary_reader_impl.cpp b/modules/platforms/cpp/binary/src/impl/binary/binary_reader_impl.cpp
new file mode 100644
index 0000000..1365c47
--- /dev/null
+++ b/modules/platforms/cpp/binary/src/impl/binary/binary_reader_impl.cpp
@@ -0,0 +1,907 @@
+/*
+ * 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/ignite_error.h>
+
+#include "ignite/impl/interop/interop.h"
+#include "ignite/impl/interop/interop_stream_position_guard.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"
+
+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_FOUR_BYTES)
+            {
+                // 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);
+            }
+
+            Date BinaryReaderImpl::ReadDate()
+            {
+                CheckRawMode(true);
+                CheckSingleMode(true);
+
+                return ReadNullable(stream, BinaryUtils::ReadDate, IGNITE_TYPE_DATE);
+            }
+
+            int32_t BinaryReaderImpl::ReadDateArray(Date* res, int32_t len)
+            {
+                CheckRawMode(true);
+                CheckSingleMode(true);
+
+                return ReadArrayInternal<Date>(res, len, stream, ReadDateArrayInternal, IGNITE_TYPE_ARRAY_DATE);
+            }
+
+            Date BinaryReaderImpl::ReadDate(const char* fieldName)
+            {
+                CheckRawMode(false);
+                CheckSingleMode(true);
+
+                int32_t fieldId = idRslvr->GetFieldId(typeId, fieldName);
+                int32_t fieldPos = FindField(fieldId);
+
+                if (fieldPos <= 0)
+                    return Date();
+
+                stream->Position(fieldPos);
+
+                return ReadNullable(stream, BinaryUtils::ReadDate, IGNITE_TYPE_DATE);
+            }
+
+            int32_t BinaryReaderImpl::ReadDateArray(const char* fieldName, Date* 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<Date>(res, len, stream, ReadDateArrayInternal, IGNITE_TYPE_ARRAY_DATE);
+
+                return realLen;
+            }
+
+            void BinaryReaderImpl::ReadDateArrayInternal(InteropInputStream* stream, Date* res, const int32_t len)
+            {
+                for (int i = 0; i < len; i++)
+                    *(res + i) = ReadNullable<Date>(stream, BinaryUtils::ReadDate, IGNITE_TYPE_DATE);
+            }
+
+            Timestamp BinaryReaderImpl::ReadTimestamp()
+            {
+                CheckRawMode(true);
+                CheckSingleMode(true);
+
+                return ReadNullable(stream, BinaryUtils::ReadTimestamp, IGNITE_TYPE_TIMESTAMP);
+            }
+
+            int32_t BinaryReaderImpl::ReadTimestampArray(Timestamp* res, int32_t len)
+            {
+                CheckRawMode(true);
+                CheckSingleMode(true);
+
+                return ReadArrayInternal<Timestamp>(res, len, stream, ReadTimestampArrayInternal, IGNITE_TYPE_ARRAY_TIMESTAMP);
+            }
+
+            Timestamp BinaryReaderImpl::ReadTimestamp(const char* fieldName)
+            {
+                CheckRawMode(false);
+                CheckSingleMode(true);
+
+                int32_t fieldId = idRslvr->GetFieldId(typeId, fieldName);
+                int32_t fieldPos = FindField(fieldId);
+
+                if (fieldPos <= 0)
+                    return Timestamp();
+
+                stream->Position(fieldPos);
+
+                return ReadNullable(stream, BinaryUtils::ReadTimestamp, IGNITE_TYPE_TIMESTAMP);
+            }
+
+            int32_t BinaryReaderImpl::ReadTimestampArray(const char* fieldName, Timestamp* 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<Timestamp>(res, len, stream, ReadTimestampArrayInternal, IGNITE_TYPE_ARRAY_TIMESTAMP);
+
+                return realLen;
+            }
+
+            void BinaryReaderImpl::ReadTimestampArrayInternal(interop::InteropInputStream* stream, Timestamp* res, const int32_t len)
+            {
+                for (int i = 0; i < len; i++)
+                    *(res + i) = ReadNullable<Timestamp>(stream, BinaryUtils::ReadTimestamp, IGNITE_TYPE_TIMESTAMP);
+            }
+
+            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)
+                }
+            }
+
+            template <>
+            Date BinaryReaderImpl::ReadTopObject<Date>()
+            {
+                int8_t typeId = stream->ReadInt8();
+
+                if (typeId == IGNITE_TYPE_DATE)
+                    return BinaryUtils::ReadDate(stream);
+                else if (typeId == IGNITE_TYPE_TIMESTAMP)
+                    return Date(BinaryUtils::ReadTimestamp(stream).GetMilliseconds());
+                else if (typeId == IGNITE_HDR_NULL)
+                    return Date();
+                else {
+                    int32_t pos = stream->Position() - 1;
+
+                    IGNITE_ERROR_FORMATTED_3(IgniteError::IGNITE_ERR_BINARY, "Invalid header", "position", pos, "expected", (int)IGNITE_TYPE_DATE, "actual", (int)typeId)
+                }
+            }
+
+            template <>
+            Timestamp BinaryReaderImpl::ReadTopObject<Timestamp>()
+            {
+                int8_t typeId = stream->ReadInt8();
+
+                if (typeId == IGNITE_TYPE_TIMESTAMP)
+                    return BinaryUtils::ReadTimestamp(stream);
+                else if (typeId == IGNITE_HDR_NULL)
+                    return Timestamp();
+                else {
+                    int32_t pos = stream->Position() - 1;
+
+                    IGNITE_ERROR_FORMATTED_3(IgniteError::IGNITE_ERR_BINARY, "Invalid header", "position", pos, "expected", (int)IGNITE_TYPE_TIMESTAMP, "actual", (int)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_ONE_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_TWO_BYTES:
+                    {
+                        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_FOUR_BYTES:
+                    {
+                        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/764c97b9/modules/platforms/cpp/binary/src/impl/binary/binary_schema.cpp
----------------------------------------------------------------------
diff --git a/modules/platforms/cpp/binary/src/impl/binary/binary_schema.cpp b/modules/platforms/cpp/binary/src/impl/binary/binary_schema.cpp
new file mode 100644
index 0000000..0b8025a
--- /dev/null
+++ b/modules/platforms/cpp/binary/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_ONE_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_TWO_BYTES:
+                    {
+                        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_FOUR_BYTES:
+                    {
+                        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_ONE_BYTE;
+                else if (maxOffset < 0x10000)
+                    return OFFSET_TYPE_TWO_BYTES;
+
+                return OFFSET_TYPE_FOUR_BYTES;
+            }
+        }
+    }
+}
\ No newline at end of file


Mime
View raw message