public object Deserialize(
StreamReader streamReader,
SerializationContext serializationContext,
PropertyMetaData propertyMetaData = null)
{
var mess = new GenericCmdMessage();
mess.N3MessageType = (N3MessageType)streamReader.ReadInt32();
mess.Identity = streamReader.ReadIdentity();
mess.Unknown = streamReader.ReadByte();
mess.Temp1 = streamReader.ReadInt32();
mess.Count = streamReader.ReadInt32();
mess.Action = (GenericCmdAction)streamReader.ReadInt32();
mess.Temp4 = streamReader.ReadInt32();
mess.User = streamReader.ReadIdentity();
int len = 1;
if (mess.Action == GenericCmdAction.UseItemOnItem)
{
len = 2;
}
mess.Target = new Identity[len];
for (int i = 0; i < mess.Target.Length; i++)
{
mess.Target[i] = streamReader.ReadIdentity();
}
return mess;
}
private static void WritePropertiesAsElements(SerializationContext serializationContext, MetaModelLibrary element, global::System.Xml.XmlWriter writer)
{
// FilePath
if (!serializationContext.Result.Failed)
{
global::System.String propValue = element.FilePath;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
LanguageDSLSerializationHelper.Instance.WriteElementString(serializationContext, element, writer, "filePath", propValue);
}
}
// Name
if (!serializationContext.Result.Failed)
{
global::System.String propValue = element.Name;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
LanguageDSLSerializationHelper.Instance.WriteElementString(serializationContext, element, writer, "name", propValue);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SerializerEmitter"/> class for enum.
/// </summary>
/// <param name="context">A <see cref="SerializationContext"/>.</param>
/// <param name="host">The host <see cref="ModuleBuilder"/>.</param>
/// <param name="specification">The specification of the serializer.</param>
/// <param name="isDebuggable">Set to <c>true</c> when <paramref name="host"/> is debuggable.</param>
public SerializerEmitter( SerializationContext context, ModuleBuilder host, SerializerSpecification specification, bool isDebuggable )
: this( host, specification, typeof( EnumMessagePackSerializer<> ).MakeGenericType( specification.TargetType ), isDebuggable )
{
Tracer.Emit.TraceEvent( Tracer.EventType.DefineType, Tracer.EventId.DefineType, "Create {0}", specification.SerializerTypeFullName );
this._defaultEnumSerializationMethod = context.EnumSerializationOptions.SerializationMethod;
}
public override void Serialize(SerializationContext context)
{
base.Serialize(context);
int target = (Owner != null) ? Owner.ServerIndex : -1;
context.Write(target);
}
/// <summary>
/// Determines <see cref="EnumSerializationMethod"/> for the target.
/// </summary>
/// <param name="context">Context information.</param>
/// <param name="enumType">The target enum type.</param>
/// <param name="enumMemberSerializationMethod">The method argued by the member.</param>
/// <returns>Determined <see cref="EnumSerializationMethod"/> for the target.</returns>
public static EnumSerializationMethod DetermineEnumSerializationMethod(
SerializationContext context,
Type enumType,
EnumMemberSerializationMethod enumMemberSerializationMethod )
{
EnumSerializationMethod method = context.EnumSerializationMethod;
switch ( enumMemberSerializationMethod )
{
case EnumMemberSerializationMethod.ByName:
{
method = EnumSerializationMethod.ByName;
break;
}
case EnumMemberSerializationMethod.ByUnderlyingValue:
{
method = EnumSerializationMethod.ByUnderlyingValue;
break;
}
default:
{
var attributesOnType = enumType.GetCustomAttributes( typeof( MessagePackEnumAttribute ), false );
if ( attributesOnType.Length > 0 )
{
// ReSharper disable once PossibleNullReferenceException
method = ( attributesOnType[ 0 ] as MessagePackEnumAttribute ).SerializationMethod;
}
break;
}
}
return method;
}
public object Deserialize(
StreamReader streamReader,
SerializationContext serializationContext,
PropertyMetaData propertyMetaData = null)
{
return streamReader.ReadInt16();
}
public void SaveToFile(string icsFilename) {
var ctx = new SerializationContext();
var factory = new SerializerFactory();
var serializer = factory.Build(ical.GetType(), ctx) as IStringSerializer;
var content = serializer.SerializeToString(ical);
File.WriteAllText(icsFilename, content);
}
public static void SerializeUnityObject(Stream stream, UnityObject obj, SerializationContext ctx)
{
var container = (List<UnityObject>)ctx.Context;
var idx = container.Count;
Basic.WriteInt32(stream, idx);
container.Add(obj);
}
public ByteArray(byte[] buffer, SerializationContext serializationContext)
{
this.serializationContext = serializationContext;
memoryStream = new MemoryStream(buffer);
ReloadStreams();
}
public ByteArray(MemoryStream ms, SerializationContext serializationContext)
{
this.serializationContext = serializationContext;
memoryStream = ms;
ReloadStreams();
}
public override void GetObjectData(SerializationContext output)
{
base.GetObjectData(output);
output.WriteVersion(1);
output.Write(ROM);
}
/// <summary>
/// Initializes a new instance of the <see cref="DynamicMethodEmittingContext"/> class.
/// </summary>
/// <param name="context">The serialization context.</param>
/// <param name="targetType">Type of the serialization target.</param>
/// <param name="emitterFactory">
/// The factory for <see cref="SerializerEmitter"/> to be used.
/// </param>
/// <param name="enumEmitterFactory">
/// The factory for <see cref="EnumSerializerEmitter"/> to be used.
/// </param>
public DynamicMethodEmittingContext( SerializationContext context, Type targetType,
Func<SerializerEmitter> emitterFactory, Func<EnumSerializerEmitter> enumEmitterFactory )
: base( context, emitterFactory, enumEmitterFactory )
{
this._context = ILConstruct.Argument( 0, typeof( SerializationContext ), "context" );
this.Reset( targetType, null );
}
internal static int Serialize(Guid value, SerializationContext context, bool lengthPrefix)
{
if (value == Guid.Empty)
{
if (lengthPrefix)
{
context.WriteByte(0);
return 1;
}
return 0;
}
byte[] buffer = value.ToByteArray();
int len = 0;
if (lengthPrefix)
{
context.WriteByte((byte)18);
len = 1;
}
context.WriteByte(FieldLo << 3 | (int)WireType.Fixed64);
context.WriteBlock(buffer, 0, 8);
context.WriteByte(FieldHi << 3 | (int)WireType.Fixed64);
context.WriteBlock(buffer, 8, 8);
return len + 18;
}
public object Deserialize(
StreamReader streamReader,
SerializationContext serializationContext,
PropertyMetaData propertyMetaData = null)
{
return this.serializer.Deserialize(streamReader, serializationContext, propertyMetaData);
}
public static int SerializeDecimal(decimal value, SerializationContext context, bool lengthPrefixed)
{
int[] bits = decimal.GetBits(value);
ulong a = ((ulong)bits[1]) << 32, b = ((ulong)bits[0]) & 0xFFFFFFFFL;
ulong low = a | b;
uint high = (uint) bits[2];
uint signScale = (uint)(((bits[3] >> 15) & 0x01FE) | ((bits[3] >> 31) & 0x0001));
int len = 0;
if (lengthPrefixed)
{
if (low != 0) len += 1 + SerializationContext.GetLength((long)low);
if (high != 0) len += 1 + SerializationContext.GetLength((long)high);
if (signScale!=0) len += 2;
len = context.EncodeInt32(len);
}
if (low != 0)
{
context.WriteByte((FieldDecimalLow << 3) | (int)WireType.Variant);
len += 1 + context.EncodeInt64((long)low);
}
if (high != 0)
{ // note encode as long to avoid high sign issues
context.WriteByte((FieldDecimalHigh << 3) | (int)WireType.Variant);
len += 1 + context.EncodeInt64((long)high);
}
if (signScale != 0)
{
context.WriteByte((FieldDecimalSignScale << 3) | (int)WireType.Variant);
context.WriteByte((byte)signScale);
len += 2;
}
return len;
}
public object Deserialize(
StreamReader streamReader,
SerializationContext serializationContext,
PropertyMetaData propertyMetaData = null)
{
var identityType = (IdentityType)streamReader.ReadInt32();
if (identityType != IdentityType.VendingMachine)
{
streamReader.Position = streamReader.Position - 4;
return null;
}
var playfieldVendorInfo = new PlayfieldVendorInfo
{
Unknown1 =
new Identity
{
Type = identityType,
Instance = streamReader.ReadInt32()
},
Unknown2 = streamReader.ReadInt32(),
VendorCount = streamReader.ReadInt32(),
FirstVendorId = streamReader.ReadInt32()
};
return playfieldVendorInfo;
}
public object ConvertTo(object item, Type sourceType, SerializationContext serializationContext)
{
// create a temp copy for processing
List<IJsonTypeConverter> clonedList = new List<IJsonTypeConverter>(_converters);
// loop through list until the last item, determining the source type along the way
// process the last converter in the list and then remove it
// repeat until all converters have been processed
while (clonedList.Count > 0)
{
Type tempType = sourceType;
for (int i = 0; i < clonedList.Count; i++)
{
if (i == clonedList.Count - 1)
{
// last element, process
item = clonedList[i].ConvertTo(item, tempType, serializationContext);
}
else
{
// just determine the source type
tempType = clonedList[i].GetSerializedType(tempType);
}
}
clonedList.RemoveAt(clonedList.Count - 1);
}
return item;
}
public void ExportSolution()
{
DDay.iCal.iCalendar iCal = new DDay.iCal.iCalendar();
var t = new DBManager();
t.initInputData();
t.initOutputData();
foreach(ScheduledTimeSlot[] solution in (t.solutions))
{
for (int i = 0; i < solution.Length; i++)
{
Event evt = iCal.Create<Event>();
evt.Start = iCalDateTime.Today.AddHours((int)solution[i].timeSlot.StartHour).AddDays((int)(solution[i].timeSlot.Day));
evt.End = iCalDateTime.Today.AddHours((int)solution[i].timeSlot.EndHour).AddDays((int)(solution[i].timeSlot.Day));
evt.Summary = string.Join(", ", solution[i].groups.Select(g => g.name));
evt.Location = solution[i].room.nameOrNumber;
}
break;
}
ISerializationContext ctx = new SerializationContext();
ISerializerFactory factory = new DDay.iCal.Serialization.iCalendar.SerializerFactory();
// Get a serializer for our object
IStringSerializer serializer = factory.Build(iCal.GetType(), ctx) as IStringSerializer;
string output = serializer.SerializeToString(iCal);
var bytes = Encoding.UTF8.GetBytes(output);
File.WriteAllBytes("solution.ics", bytes);
}
public LayoutInfo ConvertStringToLayoutInfo(string layoutInfo, Store store)
{
LayoutInfo lInfo = null;
Microsoft.VisualStudio.Modeling.SerializationResult serializationResult = new Microsoft.VisualStudio.Modeling.SerializationResult();
DomainXmlSerializerDirectory directory = this.GetDirectory(store);
System.Text.Encoding encoding = System.Text.Encoding.GetEncoding("ISO-8859-1");
Microsoft.VisualStudio.Modeling.SerializationContext serializationContext = new SerializationContext(directory, "", serializationResult);
this.InitializeSerializationContext(store.DefaultPartition, serializationContext, false);
DomainClassXmlSerializer rootSerializer = directory.GetSerializer(LayoutInfo.DomainClassId);
using(System.Xml.XmlReader reader = System.Xml.XmlReader.Create(new System.IO.StringReader(layoutInfo)) )
{
reader.Read(); // Move to the first node - will be the XmlDeclaration if there is one.
serializationResult.Encoding = encoding;
reader.MoveToContent();
lInfo = rootSerializer.TryCreateInstance(serializationContext, reader, store.DefaultPartition) as LayoutInfo;
rootSerializer.Read(serializationContext, lInfo, reader);
}
return lInfo;
}
// GET: Calendar
public ActionResult Index()
{
foreach (var r in Request.Params.AllKeys)
{
System.Diagnostics.Debug.WriteLine(r + " = " + Request.Params[r]);
}
var iCal = new iCalendar();
Event evt = iCal.Create<Event>();
evt.Start = iCalDateTime.Today.AddHours(8);
evt.End = evt.Start.AddHours(18); // This also sets the duration
evt.Description = "The event description";
evt.Location = "Event location";
evt.Summary = "18 hour event summary";
evt = iCal.Create<Event>();
evt.Start = iCalDateTime.Today.AddDays(5);
evt.End = evt.Start.AddDays(1);
evt.IsAllDay = true;
evt.Summary = "All-day event";
ISerializationContext ctx = new SerializationContext();
ISerializerFactory factory = new DDay.iCal.Serialization.iCalendar.SerializerFactory();
IStringSerializer serializer = factory.Build(iCal.GetType(), ctx) as IStringSerializer;
string output = serializer.SerializeToString(iCal);
var bytes = System.Text.Encoding.UTF8.GetBytes(output);
return File(bytes, "text/calendar");
}
public void Callback(object value, TypeModel.CallbackType callbackType, SerializationContext context)
{
IProtoTypeSerializer protoTypeSerializer = this.Tail as IProtoTypeSerializer;
if (protoTypeSerializer != null)
{
protoTypeSerializer.Callback(value, callbackType, context);
}
}
public void Serialize(
StreamWriter streamWriter,
SerializationContext serializationContext,
object value,
PropertyMetaData propertyMetaData = null)
{
streamWriter.WriteInt16((short)value);
}
public static UnityObject DeserializeUnityObject(Stream stream, SerializationContext ctx)
{
var container = (List<UnityObject>)ctx.Context;
int idx = Basic.ReadInt32(stream);
if (idx < 0 || idx >= container.Count)
return null;
return container[idx];
}
public object ConvertFrom(object item, SerializationContext serializationContext)
{
foreach (IJsonTypeConverter converter in _converters)
{
item = converter.ConvertFrom(item, serializationContext);
}
return item;
}
/// <summary>
/// Initialize the serialization context on load / save
/// </summary>
/// <remarks>We need to supply a model bus for ModelBusReference deserialization to work</remarks>
protected override void InitializeSerializationContext(Partition partition, SerializationContext serializationContext, bool isLoading)
{
Debug.Assert(partition != null, "partition should not be null");
Debug.Assert(serializationContext != null, "serializationContext should not be null");
IModelBus modelbus = partition.Store.GetService(typeof(SModelBus)) as IModelBus;
serializationContext[Microsoft.VisualStudio.Modeling.Integration.ModelBusReferencePropertySerializer.ModelBusLoadContextKey] = modelbus;
}
public object Deserialize(
StreamReader streamReader,
SerializationContext serializationContext,
PropertyMetaData propertyMetaData = null)
{
var address = new IPAddress(streamReader.ReadBytes(4));
return address;
}
public AssemblyBuilderCodeGenerationContext( SerializationContext context, AssemblyBuilder assemblyBuilder )
{
this._context = context;
this._assemblyBuilder = assemblyBuilder;
DefaultSerializationMethodGeneratorManager.SetUpAssemblyBuilderAttributes( assemblyBuilder, false );
this._generatorManager = SerializationMethodGeneratorManager.Get( assemblyBuilder );
}
public override object ConvertTo(object item, Type sourceType, SerializationContext serializationContext)
{
string typeNameOrAlias = (string)item;
Type typeResult = serializationContext.TypeAliases[typeNameOrAlias];
if (typeResult == null)
typeResult = Type.GetType(typeNameOrAlias);
return typeResult;
}
internal SerializerHelper(Type t, SerializationContext context, TextWriter writer)
: base(writer, !context.IsCompact)
{
_serializedType = t;
_context = context;
//_writer = writer;
_refs = new Dictionary<object, ReferenceInfo>(new ReferenceEqualityComparer<object>());
}
public void Ctor()
{
var c = new MockClientConnection (new MockConnectionProvider (MockProtocol.Instance));
var context = new SerializationContext (c, MockProtocol.Instance, new TypeMap());
Assert.AreSame (c, context.Connection);
Assert.AreSame (MockProtocol.Instance, context.Protocol);
}
private static T UnpackCore <T>(Unpacker source, SerializationContext context)
{
return(MessagePackSerializer.Create <T>(context).UnpackFrom(source));
}
public MessagePackHubProtocol(IOptions <MessagePackHubProtocolOptions> options)
{
SerializationContext = options.Value.SerializationContext;
}
internal OrdinaryDictionarySerializer(SerializationContext ownerContext) : base(ownerContext)
{
}
public JsonValue Serialize(SerializationContext context)
{
var schema = (JsonSchema)context.Source !;
return(schema.ToJson(context.RootSerializer));
}
public void Deserialize(BufferReader reader, ref UnmanagedArray <T> target, SerializationContext context)
{
// we already read the size in PrepareDeserializationTarget
if (target.Length > 0)
{
reader.Read((void *)target.data, target.Length);
}
}
public void PrepareDeserializationTarget(BufferReader reader, ref UnmanagedArray <T> target, SerializationContext context)
{
var size = reader.ReadInt32();
if (target == null)
{
target = new UnmanagedArray <T>(size);
}
else
{
target.Resize(size);
}
}
/// <summary>
/// Serialize an instance of type <typeparamref name="T"/> to a byte array
/// in Protobuf format. The serialized data is preceeded by:
/// 1. A "magic byte" (1 byte) that identifies this as a message with
/// Confluent Platform framing.
/// 2. The id of the schema as registered in Confluent's Schema Registry
/// (4 bytes, network byte order).
/// 3. An size-prefixed array of indices that identify the specific message
/// type in the schema (a given schema can contain many message types
/// and they can be nested). Size and indices are unsigned varints. The
/// common case where the message type is the first message in the schema
/// (i.e. index data would be [1,0]) is encoded as simply a single 0 byte
/// as an optimization.
/// This call may block or throw on first use for a particular topic during
/// schema registration / verification.
/// </summary>
/// <param name="value">
/// The value to serialize.
/// </param>
/// <param name="context">
/// Context relevant to the serialize operation.
/// </param>
/// <returns>
/// A <see cref="System.Threading.Tasks.Task" /> that completes with
/// <paramref name="value" /> serialized as a byte array.
/// </returns>
public async Task <byte[]> SerializeAsync(T value, SerializationContext context)
{
if (value == null)
{
return(null);
}
try
{
if (this.indexArray == null)
{
this.indexArray = createIndexArray(value.Descriptor, useDeprecatedFormat);
}
string fullname = value.Descriptor.FullName;
await serializeMutex.WaitAsync().ConfigureAwait(continueOnCapturedContext: false);
try
{
string subject = this.subjectNameStrategy != null
// use the subject name strategy specified in the serializer config if available.
? this.subjectNameStrategy(context, fullname)
// else fall back to the deprecated config from (or default as currently supplied by) SchemaRegistry.
: context.Component == MessageComponentType.Key
? schemaRegistryClient.ConstructKeySubjectName(context.Topic, fullname)
: schemaRegistryClient.ConstructValueSubjectName(context.Topic, fullname);
if (!subjectsRegistered.Contains(subject))
{
if (useLatestVersion)
{
var latestSchema = await schemaRegistryClient.GetLatestSchemaAsync(subject)
.ConfigureAwait(continueOnCapturedContext: false);
schemaId = latestSchema.Id;
}
else
{
var references =
await RegisterOrGetReferences(value.Descriptor.File, context, autoRegisterSchema, skipKnownTypes)
.ConfigureAwait(continueOnCapturedContext: false);
// first usage: register/get schema to check compatibility
schemaId = autoRegisterSchema
? await schemaRegistryClient.RegisterSchemaAsync(subject,
new Schema(value.Descriptor.File.SerializedData.ToBase64(), references,
SchemaType.Protobuf), normalizeSchemas)
.ConfigureAwait(continueOnCapturedContext: false)
: await schemaRegistryClient.GetSchemaIdAsync(subject,
new Schema(value.Descriptor.File.SerializedData.ToBase64(), references,
SchemaType.Protobuf), normalizeSchemas)
.ConfigureAwait(continueOnCapturedContext: false);
// note: different values for schemaId should never be seen here.
// TODO: but fail fast may be better here.
}
subjectsRegistered.Add(subject);
}
}
finally
{
serializeMutex.Release();
}
using (var stream = new MemoryStream(initialBufferSize))
using (var writer = new BinaryWriter(stream))
{
stream.WriteByte(Constants.MagicByte);
writer.Write(IPAddress.HostToNetworkOrder(schemaId.Value));
writer.Write(this.indexArray);
value.WriteTo(stream);
return(stream.ToArray());
}
}
catch (AggregateException e)
{
throw e.InnerException;
}
}
public JsonValue Serialize(SerializationContext context)
{
var guid = (Guid)context.Source !;
return(guid.ToString());
}
public System_Collections_Generic_Queue_1MessagePackSerializer(SerializationContext ownerContext)
: base(ownerContext)
{
this._itemSerializer = ownerContext.GetSerializer <TItem>();
}
/// <summary>
/// Create a new <see cref="MsgPackSerializer"/> instance.
/// </summary>
/// <param name="context">The serialization context information for internal serialization logic.</param>
public MsgPackSerializer(SerializationContext context)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
}
public T Deserialize(ReadOnlySpan <byte> data, bool isNull, SerializationContext context)
{
return(JsonConvert.DeserializeObject <T>(
Deserializers.Utf8.Deserialize(data, isNull, context),
Settings));
}
public OrganizerSerializer(SerializationContext ctx) : base(ctx)
{
}
public void PrepareCloningTarget(UnmanagedArray <T> instance, ref UnmanagedArray <T> target, SerializationContext context)
{
if (target == null)
{
target = new UnmanagedArray <T>(instance.Length);
}
else
{
target.Resize(instance.Length);
}
}
public void Callback(object value, TypeModel.CallbackType callbackType, SerializationContext context)
{
if (callbacks != null) InvokeCallback(callbacks[callbackType], value, context);
IProtoTypeSerializer ser = (IProtoTypeSerializer)GetMoreSpecificSerializer(value);
if (ser != null) ser.Callback(value, callbackType, context);
}
/// <summary>
/// This method loads the DSL view model with the items in the artifact's C-Model.
/// </summary>
internal void ReloadModel(EntityDesignerViewModel viewModel)
{
var diagram = viewModel.GetDiagram();
if (diagram == null)
{
// empty DSL diagram
return;
}
// get our artifact
var artifact = EditingContextManager.GetArtifact(viewModel.EditingContext) as EntityDesignArtifact;
Debug.Assert(artifact != null);
var serializationResult = new SerializationResult();
var serializationContext = new SerializationContext(GetDirectory(viewModel.Store), artifact.Uri.LocalPath, serializationResult);
var transactionContext = new TransactionContext();
transactionContext.Add(SerializationContext.TransactionContextKey, serializationContext);
var workaroundFixSerializationTransactionValue = false;
if (viewModel.Store.PropertyBag.ContainsKey("WorkaroundFixSerializationTransaction"))
{
workaroundFixSerializationTransactionValue = (bool)viewModel.Store.PropertyBag["WorkaroundFixSerializationTransaction"];
}
try
{
// To fix performance issue during reload, we turn-off layout during "serialization".
viewModel.Store.PropertyBag["WorkaroundFixSerializationTransaction"] = true;
using (var t = viewModel.Store.TransactionManager.BeginTransaction("ReloadModel", true, transactionContext))
{
if (artifact.ConceptualModel() == null)
{
return;
}
DesignerModel.Diagram diagramModel = null;
// If DiagramId is not string empty, try to get the diagram from the artifact.
// There is a situation where we could not find the diagram given an ID (for example: EDMX Model's Diagram that is created by VS before SQL 11;
// In that case, we assign temporary ID to the diagram and a new ID will be generated every time the model is reloaded.)
// We could safely choose the first diagram since multiple diagrams feature didn't exist in VS prior to SQL11 release.
if (!string.IsNullOrEmpty(diagram.DiagramId))
{
diagramModel = artifact.DesignerInfo.Diagrams.GetDiagram(diagram.DiagramId);
}
if (diagramModel == null)
{
diagramModel = artifact.DesignerInfo.Diagrams.FirstDiagram;
}
if (diagramModel != null)
{
// Re-establish the xref between Escher conceptual model and DSL root model.
// and between Escher Diagram model and DSL diagram model.
Debug.Assert(viewModel.ModelXRef != null, "Why ModelXRef is null?");
if (viewModel.ModelXRef != null)
{
viewModel.ModelXRef.Add(artifact.ConceptualModel(), viewModel, viewModel.EditingContext);
viewModel.ModelXRef.Add(diagramModel, diagram, viewModel.EditingContext);
ModelTranslatorContextItem.GetEntityModelTranslator(viewModel.EditingContext)
.TranslateModelToDslModel(diagramModel, viewModel.Partition);
}
}
if (t.IsActive)
{
t.Commit();
}
}
}
finally
{
viewModel.Store.PropertyBag["WorkaroundFixSerializationTransaction"] = workaroundFixSerializationTransactionValue;
}
}
public ArrayFormatObjectExpressionMessagePackSerializer(SerializationContext context, SerializingMember[] members) : base(context, members)
{
}
public BasicObjectWrapper(SerializationContext context)
{
this.context = context;
}
/// <remarks>
/// note: protobuf does not support circular file references, so this possibility isn't considered.
/// </remarks>
private async Task <List <SchemaReference> > RegisterOrGetReferences(FileDescriptor fd, SerializationContext context, bool autoRegisterSchema, bool skipKnownTypes)
{
var tasks = new List <Task <SchemaReference> >();
for (int i = 0; i < fd.Dependencies.Count; ++i)
{
FileDescriptor fileDescriptor = fd.Dependencies[i];
if (skipKnownTypes && fileDescriptor.Name.StartsWith("google/protobuf/"))
{
continue;
}
Func <FileDescriptor, Task <SchemaReference> > t = async(FileDescriptor dependency) => {
var dependencyReferences = await RegisterOrGetReferences(dependency, context, autoRegisterSchema, skipKnownTypes).ConfigureAwait(continueOnCapturedContext: false);
var subject = referenceSubjectNameStrategy(context, dependency.Name);
var schema = new Schema(dependency.SerializedData.ToBase64(), dependencyReferences, SchemaType.Protobuf);
var schemaId = autoRegisterSchema
? await schemaRegistryClient.RegisterSchemaAsync(subject, schema, normalizeSchemas).ConfigureAwait(continueOnCapturedContext: false)
: await schemaRegistryClient.GetSchemaIdAsync(subject, schema, normalizeSchemas).ConfigureAwait(continueOnCapturedContext: false);
var registeredDependentSchema = await schemaRegistryClient.LookupSchemaAsync(subject, schema, true, normalizeSchemas).ConfigureAwait(continueOnCapturedContext: false);
return(new SchemaReference(dependency.Name, subject, registeredDependentSchema.Version));
};
tasks.Add(t(fileDescriptor));
}
await Task.WhenAll(tasks.ToArray()).ConfigureAwait(continueOnCapturedContext: false);
return(tasks.Select(t => t.Result).ToList());
}
/// <summary>
/// Deserializes a <typeparamref name="TMessage"/> value from a byte array.
/// </summary>
/// <param name="data">The data to deserialize.</param>
/// <param name="isNull">is the data or value null</param>
/// <param name="context">The serialization context</param>
/// <returns><paramref name="data" /> deserialized to a <typeparamref name="TMessage"/> (or null if data is null).</returns>
public TMessage Deserialize(ReadOnlySpan <byte> data, bool isNull, SerializationContext context)
{
if (isNull || data == null)
{
return(default);
public Task <T> DeserializeAsync(ReadOnlyMemory <byte> data, bool isNull, SerializationContext context)
{
if (isNull)
{
return(default);
public AttendeeSerializer(SerializationContext ctx) : base(ctx)
{
}
void IProtoTypeSerializer.Callback(object value, ProtoBuf.Meta.TypeModel.CallbackType callbackType, SerializationContext context)
{
}
public FluentdEmitter(Stream stream)
{
this.serializationContext = new SerializationContext(PackerCompatibilityOptions.PackBinaryAsRaw);
this.serializationContext.Serializers.Register(new OrdinaryDictionarySerializer(this.serializationContext));
this.packer = Packer.Create(stream);
}
public void Clear(ref UnmanagedArray <T> target, SerializationContext context)
{
// nothing to clear since T is a pure value type
}
public System_VersionMessagePackSerializer(SerializationContext ownerContext)
: base(ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom)
{
}
public void Clone(UnmanagedArray <T> instance, ref UnmanagedArray <T> target, SerializationContext context)
{
Buffer.MemoryCopy((void *)instance.data, (void *)target.data, target.length, instance.Length);
}
public byte[] Serialize(T data, SerializationContext context)
{
return(data.ToByteArray());
}
public void Callback(object value, TypeModel.CallbackType callbackType, SerializationContext context)
{
}
public void ExceptionSerializer_UnknownException()
{
var expected = GetNewException();
var knowsException = new ILBasedExceptionSerializer(this.serializerGenerator, new TypeSerializer(new CachedTypeResolver()));
var writer = new SerializationContext(this.environment.SerializationManager)
{
StreamWriter = new BinaryTokenStreamWriter()
};
knowsException.Serialize(expected, writer, null);
// Deep copies should be reference-equal.
var copyContext = new SerializationContext(this.environment.SerializationManager);
Assert.Equal(expected, knowsException.DeepCopy(expected, copyContext), ReferenceEqualsComparer.Instance);
// Create a deserializer which doesn't know about the expected exception type.
var reader = new DeserializationContext(this.environment.SerializationManager)
{
StreamReader = new BinaryTokenStreamReader(writer.StreamWriter.ToByteArray())
};
// Ensure that the deserialized object has the fallback type.
var doesNotKnowException = new ILBasedExceptionSerializer(this.serializerGenerator, new TestTypeSerializer(new CachedTypeResolver()));
var untypedActual = doesNotKnowException.Deserialize(null, reader);
Assert.IsType <RemoteNonDeserializableException>(untypedActual);
// Ensure that the original type name is preserved correctly.
var actualDeserialized = (RemoteNonDeserializableException)untypedActual;
Assert.Equal(RuntimeTypeNameFormatter.Format(typeof(ILExceptionSerializerTestException)), actualDeserialized.OriginalTypeName);
// Re-serialize the deserialized object using the serializer which does not have access to the original type.
writer = new SerializationContext(this.environment.SerializationManager)
{
StreamWriter = new BinaryTokenStreamWriter()
};
doesNotKnowException.Serialize(untypedActual, writer, null);
reader = new DeserializationContext(this.environment.SerializationManager)
{
StreamReader = new BinaryTokenStreamReader(writer.StreamWriter.ToByteArray())
};
// Deserialize the round-tripped object and verify that it has the original type and all properties are
// correctly.
untypedActual = knowsException.Deserialize(null, reader);
Assert.IsType <ILExceptionSerializerTestException>(untypedActual);
var actual = (ILExceptionSerializerTestException)untypedActual;
Assert.Equal(expected.BaseField.Value, actual.BaseField.Value, StringComparer.Ordinal);
Assert.Equal(expected.SubClassField, actual.SubClassField, StringComparer.Ordinal);
Assert.Equal(expected.OtherField.Value, actual.OtherField.Value, StringComparer.Ordinal);
// Check for referential equality in the two fields which happened to be reference-equals.
Assert.Equal(actual.BaseField, actual.OtherField, ReferenceEqualsComparer.Instance);
}
public System_Numerics_BigIntegerMessagePackSerializer(SerializationContext ownerContext)
: base(ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom)
{
}
