/// <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> /// 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> /// Gets field value on the given object. /// </summary> /// <param name="pos">Position.</param> /// <param name="builder">Builder.</param> /// <returns>Field value.</returns> public T GetField <T>(int pos, BinaryObjectBuilder builder) { IBinaryStream stream = new BinaryHeapStream(_data); stream.Seek(pos + _offset, SeekOrigin.Begin); return(_marsh.Unmarshal <T>(stream, BinaryMode.ForceBinary, builder)); }
/// <summary> /// Constructor. /// </summary> /// <param name="binary">Binary.</param> /// <param name="parent">Parent builder.</param> /// <param name="obj">Initial binary object.</param> /// <param name="desc">Type descriptor.</param> public BinaryObjectBuilder(Binary binary, BinaryObjectBuilder parent, BinaryObject obj, IBinaryTypeDescriptor desc) { Debug.Assert(binary != null); Debug.Assert(desc != null); _binary = binary; _parent = parent ?? this; _desc = desc; _obj = obj ?? BinaryFromDescriptor(desc); }
/// <summary> /// Constructor. /// </summary> /// <param name="marsh">Marshaller.</param> /// <param name="stream">Input stream.</param> /// <param name="mode">The mode.</param> /// <param name="builder">Builder.</param> public BinaryReader (Marshaller marsh, IBinaryStream stream, BinaryMode mode, BinaryObjectBuilder builder) { _marsh = marsh; _mode = mode; _builder = builder; Stream = stream; }
/// <summary> /// Constructor. /// </summary> /// <param name="marsh">Marshaller.</param> /// <param name="descs">Descriptors.</param> /// <param name="stream">Input stream.</param> /// <param name="mode">The mode.</param> /// <param name="builder">Builder.</param> public BinaryReader (Marshaller marsh, IDictionary <long, IBinaryTypeDescriptor> descs, IBinaryStream stream, BinaryMode mode, BinaryObjectBuilder builder) { _marsh = marsh; _descs = descs; _mode = mode; _builder = builder; Stream = stream; }
/// <summary> /// Constructor. /// </summary> /// <param name="igniteBinary">Binary.</param> /// <param name="parent">Parent builder.</param> /// <param name="obj">Initial binary object.</param> /// <param name="desc">Type descriptor.</param> public BinaryObjectBuilder(IgniteBinary igniteBinary, BinaryObjectBuilder parent, BinaryObject obj, IBinaryTypeDescriptor desc) { Debug.Assert(igniteBinary != null); Debug.Assert(obj != null); Debug.Assert(desc != null); _igniteBinary = igniteBinary; _parent = parent ?? this; _obj = obj; _desc = desc; _hashCode = obj.GetHashCode(); }
/// <summary> /// Process child builder. /// </summary> /// <param name="outStream">Output stream.</param> /// <param name="builder">Builder.</param> internal void ProcessBuilder(IBinaryStream outStream, BinaryObjectBuilder builder) { BinaryHeapStream inStream = new BinaryHeapStream(builder._obj.Data); inStream.Seek(builder._obj.Offset, SeekOrigin.Begin); // Builder parent context might be null only in one case: if we never met this group of // builders before. In this case we set context to their parent and track it. Context // cleanup will be performed at the very end of build process. if (builder._parent._ctx == null || builder._parent._ctx.Closed) { builder._parent._ctx = new Context(_parent._ctx); } builder.Mutate(inStream, outStream as BinaryHeapStream, builder._desc, builder._hashCode, builder._vals); }
/// <summary> /// Constructor. /// </summary> /// <param name="binary">Binary.</param> /// <param name="parent">Parent builder.</param> /// <param name="obj">Initial binary object.</param> /// <param name="desc">Type descriptor.</param> public BinaryObjectBuilder(Binary binary, BinaryObjectBuilder parent, BinaryObject obj, IBinaryTypeDescriptor desc) { Debug.Assert(binary != null); Debug.Assert(desc != null); _binary = binary; _parent = parent ?? this; _desc = desc; if (obj != null) { _obj = obj; _hashCode = obj.GetHashCode(); } else { _obj = BinaryFromDescriptor(desc); } }
/// <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)); }
/// <summary> /// Unmarshal object. /// </summary> /// <param name="stream">Stream over underlying byte array with correct position.</param> /// <param name="mode">The mode.</param> /// <param name="builder">Builder.</param> /// <returns> /// Object. /// </returns> public T Unmarshal <T>(IBinaryStream stream, BinaryMode mode, BinaryObjectBuilder builder) { return(new BinaryReader(this, stream, mode, builder).Deserialize <T>()); }
/// <summary> /// Mutate binary object. /// </summary> /// <param name="inStream">Input stream with initial object.</param> /// <param name="outStream">Output stream.</param> /// <param name="desc">Type descriptor.</param> /// <param name="vals">Values.</param> private void Mutate( BinaryHeapStream inStream, BinaryHeapStream outStream, IBinaryTypeDescriptor desc, IDictionary <string, BinaryBuilderField> vals) { // Set correct builder to writer frame. BinaryObjectBuilder oldBuilder = _parent._ctx.Writer.SetBuilder(_parent); int streamPos = inStream.Position; try { // Prepare fields. IBinaryTypeHandler metaHnd = _binary.Marshaller.GetBinaryTypeHandler(desc); IDictionary <int, BinaryBuilderField> vals0; if (vals == null || vals.Count == 0) { vals0 = EmptyVals; } else { vals0 = new Dictionary <int, BinaryBuilderField>(vals.Count); foreach (KeyValuePair <string, BinaryBuilderField> valEntry in vals) { int fieldId = BinaryUtils.FieldId(desc.TypeId, valEntry.Key, desc.NameMapper, desc.IdMapper); if (vals0.ContainsKey(fieldId)) { throw new IgniteException("Collision in field ID detected (change field name or " + "define custom ID mapper) [fieldName=" + valEntry.Key + ", fieldId=" + fieldId + ']'); } vals0[fieldId] = valEntry.Value; // Write metadata if: 1) it is enabled for type; 2) type is not null (i.e. it is neither // remove marker, nor a field read through "GetField" method. if (metaHnd != null && valEntry.Value.Type != null) { metaHnd.OnFieldWrite(fieldId, valEntry.Key, valEntry.Value.TypeId); } } } // Actual processing. Mutate0(_parent._ctx, inStream, outStream, true, vals0); // 3. Handle metadata. if (metaHnd != null) { IDictionary <string, BinaryField> meta = metaHnd.OnObjectWriteFinished(); if (meta != null) { _parent._ctx.Writer.SaveMetadata(desc, meta); } } } finally { // Restore builder frame. _parent._ctx.Writer.SetBuilder(oldBuilder); inStream.Seek(streamPos, SeekOrigin.Begin); } }