/// <summary>
/// Write dictionary.
/// </summary>
/// <param name="writer">Portable writer.</param>
/// <param name="vals">Values.</param>
/// <returns>The same writer.</returns>
protected static PortableWriterImpl WriteDictionary <T1, T2>(PortableWriterImpl writer,
IDictionary <T1, T2> vals)
{
writer.WriteInt(vals.Count);
foreach (KeyValuePair <T1, T2> pair in vals)
{
writer.Write(pair.Key);
writer.Write(pair.Value);
}
return(writer);
}
internal bool Serialize(IPortableStream stream)
{
ClusterGroupImpl prj = _ignite.ClusterGroup;
PortableWriterImpl writer = prj.Marshaller.StartMarshal(stream);
try
{
writer.Write(this);
return(true);
}
catch (Exception e)
{
writer.WriteString("Failed to marshal job [job=" + _job + ", errType=" + e.GetType().Name +
", errMsg=" + e.Message + ']');
return(false);
}
finally
{
// 4. Process metadata.
prj.FinishMarshal(writer);
}
}
/// <summary>
/// Write task to the writer.
/// </summary>
/// <param name="writer">Writer.</param>
/// <param name="taskName">Task name.</param>
/// <param name="taskArg">Task arg.</param>
/// <param name="nodes">Nodes.</param>
private void WriteTask(PortableWriterImpl writer, string taskName, object taskArg,
ICollection <IClusterNode> nodes)
{
writer.WriteString(taskName);
writer.WriteBoolean(_keepPortable.Value);
writer.Write(taskArg);
WriteNodeIds(writer, nodes);
}
private void Marshal(PortableWriterImpl writer)
{
var pos = writer.Stream.Position;
try
{
if (Error == null)
{
writer.WriteByte((byte)Entry.State);
if (Entry.State == MutableCacheEntryState.ValueSet)
{
writer.Write(Entry.Value);
}
writer.Write(ProcessResult);
}
else
{
writer.WriteByte((byte)MutableCacheEntryState.ErrPortable);
writer.Write(new PortableResultWrapper(Error));
}
}
catch (Exception marshErr)
{
writer.Stream.Seek(pos, SeekOrigin.Begin);
writer.WriteByte((byte)MutableCacheEntryState.ErrString);
if (Error == null)
{
writer.WriteString(string.Format(
"CacheEntryProcessor completed with error, but result serialization failed [errType={0}, " +
"err={1}, serializationErrMsg={2}]", marshErr.GetType().Name, marshErr, marshErr.Message));
}
else
{
writer.WriteString(string.Format(
"CacheEntryProcessor completed with error, and error serialization failed [errType={0}, " +
"err={1}, serializationErrMsg={2}]", marshErr.GetType().Name, marshErr, marshErr.Message));
}
}
}
/// <summary>
/// Write enumerable.
/// </summary>
/// <param name="writer">Portable writer.</param>
/// <param name="vals">Values.</param>
/// <param name="selector">A transform function to apply to each element.</param>
/// <returns>The same writer for chaining.</returns>
protected static PortableWriterImpl WriteEnumerable <T1, T2>(PortableWriterImpl writer,
IEnumerable <T1> vals, Func <T1, T2> selector)
{
var col = vals as ICollection <T1>;
if (col != null)
{
return(WriteCollection(writer, col, selector));
}
var stream = writer.Stream;
var pos = stream.Position;
stream.Seek(4, SeekOrigin.Current);
var size = 0;
if (selector == null)
{
foreach (var val in vals)
{
writer.Write(val);
size++;
}
}
else
{
foreach (var val in vals)
{
writer.Write(selector(val));
size++;
}
}
stream.WriteInt(pos, size);
return(writer);
}
/// <summary>
/// Write collection.
/// </summary>
/// <param name="writer">Portable writer.</param>
/// <param name="vals">Values.</param>
/// <param name="selector">A transform function to apply to each element.</param>
/// <returns>The same writer for chaining.</returns>
protected static PortableWriterImpl WriteCollection <T1, T2>(PortableWriterImpl writer,
ICollection <T1> vals, Func <T1, T2> selector)
{
writer.WriteInt(vals.Count);
if (selector == null)
{
foreach (var val in vals)
{
writer.Write(val);
}
}
else
{
foreach (var val in vals)
{
writer.Write(selector(val));
}
}
return(writer);
}
/// <summary>
/// Write batch content.
/// </summary>
/// <param name="writer">Portable writer.</param>
private void WriteTo(PortableWriterImpl writer)
{
writer.WriteInt(_size);
object val;
while (_queue.TryDequeue(out val))
{
// 1. Is it a collection?
ICollection <KeyValuePair <TK, TV> > entries = val as ICollection <KeyValuePair <TK, TV> >;
if (entries != null)
{
foreach (KeyValuePair <TK, TV> item in entries)
{
writer.Write(item.Key);
writer.Write(item.Value);
}
continue;
}
// 2. Is it a single entry?
DataStreamerEntry <TK, TV> entry = val as DataStreamerEntry <TK, TV>;
if (entry != null)
{
writer.Write(entry.Key);
writer.Write(entry.Value);
continue;
}
// 3. Is it remove merker?
DataStreamerRemoveEntry <TK> rmvEntry = val as DataStreamerRemoveEntry <TK>;
if (rmvEntry != null)
{
writer.Write(rmvEntry.Key);
writer.Write <object>(null);
}
}
}
private void Marshal(PortableWriterImpl writer)
{
var pos = writer.Stream.Position;
try
{
if (Error == null)
{
writer.WriteByte((byte) Entry.State);
if (Entry.State == MutableCacheEntryState.ValueSet)
writer.Write(Entry.Value);
writer.Write(ProcessResult);
}
else
{
writer.WriteByte((byte) MutableCacheEntryState.ErrPortable);
writer.Write(new PortableResultWrapper(Error));
}
}
catch (Exception marshErr)
{
writer.Stream.Seek(pos, SeekOrigin.Begin);
writer.WriteByte((byte) MutableCacheEntryState.ErrString);
if (Error == null)
{
writer.WriteString(string.Format(
"CacheEntryProcessor completed with error, but result serialization failed [errType={0}, " +
"err={1}, serializationErrMsg={2}]", marshErr.GetType().Name, marshErr, marshErr.Message));
}
else
{
writer.WriteString(string.Format(
"CacheEntryProcessor completed with error, and error serialization failed [errType={0}, " +
"err={1}, serializationErrMsg={2}]", marshErr.GetType().Name, marshErr, marshErr.Message));
}
}
}
