Merge remote-tracking branch 'origin/eventengine/handshake-handler' into eventengine/handshake-handler

MikeDobrzan · MikeDobrzan · commit be568f7a1b11 · 2023-07-24T12:09:51.000+02:00
diff --git a/src/Api/PubnubApi/EventEngine/Subscribe/Effects/ReceivingEffectHandler.cs b/src/Api/PubnubApi/EventEngine/Subscribe/Effects/ReceivingEffectHandler.cs
@@ -31,13 +31,13 @@ public ReceivingEffectHandler(SubscribeManager2 manager, EventQueue eventQueue)
 
         public Task Run(ReceiveReconnectInvocation invocation)
         {
-            if (!ReconnectionDelayUtil.shouldRetry(invocation.Policy, invocation.AttemptedRetries, invocation.MaxConnectionRetry))
+            if (!ReconnectionDelayUtil.shouldRetry(invocation.ReconnectionPolicy, invocation.AttemptedRetries, invocation.MaximumReconnectionRetries))
             {
                 eventQueue.Enqueue(new ReceiveReconnectGiveUpEvent() { Status = new PNStatus(PNStatusCategory.PNCancelledCategory) });
             }
             else
             {
-                retryDelay = new Delay(ReconnectionDelayUtil.CalculateDelay(invocation.Policy, invocation.AttemptedRetries));
+                retryDelay = new Delay(ReconnectionDelayUtil.CalculateDelay(invocation.ReconnectionPolicy, invocation.AttemptedRetries));
                 // Run in the background
                 retryDelay.Start().ContinueWith((_) => this.Run((ReceiveMessagesInvocation)invocation));
             }
diff --git a/src/Api/PubnubApi/EventEngine/Subscribe/Invocations/SubscriptionInvocations.cs b/src/Api/PubnubApi/EventEngine/Subscribe/Invocations/SubscriptionInvocations.cs
@@ -56,17 +56,17 @@ internal class CancelHandshakeInvocation : HandshakeInvocation, Core.IEffectCanc
 	internal class HandshakeReconnectInvocation: HandshakeInvocation
 	{
 		public int AttemptedRetries;
-		public int MaxConnectionRetry;
-		public PNReconnectionPolicy Policy;
+		public int MaximumReconnectionRetries;
+		public PNReconnectionPolicy ReconnectionPolicy;
 	}
 
 	internal class CancelHandshakeReconnectInvocation: HandshakeReconnectInvocation, Core.IEffectCancelInvocation { }
 	
 	internal class ReceiveReconnectInvocation: ReceiveMessagesInvocation 
 	{ 
 		public int AttemptedRetries;
-		public int MaxConnectionRetry;
-		public PNReconnectionPolicy Policy;
+		public int MaximumReconnectionRetries;
+		public PNReconnectionPolicy ReconnectionPolicy;
 	}
 
 	internal class CancelReceiveReconnectInvocation: ReceiveReconnectInvocation, Core.IEffectCancelInvocation { }
diff --git a/src/Api/PubnubApi/EventEngine/Subscribe/States/HandshakeFailedState.cs b/src/Api/PubnubApi/EventEngine/Subscribe/States/HandshakeFailedState.cs
@@ -9,27 +9,37 @@ internal class HandshakeFailedState : Core.State
     {
         public IEnumerable<string> Channels;
         public IEnumerable<string> ChannelGroups;
+		public PNReconnectionPolicy ReconnectionPolicy;
+		public int MaximumReconnectionRetries;
 
-        public override TransitionResult Transition(IEvent e)
+		public override TransitionResult Transition(IEvent e)
         {
             return e switch
             {
                 Events.SubscriptionChangedEvent subscriptionChanged => new HandshakingState()
                 {
-                    Channels = subscriptionChanged.Channels, ChannelGroups = subscriptionChanged.ChannelGroups,
-                },
+                    Channels = subscriptionChanged.Channels,
+                    ChannelGroups = subscriptionChanged.ChannelGroups,
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy
+				},
 
                 Events.ReconnectEvent reconnect => new HandshakingState()
                 {
-                    Channels = reconnect.Channels, ChannelGroups = reconnect.ChannelGroups,
-                },
+                    Channels = reconnect.Channels,
+                    ChannelGroups = reconnect.ChannelGroups,
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy
+				},
 
                 Events.SubscriptionRestoredEvent subscriptionRestored => new ReceivingState()
                 {
                     Channels = subscriptionRestored.Channels,
                     ChannelGroups = subscriptionRestored.ChannelGroups,
-                    Cursor = subscriptionRestored.Cursor
-                },
+                    Cursor = subscriptionRestored.Cursor,
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy
+				},
                 
                 _ => null
             };
diff --git a/src/Api/PubnubApi/EventEngine/Subscribe/States/HandshakeReconnectingState.cs b/src/Api/PubnubApi/EventEngine/Subscribe/States/HandshakeReconnectingState.cs
@@ -9,13 +9,13 @@ internal class HandshakeReconnectingState : Core.State
     {
         public IEnumerable<string> Channels;
         public IEnumerable<string> ChannelGroups;
-        public PNReconnectionPolicy RetryPolicy;
-        public int MaxConnectionRetry;
+        public PNReconnectionPolicy ReconnectionPolicy;
+        public int MaximumReconnectionRetries;
         public int AttemptedRetries;
 
 
         public override IEnumerable<IEffectInvocation> OnEntry => new HandshakeReconnectInvocation()
-            { Channels = this.Channels, ChannelGroups = this.ChannelGroups, Policy = this.RetryPolicy, MaxConnectionRetry = this.MaxConnectionRetry, AttemptedRetries = this.AttemptedRetries }.AsArray();
+            { Channels = this.Channels, ChannelGroups = this.ChannelGroups, ReconnectionPolicy = this.ReconnectionPolicy, MaximumReconnectionRetries = this.MaximumReconnectionRetries, AttemptedRetries = this.AttemptedRetries }.AsArray();
         public override IEnumerable<IEffectInvocation> OnExit { get; } = new CancelHandshakeReconnectInvocation().AsArray();
 
         public override TransitionResult Transition(IEvent e)
diff --git a/src/Api/PubnubApi/EventEngine/Subscribe/States/HandshakeStoppedState.cs b/src/Api/PubnubApi/EventEngine/Subscribe/States/HandshakeStoppedState.cs
@@ -9,26 +9,36 @@ internal class HandshakeStoppedState : Core.State
     {
         public IEnumerable<string> Channels;
         public IEnumerable<string> ChannelGroups;
-        
-        public override TransitionResult Transition(IEvent e)
+		public PNReconnectionPolicy ReconnectionPolicy;
+		public int MaximumReconnectionRetries;
+
+		public override TransitionResult Transition(IEvent e)
         {
             return e switch
             {
                 Events.SubscriptionChangedEvent subscriptionChanged => new HandshakingState()
                 {
-                    Channels = subscriptionChanged.Channels, ChannelGroups = subscriptionChanged.ChannelGroups,
-                },
+                    Channels = subscriptionChanged.Channels,
+                    ChannelGroups = subscriptionChanged.ChannelGroups,
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy
+				},
 
                 Events.ReconnectEvent reconnect => new HandshakingState()
                 {
-                    Channels = reconnect.Channels, ChannelGroups = reconnect.ChannelGroups,
-                },
+                    Channels = reconnect.Channels,
+                    ChannelGroups = reconnect.ChannelGroups,
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy
+				},
 
                 Events.SubscriptionRestoredEvent subscriptionRestored => new ReceivingState()
                 {
                     Channels = subscriptionRestored.Channels,
                     ChannelGroups = subscriptionRestored.ChannelGroups,
-                    Cursor = subscriptionRestored.Cursor
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy,
+					Cursor = subscriptionRestored.Cursor
                 },
 
                 _ => null
diff --git a/src/Api/PubnubApi/EventEngine/Subscribe/States/HandshakingState.cs b/src/Api/PubnubApi/EventEngine/Subscribe/States/HandshakingState.cs
@@ -9,8 +9,10 @@ internal class HandshakingState : Core.State
     {
         public IEnumerable<string> Channels;
         public IEnumerable<string> ChannelGroups;
+		public PNReconnectionPolicy ReconnectionPolicy;
+		public int MaximumReconnectionRetries;
 
-        public override IEnumerable<IEffectInvocation> OnEntry => new HandshakeInvocation()
+		public override IEnumerable<IEffectInvocation> OnEntry => new HandshakeInvocation()
             { Channels = this.Channels, ChannelGroups = this.ChannelGroups }.AsArray();
 
         public override IEnumerable<IEffectInvocation> OnExit { get; } = new CancelHandshakeInvocation().AsArray();
@@ -21,30 +23,46 @@ public override TransitionResult Transition(IEvent e)
             {
                 Events.SubscriptionChangedEvent subscriptionChanged => new States.HandshakingState()
                 {
-                    Channels = subscriptionChanged.Channels, ChannelGroups = subscriptionChanged.ChannelGroups
-                },
+                    Channels = subscriptionChanged.Channels,
+                    ChannelGroups = subscriptionChanged.ChannelGroups,
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy
+				},
 
                 Events.SubscriptionRestoredEvent subscriptionRestored => new States.ReceivingState()
                 {
                     Channels = subscriptionRestored.Channels,
                     ChannelGroups = subscriptionRestored.ChannelGroups,
-                    Cursor = subscriptionRestored.Cursor
-                },
+                    Cursor = subscriptionRestored.Cursor,
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy
+				},
 
                 Events.HandshakeFailureEvent handshakeFailure => new States.HandshakeReconnectingState()
                 {
-                    Channels = this.Channels, ChannelGroups = this.ChannelGroups
-                }.With(new EmitStatusInvocation(handshakeFailure.Status)),
+                    Channels = this.Channels,
+                    ChannelGroups = this.ChannelGroups,
+                    AttemptedRetries = 0,
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy
+				}.With(new EmitStatusInvocation(handshakeFailure.Status)),
 
                 Events.DisconnectEvent disconnect => new States.HandshakeStoppedState()
                 {
-                    Channels = disconnect.Channels, ChannelGroups = disconnect.ChannelGroups,
-                }.With(new EmitStatusInvocation(PNStatusCategory.PNDisconnectedCategory)),
+                    Channels = disconnect.Channels,
+                    ChannelGroups = disconnect.ChannelGroups,
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy
+				}.With(new EmitStatusInvocation(PNStatusCategory.PNDisconnectedCategory)),
 
                 Events.HandshakeSuccessEvent success => new ReceivingState()
                 {
-                    Channels = this.Channels, ChannelGroups = this.ChannelGroups, Cursor = success.Cursor
-                }.With(new EmitStatusInvocation(success.Status)),
+                    Channels = this.Channels,
+                    ChannelGroups = this.ChannelGroups,
+                    Cursor = success.Cursor,
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy
+				}.With(new EmitStatusInvocation(success.Status)),
 
                 _ => null
             };
diff --git a/src/Api/PubnubApi/EventEngine/Subscribe/States/ReceiveFailedState.cs b/src/Api/PubnubApi/EventEngine/Subscribe/States/ReceiveFailedState.cs
@@ -11,8 +11,10 @@ internal class ReceiveFailedState : Core.State
         public IEnumerable<string> Channels;
         public IEnumerable<string> ChannelGroups;
         public SubscriptionCursor Cursor;
+		public PNReconnectionPolicy ReconnectionPolicy;
+		public int MaximumReconnectionRetries;
 
-        public IEnumerable<IEffectInvocation> OnEntry { get; }
+		public IEnumerable<IEffectInvocation> OnEntry { get; }
         public IEnumerable<IEffectInvocation> OnExit { get; }
 
         public override TransitionResult Transition(IEvent e)
@@ -23,22 +25,28 @@ public override TransitionResult Transition(IEvent e)
                 {
                     Channels = subscriptionChanged.Channels,
                     ChannelGroups = subscriptionChanged.ChannelGroups,
-                    Cursor = this.Cursor
-                },
+                    Cursor = this.Cursor,
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy
+				},
 
                 Events.ReconnectEvent reconnect => new ReceivingState()
                 {
                     Channels = reconnect.Channels,
                     ChannelGroups = reconnect.ChannelGroups,
-                    Cursor = reconnect.Cursor
-                },
+                    Cursor = reconnect.Cursor,
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy
+				},
 
                 Events.SubscriptionRestoredEvent subscriptionRestored => new ReceivingState()
                 {
                     Channels = subscriptionRestored.Channels,
                     ChannelGroups = subscriptionRestored.ChannelGroups,
-                    Cursor = subscriptionRestored.Cursor
-                },
+                    Cursor = subscriptionRestored.Cursor,
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy
+				},
 
                 _ => null
             };
diff --git a/src/Api/PubnubApi/EventEngine/Subscribe/States/ReceiveReconnectingState.cs b/src/Api/PubnubApi/EventEngine/Subscribe/States/ReceiveReconnectingState.cs
@@ -10,10 +10,20 @@ internal class ReceiveReconnectingState : Core.State
     {
         public IEnumerable<string> Channels;
         public IEnumerable<string> ChannelGroups;
-        public SubscriptionCursor Cursor;
+		public PNReconnectionPolicy ReconnectionPolicy;
+		public int MaximumReconnectionRetries;
+		public int AttemptedRetries;
+		public SubscriptionCursor Cursor;
 
         public override IEnumerable<IEffectInvocation> OnEntry => new ReceiveReconnectInvocation()
-            { Channels = this.Channels, ChannelGroups = this.ChannelGroups, Cursor = this.Cursor }.AsArray();
+            {
+                Channels = this.Channels,
+                ChannelGroups = this.ChannelGroups,
+                Cursor = this.Cursor,
+                ReconnectionPolicy = this.ReconnectionPolicy,
+                MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+                AttemptedRetries = this.AttemptedRetries
+            }.AsArray();
 
         public override IEnumerable<IEffectInvocation> OnExit { get; } =
             new CancelReceiveReconnectInvocation().AsArray();
@@ -54,7 +64,10 @@ public override TransitionResult Transition(IEvent e)
                 {
                     Channels = this.Channels,
                     ChannelGroups = this.ChannelGroups,
-                    Cursor = this.Cursor
+                    Cursor = this.Cursor,
+                    AttemptedRetries = this.AttemptedRetries,
+                    MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+                    ReconnectionPolicy = this.ReconnectionPolicy
                 }.With(new EmitStatusInvocation(receiveReconnectFailure.Status)),
 
                 Events.ReceiveReconnectGiveUpEvent receiveReconnectGiveUp => new ReceiveFailedState()
diff --git a/src/Api/PubnubApi/EventEngine/Subscribe/States/ReceiveStoppedState.cs b/src/Api/PubnubApi/EventEngine/Subscribe/States/ReceiveStoppedState.cs
@@ -11,8 +11,10 @@ internal class ReceiveStoppedState : Core.State
         public IEnumerable<string> Channels;
         public IEnumerable<string> ChannelGroups;
         public SubscriptionCursor Cursor;
+		public PNReconnectionPolicy ReconnectionPolicy;
+		public int MaximumReconnectionRetries;
 
-        public override TransitionResult Transition(IEvent e)
+		public override TransitionResult Transition(IEvent e)
         {
             return e switch
             {
@@ -21,21 +23,27 @@ public override TransitionResult Transition(IEvent e)
                     Channels = subscriptionChanged.Channels,
                     ChannelGroups = subscriptionChanged.ChannelGroups,
                     Cursor = this.Cursor,
-                },
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy
+				},
                 
                 Events.ReconnectEvent reconnect => new ReceivingState()
                 {
                     Channels = reconnect.Channels,
                     ChannelGroups = reconnect.ChannelGroups,
-                    Cursor = reconnect.Cursor
-                },
+                    Cursor = reconnect.Cursor,
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy
+				},
                 
                 Events.SubscriptionRestoredEvent subscriptionRestored => new ReceivingState()
                 {
                     Channels = subscriptionRestored.Channels,
                     ChannelGroups = subscriptionRestored.ChannelGroups,
-                    Cursor = subscriptionRestored.Cursor
-                },
+                    Cursor = subscriptionRestored.Cursor,
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy
+				},
                 
                 _ => null
             };
diff --git a/src/Api/PubnubApi/EventEngine/Subscribe/States/ReceivingState.cs b/src/Api/PubnubApi/EventEngine/Subscribe/States/ReceivingState.cs
@@ -10,7 +10,9 @@ internal class ReceivingState : Core.State
     {
         public IEnumerable<string> Channels;
         public IEnumerable<string> ChannelGroups;
-        public SubscriptionCursor Cursor;
+		public PNReconnectionPolicy ReconnectionPolicy;
+		public int MaximumReconnectionRetries;
+		public SubscriptionCursor Cursor;
 
         public override IEnumerable<IEffectInvocation> OnEntry => new ReceiveMessagesInvocation()
             { Channels = this.Channels, ChannelGroups = this.ChannelGroups, Cursor = this.Cursor }.AsArray();
@@ -56,7 +58,10 @@ public override TransitionResult Transition(IEvent e)
                 {
                     Channels = this.Channels,
                     ChannelGroups = this.ChannelGroups,
-                    Cursor = this.Cursor
+					AttemptedRetries = 0,
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy,
+					Cursor = this.Cursor
                 },
 
                 _ => null
diff --git a/src/Api/PubnubApi/EventEngine/Subscribe/States/UnsubscribedState.cs b/src/Api/PubnubApi/EventEngine/Subscribe/States/UnsubscribedState.cs
@@ -7,21 +7,29 @@ namespace PubnubApi.EventEngine.Subscribe.States
 {
     internal class UnsubscribedState : Core.State
     {
-        public override TransitionResult Transition(Core.IEvent e)
+		public PNReconnectionPolicy ReconnectionPolicy;
+		public int MaximumReconnectionRetries;
+
+		public override TransitionResult Transition(Core.IEvent e)
         {
             return e switch
             {
                 Events.SubscriptionChangedEvent subscriptionChanged => new HandshakingState()
                 {
-                    Channels = subscriptionChanged.Channels, ChannelGroups = subscriptionChanged.ChannelGroups,
-                },
+                    Channels = subscriptionChanged.Channels,
+                    ChannelGroups = subscriptionChanged.ChannelGroups,
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy
+				},
 
                 Events.SubscriptionRestoredEvent subscriptionRestored => new States.ReceivingState()
                 {
                     Channels = subscriptionRestored.Channels,
                     ChannelGroups = subscriptionRestored.ChannelGroups,
-                    Cursor = subscriptionRestored.Cursor
-                },
+                    Cursor = subscriptionRestored.Cursor,
+					MaximumReconnectionRetries = this.MaximumReconnectionRetries,
+					ReconnectionPolicy = this.ReconnectionPolicy
+				},
 
                 _ => null
             };
diff --git a/src/Api/PubnubApi/EventEngine/Subscribe/SubscribeEventEngine.cs b/src/Api/PubnubApi/EventEngine/Subscribe/SubscribeEventEngine.cs

Original file line number	Diff line number	Diff line change
`@@ -31,13 +31,13 @@ public ReceivingEffectHandler(SubscribeManager2 manager, EventQueue eventQueue)`
`31`	`31`
`32`	`32`	`public Task Run(ReceiveReconnectInvocation invocation)`
`33`	`33`	`{`
`34`		`- if (!ReconnectionDelayUtil.shouldRetry(invocation.Policy, invocation.AttemptedRetries, invocation.MaxConnectionRetry))`
	`34`	`+ if (!ReconnectionDelayUtil.shouldRetry(invocation.ReconnectionPolicy, invocation.AttemptedRetries, invocation.MaximumReconnectionRetries))`
`35`	`35`	`{`
`36`	`36`	`eventQueue.Enqueue(new ReceiveReconnectGiveUpEvent() { Status = new PNStatus(PNStatusCategory.PNCancelledCategory) });`
`37`	`37`	`}`
`38`	`38`	`else`
`39`	`39`	`{`
`40`		`- retryDelay = new Delay(ReconnectionDelayUtil.CalculateDelay(invocation.Policy, invocation.AttemptedRetries));`
	`40`	`+ retryDelay = new Delay(ReconnectionDelayUtil.CalculateDelay(invocation.ReconnectionPolicy, invocation.AttemptedRetries));`
`41`	`41`	`// Run in the background`
`42`	`42`	`retryDelay.Start().ContinueWith((_) => this.Run((ReceiveMessagesInvocation)invocation));`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -56,17 +56,17 @@ internal class CancelHandshakeInvocation : HandshakeInvocation, Core.IEffectCanc`
`56`	`56`	`internal class HandshakeReconnectInvocation: HandshakeInvocation`
`57`	`57`	`{`
`58`	`58`	`public int AttemptedRetries;`
`59`		`- public int MaxConnectionRetry;`
`60`		`- public PNReconnectionPolicy Policy;`
	`59`	`+ public int MaximumReconnectionRetries;`
	`60`	`+ public PNReconnectionPolicy ReconnectionPolicy;`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`internal class CancelHandshakeReconnectInvocation: HandshakeReconnectInvocation, Core.IEffectCancelInvocation { }`
`64`	`64`
`65`	`65`	`internal class ReceiveReconnectInvocation: ReceiveMessagesInvocation`
`66`	`66`	`{`
`67`	`67`	`public int AttemptedRetries;`
`68`		`- public int MaxConnectionRetry;`
`69`		`- public PNReconnectionPolicy Policy;`
	`68`	`+ public int MaximumReconnectionRetries;`
	`69`	`+ public PNReconnectionPolicy ReconnectionPolicy;`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`internal class CancelReceiveReconnectInvocation: ReceiveReconnectInvocation, Core.IEffectCancelInvocation { }`
Original file line number	Diff line number	Diff line change
`@@ -7,21 +7,29 @@ namespace PubnubApi.EventEngine.Subscribe.States`
`7`	`7`	`{`
`8`	`8`	`internal class UnsubscribedState : Core.State`
`9`	`9`	`{`
`10`		`- public override TransitionResult Transition(Core.IEvent e)`
	`10`	`+ public PNReconnectionPolicy ReconnectionPolicy;`
	`11`	`+ public int MaximumReconnectionRetries;`
	`12`	`+`
	`13`	`+ public override TransitionResult Transition(Core.IEvent e)`
`11`	`14`	`{`
`12`	`15`	`return e switch`
`13`	`16`	`{`
`14`	`17`	`Events.SubscriptionChangedEvent subscriptionChanged => new HandshakingState()`
`15`	`18`	`{`
`16`		`- Channels = subscriptionChanged.Channels, ChannelGroups = subscriptionChanged.ChannelGroups,`
`17`		`- },`
	`19`	`+ Channels = subscriptionChanged.Channels,`
	`20`	`+ ChannelGroups = subscriptionChanged.ChannelGroups,`
	`21`	`+ MaximumReconnectionRetries = this.MaximumReconnectionRetries,`
	`22`	`+ ReconnectionPolicy = this.ReconnectionPolicy`
	`23`	`+ },`
`18`	`24`
`19`	`25`	`Events.SubscriptionRestoredEvent subscriptionRestored => new States.ReceivingState()`
`20`	`26`	`{`
`21`	`27`	`Channels = subscriptionRestored.Channels,`
`22`	`28`	`ChannelGroups = subscriptionRestored.ChannelGroups,`
`23`		`- Cursor = subscriptionRestored.Cursor`
`24`		`- },`
	`29`	`+ Cursor = subscriptionRestored.Cursor,`
	`30`	`+ MaximumReconnectionRetries = this.MaximumReconnectionRetries,`
	`31`	`+ ReconnectionPolicy = this.ReconnectionPolicy`
	`32`	`+ },`
`25`	`33`
`26`	`34`	`_ => null`
`27`	`35`	`};`