/// <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;
}
