JetBrains.RdFramework.Reflection Mark RdExt as implementing contract from specific RdRpc interface. That means that this RdExt will be exposed by interface name, not by the type itself. It may be used when explicit marking of RdRpc is undesirable. RdRpc interface type. Must be implemented by type, which marked by this RdExt attribute. Mark implementing interface of RdExt by this attribute to indicate intent to use this interface for proxy generation It has no special semantic. Used only to tell ReSharper about ImplicitUse. Provides external marshaller for this type A type which implements for this type or any base interface. Keep in mind that if you provide an serializer for base interface a runtime casting error is possible on the receiver side if receiver want to have an inheritor from this interface Override default in proxy instances in RdReflection. Should be used either on the method of interface marked by or on the interface itself. Default value means no timeout. Marker interface for proxy types. Used to distinguish between proxy-implemented methods, for which we should only initialize RdCall fields and other reactive properties and real methods in types, for which we should Bind appropriate RdEndpoint. Built-in serializer isn't defined static CtxReadDelegate{T1} Read static CtxWriteDelegate{T2} Write static Val Read(ctx, reader) static void Write(ctx, reader, val), static Val Read(ctx, reader) void Write(ctx, writer) static Val Read(reader) static void Write(writer, ctx) static Val Read(reader) void Write(writer) static Val{T} Read(ctx, reader, CtxReadDelegate{T}, CtxWriteDelegate{T}) static void Write(ctx, writer, Val{T}) static Val{T1, T2} Read(ctx, reader, CtxReadDelegate{T1}, CtxWriteDelegate{T1}, CtxReadDelegate{T2}, CtxWriteDelegate{T2}) static void Write(ctx, writer, Val{T1, T2}) Specified using RdScalar(typeof(Marshaller)) attribute Special asymmetric serializers for collections. Used in reflection serializers to use covariant conversion instead of runtime casting. Return static serializers for type Static serializer is the serializer which always return provided type and never any of the inheritors. It makes sense to ask these serializers for struct, enums and sealed classes The source of "real" serializers serializers. Polyporhic serializers always write to the stream and only after it serializes the type itself. Wrap method into Tuple-like adapter for using regular .NEt method as RdCall endpoint. Expected signature for sync methods (this, Lifetime, TReq) → RdTask{TRes} async methods: (this, Lifetime, TReq) → Task{TRes} Get the list of tuples, used to Note the special treatment of Lifetime and CancellationToken types - they are not included in the result. Return the expected list of names in BindableChildren collection for interfaces Loads the given argument on the stack Helpers method which used by generated proxies. Sync call which allow nested call execution with help of Sync call which allow nested call execution with help of Override this method to set-up data flow in your RdExt Override this method to set-up data flow in your RdExt Reflection models can be bound on any thread To get maximal performance of Rd framework you should directly provide serializers to every Model and Property. Creating models by hand with this approach is tedious and error-prone. The main idea behind is to automatically create RdExt and initialize fields and properties with appropriate serializers. current activation stack. used to protect from circular dependencies only. Create and bind class with Create and bind class with Creates and initializes reactive primitives, RdModels and RdExts. Activate or or its members. Activate or or its members. Wrapper method to simplify search with overload resolution for two methods in RdEndpoint. Used for async methods returning generic Task. Wrapper method to simplify search with overload resolution for two methods in RdEndpoint. Used for async methods returning non-generic Task. Wrapper method to simplify search with overload resolution for two methods in RdEndpoint. Used for sync calls only. Creates and provides access to Reflection-generated serializers for Rd, thread safe Collection static serializers (serializers is not possible here! Only instance serializer can be serializers) Collection of specific serializers serializers and user-registred custom serializers. User registred serializers should be added before activating any other serializers serializer to guarantee consistency of serializers across all Rd objects. Techincally, this restriction can be lifted to lazy initialization. It only exists to reduce the amount of races in consumers. A flag to enforce consistency of serializers. New specific poly serializer can't be registered after first query of serializers serializer from outer world. current serialization stack. used to provide diagnostics about circular dependencies only. An extension point to override lazy creation of serializers instance serializers. You add your custom serializer for generic types via this extension point. You can also use method ahead of time when lazy initialization isn't necessary. Register serializers for either or Register custom serializer for provided serializers type. It will be used instead of default . Be aware, that you can register your custom serializer only before any serializer was asked via . Struct, Aggregate, ImmutableList are not supported. This enbf-like scheme can only be used to understand basic concepts and terms, there is no any strong semantics behind several leaf rules. // RdBasic, may have inexact mapping to C# types. IType ::= IBindable | IScalar Bindable ::= NullableBindable | Array[Bindable] | ImmutableListBindable | Class IScalar ::= NullableScalar | NonNullableScalar NullableScalar ::= Maybe[NonNullableScalar] NonNullableScalar ::= List[IScalar] | Array[IScalar] | PredefinedType | Struct NonNullableBindable ::= Array[Bindable] | IReadOnlyList[Bindable] | Class NonNullable::= NonNullableScalar | NonNullableBindable FieldType ::= IScalar|IType|Aggregate RdProperty ::= RdProperty[FieldType] RdSet ::= RdSet[INonNullableScalar] RdMap ::= RdMap[INonNullableScalar, INonNullable] RdCall ::= RdCall[IScalar, IScalar] RdSignal ::= RdSignal[IScalar] // C# declarations, [ and ] mean < >. FieldDeclaration[T] ::= C#(public readonly? T identifier) PropertyDeclaration[T] ::= C#(public T identifier { get; }) | C#(public T identifier { get; private set; }) // etc. // PropOrFieldDeclaration[T] ::= FieldDeclaration[T] || PropertyDeclaration[T] EnumDeclaration ::= C#(Enum[enum_const*]) // Not supported. No RdGenerator analogue. // StructDeclaration ::= C#(struct field* ) Member ::= RdSignal | RdProperty| RdList | RdSet | RdMap | RdModel | RdCall Declaration ::= BindableDeclaration | Struct | Enum | RdExtDeclaration BindableDeclaration ::= TopLevel | Class MemberDeclaration ::= PropOrFieldDeclaration[Member] RdModelMemberDeclaration ::= PropOrFieldDeclaration[Member|FieldType] RdModelDeclaration ::= C#([RdModel] class {RdModelMemberDeclaration*}) | EnumDeclaration | ValueTuple[FieldType{1,7}] RdExtDeclaration ::= C#([RdExt] class {MemberDeclaration}* ) ROOT ::= RdModelDeclaration ROOT | RdExtDeclaration ROOT | Nothing * An extension for for basic collections and dictionaries Types catalog required for providing information about statically discovered types during concrete serializer construction for sake of possibility for Rd serializers to lookup real type by representing RdId Black listed type. Any attempt to create serializer for these types should throw exception. Used to prevent attempts to pass an object which is well-known as non-serializable. For example, any component of tree-like structure or object graph should not be passed to serializer This predicate should return true only for blacklisted type Creates static serializers for type Register serializer for ValueTuples Create serializer from Read and Write method without Get lists of members which take part in object serialization. Can be used for RdExt, RdModel and any RdScalar. A special scheduler which can be globally temporarily switched to another implementation. Default constructor detector