/// <summary> /// Compare two FieldInfo instances. /// </summary> private static int Compare(FieldInfo info1, FieldInfo info2) { string name1 = PortableUtils.CleanFieldName(info1.Name); string name2 = PortableUtils.CleanFieldName(info2.Name); return(string.Compare(name1, name2, StringComparison.OrdinalIgnoreCase)); }
/** <inheritDoc /> */ public void WritePortable(IPortableWriter writer) { var writer0 = (PortableWriterImpl)writer.RawWriter(); writer0.DetachNext(); PortableUtils.WritePortableOrSerializable(writer0, Result); }
/// <summary> /// Get field with builder. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="fieldName"></param> /// <param name="builder"></param> /// <returns></returns> public T Field <T>(string fieldName, PortableBuilderImpl builder) { IPortableTypeDescriptor desc = _marsh.Descriptor(true, _typeId); InitializeFields(); int fieldId = PortableUtils.FieldId(_typeId, fieldName, desc.NameConverter, desc.Mapper); int pos; if (_fields.TryGetValue(fieldId, out pos)) { if (builder != null) { // Read in scope of build process. T res; if (!builder.CachedField(pos, out res)) { res = Field0 <T>(pos, builder); builder.CacheField(pos, res); } return(res); } return(Field0 <T>(pos, null)); } return(default(T)); }
/// <summary> /// Constrcutor. /// </summary> /// <param name="cfg">Portable configuration.</param> /// <param name="name">Type name.</param> public PortableSurrogateTypeDescriptor(PortableConfiguration cfg, string name) { _cfg = cfg; _name = name; _id = PortableUtils.TypeId(name, cfg.DefaultNameMapper, cfg.DefaultIdMapper); }
/// <summary> /// Gets the reader with a specified write action. /// </summary> private static PortableReflectiveWriteAction GetWriter <T>(FieldInfo field, Expression <Action <string, IPortableWriter, T> > write, bool convertFieldValToObject = false) { Debug.Assert(field != null); Debug.Assert(field.DeclaringType != null); // non-static // Get field value var targetParam = Expression.Parameter(typeof(object)); var targetParamConverted = Expression.Convert(targetParam, field.DeclaringType); Expression fldExpr = Expression.Field(targetParamConverted, field); if (convertFieldValToObject) { fldExpr = Expression.Convert(fldExpr, typeof(object)); } // Call IPortableWriter method var writerParam = Expression.Parameter(typeof(IPortableWriter)); var fldNameParam = Expression.Constant(PortableUtils.CleanFieldName(field.Name)); var writeExpr = Expression.Invoke(write, fldNameParam, writerParam, fldExpr); // Compile and return return(Expression.Lambda <PortableReflectiveWriteAction>(writeExpr, targetParam, writerParam).Compile()); }
/// <summary> /// Initializes a new instance of the <see cref="ComputeFuncJob"/> class. /// </summary> /// <param name="reader">The reader.</param> public ComputeFuncJob(IPortableReader reader) { var reader0 = (PortableReaderImpl)reader.RawReader(); _clo = PortableUtils.ReadPortableOrSerializable <IComputeFunc>(reader0); _arg = PortableUtils.ReadPortableOrSerializable <object>(reader0); }
/// <summary> /// /// </summary> /// <param name="userType"></param> /// <param name="typeId"></param> /// <returns></returns> public IPortableTypeDescriptor Descriptor(bool userType, int typeId) { IPortableTypeDescriptor desc; return(_idToDesc.TryGetValue(PortableUtils.TypeKey(userType, typeId), out desc) ? desc : userType ? new PortableSurrogateTypeDescriptor(_cfg, typeId) : null); }
/// <summary> /// Gets the reader with a specified read action. /// </summary> private static PortableReflectiveReadAction GetReader <T>(FieldInfo field, Expression <Func <string, IPortableReader, T> > read) { Debug.Assert(field != null); Debug.Assert(field.DeclaringType != null); // non-static // Call IPortableReader method var readerParam = Expression.Parameter(typeof(IPortableReader)); var fldNameParam = Expression.Constant(PortableUtils.CleanFieldName(field.Name)); Expression readExpr = Expression.Invoke(read, fldNameParam, readerParam); if (typeof(T) != field.FieldType) { readExpr = Expression.Convert(readExpr, field.FieldType); } // Assign field value var targetParam = Expression.Parameter(typeof(object)); var targetParamConverted = Expression.Convert(targetParam, field.DeclaringType); var assignExpr = Expression.Call(DelegateConverter.GetWriteFieldMethod(field), targetParamConverted, readExpr); // Compile and return return(Expression.Lambda <PortableReflectiveReadAction>(assignExpr, targetParam, readerParam).Compile()); }
/// <summary> /// Gets the writer with a specified generic method. /// </summary> private static PortableReflectiveWriteAction GetWriter(FieldInfo field, MethodInfo method, params Type[] genericArgs) { Debug.Assert(field != null); Debug.Assert(field.DeclaringType != null); // non-static if (genericArgs.Length == 0) { genericArgs = new[] { field.FieldType } } ; // Get field value var targetParam = Expression.Parameter(typeof(object)); var targetParamConverted = Expression.Convert(targetParam, field.DeclaringType); var fldExpr = Expression.Field(targetParamConverted, field); // Call IPortableWriter method var writerParam = Expression.Parameter(typeof(IPortableWriter)); var fldNameParam = Expression.Constant(PortableUtils.CleanFieldName(field.Name)); var writeMethod = method.MakeGenericMethod(genericArgs); var writeExpr = Expression.Call(writerParam, writeMethod, fldNameParam, fldExpr); // Compile and return return(Expression.Lambda <PortableReflectiveWriteAction>(writeExpr, targetParam, writerParam).Compile()); }
public int JobResultRemote(ComputeJobHolder job, PlatformMemoryStream stream) { // 1. Unmarshal result. PortableReaderImpl reader = _compute.Marshaller.StartUnmarshal(stream); Guid nodeId = reader.ReadGuid().Value; bool cancelled = reader.ReadBoolean(); try { object err; var data = PortableUtils.ReadWrappedInvocationResult(reader, out err); // 2. Process the result. return((int)JobResult0(new ComputeJobResultImpl(data, (Exception)err, job.Job, nodeId, cancelled))); } catch (Exception e) { Finish(default(TR), e); if (!(e is IgniteException)) { throw new IgniteException("Failed to process job result: " + e.Message, e); } throw; } }
/// <summary> /// Reads method invocation result. /// </summary> /// <param name="stream">Stream.</param> /// <param name="marsh">Marshaller.</param> /// <param name="keepPortable">Portable flag.</param> /// <returns> /// Method invocation result, or exception in case of error. /// </returns> public static object ReadInvocationResult(IPortableStream stream, PortableMarshaller marsh, bool keepPortable) { Debug.Assert(stream != null); Debug.Assert(marsh != null); var mode = keepPortable ? PortableMode.ForcePortable : PortableMode.Deserialize; var reader = marsh.StartUnmarshal(stream, mode); object err; var res = PortableUtils.ReadInvocationResult(reader, out err); if (err == null) { return(res); } var portErr = err as IPortableObject; throw portErr != null ? new ServiceInvocationException("Proxy method invocation failed with a portable error. " + "Examine PortableCause for details.", portErr) : new ServiceInvocationException("Proxy method invocation failed with an exception. " + "Examine InnerException for details.", (Exception)err); }
/// <summary> /// Gets the reader with a specified generic method. /// </summary> private static PortableReflectiveReadAction GetReader(FieldInfo field, MethodInfo method, params Type[] genericArgs) { Debug.Assert(field != null); Debug.Assert(field.DeclaringType != null); // non-static if (genericArgs.Length == 0) { genericArgs = new[] { field.FieldType } } ; // Call IPortableReader method var readerParam = Expression.Parameter(typeof(IPortableReader)); var fldNameParam = Expression.Constant(PortableUtils.CleanFieldName(field.Name)); var readMethod = method.MakeGenericMethod(genericArgs); Expression readExpr = Expression.Call(readerParam, readMethod, fldNameParam); if (readMethod.ReturnType != field.FieldType) { readExpr = Expression.Convert(readExpr, field.FieldType); } // Assign field value var targetParam = Expression.Parameter(typeof(object)); var targetParamConverted = Expression.Convert(targetParam, field.DeclaringType); var assignExpr = Expression.Call(DelegateConverter.GetWriteFieldMethod(field), targetParamConverted, readExpr); // Compile and return return(Expression.Lambda <PortableReflectiveReadAction>(assignExpr, targetParam, readerParam).Compile()); } }
/// <summary> /// Deserialize object. /// </summary> /// <returns>Deserialized object.</returns> public T Deserialize <T>() { int pos = Stream.Position; byte hdr = Stream.ReadByte(); var doDetach = _detach; // save detach flag into a var and reset so it does not go deeper _detach = false; switch (hdr) { case PortableUtils.HdrNull: return(default(T)); case PortableUtils.HdrHnd: return(ReadHandleObject <T>(pos)); case PortableUtils.HdrFull: return(ReadFullObject <T>(pos)); case PortableUtils.TypePortable: return(ReadPortableObject <T>(doDetach)); } if (PortableUtils.IsPredefinedType(hdr)) { return(PortableSystemHandlers.ReadSystemType <T>(hdr, this)); } throw new PortableException("Invalid header on deserialization [pos=" + pos + ", hdr=" + hdr + ']'); }
/** <inheritdoc /> */ void IPortableWriteAware.WritePortable(IPortableWriter writer) { var w = (PortableWriterImpl)writer; w.WriteByte(StreamReceiverHolder.RcvTransformer); PortableUtils.WritePortableOrSerializable(w, _proc); }
/** * <summary>Read dictionary.</summary> */ private static object ReadDictionary(PortableReaderImpl ctx, Type type) { PortableCollectionInfo info = PortableCollectionInfo.Info(type); return(info.IsGenericDictionary ? info.ReadGeneric(ctx) : PortableUtils.ReadDictionary(ctx, null)); }
/// <summary> /// Initializes a new instance of the <see cref="ComputeJobWrapper"/> class. /// </summary> /// <param name="reader">The reader.</param> public ComputeJobWrapper(IPortableReader reader) { var reader0 = (PortableReaderImpl)reader.RawReader(); _job = PortableUtils.ReadPortableOrSerializable <object>(reader0); DelegateTypeDescriptor.GetComputeJob(_job.GetType(), out _execute, out _cancel); }
/// <summary> /// Initializes a new instance of the <see cref="ComputeFuncWrapper"/> class. /// </summary> /// <param name="reader">The reader.</param> public ComputeFuncWrapper(IPortableReader reader) { var reader0 = (PortableReaderImpl)reader.RawReader(); _func = PortableUtils.ReadPortableOrSerializable <object>(reader0); _invoker = DelegateTypeDescriptor.GetComputeFunc(_func.GetType()); }
/// <summary> /// Initializes a new instance of the <see cref="ContinuousQueryFilterHolder"/> class. /// </summary> /// <param name="reader">The reader.</param> public ContinuousQueryFilterHolder(IPortableReader reader) { PortableReaderImpl rawReader = (PortableReaderImpl)reader.RawReader(); _keyTyp = PortableUtils.ReadPortableOrSerializable <Type>(rawReader); _valTyp = PortableUtils.ReadPortableOrSerializable <Type>(rawReader); _filter = PortableUtils.ReadPortableOrSerializable <object>(rawReader); _keepPortable = rawReader.ReadBoolean(); }
/** <inheritdoc /> */ public void WritePortable(IPortableWriter writer) { var writer0 = (PortableWriterImpl)writer.RawWriter(); writer0.DetachNext(); PortableUtils.WritePortableOrSerializable(writer0, _pred); writer0.WriteBoolean(_keepPortable); }
/// <summary> /// Writes method invocation result. /// </summary> /// <param name="stream">Stream.</param> /// <param name="marsh">Marshaller.</param> /// <param name="methodResult">Method result.</param> /// <param name="invocationError">Method invocation error.</param> public static void WriteInvocationResult(IPortableStream stream, PortableMarshaller marsh, object methodResult, Exception invocationError) { Debug.Assert(stream != null); Debug.Assert(marsh != null); var writer = marsh.StartMarshal(stream); PortableUtils.WriteInvocationResult(writer, invocationError == null, invocationError ?? methodResult); }
/// <summary> /// Writes this object to the given writer. /// </summary> /// <param name="writer">Writer.</param> public void WritePortable(IPortableWriter writer) { PortableWriterImpl rawWriter = (PortableWriterImpl)writer.RawWriter(); PortableUtils.WritePortableOrSerializable(rawWriter, _keyTyp); PortableUtils.WritePortableOrSerializable(rawWriter, _valTyp); PortableUtils.WritePortableOrSerializable(rawWriter, _filter); rawWriter.WriteBoolean(_keepPortable); }
/** <inheritDoc /> */ public void WritePortable(IPortableWriter writer) { PortableWriterImpl writer0 = (PortableWriterImpl)writer.RawWriter(); writer0.DetachNext(); PortableUtils.WritePortableOrSerializable(writer0, _clo); writer0.DetachNext(); PortableUtils.WritePortableOrSerializable(writer0, _arg); }
/// <summary> /// Default ctor for marshalling. /// </summary> /// <param name="reader"></param> public ComputeJobHolder(IPortableReader reader) { Debug.Assert(reader != null); var reader0 = (PortableReaderImpl)reader.RawReader(); _ignite = reader0.Marshaller.Ignite; _job = PortableUtils.ReadPortableOrSerializable <IComputeJob>(reader0); }
/// <summary> /// Write field. /// </summary> /// <param name="fieldName">Field name.</param> /// <param name="typeId">Type ID.</param> /// <param name="val">Value.</param> /// <param name="handler">Handler.</param> private void WriteField(string fieldName, byte typeId, object val, PortableSystemWriteDelegate handler) { int fieldId = PortableUtils.FieldId(_curTypeId, fieldName, _curConverter, _curMapper); WriteField(fieldId, val, handler); if (_curMetaHnd != null) { _curMetaHnd.OnFieldWrite(fieldId, fieldName, typeId); } }
/// <summary> /// Write simple nullable field with known length. /// </summary> /// <param name="fieldName">Field name.</param> /// <param name="typeId">Type ID.</param> /// <param name="val">Value.</param> /// <param name="handler">Handler.</param> /// <param name="len">Length.</param> private void WriteSimpleNullableField <T>(string fieldName, byte typeId, T val, PortableSystemTypedWriteDelegate <T> handler, int len) { int fieldId = PortableUtils.FieldId(_curTypeId, fieldName, _curConverter, _curMapper); WriteSimpleNullableField(fieldId, val, handler, len); if (_curMetaHnd != null) { _curMetaHnd.OnFieldWrite(fieldId, fieldName, typeId); } }
/// <summary> /// Initializes a new instance of the <see cref="MessageFilterHolder"/> class. /// </summary> /// <param name="reader">The reader.</param> public MessageFilterHolder(IPortableReader reader) { var reader0 = (PortableReaderImpl)reader.RawReader(); _filter = PortableUtils.ReadPortableOrSerializable <object>(reader0); _invoker = GetInvoker(_filter); _ignite = reader0.Marshaller.Ignite; ResourceProcessor.Inject(_filter, _ignite); }
/// <summary> /// Lazy fields initialization routine. /// </summary> private void InitializeFields() { if (_fields == null) { IPortableStream stream = new PortableHeapStream(_data); stream.Seek(_offset + 14, SeekOrigin.Begin); int rawDataOffset = stream.ReadInt(); _fields = PortableUtils.ObjectFields(stream, _typeId, rawDataOffset); } }
/// <summary> /// Initializes a new instance of the <see cref="CacheEntryProcessorHolder"/> class. /// </summary> /// <param name="reader">The reader.</param> public CacheEntryProcessorHolder(IPortableReader reader) { var reader0 = (PortableReaderImpl)reader.RawReader(); _proc = PortableUtils.ReadPortableOrSerializable <object>(reader0); _arg = PortableUtils.ReadPortableOrSerializable <object>(reader0); _processFunc = GetProcessFunc(_proc); var kvTypes = DelegateTypeDescriptor.GetCacheEntryProcessorTypes(_proc.GetType()); _entryCtor = MutableCacheEntry.GetCtor(kvTypes.Item1, kvTypes.Item2); }
/// <summary> /// Initializes a new instance of the <see cref="CacheEntryFilterHolder"/> class. /// </summary> /// <param name="reader">The reader.</param> public CacheEntryFilterHolder(IPortableReader reader) { var reader0 = (PortableReaderImpl)reader.RawReader(); _pred = PortableUtils.ReadPortableOrSerializable <object>(reader0); _keepPortable = reader0.ReadBoolean(); _marsh = reader0.Marshaller; _invoker = GetInvoker(_pred); _handle = _marsh.Ignite.HandleRegistry.Allocate(this); }
/// <summary>Register type.</summary> /// <param name="type">Type.</param> /// <param name="typeId">Type ID.</param> /// <param name="converter">Name converter.</param> /// <param name="idMapper">ID mapper.</param> public void Register(Type type, int typeId, IPortableNameMapper converter, IPortableIdMapper idMapper) { if (type.GetInterface(typeof(IPortableMarshalAware).Name) != null) { return; } List <FieldInfo> fields = new List <FieldInfo>(); Type curType = type; while (curType != null) { foreach (FieldInfo field in curType.GetFields(Flags)) { if (!field.IsNotSerialized) { fields.Add(field); } } curType = curType.BaseType; } IDictionary <int, string> idMap = new Dictionary <int, string>(); foreach (FieldInfo field in fields) { string fieldName = PortableUtils.CleanFieldName(field.Name); int fieldId = PortableUtils.FieldId(typeId, fieldName, converter, idMapper); if (idMap.ContainsKey(fieldId)) { throw new PortableException("Conflicting field IDs [type=" + type.Name + ", field1=" + idMap[fieldId] + ", field2=" + fieldName + ", fieldId=" + fieldId + ']'); } idMap[fieldId] = fieldName; } fields.Sort(Compare); Descriptor desc = new Descriptor(fields); _types[type] = desc; }