You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by vo...@apache.org on 2015/11/11 10:15:47 UTC
[14/26] ignite git commit: IGNITE-1845: Adopted new binary API in
.Net.
http://git-wip-us.apache.org/repos/asf/ignite/blob/894057e5/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/BinaryWriter.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/BinaryWriter.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/BinaryWriter.cs
new file mode 100644
index 0000000..58973f7
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/BinaryWriter.cs
@@ -0,0 +1,1417 @@
+/*
+ * 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.
+ */
+
+namespace Apache.Ignite.Core.Impl.Binary
+{
+ using System;
+ using System.Collections;
+ using System.Collections.Generic;
+ using System.IO;
+ using Apache.Ignite.Core.Binary;
+ using Apache.Ignite.Core.Impl.Binary.IO;
+ using Apache.Ignite.Core.Impl.Binary.Metadata;
+ using Apache.Ignite.Core.Impl.Binary.Structure;
+
+ /// <summary>
+ /// Binary writer implementation.
+ /// </summary>
+ internal class BinaryWriter : IBinaryWriter, IBinaryRawWriter
+ {
+ /** Marshaller. */
+ private readonly Marshaller _marsh;
+
+ /** Stream. */
+ private readonly IBinaryStream _stream;
+
+ /** Builder (used only during build). */
+ private BinaryObjectBuilder _builder;
+
+ /** Handles. */
+ private BinaryHandleDictionary<object, long> _hnds;
+
+ /** Metadatas collected during this write session. */
+ private IDictionary<int, IBinaryType> _metas;
+
+ /** Current type ID. */
+ private int _curTypeId;
+
+ /** Current name converter */
+ private IBinaryNameMapper _curConverter;
+
+ /** Current mapper. */
+ private IBinaryIdMapper _curMapper;
+
+ /** Current object start position. */
+ private int _curPos;
+
+ /** Current raw position. */
+ private int _curRawPos;
+
+ /** Whether we are currently detaching an object. */
+ private bool _detaching;
+
+ /** Current type structure tracker, */
+ private BinaryStructureTracker _curStruct;
+
+ /** Schema holder. */
+ private readonly BinaryObjectSchemaHolder _schema = BinaryObjectSchemaHolder.Current;
+
+ /// <summary>
+ /// Gets the marshaller.
+ /// </summary>
+ internal Marshaller Marshaller
+ {
+ get { return _marsh; }
+ }
+
+ /// <summary>
+ /// Write named boolean value.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Boolean value.</param>
+ public void WriteBoolean(string fieldName, bool val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeBool);
+
+ _stream.WriteByte(BinaryUtils.TypeBool);
+ _stream.WriteBool(val);
+ }
+
+ /// <summary>
+ /// Write boolean value.
+ /// </summary>
+ /// <param name="val">Boolean value.</param>
+ public void WriteBoolean(bool val)
+ {
+ _stream.WriteBool(val);
+ }
+
+ /// <summary>
+ /// Write named boolean array.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Boolean array.</param>
+ public void WriteBooleanArray(string fieldName, bool[] val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeArrayBool);
+
+ if (val == null)
+ WriteNullField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayBool);
+ BinaryUtils.WriteBooleanArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write boolean array.
+ /// </summary>
+ /// <param name="val">Boolean array.</param>
+ public void WriteBooleanArray(bool[] val)
+ {
+ if (val == null)
+ WriteNullRawField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayBool);
+ BinaryUtils.WriteBooleanArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write named byte value.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Byte value.</param>
+ public void WriteByte(string fieldName, byte val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeBool);
+
+ _stream.WriteByte(BinaryUtils.TypeByte);
+ _stream.WriteByte(val);
+ }
+
+ /// <summary>
+ /// Write byte value.
+ /// </summary>
+ /// <param name="val">Byte value.</param>
+ public void WriteByte(byte val)
+ {
+ _stream.WriteByte(val);
+ }
+
+ /// <summary>
+ /// Write named byte array.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Byte array.</param>
+ public void WriteByteArray(string fieldName, byte[] val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeArrayByte);
+
+ if (val == null)
+ WriteNullField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayByte);
+ BinaryUtils.WriteByteArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write byte array.
+ /// </summary>
+ /// <param name="val">Byte array.</param>
+ public void WriteByteArray(byte[] val)
+ {
+ if (val == null)
+ WriteNullRawField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayByte);
+ BinaryUtils.WriteByteArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write named short value.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Short value.</param>
+ public void WriteShort(string fieldName, short val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeShort);
+
+ _stream.WriteByte(BinaryUtils.TypeShort);
+ _stream.WriteShort(val);
+ }
+
+ /// <summary>
+ /// Write short value.
+ /// </summary>
+ /// <param name="val">Short value.</param>
+ public void WriteShort(short val)
+ {
+ _stream.WriteShort(val);
+ }
+
+ /// <summary>
+ /// Write named short array.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Short array.</param>
+ public void WriteShortArray(string fieldName, short[] val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeArrayShort);
+
+ if (val == null)
+ WriteNullField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayShort);
+ BinaryUtils.WriteShortArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write short array.
+ /// </summary>
+ /// <param name="val">Short array.</param>
+ public void WriteShortArray(short[] val)
+ {
+ if (val == null)
+ WriteNullRawField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayShort);
+ BinaryUtils.WriteShortArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write named char value.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Char value.</param>
+ public void WriteChar(string fieldName, char val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeChar);
+
+ _stream.WriteByte(BinaryUtils.TypeChar);
+ _stream.WriteChar(val);
+ }
+
+ /// <summary>
+ /// Write char value.
+ /// </summary>
+ /// <param name="val">Char value.</param>
+ public void WriteChar(char val)
+ {
+ _stream.WriteChar(val);
+ }
+
+ /// <summary>
+ /// Write named char array.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Char array.</param>
+ public void WriteCharArray(string fieldName, char[] val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeArrayChar);
+
+ if (val == null)
+ WriteNullField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayChar);
+ BinaryUtils.WriteCharArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write char array.
+ /// </summary>
+ /// <param name="val">Char array.</param>
+ public void WriteCharArray(char[] val)
+ {
+ if (val == null)
+ WriteNullRawField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayChar);
+ BinaryUtils.WriteCharArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write named int value.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Int value.</param>
+ public void WriteInt(string fieldName, int val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeInt);
+
+ _stream.WriteByte(BinaryUtils.TypeInt);
+ _stream.WriteInt(val);
+ }
+
+ /// <summary>
+ /// Write int value.
+ /// </summary>
+ /// <param name="val">Int value.</param>
+ public void WriteInt(int val)
+ {
+ _stream.WriteInt(val);
+ }
+
+ /// <summary>
+ /// Write named int array.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Int array.</param>
+ public void WriteIntArray(string fieldName, int[] val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeArrayInt);
+
+ if (val == null)
+ WriteNullField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayInt);
+ BinaryUtils.WriteIntArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write int array.
+ /// </summary>
+ /// <param name="val">Int array.</param>
+ public void WriteIntArray(int[] val)
+ {
+ if (val == null)
+ WriteNullRawField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayInt);
+ BinaryUtils.WriteIntArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write named long value.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Long value.</param>
+ public void WriteLong(string fieldName, long val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeLong);
+
+ _stream.WriteByte(BinaryUtils.TypeLong);
+ _stream.WriteLong(val);
+ }
+
+ /// <summary>
+ /// Write long value.
+ /// </summary>
+ /// <param name="val">Long value.</param>
+ public void WriteLong(long val)
+ {
+ _stream.WriteLong(val);
+ }
+
+ /// <summary>
+ /// Write named long array.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Long array.</param>
+ public void WriteLongArray(string fieldName, long[] val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeArrayLong);
+
+ if (val == null)
+ WriteNullField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayLong);
+ BinaryUtils.WriteLongArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write long array.
+ /// </summary>
+ /// <param name="val">Long array.</param>
+ public void WriteLongArray(long[] val)
+ {
+ if (val == null)
+ WriteNullRawField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayLong);
+ BinaryUtils.WriteLongArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write named float value.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Float value.</param>
+ public void WriteFloat(string fieldName, float val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeFloat);
+
+ _stream.WriteByte(BinaryUtils.TypeFloat);
+ _stream.WriteFloat(val);
+ }
+
+ /// <summary>
+ /// Write float value.
+ /// </summary>
+ /// <param name="val">Float value.</param>
+ public void WriteFloat(float val)
+ {
+ _stream.WriteFloat(val);
+ }
+
+ /// <summary>
+ /// Write named float array.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Float array.</param>
+ public void WriteFloatArray(string fieldName, float[] val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeArrayFloat);
+
+ if (val == null)
+ WriteNullField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayFloat);
+ BinaryUtils.WriteFloatArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write float array.
+ /// </summary>
+ /// <param name="val">Float array.</param>
+ public void WriteFloatArray(float[] val)
+ {
+ if (val == null)
+ WriteNullRawField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayFloat);
+ BinaryUtils.WriteFloatArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write named double value.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Double value.</param>
+ public void WriteDouble(string fieldName, double val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeDouble);
+
+ _stream.WriteByte(BinaryUtils.TypeDouble);
+ _stream.WriteDouble(val);
+ }
+
+ /// <summary>
+ /// Write double value.
+ /// </summary>
+ /// <param name="val">Double value.</param>
+ public void WriteDouble(double val)
+ {
+ _stream.WriteDouble(val);
+ }
+
+ /// <summary>
+ /// Write named double array.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Double array.</param>
+ public void WriteDoubleArray(string fieldName, double[] val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeArrayDouble);
+
+ if (val == null)
+ WriteNullField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayDouble);
+ BinaryUtils.WriteDoubleArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write double array.
+ /// </summary>
+ /// <param name="val">Double array.</param>
+ public void WriteDoubleArray(double[] val)
+ {
+ if (val == null)
+ WriteNullRawField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayDouble);
+ BinaryUtils.WriteDoubleArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write named decimal value.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Decimal value.</param>
+ public void WriteDecimal(string fieldName, decimal? val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeDecimal);
+
+ if (val == null)
+ WriteNullField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeDecimal);
+ BinaryUtils.WriteDecimal(val.Value, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write decimal value.
+ /// </summary>
+ /// <param name="val">Decimal value.</param>
+ public void WriteDecimal(decimal? val)
+ {
+ if (val == null)
+ WriteNullRawField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeDecimal);
+ BinaryUtils.WriteDecimal(val.Value, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write named decimal array.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Decimal array.</param>
+ public void WriteDecimalArray(string fieldName, decimal?[] val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeArrayDecimal);
+
+ if (val == null)
+ WriteNullField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayDecimal);
+ BinaryUtils.WriteDecimalArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write decimal array.
+ /// </summary>
+ /// <param name="val">Decimal array.</param>
+ public void WriteDecimalArray(decimal?[] val)
+ {
+ if (val == null)
+ WriteNullRawField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayDecimal);
+ BinaryUtils.WriteDecimalArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write named date value.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Date value.</param>
+ public void WriteTimestamp(string fieldName, DateTime? val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeTimestamp);
+
+ if (val == null)
+ WriteNullField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeTimestamp);
+ BinaryUtils.WriteTimestamp(val.Value, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write date value.
+ /// </summary>
+ /// <param name="val">Date value.</param>
+ public void WriteTimestamp(DateTime? val)
+ {
+ if (val == null)
+ WriteNullRawField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeTimestamp);
+ BinaryUtils.WriteTimestamp(val.Value, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write named date array.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Date array.</param>
+ public void WriteTimestampArray(string fieldName, DateTime?[] val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeTimestamp);
+
+ if (val == null)
+ WriteNullField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayTimestamp);
+ BinaryUtils.WriteTimestampArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write date array.
+ /// </summary>
+ /// <param name="val">Date array.</param>
+ public void WriteTimestampArray(DateTime?[] val)
+ {
+ if (val == null)
+ WriteNullRawField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayTimestamp);
+ BinaryUtils.WriteTimestampArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write named string value.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">String value.</param>
+ public void WriteString(string fieldName, string val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeString);
+
+ if (val == null)
+ WriteNullField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeString);
+ BinaryUtils.WriteString(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write string value.
+ /// </summary>
+ /// <param name="val">String value.</param>
+ public void WriteString(string val)
+ {
+ if (val == null)
+ WriteNullRawField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeString);
+ BinaryUtils.WriteString(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write named string array.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">String array.</param>
+ public void WriteStringArray(string fieldName, string[] val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeArrayString);
+
+ if (val == null)
+ WriteNullField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayString);
+ BinaryUtils.WriteStringArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write string array.
+ /// </summary>
+ /// <param name="val">String array.</param>
+ public void WriteStringArray(string[] val)
+ {
+ if (val == null)
+ WriteNullRawField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayString);
+ BinaryUtils.WriteStringArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write named GUID value.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">GUID value.</param>
+ public void WriteGuid(string fieldName, Guid? val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeGuid);
+
+ if (val == null)
+ WriteNullField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeGuid);
+ BinaryUtils.WriteGuid(val.Value, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write GUID value.
+ /// </summary>
+ /// <param name="val">GUID value.</param>
+ public void WriteGuid(Guid? val)
+ {
+ if (val == null)
+ WriteNullRawField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeGuid);
+ BinaryUtils.WriteGuid(val.Value, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write named GUID array.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">GUID array.</param>
+ public void WriteGuidArray(string fieldName, Guid?[] val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeArrayGuid);
+
+ if (val == null)
+ WriteNullField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayGuid);
+ BinaryUtils.WriteGuidArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write GUID array.
+ /// </summary>
+ /// <param name="val">GUID array.</param>
+ public void WriteGuidArray(Guid?[] val)
+ {
+ if (val == null)
+ WriteNullRawField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayGuid);
+ BinaryUtils.WriteGuidArray(val, _stream);
+ }
+ }
+
+ /// <summary>
+ /// Write named enum value.
+ /// </summary>
+ /// <typeparam name="T"></typeparam>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Enum value.</param>
+ public void WriteEnum<T>(string fieldName, T val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeEnum);
+
+ _stream.WriteByte(BinaryUtils.TypeEnum);
+ BinaryUtils.WriteEnum(_stream, (Enum)(object)val);
+ }
+
+ /// <summary>
+ /// Write enum value.
+ /// </summary>
+ /// <typeparam name="T"></typeparam>
+ /// <param name="val">Enum value.</param>
+ public void WriteEnum<T>(T val)
+ {
+ _stream.WriteByte(BinaryUtils.TypeEnum);
+ BinaryUtils.WriteEnum(_stream, (Enum)(object)val);
+ }
+
+ /// <summary>
+ /// Write named enum array.
+ /// </summary>
+ /// <typeparam name="T"></typeparam>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Enum array.</param>
+ public void WriteEnumArray<T>(string fieldName, T[] val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeArrayEnum);
+
+ if (val == null)
+ WriteNullField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayEnum);
+ BinaryUtils.WriteArray(val, this);
+ }
+ }
+
+ /// <summary>
+ /// Write enum array.
+ /// </summary>
+ /// <typeparam name="T"></typeparam>
+ /// <param name="val">Enum array.</param>
+ public void WriteEnumArray<T>(T[] val)
+ {
+ if (val == null)
+ WriteNullRawField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArrayEnum);
+ BinaryUtils.WriteArray(val, this);
+ }
+ }
+
+ /// <summary>
+ /// Write named object value.
+ /// </summary>
+ /// <typeparam name="T"></typeparam>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Object value.</param>
+ public void WriteObject<T>(string fieldName, T val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeObject);
+
+ if (val == null)
+ WriteNullField();
+ else
+ Write(val);
+ }
+
+ /// <summary>
+ /// Write object value.
+ /// </summary>
+ /// <typeparam name="T"></typeparam>
+ /// <param name="val">Object value.</param>
+ public void WriteObject<T>(T val)
+ {
+ Write(val);
+ }
+
+ /// <summary>
+ /// Write named object array.
+ /// </summary>
+ /// <typeparam name="T">Element type.</typeparam>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Object array.</param>
+ public void WriteArray<T>(string fieldName, T[] val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeArray);
+
+ if (val == null)
+ WriteNullField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArray);
+ BinaryUtils.WriteArray(val, this);
+ }
+ }
+
+ /// <summary>
+ /// Write object array.
+ /// </summary>
+ /// <typeparam name="T">Element type.</typeparam>
+ /// <param name="val">Object array.</param>
+ public void WriteArray<T>(T[] val)
+ {
+ WriteArrayInternal(val);
+ }
+
+ /// <summary>
+ /// Write object array.
+ /// </summary>
+ /// <param name="val">Object array.</param>
+ public void WriteArrayInternal(Array val)
+ {
+ if (val == null)
+ WriteNullRawField();
+ else
+ {
+ _stream.WriteByte(BinaryUtils.TypeArray);
+ BinaryUtils.WriteArray(val, this);
+ }
+ }
+
+ /// <summary>
+ /// Write named collection.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Collection.</param>
+ public void WriteCollection(string fieldName, ICollection val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeCollection);
+
+ if (val == null)
+ WriteNullField();
+ else
+ WriteCollection(val);
+ }
+
+ /// <summary>
+ /// Write collection.
+ /// </summary>
+ /// <param name="val">Collection.</param>
+ public void WriteCollection(ICollection val)
+ {
+ WriteByte(BinaryUtils.TypeCollection);
+ BinaryUtils.WriteCollection(val, this);
+ }
+
+ /// <summary>
+ /// Write named dictionary.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="val">Dictionary.</param>
+ public void WriteDictionary(string fieldName, IDictionary val)
+ {
+ WriteFieldId(fieldName, BinaryUtils.TypeDictionary);
+
+ if (val == null)
+ WriteNullField();
+ else
+ WriteDictionary(val);
+ }
+
+ /// <summary>
+ /// Write dictionary.
+ /// </summary>
+ /// <param name="val">Dictionary.</param>
+ public void WriteDictionary(IDictionary val)
+ {
+ WriteByte(BinaryUtils.TypeDictionary);
+ BinaryUtils.WriteDictionary(val, this);
+ }
+
+ /// <summary>
+ /// Write NULL field.
+ /// </summary>
+ private void WriteNullField()
+ {
+ _stream.WriteByte(BinaryUtils.HdrNull);
+ }
+
+ /// <summary>
+ /// Write NULL raw field.
+ /// </summary>
+ private void WriteNullRawField()
+ {
+ _stream.WriteByte(BinaryUtils.HdrNull);
+ }
+
+ /// <summary>
+ /// Get raw writer.
+ /// </summary>
+ /// <returns>
+ /// Raw writer.
+ /// </returns>
+ public IBinaryRawWriter GetRawWriter()
+ {
+ if (_curRawPos == 0)
+ _curRawPos = _stream.Position;
+
+ return this;
+ }
+
+ /// <summary>
+ /// Set new builder.
+ /// </summary>
+ /// <param name="builder">Builder.</param>
+ /// <returns>Previous builder.</returns>
+ internal BinaryObjectBuilder SetBuilder(BinaryObjectBuilder builder)
+ {
+ BinaryObjectBuilder ret = _builder;
+
+ _builder = builder;
+
+ return ret;
+ }
+
+ /// <summary>
+ /// Constructor.
+ /// </summary>
+ /// <param name="marsh">Marshaller.</param>
+ /// <param name="stream">Stream.</param>
+ internal BinaryWriter(Marshaller marsh, IBinaryStream stream)
+ {
+ _marsh = marsh;
+ _stream = stream;
+ }
+
+ /// <summary>
+ /// Write object.
+ /// </summary>
+ /// <param name="obj">Object.</param>
+ public void Write<T>(T obj)
+ {
+ // Handle special case for null.
+ if (obj == null)
+ {
+ _stream.WriteByte(BinaryUtils.HdrNull);
+
+ return;
+ }
+
+ // We use GetType() of a real object instead of typeof(T) to take advantage of
+ // automatic Nullable'1 unwrapping.
+ Type type = obj.GetType();
+
+ // Handle common case when primitive is written.
+ if (type.IsPrimitive)
+ {
+ WritePrimitive(obj, type);
+
+ return;
+ }
+
+ // Handle special case for builder.
+ if (WriteBuilderSpecials(obj))
+ return;
+
+ // Suppose that we faced normal object and perform descriptor lookup.
+ IBinaryTypeDescriptor desc = _marsh.GetDescriptor(type);
+
+ if (desc != null)
+ {
+ // Writing normal object.
+ var pos = _stream.Position;
+
+ // Dealing with handles.
+ if (!(desc.Serializer is IBinarySystemTypeSerializer) && WriteHandle(pos, obj))
+ return;
+
+ // Skip header length as not everything is known now
+ _stream.Seek(BinaryObjectHeader.Size, SeekOrigin.Current);
+
+ // Preserve old frame.
+ int oldTypeId = _curTypeId;
+ IBinaryNameMapper oldConverter = _curConverter;
+ IBinaryIdMapper oldMapper = _curMapper;
+ int oldRawPos = _curRawPos;
+ var oldPos = _curPos;
+
+ var oldStruct = _curStruct;
+
+ // Push new frame.
+ _curTypeId = desc.TypeId;
+ _curConverter = desc.NameMapper;
+ _curMapper = desc.IdMapper;
+ _curRawPos = 0;
+ _curPos = pos;
+
+ _curStruct = new BinaryStructureTracker(desc, desc.WriterTypeStructure);
+ var schemaIdx = _schema.PushSchema();
+
+ try
+ {
+ // Write object fields.
+ desc.Serializer.WriteBinary(obj, this);
+
+ // Write schema
+ var schemaOffset = _stream.Position - pos;
+
+ int schemaId;
+ short flags;
+ var hasSchema = _schema.WriteSchema(_stream, schemaIdx, out schemaId, out flags);
+
+ if (!hasSchema)
+ schemaOffset = BinaryObjectHeader.Size;
+
+ // Calculate and write header.
+ if (hasSchema && _curRawPos > 0)
+ _stream.WriteInt(_curRawPos - pos); // raw offset is in the last 4 bytes
+
+ var len = _stream.Position - pos;
+
+ var header = new BinaryObjectHeader(desc.UserType, desc.TypeId, obj.GetHashCode(), len,
+ schemaId, schemaOffset, !hasSchema, flags);
+
+ BinaryObjectHeader.Write(header, _stream, pos);
+
+ Stream.Seek(pos + len, SeekOrigin.Begin); // Seek to the end
+ }
+ finally
+ {
+ _schema.PopSchema(schemaIdx);
+ }
+
+ // Apply structure updates if any.
+ _curStruct.UpdateWriterStructure(this);
+
+ // Restore old frame.
+ _curTypeId = oldTypeId;
+ _curConverter = oldConverter;
+ _curMapper = oldMapper;
+ _curRawPos = oldRawPos;
+ _curPos = oldPos;
+
+ _curStruct = oldStruct;
+ }
+ else
+ {
+ // Are we dealing with a well-known type?
+ var handler = BinarySystemHandlers.GetWriteHandler(type);
+
+ if (handler == null) // We did our best, object cannot be marshalled.
+ throw new BinaryObjectException("Unsupported object type [type=" + type + ", object=" + obj + ']');
+
+ handler(this, obj);
+ }
+ }
+
+ /// <summary>
+ /// Write primitive type.
+ /// </summary>
+ /// <param name="val">Object.</param>
+ /// <param name="type">Type.</param>
+ private unsafe void WritePrimitive<T>(T val, Type type)
+ {
+ // .Net defines 14 primitive types. We support 12 - excluding IntPtr and UIntPtr.
+ // Types check sequence is designed to minimize comparisons for the most frequent types.
+
+ if (type == typeof(int))
+ {
+ _stream.WriteByte(BinaryUtils.TypeInt);
+ _stream.WriteInt((int)(object)val);
+ }
+ else if (type == typeof(long))
+ {
+ _stream.WriteByte(BinaryUtils.TypeLong);
+ _stream.WriteLong((long)(object)val);
+ }
+ else if (type == typeof(bool))
+ {
+ _stream.WriteByte(BinaryUtils.TypeBool);
+ _stream.WriteBool((bool)(object)val);
+ }
+ else if (type == typeof(byte))
+ {
+ _stream.WriteByte(BinaryUtils.TypeByte);
+ _stream.WriteByte((byte)(object)val);
+ }
+ else if (type == typeof(short))
+ {
+ _stream.WriteByte(BinaryUtils.TypeShort);
+ _stream.WriteShort((short)(object)val);
+ }
+ else if (type == typeof (char))
+ {
+ _stream.WriteByte(BinaryUtils.TypeChar);
+ _stream.WriteChar((char)(object)val);
+ }
+ else if (type == typeof(float))
+ {
+ _stream.WriteByte(BinaryUtils.TypeFloat);
+ _stream.WriteFloat((float)(object)val);
+ }
+ else if (type == typeof(double))
+ {
+ _stream.WriteByte(BinaryUtils.TypeDouble);
+ _stream.WriteDouble((double)(object)val);
+ }
+ else if (type == typeof(sbyte))
+ {
+ sbyte val0 = (sbyte)(object)val;
+
+ _stream.WriteByte(BinaryUtils.TypeByte);
+ _stream.WriteByte(*(byte*)&val0);
+ }
+ else if (type == typeof(ushort))
+ {
+ ushort val0 = (ushort)(object)val;
+
+ _stream.WriteByte(BinaryUtils.TypeShort);
+ _stream.WriteShort(*(short*)&val0);
+ }
+ else if (type == typeof(uint))
+ {
+ uint val0 = (uint)(object)val;
+
+ _stream.WriteByte(BinaryUtils.TypeInt);
+ _stream.WriteInt(*(int*)&val0);
+ }
+ else if (type == typeof(ulong))
+ {
+ ulong val0 = (ulong)(object)val;
+
+ _stream.WriteByte(BinaryUtils.TypeLong);
+ _stream.WriteLong(*(long*)&val0);
+ }
+ else
+ throw new BinaryObjectException("Unsupported object type [type=" + type.FullName + ", object=" + val + ']');
+ }
+
+ /// <summary>
+ /// Try writing object as special builder type.
+ /// </summary>
+ /// <param name="obj">Object.</param>
+ /// <returns>True if object was written, false otherwise.</returns>
+ private bool WriteBuilderSpecials<T>(T obj)
+ {
+ if (_builder != null)
+ {
+ // Special case for binary object during build.
+ BinaryObject portObj = obj as BinaryObject;
+
+ if (portObj != null)
+ {
+ if (!WriteHandle(_stream.Position, portObj))
+ _builder.ProcessBinary(_stream, portObj);
+
+ return true;
+ }
+
+ // Special case for builder during build.
+ BinaryObjectBuilder portBuilder = obj as BinaryObjectBuilder;
+
+ if (portBuilder != null)
+ {
+ if (!WriteHandle(_stream.Position, portBuilder))
+ _builder.ProcessBuilder(_stream, portBuilder);
+
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /// <summary>
+ /// Add handle to handles map.
+ /// </summary>
+ /// <param name="pos">Position in stream.</param>
+ /// <param name="obj">Object.</param>
+ /// <returns><c>true</c> if object was written as handle.</returns>
+ private bool WriteHandle(long pos, object obj)
+ {
+ if (_hnds == null)
+ {
+ // Cache absolute handle position.
+ _hnds = new BinaryHandleDictionary<object, long>(obj, pos);
+
+ return false;
+ }
+
+ long hndPos;
+
+ if (!_hnds.TryGetValue(obj, out hndPos))
+ {
+ // Cache absolute handle position.
+ _hnds.Add(obj, pos);
+
+ return false;
+ }
+
+ _stream.WriteByte(BinaryUtils.HdrHnd);
+
+ // Handle is written as difference between position before header and handle position.
+ _stream.WriteInt((int)(pos - hndPos));
+
+ return true;
+ }
+
+ /// <summary>
+ /// Perform action with detached semantics.
+ /// </summary>
+ /// <param name="a"></param>
+ internal void WithDetach(Action<BinaryWriter> a)
+ {
+ if (_detaching)
+ a(this);
+ else
+ {
+ _detaching = true;
+
+ BinaryHandleDictionary<object, long> oldHnds = _hnds;
+ _hnds = null;
+
+ try
+ {
+ a(this);
+ }
+ finally
+ {
+ _detaching = false;
+
+ if (oldHnds != null)
+ {
+ // Merge newly recorded handles with old ones and restore old on the stack.
+ // Otherwise we can use current handles right away.
+ if (_hnds != null)
+ oldHnds.Merge(_hnds);
+
+ _hnds = oldHnds;
+ }
+ }
+ }
+ }
+
+ /// <summary>
+ /// Stream.
+ /// </summary>
+ internal IBinaryStream Stream
+ {
+ get { return _stream; }
+ }
+
+ /// <summary>
+ /// Gets collected metadatas.
+ /// </summary>
+ /// <returns>Collected metadatas (if any).</returns>
+ internal IDictionary<int, IBinaryType> GetBinaryTypes()
+ {
+ return _metas;
+ }
+
+ /// <summary>
+ /// Check whether the given object is binarizeble, i.e. it can be serialized with binary marshaller.
+ /// </summary>
+ /// <param name="obj">Object.</param>
+ /// <returns>True if binarizable.</returns>
+ internal bool IsBinarizable(object obj)
+ {
+ if (obj != null)
+ {
+ Type type = obj.GetType();
+
+ // We assume object as binarizable only in case it has descriptor.
+ // Collections, Enums and non-primitive arrays do not have descriptors
+ // and this is fine here because we cannot know whether their members are binarizable.
+ return _marsh.GetDescriptor(type) != null || BinarySystemHandlers.GetWriteHandler(type) != null;
+ }
+
+ return true;
+ }
+
+ /// <summary>
+ /// Write field ID.
+ /// </summary>
+ /// <param name="fieldName">Field name.</param>
+ /// <param name="fieldTypeId">Field type ID.</param>
+ private void WriteFieldId(string fieldName, byte fieldTypeId)
+ {
+ if (_curRawPos != 0)
+ throw new BinaryObjectException("Cannot write named fields after raw data is written.");
+
+ var fieldId = _curStruct.GetFieldId(fieldName, fieldTypeId);
+
+ _schema.PushField(fieldId, _stream.Position - _curPos);
+ }
+
+ /// <summary>
+ /// Saves metadata for this session.
+ /// </summary>
+ /// <param name="typeId">Type ID.</param>
+ /// <param name="typeName">Type name.</param>
+ /// <param name="affKeyFieldName">Affinity key field name.</param>
+ /// <param name="fields">Fields metadata.</param>
+ internal void SaveMetadata(int typeId, string typeName, string affKeyFieldName, IDictionary<string, int> fields)
+ {
+ if (_metas == null)
+ {
+ BinaryType meta =
+ new BinaryType(typeId, typeName, fields, affKeyFieldName);
+
+ _metas = new Dictionary<int, IBinaryType>(1);
+
+ _metas[typeId] = meta;
+ }
+ else
+ {
+ IBinaryType meta;
+
+ if (_metas.TryGetValue(typeId, out meta))
+ {
+ IDictionary<string, int> existingFields = ((BinaryType)meta).FieldsMap();
+
+ foreach (KeyValuePair<string, int> field in fields)
+ {
+ if (!existingFields.ContainsKey(field.Key))
+ existingFields[field.Key] = field.Value;
+ }
+ }
+ else
+ _metas[typeId] = new BinaryType(typeId, typeName, fields, affKeyFieldName);
+ }
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/894057e5/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/DateTimeHolder.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/DateTimeHolder.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/DateTimeHolder.cs
new file mode 100644
index 0000000..473f6c4
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/DateTimeHolder.cs
@@ -0,0 +1,68 @@
+/*
+ * 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.
+ */
+
+namespace Apache.Ignite.Core.Impl.Binary
+{
+ using System;
+ using System.Diagnostics;
+ using Apache.Ignite.Core.Binary;
+
+ /// <summary>
+ /// Wraps DateTime item in a binarizable.
+ /// </summary>
+ internal class DateTimeHolder : IBinaryWriteAware
+ {
+ /** */
+ private readonly DateTime _item;
+
+ /// <summary>
+ /// Constructor.
+ /// </summary>
+ /// <param name="item">The item to wrap.</param>
+ public DateTimeHolder(DateTime item)
+ {
+ _item = item;
+ }
+
+ /// <summary>
+ /// Constructor.
+ /// </summary>
+ /// <param name="reader">The reader.</param>
+ public DateTimeHolder(IBinaryReader reader)
+ {
+ Debug.Assert(reader != null);
+
+ _item = DateTime.FromBinary(reader.GetRawReader().ReadLong());
+ }
+
+ /// <summary>
+ /// Gets the item to wrap.
+ /// </summary>
+ public DateTime Item
+ {
+ get { return _item; }
+ }
+
+ /** <inheritDoc /> */
+ public void WriteBinary(IBinaryWriter writer)
+ {
+ Debug.Assert(writer != null);
+
+ writer.GetRawWriter().WriteLong(_item.ToBinary());
+ }
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/894057e5/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/IBinarySystemTypeSerializer.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/IBinarySystemTypeSerializer.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/IBinarySystemTypeSerializer.cs
new file mode 100644
index 0000000..3571ffb
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/IBinarySystemTypeSerializer.cs
@@ -0,0 +1,34 @@
+/*
+ * 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.
+ */
+
+namespace Apache.Ignite.Core.Impl.Binary
+{
+ using Apache.Ignite.Core.Binary;
+
+ /// <summary>
+ /// Serializer for system types that can create instances directly from a stream and does not support handles.
+ /// </summary>
+ internal interface IBinarySystemTypeSerializer : IBinarySerializer
+ {
+ /// <summary>
+ /// Reads the instance from a reader.
+ /// </summary>
+ /// <param name="reader">The reader.</param>
+ /// <returns>Deserialized instance.</returns>
+ object ReadInstance(BinaryReader reader);
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/894057e5/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/IBinaryTypeDescriptor.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/IBinaryTypeDescriptor.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/IBinaryTypeDescriptor.cs
new file mode 100644
index 0000000..99af56d
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/IBinaryTypeDescriptor.cs
@@ -0,0 +1,133 @@
+/*
+ * 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.
+ */
+
+namespace Apache.Ignite.Core.Impl.Binary
+{
+ using System;
+ using System.Collections.Generic;
+ using Apache.Ignite.Core.Binary;
+ using Apache.Ignite.Core.Impl.Binary.Structure;
+
+ /// <summary>
+ /// Type descriptor.
+ /// </summary>
+ internal interface IBinaryTypeDescriptor
+ {
+ /// <summary>
+ /// Type.
+ /// </summary>
+ Type Type
+ {
+ get;
+ }
+
+ /// <summary>
+ /// Type ID.
+ /// </summary>
+ int TypeId
+ {
+ get;
+ }
+
+ /// <summary>
+ /// Type name.
+ /// </summary>
+ string TypeName
+ {
+ get;
+ }
+
+ /// <summary>
+ /// User type flag.
+ /// </summary>
+ bool UserType
+ {
+ get;
+ }
+
+ /// <summary>
+ /// Whether to cache deserialized value in IBinaryObject
+ /// </summary>
+ bool KeepDeserialized
+ {
+ get;
+ }
+
+ /// <summary>
+ /// Name converter.
+ /// </summary>
+ IBinaryNameMapper NameMapper
+ {
+ get;
+ }
+
+ /// <summary>
+ /// Mapper.
+ /// </summary>
+ IBinaryIdMapper IdMapper
+ {
+ get;
+ }
+
+ /// <summary>
+ /// Serializer.
+ /// </summary>
+ IBinarySerializer Serializer
+ {
+ get;
+ }
+
+ /// <summary>
+ /// Affinity key field name.
+ /// </summary>
+ string AffinityKeyFieldName
+ {
+ get;
+ }
+
+ /// <summary>
+ /// Write type structure.
+ /// </summary>
+ BinaryStructure WriterTypeStructure { get; }
+
+ /// <summary>
+ /// Read type structure.
+ /// </summary>
+ BinaryStructure ReaderTypeStructure { get; }
+
+ /// <summary>
+ /// Update write type structure.
+ /// </summary>
+ /// <param name="exp">Expected type structure.</param>
+ /// <param name="pathIdx">Path index.</param>
+ /// <param name="updates">Recorded updates.</param>
+ void UpdateWriteStructure(BinaryStructure exp, int pathIdx, IList<BinaryStructureUpdate> updates);
+
+ /// <summary>
+ /// Update read type structure.
+ /// </summary>
+ /// <param name="exp">Expected type structure.</param>
+ /// <param name="pathIdx">Path index.</param>
+ /// <param name="updates">Recorded updates.</param>
+ void UpdateReadStructure(BinaryStructure exp, int pathIdx, IList<BinaryStructureUpdate> updates);
+
+ /// <summary>
+ /// Gets the schema.
+ /// </summary>
+ BinaryObjectSchema Schema { get; }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/894057e5/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/IBinaryWriteAware.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/IBinaryWriteAware.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/IBinaryWriteAware.cs
new file mode 100644
index 0000000..151338b
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/IBinaryWriteAware.cs
@@ -0,0 +1,34 @@
+/*
+ * 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.
+ */
+
+namespace Apache.Ignite.Core.Impl.Binary
+{
+ using Apache.Ignite.Core.Binary;
+
+ /// <summary>
+ /// Represents an object that can write itself to a binary writer.
+ /// </summary>
+ internal interface IBinaryWriteAware
+ {
+ /// <summary>
+ /// Writes this object to the given writer.
+ /// </summary>
+ /// <param name="writer">Writer.</param>
+ /// <exception cref="System.IO.IOException">If write failed.</exception>
+ void WriteBinary(IBinaryWriter writer);
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/894057e5/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/IgniteBinary.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/IgniteBinary.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/IgniteBinary.cs
new file mode 100644
index 0000000..927ebaf
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/IgniteBinary.cs
@@ -0,0 +1,191 @@
+/*
+ * 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.
+ */
+
+namespace Apache.Ignite.Core.Impl.Binary
+{
+ using System;
+ using System.Collections.Generic;
+ using System.IO;
+ using Apache.Ignite.Core.Binary;
+ using Apache.Ignite.Core.Common;
+ using Apache.Ignite.Core.Impl.Binary.IO;
+ using Apache.Ignite.Core.Impl.Common;
+
+ /// <summary>
+ /// Binary implementation.
+ /// </summary>
+ internal class IgniteBinary : IIgniteBinary
+ {
+ /** Owning grid. */
+ private readonly Marshaller _marsh;
+
+ /// <summary>
+ /// Constructor.
+ /// </summary>
+ /// <param name="marsh">Marshaller.</param>
+ internal IgniteBinary(Marshaller marsh)
+ {
+ _marsh = marsh;
+ }
+
+ /** <inheritDoc /> */
+ public T ToBinary<T>(object obj)
+ {
+ if (obj is IBinaryObject)
+ return (T)obj;
+
+ IBinaryStream stream = new BinaryHeapStream(1024);
+
+ // Serialize.
+ BinaryWriter writer = _marsh.StartMarshal(stream);
+
+ try
+ {
+ writer.Write(obj);
+ }
+ finally
+ {
+ // Save metadata.
+ _marsh.FinishMarshal(writer);
+ }
+
+ // Deserialize.
+ stream.Seek(0, SeekOrigin.Begin);
+
+ return _marsh.Unmarshal<T>(stream, BinaryMode.ForceBinary);
+ }
+
+ /** <inheritDoc /> */
+ public IBinaryObjectBuilder GetBuilder(Type type)
+ {
+ IgniteArgumentCheck.NotNull(type, "type");
+
+ IBinaryTypeDescriptor desc = _marsh.GetDescriptor(type);
+
+ if (desc == null)
+ throw new IgniteException("Type is not binary (add it to BinaryConfiguration): " +
+ type.FullName);
+
+ return Builder0(null, BinaryFromDescriptor(desc), desc);
+ }
+
+ /** <inheritDoc /> */
+ public IBinaryObjectBuilder GetBuilder(string typeName)
+ {
+ IgniteArgumentCheck.NotNullOrEmpty(typeName, "typeName");
+
+ IBinaryTypeDescriptor desc = _marsh.GetDescriptor(typeName);
+
+ return Builder0(null, BinaryFromDescriptor(desc), desc);
+ }
+
+ /** <inheritDoc /> */
+ public IBinaryObjectBuilder GetBuilder(IBinaryObject obj)
+ {
+ IgniteArgumentCheck.NotNull(obj, "obj");
+
+ BinaryObject obj0 = obj as BinaryObject;
+
+ if (obj0 == null)
+ throw new ArgumentException("Unsupported object type: " + obj.GetType());
+
+ IBinaryTypeDescriptor desc = _marsh.GetDescriptor(true, obj0.TypeId);
+
+ return Builder0(null, obj0, desc);
+ }
+
+ /** <inheritDoc /> */
+ public int GetTypeId(string typeName)
+ {
+ IgniteArgumentCheck.NotNullOrEmpty(typeName, "typeName");
+
+ return Marshaller.GetDescriptor(typeName).TypeId;
+ }
+
+ /** <inheritDoc /> */
+ public ICollection<IBinaryType> GetBinaryTypes()
+ {
+ return Marshaller.Ignite.ClusterGroup.GetBinaryTypes();
+ }
+
+ /** <inheritDoc /> */
+ public IBinaryType GetBinaryType(int typeId)
+ {
+ return Marshaller.GetBinaryType(typeId);
+ }
+
+ /** <inheritDoc /> */
+ public IBinaryType GetBinaryType(string typeName)
+ {
+ IgniteArgumentCheck.NotNullOrEmpty(typeName, "typeName");
+
+ return GetBinaryType(GetTypeId(typeName));
+ }
+
+ /** <inheritDoc /> */
+ public IBinaryType GetBinaryType(Type type)
+ {
+ IgniteArgumentCheck.NotNull(type, "type");
+
+ var desc = Marshaller.GetDescriptor(type);
+
+ return desc == null ? null : Marshaller.GetBinaryType(desc.TypeId);
+ }
+
+ /// <summary>
+ /// Marshaller.
+ /// </summary>
+ internal Marshaller Marshaller
+ {
+ get
+ {
+ return _marsh;
+ }
+ }
+
+ /// <summary>
+ /// Create empty binary object from descriptor.
+ /// </summary>
+ /// <param name="desc">Descriptor.</param>
+ /// <returns>Empty binary object.</returns>
+ private BinaryObject BinaryFromDescriptor(IBinaryTypeDescriptor desc)
+ {
+ var len = BinaryObjectHeader.Size;
+
+ var hdr = new BinaryObjectHeader(desc.UserType, desc.TypeId, 0, len, 0, len, true, 0);
+
+ var stream = new BinaryHeapStream(len);
+
+ BinaryObjectHeader.Write(hdr, stream, 0);
+
+ return new BinaryObject(_marsh, stream.InternalArray, 0, hdr);
+ }
+
+ /// <summary>
+ /// Internal builder creation routine.
+ /// </summary>
+ /// <param name="parent">Parent builder.</param>
+ /// <param name="obj">binary object.</param>
+ /// <param name="desc">Type descriptor.</param>
+ /// <returns>Builder.</returns>
+ private BinaryObjectBuilder Builder0(BinaryObjectBuilder parent, BinaryObject obj,
+ IBinaryTypeDescriptor desc)
+ {
+ return new BinaryObjectBuilder(this, parent, obj, desc);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/894057e5/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/Io/BinaryHeapStream.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/Io/BinaryHeapStream.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/Io/BinaryHeapStream.cs
new file mode 100644
index 0000000..2265abc
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/Io/BinaryHeapStream.cs
@@ -0,0 +1,452 @@
+/*
+ * 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.
+ */
+
+namespace Apache.Ignite.Core.Impl.Binary.IO
+{
+ using System;
+ using System.Diagnostics;
+ using System.IO;
+ using System.Text;
+
+ /// <summary>
+ /// Binary onheap stream.
+ /// </summary>
+ internal unsafe class BinaryHeapStream : BinaryStreamBase
+ {
+ /** Data array. */
+ private byte[] _data;
+
+ /// <summary>
+ /// Constructor.
+ /// </summary>
+ /// <param name="cap">Initial capacity.</param>
+ public BinaryHeapStream(int cap)
+ {
+ Debug.Assert(cap >= 0);
+
+ _data = new byte[cap];
+ }
+
+ /// <summary>
+ /// Constructor.
+ /// </summary>
+ /// <param name="data">Data array.</param>
+ public BinaryHeapStream(byte[] data)
+ {
+ Debug.Assert(data != null);
+
+ _data = data;
+ }
+
+ /** <inheritdoc /> */
+ public override void WriteByte(byte val)
+ {
+ int pos0 = EnsureWriteCapacityAndShift(1);
+
+ _data[pos0] = val;
+ }
+
+ /** <inheritdoc /> */
+ public override byte ReadByte()
+ {
+ int pos0 = EnsureReadCapacityAndShift(1);
+
+ return _data[pos0];
+ }
+
+ /** <inheritdoc /> */
+ public override void WriteByteArray(byte[] val)
+ {
+ int pos0 = EnsureWriteCapacityAndShift(val.Length);
+
+ fixed (byte* data0 = _data)
+ {
+ WriteByteArray0(val, data0 + pos0);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override byte[] ReadByteArray(int cnt)
+ {
+ int pos0 = EnsureReadCapacityAndShift(cnt);
+
+ fixed (byte* data0 = _data)
+ {
+ return ReadByteArray0(cnt, data0 + pos0);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override void WriteBoolArray(bool[] val)
+ {
+ int pos0 = EnsureWriteCapacityAndShift(val.Length);
+
+ fixed (byte* data0 = _data)
+ {
+ WriteBoolArray0(val, data0 + pos0);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override bool[] ReadBoolArray(int cnt)
+ {
+ int pos0 = EnsureReadCapacityAndShift(cnt);
+
+ fixed (byte* data0 = _data)
+ {
+ return ReadBoolArray0(cnt, data0 + pos0);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override void WriteShort(short val)
+ {
+ int pos0 = EnsureWriteCapacityAndShift(2);
+
+ fixed (byte* data0 = _data)
+ {
+ WriteShort0(val, data0 + pos0);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override short ReadShort()
+ {
+ int pos0 = EnsureReadCapacityAndShift(2);
+
+ fixed (byte* data0 = _data)
+ {
+ return ReadShort0(data0 + pos0);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override void WriteShortArray(short[] val)
+ {
+ int cnt = val.Length << 1;
+
+ int pos0 = EnsureWriteCapacityAndShift(cnt);
+
+ fixed (byte* data0 = _data)
+ {
+ WriteShortArray0(val, data0 + pos0, cnt);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override short[] ReadShortArray(int cnt)
+ {
+ int cnt0 = cnt << 1;
+
+ int pos0 = EnsureReadCapacityAndShift(cnt0);
+
+ fixed (byte* data0 = _data)
+ {
+ return ReadShortArray0(cnt, data0 + pos0, cnt0);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override void WriteCharArray(char[] val)
+ {
+ int cnt = val.Length << 1;
+
+ int pos0 = EnsureWriteCapacityAndShift(cnt);
+
+ fixed (byte* data0 = _data)
+ {
+ WriteCharArray0(val, data0 + pos0, cnt);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override char[] ReadCharArray(int cnt)
+ {
+ int cnt0 = cnt << 1;
+
+ int pos0 = EnsureReadCapacityAndShift(cnt0);
+
+ fixed (byte* data0 = _data)
+ {
+ return ReadCharArray0(cnt, data0 + pos0, cnt0);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override void WriteInt(int val)
+ {
+ int pos0 = EnsureWriteCapacityAndShift(4);
+
+ fixed (byte* data0 = _data)
+ {
+ WriteInt0(val, data0 + pos0);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override void WriteInt(int writePos, int val)
+ {
+ EnsureWriteCapacity(writePos + 4);
+
+ fixed (byte* data0 = _data)
+ {
+ WriteInt0(val, data0 + writePos);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override int ReadInt()
+ {
+ int pos0 = EnsureReadCapacityAndShift(4);
+
+ fixed (byte* data0 = _data)
+ {
+ return ReadInt0(data0 + pos0);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override void WriteIntArray(int[] val)
+ {
+ int cnt = val.Length << 2;
+
+ int pos0 = EnsureWriteCapacityAndShift(cnt);
+
+ fixed (byte* data0 = _data)
+ {
+ WriteIntArray0(val, data0 + pos0, cnt);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override int[] ReadIntArray(int cnt)
+ {
+ int cnt0 = cnt << 2;
+
+ int pos0 = EnsureReadCapacityAndShift(cnt0);
+
+ fixed (byte* data0 = _data)
+ {
+ return ReadIntArray0(cnt, data0 + pos0, cnt0);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override void WriteFloatArray(float[] val)
+ {
+ int cnt = val.Length << 2;
+
+ int pos0 = EnsureWriteCapacityAndShift(cnt);
+
+ fixed (byte* data0 = _data)
+ {
+ WriteFloatArray0(val, data0 + pos0, cnt);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override float[] ReadFloatArray(int cnt)
+ {
+ int cnt0 = cnt << 2;
+
+ int pos0 = EnsureReadCapacityAndShift(cnt0);
+
+ fixed (byte* data0 = _data)
+ {
+ return ReadFloatArray0(cnt, data0 + pos0, cnt0);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override void WriteLong(long val)
+ {
+ int pos0 = EnsureWriteCapacityAndShift(8);
+
+ fixed (byte* data0 = _data)
+ {
+ WriteLong0(val, data0 + pos0);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override long ReadLong()
+ {
+ int pos0 = EnsureReadCapacityAndShift(8);
+
+ fixed (byte* data0 = _data)
+ {
+ return ReadLong0(data0 + pos0);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override void WriteLongArray(long[] val)
+ {
+ int cnt = val.Length << 3;
+
+ int pos0 = EnsureWriteCapacityAndShift(cnt);
+
+ fixed (byte* data0 = _data)
+ {
+ WriteLongArray0(val, data0 + pos0, cnt);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override long[] ReadLongArray(int cnt)
+ {
+ int cnt0 = cnt << 3;
+
+ int pos0 = EnsureReadCapacityAndShift(cnt0);
+
+ fixed (byte* data0 = _data)
+ {
+ return ReadLongArray0(cnt, data0 + pos0, cnt0);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override void WriteDoubleArray(double[] val)
+ {
+ int cnt = val.Length << 3;
+
+ int pos0 = EnsureWriteCapacityAndShift(cnt);
+
+ fixed (byte* data0 = _data)
+ {
+ WriteDoubleArray0(val, data0 + pos0, cnt);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override double[] ReadDoubleArray(int cnt)
+ {
+ int cnt0 = cnt << 3;
+
+ int pos0 = EnsureReadCapacityAndShift(cnt0);
+
+ fixed (byte* data0 = _data)
+ {
+ return ReadDoubleArray0(cnt, data0 + pos0, cnt0);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override int WriteString(char* chars, int charCnt, int byteCnt, Encoding encoding)
+ {
+ int pos0 = EnsureWriteCapacityAndShift(byteCnt);
+
+ int written;
+
+ fixed (byte* data0 = _data)
+ {
+ written = WriteString0(chars, charCnt, byteCnt, encoding, data0 + pos0);
+ }
+
+ return written;
+ }
+
+ /** <inheritdoc /> */
+ public override void Write(byte* src, int cnt)
+ {
+ EnsureWriteCapacity(Pos + cnt);
+
+ fixed (byte* data0 = _data)
+ {
+ WriteInternal(src, cnt, data0);
+ }
+
+ ShiftWrite(cnt);
+ }
+
+ /** <inheritdoc /> */
+ public override void Read(byte* dest, int cnt)
+ {
+ fixed (byte* data0 = _data)
+ {
+ ReadInternal(data0, dest, cnt);
+ }
+ }
+
+ /** <inheritdoc /> */
+ public override int Remaining
+ {
+ get { return _data.Length - Pos; }
+ }
+
+ /** <inheritdoc /> */
+ public override byte[] GetArray()
+ {
+ return _data;
+ }
+
+ /** <inheritdoc /> */
+ public override byte[] GetArrayCopy()
+ {
+ byte[] copy = new byte[Pos];
+
+ Buffer.BlockCopy(_data, 0, copy, 0, Pos);
+
+ return copy;
+ }
+
+ /** <inheritdoc /> */
+ public override bool IsSameArray(byte[] arr)
+ {
+ return _data == arr;
+ }
+
+ /** <inheritdoc /> */
+ protected override void Dispose(bool disposing)
+ {
+ // No-op.
+ }
+
+ /// <summary>
+ /// Internal array.
+ /// </summary>
+ internal byte[] InternalArray
+ {
+ get { return _data; }
+ }
+
+ /** <inheritdoc /> */
+ protected override void EnsureWriteCapacity(int cnt)
+ {
+ if (cnt > _data.Length)
+ {
+ int newCap = Capacity(_data.Length, cnt);
+
+ byte[] data0 = new byte[newCap];
+
+ // Copy the whole initial array length here because it can be changed
+ // from Java without position adjusting.
+ Buffer.BlockCopy(_data, 0, data0, 0, _data.Length);
+
+ _data = data0;
+ }
+ }
+
+ /** <inheritdoc /> */
+ protected override void EnsureReadCapacity(int cnt)
+ {
+ if (_data.Length - Pos < cnt)
+ throw new EndOfStreamException("Not enough data in stream [expected=" + cnt +
+ ", remaining=" + (_data.Length - Pos) + ']');
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/894057e5/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/Io/BinaryStreamAdapter.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/Io/BinaryStreamAdapter.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/Io/BinaryStreamAdapter.cs
new file mode 100644
index 0000000..dcbff81
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/Io/BinaryStreamAdapter.cs
@@ -0,0 +1,114 @@
+/*
+ * 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.
+ */
+
+namespace Apache.Ignite.Core.Impl.Binary.IO
+{
+ using System;
+ using System.IO;
+
+ /// <summary>
+ /// Adapter providing .Net streaming functionality over the binary stream.
+ /// </summary>
+ internal class BinaryStreamAdapter : Stream
+ {
+ /// <summary>
+ ///
+ /// </summary>
+ private readonly IBinaryStream _stream;
+
+ /// <summary>
+ /// Constructor.
+ /// </summary>
+ /// <param name="stream">Stream.</param>
+ public BinaryStreamAdapter(IBinaryStream stream)
+ {
+ _stream = stream;
+ }
+
+ /** <inheritDoc /> */
+ public override void Write(byte[] buffer, int offset, int count)
+ {
+ _stream.Write(buffer, offset, count);
+ }
+
+ /** <inheritDoc /> */
+ public override int Read(byte[] buffer, int offset, int count)
+ {
+ _stream.Read(buffer, offset, count);
+
+ return count;
+ }
+
+ /** <inheritDoc /> */
+ public override void Flush()
+ {
+ // No-op.
+ }
+
+ /** <inheritDoc /> */
+ public override bool CanRead
+ {
+ get { return true; }
+ }
+
+ /** <inheritDoc /> */
+ public override bool CanWrite
+ {
+ get { return true; }
+ }
+
+ /** <inheritDoc /> */
+ public override bool CanSeek
+ {
+ get { return false; }
+ }
+
+ /** <inheritDoc /> */
+ public override long Seek(long offset, SeekOrigin origin)
+ {
+ throw new NotSupportedException("Stream is not seekable.");
+ }
+
+ /** <inheritDoc /> */
+ public override long Position
+ {
+ get
+ {
+ throw new NotSupportedException("Stream is not seekable.");
+ }
+ set
+ {
+ throw new NotSupportedException("Stream is not seekable.");
+ }
+ }
+
+ /** <inheritDoc /> */
+ public override long Length
+ {
+ get
+ {
+ throw new NotSupportedException("Stream is not seekable.");
+ }
+ }
+
+ /** <inheritDoc /> */
+ public override void SetLength(long value)
+ {
+ throw new NotSupportedException("Stream is not seekable.");
+ }
+ }
+}