/// <summary> /// Write enum value. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="val">Enum value.</param> public void WriteEnum <T>(T val) { // ReSharper disable once CompareNonConstrainedGenericWithNull if (val == null) { WriteNullField(); } else { var desc = _marsh.GetDescriptor(val.GetType()); if (desc != null) { var metaHnd = _marsh.GetBinaryTypeHandler(desc); _stream.WriteByte(BinaryUtils.TypeEnum); BinaryUtils.WriteEnum(this, val); SaveMetadata(desc, metaHnd.OnObjectWriteFinished()); } else { // Unregistered enum, write as serializable Write(new SerializableObjectHolder(val)); } } }
/// <summary> /// Internal deserialization routine. /// </summary> /// <param name="mode">The mode.</param> /// <returns> /// Deserialized object. /// </returns> private T Deserialize <T>(BinaryMode mode) { if (_deserialized == null) { T res; using (IBinaryStream stream = new BinaryHeapStream(_data)) { stream.Seek(_offset, SeekOrigin.Begin); res = _marsh.Unmarshal <T>(stream, mode); } var desc = _marsh.GetDescriptor(true, _header.TypeId); if (!desc.KeepDeserialized) { return(res); } _deserialized = res; } return((T)_deserialized); }
/** <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, null, desc); }
/** <inheritDoc /> */ public IBinaryType GetBinaryType(Type type) { IgniteArgumentCheck.NotNull(type, "type"); var desc = Marshaller.GetDescriptor(type); return(desc == null ? null : Marshaller.GetBinaryType(desc.TypeId)); }
/** <inheritDoc /> */ public IBinaryObject BuildEnum(string typeName, int value) { IgniteArgumentCheck.NotNullOrEmpty(typeName, "typeName"); var desc = Marshaller.GetDescriptor(typeName); IgniteArgumentCheck.Ensure(desc.IsEnum, "typeName", "Type should be an Enum."); _marsh.PutBinaryType(desc); return(new BinaryEnum(GetTypeId(typeName), value, Marshaller)); }
/** <inheritDoc /> */ public IBinaryObject BuildEnum(Type type, int value) { IgniteArgumentCheck.NotNull(type, "type"); IgniteArgumentCheck.Ensure(type.IsEnum, "type", "Type should be an Enum."); var desc = Marshaller.GetDescriptor(type); IgniteArgumentCheck.Ensure(desc.IsEnum, "typeName", "Type should be an Enum."); _marsh.PutBinaryType(desc); return new BinaryEnum(desc.TypeId, value, Marshaller); }
/** <inheritDoc /> */ public IBinaryObject BuildEnum(Type type, string valueName) { IgniteArgumentCheck.NotNull(type, "type"); IgniteArgumentCheck.NotNullOrEmpty(valueName, "valueName"); var desc = Marshaller.GetDescriptor(type); IgniteArgumentCheck.Ensure(desc.IsEnum, "typeName", "Type should be an Enum."); _marsh.PutBinaryType(desc); var value = GetEnumValueAsInt(type.ToString(), valueName, desc); return(new BinaryEnum(desc.TypeId, value, Marshaller)); }
/** <inheritdoc /> */ public override string ToString() { var meta = GetBinaryType(); if (meta == null || meta == BinaryType.Empty) { return(string.Format("BinaryEnum [typeId={0}, enumValue={1}]", _typeId, _enumValue)); } var desc = _marsh.GetDescriptor(true, _typeId); var enumValueName = desc != null && desc.Type != null?Enum.GetName(desc.Type, _enumValue) : null; return(string.Format("{0} [typeId={1}, enumValue={2}, enumValueName={3}]", meta.TypeName, _typeId, _enumValue, enumValueName)); }
/** <inheritDoc /> */ public int GetTypeId(string typeName) { IgniteArgumentCheck.NotNullOrEmpty(typeName, "typeName"); return(Marshaller.GetDescriptor(typeName).TypeId); }
/// <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 = type.IsEnum ? null : _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; var flags = desc.UserType ? BinaryObjectHeader.Flag.UserType : BinaryObjectHeader.Flag.None; var hasSchema = _schema.WriteSchema(_stream, schemaIdx, out schemaId, ref flags); if (hasSchema) { flags |= BinaryObjectHeader.Flag.HasSchema; // Calculate and write header. if (_curRawPos > 0) { _stream.WriteInt(_curRawPos - pos); // raw offset is in the last 4 bytes } } else { schemaOffset = BinaryObjectHeader.Size; } if (_curRawPos > 0) { flags |= BinaryObjectHeader.Flag.HasRaw; } var len = _stream.Position - pos; var header = new BinaryObjectHeader(desc.TypeId, obj.GetHashCode(), len, schemaId, schemaOffset, 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); } }
private T ReadFullObject <T>(int pos) { var hdr = BinaryObjectHeader.Read(Stream, pos); // Validate protocol version. BinaryUtils.ValidateProtocolVersion(hdr.Version); try { // Already read this object? object hndObj; if (_hnds != null && _hnds.TryGetValue(pos, out hndObj)) { return((T)hndObj); } if (hdr.IsUserType && _mode == BinaryMode.ForceBinary) { BinaryObject portObj; if (_detach) { Stream.Seek(pos, SeekOrigin.Begin); portObj = new BinaryObject(_marsh, Stream.ReadByteArray(hdr.Length), 0, hdr); } else { portObj = new BinaryObject(_marsh, Stream.GetArray(), pos, hdr); } T obj = _builder == null ? TypeCaster <T> .Cast(portObj) : TypeCaster <T> .Cast(_builder.Child(portObj)); AddHandle(pos, obj); return(obj); } else { // Find descriptor. var desc = _marsh.GetDescriptor(hdr.IsUserType, hdr.TypeId); // Instantiate object. if (desc.Type == null) { if (desc is BinarySurrogateTypeDescriptor) { throw new BinaryObjectException("Unknown type ID: " + hdr.TypeId); } throw new BinaryObjectException("No matching type found for object [typeId=" + desc.TypeId + ", typeName=" + desc.TypeName + ']'); } // Preserve old frame. var oldHdr = _curHdr; int oldPos = _curPos; var oldStruct = _curStruct; bool oldRaw = _curRaw; var oldSchema = _curSchema; var oldSchemaMap = _curSchemaMap; // Set new frame. _curHdr = hdr; _curPos = pos; SetCurSchema(desc); _curStruct = new BinaryStructureTracker(desc, desc.ReaderTypeStructure); _curRaw = false; // Read object. Stream.Seek(pos + BinaryObjectHeader.Size, SeekOrigin.Begin); var obj = desc.Serializer.ReadBinary <T>(this, desc.Type, pos); _curStruct.UpdateReaderStructure(); // Restore old frame. _curHdr = oldHdr; _curPos = oldPos; _curStruct = oldStruct; _curRaw = oldRaw; _curSchema = oldSchema; _curSchemaMap = oldSchemaMap; return(obj); } } finally { // Advance stream pointer. Stream.Seek(pos + hdr.Length, SeekOrigin.Begin); } }