internal Protocol([NotNull] string name, [NotNull] ISerializers serializers, [NotNull] IIdentities identities, [NotNull] IScheduler scheduler,
[NotNull] IWire wire, Lifetime lifetime, SerializationCtx?serializationCtx = null, [CanBeNull] ProtocolContexts parentContexts = null, params RdContextBase[] initialContexts)
{
Name = name ?? throw new ArgumentNullException(nameof(name));
Location = new RName(name);
Serializers = serializers ?? throw new ArgumentNullException(nameof(serializers));
Identities = identities ?? throw new ArgumentNullException(nameof(identities));
Scheduler = scheduler ?? throw new ArgumentNullException(nameof(scheduler));
Wire = wire ?? throw new ArgumentNullException(nameof(wire));
SerializationContext = serializationCtx ?? new SerializationCtx(this, new Dictionary <string, IInternRoot <object> >()
{
{ ProtocolInternScopeStringId, CreateProtocolInternRoot(lifetime) }
});
Contexts = parentContexts ?? new ProtocolContexts(SerializationContext);
wire.Contexts = Contexts;
if (serializationCtx == null)
{
SerializationContext.InternRoots[ProtocolInternScopeStringId].Bind(lifetime, this, ProtocolInternRootRdId);
}
foreach (var rdContextBase in initialContexts)
{
rdContextBase.RegisterOn(Contexts);
}
if (parentContexts == null)
{
BindContexts(lifetime);
}
OutOfSyncModels = new ViewableSet <RdExtBase>();
}
public static void RegisterDeclaredTypesSerializers(ISerializers serializers)
{
serializers.RegisterEnum <JetBrains.Rider.Model.MyEnum>();
serializers.Register(JetBrains.Rider.Model.MyStructure.Read, JetBrains.Rider.Model.MyStructure.Write);
serializers.RegisterToplevelOnce(typeof(IdeRoot), IdeRoot.RegisterDeclaredTypesSerializers);
}
public Serializers(ISpecification <object> conditions, ISpecification <TypeInfo> specification, ISerializers writers, IRootInstances instances)
{
_conditions = conditions;
_specification = specification;
_writers = writers;
_instances = instances;
}
public Collections(RuntimeSerializers serializers, ICollectionItemTypeLocator locator,
ICollectionContents contents)
{
_serializers = serializers;
_locator = locator;
_contents = contents;
}
internal void Register(Type type, ISerializers serializers)
{
var serializerPair = myReflectionSerializersFactory.GetOrRegisterSerializerPair(type);
ReflectionUtil.InvokeGenericThis(serializers, nameof(serializers.Register), type,
new[] { serializerPair.Reader, serializerPair.Writer, RdId.DefineByFqn(type).Value });
}
public ReferenceAwareSerializers(ISpecification <object> conditions, IStaticReferenceSpecification specification, IReferences references,
ISerializers serializers)
{
_conditions = conditions;
_specification = specification;
_references = references;
_serializers = serializers;
}
public static void RegisterDeclaredTypesSerializers(ISerializers serializers)
{
serializers.Register(RdOpenFileArgs.Read, RdOpenFileArgs.Write);
serializers.Register(RdLogEvent.Read, RdLogEvent.Write);
serializers.RegisterEnum <RdLogEventType>();
serializers.RegisterEnum <RdLogEventMode>();
serializers.Register(UnityLogModelInitialized.Read, UnityLogModelInitialized.Write);
}
public void TryRegister(Type clrType, ISerializers serializers)
{
if (clrType.IsInterface || clrType.IsAbstract)
{
return;
}
Register(clrType, serializers);
}
public void TryRegister(RdId id, ISerializers serializers)
{
var clrType = myCatalog.GetById(id);
if (clrType != null)
{
Register(clrType, serializers);
}
}
public static void RegisterDeclaredTypesSerializers(ISerializers serializers)
{
serializers.Register(OpenClass.Read, OpenClass.Write);
serializers.Register(Derived.Read, Derived.Write);
serializers.Register(Open.Read, Open.Write);
serializers.Register(OpenDerived.Read, OpenDerived.Write);
serializers.Register(Base_Unknown.Read, Base_Unknown.Write);
serializers.Register(OpenClass_Unknown.Read, OpenClass_Unknown.Write);
serializers.Register(Open_Unknown.Read, Open_Unknown.Write);
serializers.Register(OpenDerived_Unknown.Read, OpenDerived_Unknown.Write);
serializers.RegisterToplevelOnce(typeof(RefRoot), RefRoot.RegisterDeclaredTypesSerializers);
}
public static void RegisterDeclaredTypesSerializers(ISerializers serializers)
{
serializers.Register(InterningTestModel.Read, InterningTestModel.Write);
serializers.Register(InterningNestedTestModel.Read, InterningNestedTestModel.Write);
serializers.Register(InterningNestedTestStringModel.Read, InterningNestedTestStringModel.Write);
serializers.Register(InterningProtocolLevelModel.Read, InterningProtocolLevelModel.Write);
serializers.Register(InterningMtModel.Read, InterningMtModel.Write);
serializers.Register(InterningExtensionHolder.Read, InterningExtensionHolder.Write);
serializers.Register(WrappedStringModel.Read, WrappedStringModel.Write);
serializers.Register(ProtocolWrappedStringModel.Read, ProtocolWrappedStringModel.Write);
serializers.RegisterToplevelOnce(typeof(InterningRoot1), InterningRoot1.RegisterDeclaredTypesSerializers);
serializers.RegisterToplevelOnce(typeof(InterningExt), InterningExt.RegisterDeclaredTypesSerializers);
}
//secondary constructor
//statics
public static void Register(ISerializers serializers)
{
if (!serializers.Toplevels.Add(typeof(UnityModel)))
{
return;
}
Protocol.InitializationLogger.Trace("REGISTER serializers for {0}", typeof(UnityModel).Name);
serializers.Register(RdOpenFileArgs.Read, RdOpenFileArgs.Write);
serializers.Register(RdLogEvent.Read, RdLogEvent.Write);
serializers.RegisterEnum <RdLogEventType>();
serializers.RegisterEnum <RdLogEventMode>();
serializers.Register(UnityLogModelInitialized.Read, UnityLogModelInitialized.Write);
}
public static void RegisterDeclaredTypesSerializers(ISerializers serializers)
{
serializers.Register(RdOpenFileArgs.Read, RdOpenFileArgs.Write);
serializers.Register(RdLogEvent.Read, RdLogEvent.Write);
serializers.RegisterEnum <RdLogEventType>();
serializers.RegisterEnum <RdLogEventMode>();
serializers.Register(UnityLogModelInitialized.Read, UnityLogModelInitialized.Write);
serializers.Register(TestResult.Read, TestResult.Write);
serializers.Register(RunResult.Read, RunResult.Write);
serializers.Register(JetBrains.Platform.Unity.Model.UnitTestLaunch.Read, JetBrains.Platform.Unity.Model.UnitTestLaunch.Write);
serializers.RegisterEnum <UnityEditorState>();
serializers.RegisterEnum <Status>();
serializers.RegisterToplevelOnce(typeof(UnityModel), UnityModel.RegisterDeclaredTypesSerializers);
}
public Protocol([NotNull] string name, [NotNull] ISerializers serializers, [NotNull] IIdentities identities, [NotNull] IScheduler scheduler,
[NotNull] IWire wire, Lifetime lifetime, SerializationCtx?serializationCtx = null)
{
Name = name ?? throw new ArgumentNullException(nameof(name));
Location = new RName(name);
Serializers = serializers ?? throw new ArgumentNullException(nameof(serializers));
Identities = identities ?? throw new ArgumentNullException(nameof(identities));
Scheduler = scheduler ?? throw new ArgumentNullException(nameof(scheduler));
Wire = wire ?? throw new ArgumentNullException(nameof(wire));
SerializationContext = serializationCtx ?? new SerializationCtx(this, new Dictionary <string, IInternRoot>()
{
{ ProtocolInternScopeStringId, CreateProtocolInternRoot(lifetime) }
});
OutOfSyncModels = new ViewableSet <RdExtBase>();
}
static Default()
{
Initializer = null;
Serializers = new Serializers
{
new Serializers.Direct(),
new Serializers.Guid(),
new Serializers.TimeSpan()
};
Grapher = new Grapher
{
typeof(string),
typeof(decimal),
typeof(DateTime),
typeof(DateTimeOffset),
typeof(Guid),
typeof(TimeSpan)
};
Mapper = new Mapper();
}
public static void RegisterDeclaredTypesSerializers(ISerializers serializers)
{
serializers.RegisterToplevelOnce(typeof(IdeRoot), IdeRoot.RegisterDeclaredTypesSerializers);
}
public Serializers(ISerializers writers, IRootInstances instances)
: this(new InstanceConditionalSpecification(), IsReferenceSpecification.Default, writers, instances)
{
}
public static void RegisterDeclaredTypesSerializers(ISerializers serializers)
{
serializers.RegisterToplevelOnce(typeof(TestRoot1), TestRoot1.RegisterDeclaredTypesSerializers);
}
public Write(ISerializers serializers, IFormatWriters <T> writers)
{
_serializers = serializers;
_writers = writers;
}
public Writer(ISerializers serializers) => _serializers = serializers;
public MyProtocol(string name, ISerializers serializers, IIdentities identities, IScheduler scheduler, IWire wire, Lifetime lifetime)
: base(name, serializers, identities, scheduler, wire, lifetime)
{
}
public Protocol([NotNull] string name, [NotNull] ISerializers serializers, [NotNull] IIdentities identities, [NotNull] IScheduler scheduler,
[NotNull] IWire wire, Lifetime lifetime, params RdContextBase[] initialContexts)
: this(name, serializers, identities, scheduler, wire, lifetime, null, null, initialContexts)
{
}
public DynamicAwareSerializers(ISpecification <TypeInfo> specification, ISerializers previous)
{
_specification = specification;
_previous = previous;
}
public DynamicAwareSerializers(ISerializers previous) : this(IsAnonymousType.Default, previous)
{
}
/// <summary>
/// Creates an instance.
/// </summary>
/// <param name="serializers">The serializer selector to decorate.</param>
public RuntimeSerializers(ISerializers serializers) : this(VariableTypeSpecification.Default, serializers)
{
}
public SerializationCtx(ISerializers serializers, IDictionary <string, IInternRoot> internRoots = null) : this()
{
Serializers = serializers;
InternRoots = internRoots ?? new Dictionary <string, IInternRoot>();
}
/// <summary>
/// Creates an instance.
/// </summary>
/// <param name="specification">The specification to determine whether to use the provided serializer selector or this
/// instance.</param>
/// <param name="serializers">The serializer selector to decorate.</param>
public RuntimeSerializers(ISpecification <TypeInfo> specification, ISerializers serializers)
{
_specification = specification;
_serializers = serializers;
}
public ActivatedSerializer(ISerializers serializers) => _serializers = serializers;
public Serializers(IEnhancer enhancer, ISerializers serializers)
: base(new AlteredSource <TypeInfo, ISerializer>(enhancer, serializers))
{
}
public Read(ISerializers serializers, IFormatReaders <T> readers, IClassification classification)
{
_serializers = serializers;
_readers = readers;
_classification = classification;
}
