Heavy refactorings

Heavy refactorings

--- WWCP_Core/Commands/PushDataAndStatus/IRemotePushStatusExtentions.cs
+++ WWCP_Core/Commands/PushDataAndStatus/IRemotePushStatusExtentions.cs
@@ -126,7 +126,7 @@
         /// </summary>
         /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
         /// <param name="EVSEs">An enumeration of EVSEs to upload.</param>
-        /// <param name="TransmissionType">Whether to send the EVSE admin status update directly or enqueue it for a while.</param>
+        /// <param name="TransmissionType">Whether to send the EVSE admin status updates directly or enqueue it for a while.</param>
         ///
         /// <param name="Timestamp">The optional timestamp of the request.</param>
         /// <param name="CancellationToken">An optional token to cancel this request.</param>
@@ -220,7 +220,7 @@
         /// </summary>
         /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
         /// <param name="ChargingStations">An enumeration of charging stations to upload.</param>
-        /// <param name="TransmissionType">Whether to send the EVSE admin status update directly or enqueue it for a while.</param>
+        /// <param name="TransmissionType">Whether to send the EVSE admin status updates directly or enqueue it for a while.</param>
         ///
         /// <param name="Timestamp">The optional timestamp of the request.</param>
         /// <param name="CancellationToken">An optional token to cancel this request.</param>
@@ -316,7 +316,7 @@
         /// </summary>
         /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
         /// <param name="ChargingPools">An enumeration of charging pools to upload.</param>
-        /// <param name="TransmissionType">Whether to send the EVSE admin status update directly or enqueue it for a while.</param>
+        /// <param name="TransmissionType">Whether to send the EVSE admin status updates directly or enqueue it for a while.</param>
         ///
         /// <param name="Timestamp">The optional timestamp of the request.</param>
         /// <param name="CancellationToken">An optional token to cancel this request.</param>
@@ -412,7 +412,7 @@
         /// </summary>
         /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
         /// <param name="ChargingStationOperators">An enumeration of charging station operators to upload.</param>
-        /// <param name="TransmissionType">Whether to send the EVSE admin status update directly or enqueue it for a while.</param>
+        /// <param name="TransmissionType">Whether to send the EVSE admin status updates directly or enqueue it for a while.</param>
         ///
         /// <param name="Timestamp">The optional timestamp of the request.</param>
         /// <param name="CancellationToken">An optional token to cancel this request.</param>
@@ -593,7 +593,7 @@
         /// </summary>
         /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
         /// <param name="EVSEs">An enumeration of EVSEs to upload.</param>
-        /// <param name="TransmissionType">Whether to send the EVSE status update directly or enqueue it for a while.</param>
+        /// <param name="TransmissionType">Whether to send the EVSE status updates directly or enqueue it for a while.</param>
         ///
         /// <param name="Timestamp">The optional timestamp of the request.</param>
         /// <param name="CancellationToken">An optional token to cancel this request.</param>
@@ -687,7 +687,7 @@
         /// </summary>
         /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
         /// <param name="ChargingStations">An enumeration of charging stations to upload.</param>
-        /// <param name="TransmissionType">Whether to send the EVSE status update directly or enqueue it for a while.</param>
+        /// <param name="TransmissionType">Whether to send the EVSE status updates directly or enqueue it for a while.</param>
         ///
         /// <param name="Timestamp">The optional timestamp of the request.</param>
         /// <param name="CancellationToken">An optional token to cancel this request.</param>
@@ -783,7 +783,7 @@
         /// </summary>
         /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
         /// <param name="ChargingPools">An enumeration of charging pools to upload.</param>
-        /// <param name="TransmissionType">Whether to send the EVSE status update directly or enqueue it for a while.</param>
+        /// <param name="TransmissionType">Whether to send the EVSE status updates directly or enqueue it for a while.</param>
         ///
         /// <param name="Timestamp">The optional timestamp of the request.</param>
         /// <param name="CancellationToken">An optional token to cancel this request.</param>
@@ -879,7 +879,7 @@
         /// </summary>
         /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
         /// <param name="ChargingStationOperators">An enumeration of charging station operators to upload.</param>
-        /// <param name="TransmissionType">Whether to send the EVSE status update directly or enqueue it for a while.</param>
+        /// <param name="TransmissionType">Whether to send the EVSE status updates directly or enqueue it for a while.</param>
         ///
         /// <param name="Timestamp">The optional timestamp of the request.</param>
         /// <param name="CancellationToken">An optional token to cancel this request.</param>
@@ -1061,7 +1061,7 @@
         /// </summary>
         /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
         /// <param name="ChargingStations">An enumeration of charging stations to upload.</param>
-        /// <param name="TransmissionType">Whether to send the charging station admin status update directly or enqueue it for a while.</param>
+        /// <param name="TransmissionType">Whether to send the charging station admin status updates directly or enqueue it for a while.</param>
         ///
         /// <param name="Timestamp">The optional timestamp of the request.</param>
         /// <param name="CancellationToken">An optional token to cancel this request.</param>
@@ -1155,7 +1155,7 @@
         /// </summary>
         /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
         /// <param name="ChargingPools">An enumeration of charging pools to upload.</param>
-        /// <param name="TransmissionType">Whether to send the charging station admin status update directly or enqueue it for a while.</param>
+        /// <param name="TransmissionType">Whether to send the charging station admin status updates directly or enqueue it for a while.</param>
         ///
         /// <param name="Timestamp">The optional timestamp of the request.</param>
         /// <param name="CancellationToken">An optional token to cancel this request.</param>
@@ -1251,7 +1251,7 @@
         /// </summary>
         /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
         /// <param name="ChargingStationOperators">An enumeration of charging station operators to upload.</param>
-        /// <param name="TransmissionType">Whether to send the charging station admin status update directly or enqueue it for a while.</param>
+        /// <param name="TransmissionType">Whether to send the charging station admin status updates directly or enqueue it for a while.</param>
         ///
         /// <param name="Timestamp">The optional timestamp of the request.</param>
         /// <param name="CancellationToken">An optional token to cancel this request.</param>
@@ -1432,7 +1432,7 @@
         /// </summary>
         /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
         /// <param name="ChargingStations">An enumeration of charging stations to upload.</param>
-        /// <param name="TransmissionType">Whether to send the charging station status update directly or enqueue it for a while.</param>
+        /// <param name="TransmissionType">Whether to send the charging station status updates directly or enqueue it for a while.</param>
         ///
         /// <param name="Timestamp">The optional timestamp of the request.</param>
         /// <param name="CancellationToken">An optional token to cancel this request.</param>
@@ -1526,7 +1526,7 @@
         /// </summary>
         /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
         /// <param name="ChargingPools">An enumeration of charging pools to upload.</param>
-        /// <param name="TransmissionType">Whether to send the charging station status update directly or enqueue it for a while.</param>
+        /// <param name="TransmissionType">Whether to send the charging station status updates directly or enqueue it for a while.</param>
         ///
         /// <param name="Timestamp">The optional timestamp of the request.</param>
         /// <param name="CancellationToken">An optional token to cancel this request.</param>
@@ -1622,7 +1622,7 @@
         /// </summary>
         /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
         /// <param name="ChargingStationOperators">An enumeration of charging station operators to upload.</param>
-        /// <param name="TransmissionType">Whether to send the charging station status update directly or enqueue it for a while.</param>
+        /// <param name="TransmissionType">Whether to send the charging station status updates directly or enqueue it for a while.</param>
         ///
         /// <param name="Timestamp">The optional timestamp of the request.</param>
         /// <param name="CancellationToken">An optional token to cancel this request.</param>
@@ -1713,7 +1713,7 @@

-        #region UpdateChargingPoolAdminStatus(this IRemotePushStatus, ChargingPoolAdminStatusUpdate,    TransmissionType = Enqueued, ...)
+        #region UpdateChargingPoolAdminStatus(this IRemotePushStatus, ChargingPoolAdminStatusUpdate, TransmissionType = Enqueued, ...)

         /// <summary>
         /// Update the given charging pool admin status update.
@@ -1750,8 +1750,245 @@

         #endregion

-
-        #region UpdateChargingPoolStatus(this IRemotePushStatus, ChargingPoolStatusUpdate,    TransmissionType = Enqueued, ...)
+        #region UpdateChargingPoolAdminStatus(this IRemotePushStatus, ChargingPool,                  TransmissionType = Enqueued, ...)
+
+        /// <summary>
+        /// Update the admin status of the given charging pool.
+        /// </summary>
+        /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
+        /// <param name="ChargingPool">A charging pool to upload.</param>
+        /// <param name="TransmissionType">Whether to send the charging pool status update directly or enqueue it for a while.</param>
+        ///
+        /// <param name="Timestamp">The optional timestamp of the request.</param>
+        /// <param name="CancellationToken">An optional token to cancel this request.</param>
+        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
+        /// <param name="RequestTimeout">An optional timeout for this request.</param>
+        public static async Task<Acknowledgement>
+
+            UpdateChargingPoolAdminStatus(this IRemotePushStatus  IRemotePushStatus,
+                                          ChargingPool            ChargingPool,
+                                          TransmissionTypes       TransmissionType    = TransmissionTypes.Enqueued,
+
+                                          DateTime?               Timestamp           = null,
+                                          CancellationToken?      CancellationToken   = null,
+                                          EventTracking_Id        EventTrackingId     = null,
+                                          TimeSpan?               RequestTimeout      = null)
+
+        {
+
+            #region Initial checks
+
+            if (ChargingPool == null)
+                throw new ArgumentNullException(nameof(ChargingPool), "The given charging pool must not be null!");
+
+            #endregion
+
+            return await IRemotePushStatus.UpdateChargingPoolAdminStatus(ChargingPoolAdminStatusUpdate.Snapshot(ChargingPool),
+                                                                         TransmissionType,
+
+                                                                         Timestamp,
+                                                                         CancellationToken,
+                                                                         EventTrackingId,
+                                                                         RequestTimeout).
+
+                                                                         ConfigureAwait(false);
+
+        }
+
+        #endregion
+
+        #region UpdateChargingPoolAdminStatus(this IRemotePushStatus, ChargingPools,                 TransmissionType = Enqueued, ...)
+
+        /// <summary>
+        /// Update the given enumeration of charging pool admin status.
+        /// </summary>
+        /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
+        /// <param name="ChargingPools">An enumeration of charging pools to upload.</param>
+        /// <param name="TransmissionType">Whether to send the charging pool admin status updates directly or enqueue it for a while.</param>
+        ///
+        /// <param name="Timestamp">The optional timestamp of the request.</param>
+        /// <param name="CancellationToken">An optional token to cancel this request.</param>
+        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
+        /// <param name="RequestTimeout">An optional timeout for this request.</param>
+        public static async Task<Acknowledgement>
+
+            UpdateChargingPoolAdminStatus(this IRemotePushStatus     IRemotePushStatus,
+                                          IEnumerable<ChargingPool>  ChargingPools,
+                                          TransmissionTypes          TransmissionType    = TransmissionTypes.Enqueued,
+
+                                          DateTime?                  Timestamp           = null,
+                                          CancellationToken?         CancellationToken   = null,
+                                          EventTracking_Id           EventTrackingId     = null,
+                                          TimeSpan?                  RequestTimeout      = null)
+
+        {
+
+            #region Initial checks
+
+            if (ChargingPools == null)
+                throw new ArgumentNullException(nameof(ChargingPools), "The given enumeration of charging pools must not be null!");
+
+            #endregion
+
+            return await IRemotePushStatus.UpdateChargingPoolAdminStatus(ChargingPools.SafeSelect(pool => ChargingPoolAdminStatusUpdate.Snapshot(pool)),
+                                                                         TransmissionType,
+
+                                                                         Timestamp,
+                                                                         CancellationToken,
+                                                                         EventTrackingId,
+                                                                         RequestTimeout).
+
+                                                                         ConfigureAwait(false);
+
+        }
+
+        #endregion
+
+        #region UpdateChargingPoolAdminStatus(this IRemotePushStatus, ChargingStationOperator,       TransmissionType = Enqueued, ...)
+
+        /// <summary>
+        /// Update all charging pool admin status of the given charging station operator.
+        /// </summary>
+        /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
+        /// <param name="ChargingStationOperator">A charging station operator to upload.</param>
+        /// <param name="TransmissionType">Whether to send the charging station operator admin status update directly or enqueue it for a while.</param>
+        ///
+        /// <param name="Timestamp">The optional timestamp of the request.</param>
+        /// <param name="CancellationToken">An optional token to cancel this request.</param>
+        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
+        /// <param name="RequestTimeout">An optional timeout for this request.</param>
+        public static async Task<Acknowledgement>
+
+            UpdateChargingPoolAdminStatus(this IRemotePushStatus   IRemotePushStatus,
+                                          ChargingStationOperator  ChargingStationOperator,
+                                          TransmissionTypes        TransmissionType    = TransmissionTypes.Enqueued,
+
+                                          DateTime?                Timestamp           = null,
+                                          CancellationToken?       CancellationToken   = null,
+                                          EventTracking_Id         EventTrackingId     = null,
+                                          TimeSpan?                RequestTimeout      = null)
+
+        {
+
+            #region Initial checks
+
+            if (ChargingStationOperator == null)
+                throw new ArgumentNullException(nameof(ChargingStationOperator), "The given charging station operator must not be null!");
+
+            #endregion
+
+            return await IRemotePushStatus.UpdateChargingPoolAdminStatus(ChargingStationOperator.ChargingPools.SafeSelect(pool => ChargingPoolAdminStatusUpdate.Snapshot(pool)),
+                                                                         TransmissionType,
+
+                                                                         Timestamp,
+                                                                         CancellationToken,
+                                                                         EventTrackingId,
+                                                                         RequestTimeout).
+
+                                                                         ConfigureAwait(false);
+
+        }
+
+        #endregion
+
+        #region UpdateChargingPoolAdminStatus(this IRemotePushStatus, ChargingStationOperators,      TransmissionType = Enqueued, ...)
+
+        /// <summary>
+        /// Update all charging pool admin status of the given enumeration of charging station operators.
+        /// </summary>
+        /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
+        /// <param name="ChargingStationOperators">An enumeration of charging station operators to upload.</param>
+        /// <param name="TransmissionType">Whether to send the charging pool admin status updates directly or enqueue it for a while.</param>
+        ///
+        /// <param name="Timestamp">The optional timestamp of the request.</param>
+        /// <param name="CancellationToken">An optional token to cancel this request.</param>
+        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
+        /// <param name="RequestTimeout">An optional timeout for this request.</param>
+        public static async Task<Acknowledgement>
+
+            UpdateChargingPoolAdminStatus(this IRemotePushStatus                IRemotePushStatus,
+                                          IEnumerable<ChargingStationOperator>  ChargingStationOperators,
+                                          TransmissionTypes                     TransmissionType    = TransmissionTypes.Enqueued,
+
+                                          DateTime?                             Timestamp           = null,
+                                          CancellationToken?                    CancellationToken   = null,
+                                          EventTracking_Id                      EventTrackingId     = null,
+                                          TimeSpan?                             RequestTimeout      = null)
+
+        {
+
+            #region Initial checks
+
+            if (ChargingStationOperators == null)
+                throw new ArgumentNullException(nameof(ChargingStationOperators), "The given enumeration of charging station operators must not be null!");
+
+            #endregion
+
+            return await IRemotePushStatus.UpdateChargingPoolAdminStatus(ChargingStationOperators.
+                                                                             SafeSelectMany(cso  => cso.ChargingPools).
+                                                                             SafeSelect    (pool => ChargingPoolAdminStatusUpdate.Snapshot(pool)),
+                                                                         TransmissionType,
+
+                                                                         Timestamp,
+                                                                         CancellationToken,
+                                                                         EventTrackingId,
+                                                                         RequestTimeout).
+
+                                                                         ConfigureAwait(false);
+
+        }
+
+        #endregion
+
+        #region UpdateChargingPoolAdminStatus(this IRemotePushStatus, RoamingNetwork,                TransmissionType = Enqueued, ...)
+
+        /// <summary>
+        /// Update all charging pool admin status of the given roaming network.
+        /// </summary>
+        /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
+        /// <param name="RoamingNetwork">A roaming network to upload.</param>
+        /// <param name="TransmissionType">Whether to send the charging pool admin status update directly or enqueue it for a while.</param>
+        ///
+        /// <param name="Timestamp">The optional timestamp of the request.</param>
+        /// <param name="CancellationToken">An optional token to cancel this request.</param>
+        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
+        /// <param name="RequestTimeout">An optional timeout for this request.</param>
+        public static async Task<Acknowledgement>
+
+            UpdateChargingPoolAdminStatus(this IRemotePushStatus  IRemotePushStatus,
+                                          RoamingNetwork          RoamingNetwork,
+                                          TransmissionTypes       TransmissionType    = TransmissionTypes.Enqueued,
+
+                                          DateTime?               Timestamp           = null,
+                                          CancellationToken?      CancellationToken   = null,
+                                          EventTracking_Id        EventTrackingId     = null,
+                                          TimeSpan?               RequestTimeout      = null)
+
+        {
+
+            #region Initial checks
+
+            if (RoamingNetwork == null)
+                throw new ArgumentNullException(nameof(RoamingNetwork), "The given roaming network must not be null!");
+
+            #endregion
+
+            return await IRemotePushStatus.UpdateChargingPoolAdminStatus(RoamingNetwork.ChargingPools.SafeSelect(pool => ChargingPoolAdminStatusUpdate.Snapshot(pool)),
+                                                                         TransmissionType,
+
+                                                                         Timestamp,
+                                                                         CancellationToken,
+                                                                         EventTrackingId,
+                                                                         RequestTimeout).
+
+                                                                         ConfigureAwait(false);
+
+        }
+
+        #endregion
+
+
+        #region UpdateChargingPoolStatus(this IRemotePushStatus, ChargingPoolStatusUpdate, TransmissionType = Enqueued, ...)

         /// <summary>
         /// Update the given charging pool status update.
@@ -1788,9 +2025,246 @@

         #endregion

-
-
-        #region UpdateChargingStationOperatorAdminStatus(this IRemotePushStatus, ChargingStationOperatorAdminStatusUpdate,    TransmissionType = Enqueued, ...)
+        #region UpdateChargingPoolStatus(this IRemotePushStatus, ChargingPool,             TransmissionType = Enqueued, ...)
+
+        /// <summary>
+        /// Update the status of the given charging pool.
+        /// </summary>
+        /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
+        /// <param name="ChargingPool">A charging pool to upload.</param>
+        /// <param name="TransmissionType">Whether to send the charging pool status update directly or enqueue it for a while.</param>
+        ///
+        /// <param name="Timestamp">The optional timestamp of the request.</param>
+        /// <param name="CancellationToken">An optional token to cancel this request.</param>
+        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
+        /// <param name="RequestTimeout">An optional timeout for this request.</param>
+        public static async Task<Acknowledgement>
+
+            UpdateChargingPoolStatus(this IRemotePushStatus  IRemotePushStatus,
+                                     ChargingPool            ChargingPool,
+                                     TransmissionTypes       TransmissionType    = TransmissionTypes.Enqueued,
+
+                                     DateTime?               Timestamp           = null,
+                                     CancellationToken?      CancellationToken   = null,
+                                     EventTracking_Id        EventTrackingId     = null,
+                                     TimeSpan?               RequestTimeout      = null)
+
+        {
+
+            #region Initial checks
+
+            if (ChargingPool == null)
+                throw new ArgumentNullException(nameof(ChargingPool), "The given charging pool must not be null!");
+
+            #endregion
+
+            return await IRemotePushStatus.UpdateChargingPoolStatus(ChargingPoolStatusUpdate.Snapshot(ChargingPool),
+                                                                    TransmissionType,
+
+                                                                    Timestamp,
+                                                                    CancellationToken,
+                                                                    EventTrackingId,
+                                                                    RequestTimeout).
+
+                                                                    ConfigureAwait(false);
+
+        }
+
+        #endregion
+
+        #region UpdateChargingPoolStatus(this IRemotePushStatus, ChargingPools,            TransmissionType = Enqueued, ...)
+
+        /// <summary>
+        /// Update the given enumeration of charging pool status.
+        /// </summary>
+        /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
+        /// <param name="ChargingPools">An enumeration of charging pools to upload.</param>
+        /// <param name="TransmissionType">Whether to send the charging pool status updates directly or enqueue it for a while.</param>
+        ///
+        /// <param name="Timestamp">The optional timestamp of the request.</param>
+        /// <param name="CancellationToken">An optional token to cancel this request.</param>
+        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
+        /// <param name="RequestTimeout">An optional timeout for this request.</param>
+        public static async Task<Acknowledgement>
+
+            UpdateChargingPoolStatus(this IRemotePushStatus     IRemotePushStatus,
+                                     IEnumerable<ChargingPool>  ChargingPools,
+                                     TransmissionTypes          TransmissionType    = TransmissionTypes.Enqueued,
+
+                                     DateTime?                  Timestamp           = null,
+                                     CancellationToken?         CancellationToken   = null,
+                                     EventTracking_Id           EventTrackingId     = null,
+                                     TimeSpan?                  RequestTimeout      = null)
+
+        {
+
+            #region Initial checks
+
+            if (ChargingPools == null)
+                throw new ArgumentNullException(nameof(ChargingPools), "The given enumeration of charging pools must not be null!");
+
+            #endregion
+
+            return await IRemotePushStatus.UpdateChargingPoolStatus(ChargingPools.SafeSelect(pool => ChargingPoolStatusUpdate.Snapshot(pool)),
+                                                                    TransmissionType,
+
+                                                                    Timestamp,
+                                                                    CancellationToken,
+                                                                    EventTrackingId,
+                                                                    RequestTimeout).
+
+                                                                    ConfigureAwait(false);
+
+        }
+
+        #endregion
+
+        #region UpdateChargingPoolStatus(this IRemotePushStatus, ChargingStationOperator,  TransmissionType = Enqueued, ...)
+
+        /// <summary>
+        /// Update all charging pool status of the given charging station operator.
+        /// </summary>
+        /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
+        /// <param name="ChargingStationOperator">A charging station operator to upload.</param>
+        /// <param name="TransmissionType">Whether to send the charging station operator status update directly or enqueue it for a while.</param>
+        ///
+        /// <param name="Timestamp">The optional timestamp of the request.</param>
+        /// <param name="CancellationToken">An optional token to cancel this request.</param>
+        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
+        /// <param name="RequestTimeout">An optional timeout for this request.</param>
+        public static async Task<Acknowledgement>
+
+            UpdateChargingPoolStatus(this IRemotePushStatus   IRemotePushStatus,
+                                     ChargingStationOperator  ChargingStationOperator,
+                                     TransmissionTypes        TransmissionType    = TransmissionTypes.Enqueued,
+
+                                     DateTime?                Timestamp           = null,
+                                     CancellationToken?       CancellationToken   = null,
+                                     EventTracking_Id         EventTrackingId     = null,
+                                     TimeSpan?                RequestTimeout      = null)
+
+        {
+
+            #region Initial checks
+
+            if (ChargingStationOperator == null)
+                throw new ArgumentNullException(nameof(ChargingStationOperator), "The given charging station operator must not be null!");
+
+            #endregion
+
+            return await IRemotePushStatus.UpdateChargingPoolStatus(ChargingStationOperator.ChargingPools.SafeSelect(pool => ChargingPoolStatusUpdate.Snapshot(pool)),
+                                                                    TransmissionType,
+
+                                                                    Timestamp,
+                                                                    CancellationToken,
+                                                                    EventTrackingId,
+                                                                    RequestTimeout).
+
+                                                                    ConfigureAwait(false);
+
+        }
+
+        #endregion
+
+        #region UpdateChargingPoolStatus(this IRemotePushStatus, ChargingStationOperators, TransmissionType = Enqueued, ...)
+
+        /// <summary>
+        /// Update all charging pool status of the given enumeration of charging station operators.
+        /// </summary>
+        /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
+        /// <param name="ChargingStationOperators">An enumeration of charging station operators to upload.</param>
+        /// <param name="TransmissionType">Whether to send the charging pool status updates directly or enqueue it for a while.</param>
+        ///
+        /// <param name="Timestamp">The optional timestamp of the request.</param>
+        /// <param name="CancellationToken">An optional token to cancel this request.</param>
+        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
+        /// <param name="RequestTimeout">An optional timeout for this request.</param>
+        public static async Task<Acknowledgement>
+
+            UpdateChargingPoolStatus(this IRemotePushStatus                IRemotePushStatus,
+                                     IEnumerable<ChargingStationOperator>  ChargingStationOperators,
+                                     TransmissionTypes                     TransmissionType    = TransmissionTypes.Enqueued,
+
+                                     DateTime?                             Timestamp           = null,
+                                     CancellationToken?                    CancellationToken   = null,
+                                     EventTracking_Id                      EventTrackingId     = null,
+                                     TimeSpan?                             RequestTimeout      = null)
+
+        {
+
+            #region Initial checks
+
+            if (ChargingStationOperators == null)
+                throw new ArgumentNullException(nameof(ChargingStationOperators), "The given enumeration of charging station operators must not be null!");
+
+            #endregion
+
+            return await IRemotePushStatus.UpdateChargingPoolStatus(ChargingStationOperators.
+                                                                        SafeSelectMany(cso  => cso.ChargingPools).
+                                                                        SafeSelect    (pool => ChargingPoolStatusUpdate.Snapshot(pool)),
+                                                                    TransmissionType,
+
+                                                                    Timestamp,
+                                                                    CancellationToken,
+                                                                    EventTrackingId,
+                                                                    RequestTimeout).
+
+                                                                    ConfigureAwait(false);
+
+        }
+
+        #endregion
+
+        #region UpdateChargingPoolStatus(this IRemotePushStatus, RoamingNetwork,           TransmissionType = Enqueued, ...)
+
+        /// <summary>
+        /// Update all charging pool status of the given roaming network.
+        /// </summary>
+        /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
+        /// <param name="RoamingNetwork">A roaming network to upload.</param>
+        /// <param name="TransmissionType">Whether to send the charging pool status update directly or enqueue it for a while.</param>
+        ///
+        /// <param name="Timestamp">The optional timestamp of the request.</param>
+        /// <param name="CancellationToken">An optional token to cancel this request.</param>
+        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
+        /// <param name="RequestTimeout">An optional timeout for this request.</param>
+        public static async Task<Acknowledgement>
+
+            UpdateChargingPoolStatus(this IRemotePushStatus  IRemotePushStatus,
+                                     RoamingNetwork          RoamingNetwork,
+                                     TransmissionTypes       TransmissionType    = TransmissionTypes.Enqueued,
+
+                                     DateTime?               Timestamp           = null,
+                                     CancellationToken?      CancellationToken   = null,
+                                     EventTracking_Id        EventTrackingId     = null,
+                                     TimeSpan?               RequestTimeout      = null)
+
+        {
+
+            #region Initial checks
+
+            if (RoamingNetwork == null)
+                throw new ArgumentNullException(nameof(RoamingNetwork), "The given roaming network must not be null!");
+
+            #endregion
+
+            return await IRemotePushStatus.UpdateChargingPoolStatus(RoamingNetwork.ChargingPools.SafeSelect(pool => ChargingPoolStatusUpdate.Snapshot(pool)),
+                                                                    TransmissionType,
+
+                                                                    Timestamp,
+                                                                    CancellationToken,
+                                                                    EventTrackingId,
+                                                                    RequestTimeout).
+
+                                                                    ConfigureAwait(false);
+
+        }
+
+        #endregion
+
+
+
+        #region UpdateChargingStationOperatorAdminStatus(this IRemotePushStatus, ChargingStationOperatorAdminStatusUpdate, TransmissionType = Enqueued, ...)

         /// <summary>
         /// Update the given charging station operator admin status update.
@@ -1827,8 +2301,149 @@

         #endregion

-
-        #region UpdateChargingStationOperatorStatus(this IRemotePushStatus, ChargingStationOperatorStatusUpdate,    TransmissionType = Enqueued, ...)
+        #region UpdateChargingStationOperatorAdminStatus(this IRemotePushStatus, ChargingStationOperator,                  TransmissionType = Enqueued, ...)
+
+        /// <summary>
+        /// Update the admin status of the given charging station operator.
+        /// </summary>
+        /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
+        /// <param name="ChargingStationOperator">A charging station operator to upload.</param>
+        /// <param name="TransmissionType">Whether to send the charging station operator status update directly or enqueue it for a while.</param>
+        ///
+        /// <param name="Timestamp">The optional timestamp of the request.</param>
+        /// <param name="CancellationToken">An optional token to cancel this request.</param>
+        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
+        /// <param name="RequestTimeout">An optional timeout for this request.</param>
+        public static async Task<Acknowledgement>
+
+            UpdateChargingStationOperatorAdminStatus(this IRemotePushStatus   IRemotePushStatus,
+                                                     ChargingStationOperator  ChargingStationOperator,
+                                                     TransmissionTypes        TransmissionType    = TransmissionTypes.Enqueued,
+
+                                                     DateTime?                Timestamp           = null,
+                                                     CancellationToken?       CancellationToken   = null,
+                                                     EventTracking_Id         EventTrackingId     = null,
+                                                     TimeSpan?                RequestTimeout      = null)
+
+        {
+
+            #region Initial checks
+
+            if (ChargingStationOperator == null)
+                throw new ArgumentNullException(nameof(ChargingStationOperator), "The given charging station operator must not be null!");
+
+            #endregion
+
+            return await IRemotePushStatus.UpdateChargingStationOperatorAdminStatus(ChargingStationOperatorAdminStatusUpdate.Snapshot(ChargingStationOperator),
+                                                                                TransmissionType,
+
+                                                                                Timestamp,
+                                                                                CancellationToken,
+                                                                                EventTrackingId,
+                                                                                RequestTimeout).
+
+                                                                                ConfigureAwait(false);
+
+        }
+
+        #endregion
+
+        #region UpdateChargingStationOperatorAdminStatus(this IRemotePushStatus, ChargingStationOperators,                 TransmissionType = Enqueued, ...)
+
+        /// <summary>
+        /// Update the given enumeration of charging station operator admin status.
+        /// </summary>
+        /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
+        /// <param name="ChargingStationOperators">An enumeration of charging station operators to upload.</param>
+        /// <param name="TransmissionType">Whether to send the charging station operator admin status updates directly or enqueue it for a while.</param>
+        ///
+        /// <param name="Timestamp">The optional timestamp of the request.</param>
+        /// <param name="CancellationToken">An optional token to cancel this request.</param>
+        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
+        /// <param name="RequestTimeout">An optional timeout for this request.</param>
+        public static async Task<Acknowledgement>
+
+            UpdateChargingStationOperatorAdminStatus(this IRemotePushStatus                IRemotePushStatus,
+                                                     IEnumerable<ChargingStationOperator>  ChargingStationOperators,
+                                                     TransmissionTypes                     TransmissionType    = TransmissionTypes.Enqueued,
+
+                                                     DateTime?                             Timestamp           = null,
+                                                     CancellationToken?                    CancellationToken   = null,
+                                                     EventTracking_Id                      EventTrackingId     = null,
+                                                     TimeSpan?                             RequestTimeout      = null)
+
+        {
+
+            #region Initial checks
+
+            if (ChargingStationOperators == null)
+                throw new ArgumentNullException(nameof(ChargingStationOperators), "The given enumeration of charging station operators must not be null!");
+
+            #endregion
+
+            return await IRemotePushStatus.UpdateChargingStationOperatorAdminStatus(ChargingStationOperators.SafeSelect(cso => ChargingStationOperatorAdminStatusUpdate.Snapshot(cso)),
+                                                                                TransmissionType,
+
+                                                                                Timestamp,
+                                                                                CancellationToken,
+                                                                                EventTrackingId,
+                                                                                RequestTimeout).
+
+                                                                                ConfigureAwait(false);
+
+        }
+
+        #endregion
+
+        #region UpdateChargingStationOperatorAdminStatus(this IRemotePushStatus, RoamingNetwork,                           TransmissionType = Enqueued, ...)
+
+        /// <summary>
+        /// Update all charging station operator admin status of the given roaming network.
+        /// </summary>
+        /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
+        /// <param name="RoamingNetwork">A roaming network to upload.</param>
+        /// <param name="TransmissionType">Whether to send the charging station operator admin status update directly or enqueue it for a while.</param>
+        ///
+        /// <param name="Timestamp">The optional timestamp of the request.</param>
+        /// <param name="CancellationToken">An optional token to cancel this request.</param>
+        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
+        /// <param name="RequestTimeout">An optional timeout for this request.</param>
+        public static async Task<Acknowledgement>
+
+            UpdateChargingStationOperatorAdminStatus(this IRemotePushStatus  IRemotePushStatus,
+                                                     RoamingNetwork          RoamingNetwork,
+                                                     TransmissionTypes       TransmissionType    = TransmissionTypes.Enqueued,
+
+                                                     DateTime?               Timestamp           = null,
+                                                     CancellationToken?      CancellationToken   = null,
+                                                     EventTracking_Id        EventTrackingId     = null,
+                                                     TimeSpan?               RequestTimeout      = null)
+
+        {
+
+            #region Initial checks
+
+            if (RoamingNetwork == null)
+                throw new ArgumentNullException(nameof(RoamingNetwork), "The given roaming network must not be null!");
+
+            #endregion
+
+            return await IRemotePushStatus.UpdateChargingStationOperatorAdminStatus(RoamingNetwork.ChargingStationOperators.SafeSelect(cso => ChargingStationOperatorAdminStatusUpdate.Snapshot(cso)),
+                                                                                TransmissionType,
+
+                                                                                Timestamp,
+                                                                                CancellationToken,
+                                                                                EventTrackingId,
+                                                                                RequestTimeout).
+
+                                                                                ConfigureAwait(false);
+
+        }
+
+        #endregion
+
+
+        #region UpdateChargingStationOperatorStatus(this IRemotePushStatus, ChargingStationOperatorStatusUpdate, TransmissionType = Enqueued, ...)

         /// <summary>
         /// Update the given charging station operator status update.
@@ -1865,9 +2480,150 @@

         #endregion

-
-
-        #region UpdateRoamingNetworkAdminStatus(this IRemotePushStatus, RoamingNetworkAdminStatusUpdate,    TransmissionType = Enqueued, ...)
+        #region UpdateChargingStationOperatorStatus(this IRemotePushStatus, ChargingStationOperator,             TransmissionType = Enqueued, ...)
+
+        /// <summary>
+        /// Update the status of the given charging station operator.
+        /// </summary>
+        /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
+        /// <param name="ChargingStationOperator">A charging station operator to upload.</param>
+        /// <param name="TransmissionType">Whether to send the charging station operator status update directly or enqueue it for a while.</param>
+        ///
+        /// <param name="Timestamp">The optional timestamp of the request.</param>
+        /// <param name="CancellationToken">An optional token to cancel this request.</param>
+        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
+        /// <param name="RequestTimeout">An optional timeout for this request.</param>
+        public static async Task<Acknowledgement>
+
+            UpdateChargingStationOperatorStatus(this IRemotePushStatus   IRemotePushStatus,
+                                                ChargingStationOperator  ChargingStationOperator,
+                                                TransmissionTypes        TransmissionType    = TransmissionTypes.Enqueued,
+
+                                                DateTime?                Timestamp           = null,
+                                                CancellationToken?       CancellationToken   = null,
+                                                EventTracking_Id         EventTrackingId     = null,
+                                                TimeSpan?                RequestTimeout      = null)
+
+        {
+
+            #region Initial checks
+
+            if (ChargingStationOperator == null)
+                throw new ArgumentNullException(nameof(ChargingStationOperator), "The given charging station operator must not be null!");
+
+            #endregion
+
+            return await IRemotePushStatus.UpdateChargingStationOperatorStatus(ChargingStationOperatorStatusUpdate.Snapshot(ChargingStationOperator),
+                                                                               TransmissionType,
+
+                                                                               Timestamp,
+                                                                               CancellationToken,
+                                                                               EventTrackingId,
+                                                                               RequestTimeout).
+
+                                                                               ConfigureAwait(false);
+
+        }
+
+        #endregion
+
+        #region UpdateChargingStationOperatorStatus(this IRemotePushStatus, ChargingStationOperators,            TransmissionType = Enqueued, ...)
+
+        /// <summary>
+        /// Update the given enumeration of charging station operator status.
+        /// </summary>
+        /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
+        /// <param name="ChargingStationOperators">An enumeration of charging station operators to upload.</param>
+        /// <param name="TransmissionType">Whether to send the charging station operator status updates directly or enqueue it for a while.</param>
+        ///
+        /// <param name="Timestamp">The optional timestamp of the request.</param>
+        /// <param name="CancellationToken">An optional token to cancel this request.</param>
+        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
+        /// <param name="RequestTimeout">An optional timeout for this request.</param>
+        public static async Task<Acknowledgement>
+
+            UpdateChargingStationOperatorStatus(this IRemotePushStatus                IRemotePushStatus,
+                                                IEnumerable<ChargingStationOperator>  ChargingStationOperators,
+                                                TransmissionTypes                     TransmissionType    = TransmissionTypes.Enqueued,
+
+                                                DateTime?                             Timestamp           = null,
+                                                CancellationToken?                    CancellationToken   = null,
+                                                EventTracking_Id                      EventTrackingId     = null,
+                                                TimeSpan?                             RequestTimeout      = null)
+
+        {
+
+            #region Initial checks
+
+            if (ChargingStationOperators == null)
+                throw new ArgumentNullException(nameof(ChargingStationOperators), "The given enumeration of charging station operators must not be null!");
+
+            #endregion
+
+            return await IRemotePushStatus.UpdateChargingStationOperatorStatus(ChargingStationOperators.SafeSelect(cso => ChargingStationOperatorStatusUpdate.Snapshot(cso)),
+                                                                               TransmissionType,
+
+                                                                               Timestamp,
+                                                                               CancellationToken,
+                                                                               EventTrackingId,
+                                                                               RequestTimeout).
+
+                                                                               ConfigureAwait(false);
+
+        }
+
+        #endregion
+
+        #region UpdateChargingStationOperatorStatus(this IRemotePushStatus, RoamingNetwork,                      TransmissionType = Enqueued, ...)
+
+        /// <summary>
+        /// Update all charging station operator status of the given roaming network.
+        /// </summary>
+        /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
+        /// <param name="RoamingNetwork">A roaming network to upload.</param>
+        /// <param name="TransmissionType">Whether to send the charging station operator status update directly or enqueue it for a while.</param>
+        ///
+        /// <param name="Timestamp">The optional timestamp of the request.</param>
+        /// <param name="CancellationToken">An optional token to cancel this request.</param>
+        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
+        /// <param name="RequestTimeout">An optional timeout for this request.</param>
+        public static async Task<Acknowledgement>
+
+            UpdateChargingStationOperatorStatus(this IRemotePushStatus  IRemotePushStatus,
+                                                RoamingNetwork          RoamingNetwork,
+                                                TransmissionTypes       TransmissionType    = TransmissionTypes.Enqueued,
+
+                                                DateTime?               Timestamp           = null,
+                                                CancellationToken?      CancellationToken   = null,
+                                                EventTracking_Id        EventTrackingId     = null,
+                                                TimeSpan?               RequestTimeout      = null)
+
+        {
+
+            #region Initial checks
+
+            if (RoamingNetwork == null)
+                throw new ArgumentNullException(nameof(RoamingNetwork), "The given roaming network must not be null!");
+
+            #endregion
+
+            return await IRemotePushStatus.UpdateChargingStationOperatorStatus(RoamingNetwork.ChargingStationOperators.SafeSelect(cso => ChargingStationOperatorStatusUpdate.Snapshot(cso)),
+                                                                               TransmissionType,
+
+                                                                               Timestamp,
+                                                                               CancellationToken,
+                                                                               EventTrackingId,
+                                                                               RequestTimeout).
+
+                                                                               ConfigureAwait(false);
+
+        }
+
+        #endregion
+
+
+
+        #region UpdateRoamingNetworkAdminStatus(this IRemotePushStatus, RoamingNetworkAdminStatusUpdate, TransmissionType = Enqueued, ...)

         /// <summary>
         /// Update the given roaming network admin status update.
@@ -1882,14 +2638,14 @@
         /// <param name="RequestTimeout">An optional timeout for this request.</param>
         public static async Task<Acknowledgement>

-            UpdateChargingRoamingNetworkAdminStatus(this IRemotePushStatus           IRemotePushStatus,
-                                                    RoamingNetworkAdminStatusUpdate  RoamingNetworkAdminStatusUpdate,
-                                                    TransmissionTypes                TransmissionType    = TransmissionTypes.Enqueued,
-
-                                                    DateTime?                        Timestamp           = null,
-                                                    CancellationToken?               CancellationToken   = null,
-                                                    EventTracking_Id                 EventTrackingId     = null,
-                                                    TimeSpan?                        RequestTimeout      = null)
+            UpdateRoamingNetworkAdminStatus(this IRemotePushStatus           IRemotePushStatus,
+                                            RoamingNetworkAdminStatusUpdate  RoamingNetworkAdminStatusUpdate,
+                                            TransmissionTypes                TransmissionType    = TransmissionTypes.Enqueued,
+
+                                            DateTime?                        Timestamp           = null,
+                                            CancellationToken?               CancellationToken   = null,
+                                            EventTracking_Id                 EventTrackingId     = null,
+                                            TimeSpan?                        RequestTimeout      = null)

             => await IRemotePushStatus.UpdateRoamingNetworkAdminStatus(new RoamingNetworkAdminStatusUpdate[] { RoamingNetworkAdminStatusUpdate },
@@ -1904,8 +2660,55 @@

         #endregion

-
-        #region UpdateRoamingNetworkStatus(this IRemotePushStatus, RoamingNetworkStatusUpdate,    TransmissionType = Enqueued, ...)
+        #region UpdateRoamingNetworkAdminStatus(this IRemotePushStatus, RoamingNetwork,                  TransmissionType = Enqueued, ...)
+
+        /// <summary>
+        /// Update the admin status of the given roaming network.
+        /// </summary>
+        /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
+        /// <param name="RoamingNetwork">A roaming network to upload.</param>
+        /// <param name="TransmissionType">Whether to send the roaming network status update directly or enqueue it for a while.</param>
+        ///
+        /// <param name="Timestamp">The optional timestamp of the request.</param>
+        /// <param name="CancellationToken">An optional token to cancel this request.</param>
+        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
+        /// <param name="RequestTimeout">An optional timeout for this request.</param>
+        public static async Task<Acknowledgement>
+
+            UpdateRoamingNetworkAdminStatus(this IRemotePushStatus  IRemotePushStatus,
+                                            RoamingNetwork          RoamingNetwork,
+                                            TransmissionTypes       TransmissionType    = TransmissionTypes.Enqueued,
+
+                                            DateTime?               Timestamp           = null,
+                                            CancellationToken?      CancellationToken   = null,
+                                            EventTracking_Id        EventTrackingId     = null,
+                                            TimeSpan?               RequestTimeout      = null)
+
+        {
+
+            #region Initial checks
+
+            if (RoamingNetwork == null)
+                throw new ArgumentNullException(nameof(RoamingNetwork), "The given roaming network must not be null!");
+
+            #endregion
+
+            return await IRemotePushStatus.UpdateRoamingNetworkAdminStatus(RoamingNetworkAdminStatusUpdate.Snapshot(RoamingNetwork),
+                                                                           TransmissionType,
+
+                                                                           Timestamp,
+                                                                           CancellationToken,
+                                                                           EventTrackingId,
+                                                                           RequestTimeout).
+
+                                                                           ConfigureAwait(false);
+
+        }
+
+        #endregion
+
+
+        #region UpdateRoamingNetworkStatus(this IRemotePushStatus, RoamingNetworkStatusUpdate, TransmissionType = Enqueued, ...)

         /// <summary>
         /// Update the given roaming network status update.
@@ -1920,14 +2723,14 @@
         /// <param name="RequestTimeout">An optional timeout for this request.</param>
         public static async Task<Acknowledgement>

-            UpdateChargingRoamingNetworkStatus(this IRemotePushStatus      IRemotePushStatus,
-                                               RoamingNetworkStatusUpdate  RoamingNetworkStatusUpdate,
-                                               TransmissionTypes           TransmissionType    = TransmissionTypes.Enqueued,
-
-                                               DateTime?                   Timestamp           = null,
-                                               CancellationToken?          CancellationToken   = null,
-                                               EventTracking_Id            EventTrackingId     = null,
-                                               TimeSpan?                   RequestTimeout      = null)
+            UpdateRoamingNetworkStatus(this IRemotePushStatus      IRemotePushStatus,
+                                       RoamingNetworkStatusUpdate  RoamingNetworkStatusUpdate,
+                                       TransmissionTypes           TransmissionType    = TransmissionTypes.Enqueued,
+
+                                       DateTime?                   Timestamp           = null,
+                                       CancellationToken?          CancellationToken   = null,
+                                       EventTracking_Id            EventTrackingId     = null,
+                                       TimeSpan?                   RequestTimeout      = null)

             => await IRemotePushStatus.UpdateRoamingNetworkStatus(new RoamingNetworkStatusUpdate[] { RoamingNetworkStatusUpdate },
@@ -1942,6 +2745,53 @@

         #endregion

+        #region UpdateRoamingNetworkStatus(this IRemotePushStatus, RoamingNetwork,             TransmissionType = Enqueued, ...)
+
+        /// <summary>
+        /// Update the status of the given roaming network.
+        /// </summary>
+        /// <param name="IRemotePushStatus">A class implementing the IRemotePushStatus interface.</param>
+        /// <param name="RoamingNetwork">A roaming network to upload.</param>
+        /// <param name="TransmissionType">Whether to send the roaming network status update directly or enqueue it for a while.</param>
+        ///
+        /// <param name="Timestamp">The optional timestamp of the request.</param>
+        /// <param name="CancellationToken">An optional token to cancel this request.</param>
+        /// <param name="EventTrackingId">An optional event tracking identification for correlating this request with other events.</param>
+        /// <param name="RequestTimeout">An optional timeout for this request.</param>
+        public static async Task<Acknowledgement>
+
+            UpdateRoamingNetworkStatus(this IRemotePushStatus  IRemotePushStatus,
+                                       RoamingNetwork          RoamingNetwork,
+                                       TransmissionTypes       TransmissionType    = TransmissionTypes.Enqueued,
+
+                                       DateTime?               Timestamp           = null,
+                                       CancellationToken?      CancellationToken   = null,
+                                       EventTracking_Id        EventTrackingId     = null,
+                                       TimeSpan?               RequestTimeout      = null)
+
+        {
+
+            #region Initial checks
+
+            if (RoamingNetwork == null)
+                throw new ArgumentNullException(nameof(RoamingNetwork), "The given roaming network must not be null!");
+
+            #endregion
+
+            return await IRemotePushStatus.UpdateRoamingNetworkStatus(RoamingNetworkStatusUpdate.Snapshot(RoamingNetwork),
+                                                                      TransmissionType,
+
+                                                                      Timestamp,
+                                                                      CancellationToken,
+                                                                      EventTrackingId,
+                                                                      RequestTimeout).
+
+                                                                      ConfigureAwait(false);
+
+        }
+
+        #endregion
+

     }


Delete Form1.Designer.cs

Delete Form1.Designer.cs

--- WindowsFormsApplication1/WindowsFormsApplication1/Form1.Designer.cs
+++ WindowsFormsApplication1/WindowsFormsApplication1/Form1.Designer.cs
@@ -1,39 +0,0 @@
-namespace WindowsFormsApplication1
-{
-    partial class Form1
-    {
-        /// <summary>
-        /// Required designer variable.
-        /// </summary>
-        private System.ComponentModel.IContainer components = null;
-
-        /// <summary>
-        /// Clean up any resources being used.
-        /// </summary>
-        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-        protected override void Dispose(bool disposing)
-        {
-            if (disposing && (components != null))
-            {
-                components.Dispose();
-            }
-            base.Dispose(disposing);
-        }
-
-        #region Windows Form Designer generated code
-
-        /// <summary>
-        /// Required method for Designer support - do not modify
-        /// the contents of this method with the code editor.
-        /// </summary>
-        private void InitializeComponent()
-        {
-            this.components = new System.ComponentModel.Container();
-            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-            this.Text = "Form1";
-        }
-
-        #endregion
-    }
-}
-


Use BeginInvoke to display unobserved task exceptions so that the task finalizer thread isn't blocked.

--- PlantUmlEditor/App.xaml.cs
+++ PlantUmlEditor/App.xaml.cs
@@ -106,7 +106,7 @@
 		void TaskScheduler_UnobservedTaskException(object sender, UnobservedTaskExceptionEventArgs e)
 		{
 			e.SetObserved();
-			uiDispatcher.Invoke(() => ShowMessageBox(e.Exception));
+			uiDispatcher.BeginInvoke(new Action(() => ShowMessageBox(e.Exception)));
 		}

 		private static void ShowMessageBox(Exception exception)


PluginShogi/ShogiPlugin.cs: 局面を表示するようにしました。

--- PluginShogi/ShogiPlugin.cs
+++ PluginShogi/ShogiPlugin.cs
@@ -195,10 +195,10 @@
                 ShogiGlobal.MainWindow = null;

             ShogiGlobal.MainWindow = window;
-            //window.Show();
-
-            var xx = new View.ShogiEndRollControl();
-            xx.Show();
+            window.Show();
+
+            //var xx = new View.ShogiEndRollControl();
+            //xx.Show();
         }

         /// <summary>
@@ -406,7 +406,7 @@
         }

         /// <summary>
-        /// 現局面を必要なら更新します。
+        /// サーバーの現局面更新時に、自分の現局を必要なら更新します。
         /// </summary>
         private void UpdateBoard(Board board)
         {


Testowy commit

Testowy commit

--- ProgramingStudy/Program.cs
+++ ProgramingStudy/Program.cs
@@ -16,7 +16,7 @@
         {
             var name = StudyTest.GetType().Name;

-            Console.WriteLine("Start {0}", name);
+            Console.WriteLine("Start {0} ", name);

             var stopWatch = new Stopwatch();


Version bump to 3.1-dev1.0.

Version bump to 3.1-dev1.0.

Signed-off-by: V10lator <fd1911a80a45064cec08d87c592168c9000a1489@myway.de>

--- Properties/AssemblyInfo.cs
+++ Properties/AssemblyInfo.cs
@@ -32,5 +32,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("3.1.0.0")]
-[assembly: AssemblyFileVersion("3.1.0.0")]
+[assembly: AssemblyVersion("3.1.1.0")]
+[assembly: AssemblyFileVersion("3.1.1.0")]


Add application title and copyright.

Add application title and copyright.

--- Properties/AssemblyInfo.cs
+++ Properties/AssemblyInfo.cs
@@ -5,12 +5,12 @@
 // General Information about an assembly is controlled through the following
 // set of attributes. Change these attribute values to modify the information
 // associated with an assembly.
-[assembly: AssemblyTitle("dcm")]
+[assembly: AssemblyTitle("Digital Color Meter")]
 [assembly: AssemblyDescription("")]
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("dcm")]
-[assembly: AssemblyCopyright("Copyright ©  2014")]
+[assembly: AssemblyProduct("Digital Color Meter")]
+[assembly: AssemblyCopyright("Copyright © 2014 Stian Hanger")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]


Version Number

Version Number

--- Properties/AssemblyInfo.cs
+++ Properties/AssemblyInfo.cs
@@ -22,7 +22,7 @@
 // The following GUID is for the ID of the typelib if this project is exposed to COM
 [assembly: Guid("f18527dd-a54e-4711-9dcd-c73a221ebb2d")]

-[assembly: AssemblyVersion("1.0.2.0")]
-[assembly: AssemblyFileVersion("1.0.2.0")]
-[assembly: AssemblyInformationalVersion("v2.0")]
-[assembly: KSPAssembly("Contracts_Window", 2, 0)]
+[assembly: AssemblyVersion("1.0.2.1")]
+[assembly: AssemblyFileVersion("1.0.2.1")]
+[assembly: AssemblyInformationalVersion("v2.1")]
+[assembly: KSPAssembly("Contracts_Window", 2, 1)]


bumped version to 1.0.1.0

bumped version to 1.0.1.0

--- Properties/AssemblyInfo.cs
+++ Properties/AssemblyInfo.cs
@@ -51,5 +51,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: AssemblyVersion("1.0.1.0")]
+[assembly: AssemblyFileVersion("1.0.1.0")]


-release 4.9.2704

-release 4.9.2704

--- Properties/AssemblyInfo.cs
+++ Properties/AssemblyInfo.cs
@@ -9,7 +9,7 @@
 //      Revision -.Net framework

 //---------------------------- WinForms Viewer -------------------------------------------------
-[assembly: AssemblyInformationalVersion("4.8.2704")]  //Should be equal to the same property of Patagames.Pdf assembly
+[assembly: AssemblyInformationalVersion("4.9.2704")]  //Should be equal to the same property of Patagames.Pdf assembly
 [assembly: AssemblyVersion("4.2.1." +
 #if DOTNET20
 "20"


-release 4.62.2704

-release 4.62.2704

--- Properties/AssemblyInfo.cs
+++ Properties/AssemblyInfo.cs
@@ -11,7 +11,7 @@
 //      Revision -.Net framework

 //---------------------------- WPF Viewer -------------------------------------------------
-[assembly: AssemblyInformationalVersion("4.61.2704")]  //Should be equal to the same property of Patagames.Pdf assembly
+[assembly: AssemblyInformationalVersion("4.62.2704")]  //Should be equal to the same property of Patagames.Pdf assembly
 [assembly: AssemblyVersion("4.19.19." +
 #if DOTNET20
 "20"


v2.8.8

--- Properties/AssemblyInfo.cs
+++ Properties/AssemblyInfo.cs
@@ -34,5 +34,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("2.8.7.0")]
-[assembly: AssemblyFileVersion("2.8.7.0")]
+[assembly: AssemblyVersion("2.8.8.0")]
+[assembly: AssemblyFileVersion("2.8.8.0")]


change chart type and fix format into page

--- RepoStats/HtmlTemplates.cs
+++ RepoStats/HtmlTemplates.cs
@@ -79,18 +79,13 @@

             ";

-        public static string FillerTemplate = @"
-
+        public static string FillerTemplate = @"

Content

-
-

-
-

-
-

-
+

+

+

";

         public static class Table
@@ -193,12 +188,15 @@

         public static class Graph
         {
-            public static string ContainerTempalte = @"

";
+            public static string ContainerTempalte = @"";
             public static string GraphTemplate = @"


Android building

Android building

--- ActionBar/PrinterConnectButton.cs
+++ ActionBar/PrinterConnectButton.cs
@@ -32,6 +32,8 @@
 using MatterHackers.Agg.UI;
 using MatterHackers.Localizations;
 using MatterHackers.MatterControl.PrinterCommunication;
+using MatterHackers.MatterControl.SlicerConfiguration;
+using MatterHackers.SerialPortCommunication.FrostedSerial;

 namespace MatterHackers.MatterControl.ActionBar
 {


Param type added to NoBot documentation

Param type added to NoBot documentation

--- AjaxControlToolkit/NoBot/NoBot.cs
+++ AjaxControlToolkit/NoBot/NoBot.cs
@@ -94,7 +94,7 @@
         /// <summary>
         /// Returns whether the user is believed to be valid
         /// </summary>
-        /// <param name="state">NoBot state</param>
+        /// <param name="state" type="NoBotState">NoBot state</param>
         /// <returns>Whether user is valid</returns>
         public bool IsValid(out NoBotState state) {
             EnsureChildControls();


Transform finished

Transform finished

--- AngleSharp/DOM/Css/CSSProperty.cs
+++ AngleSharp/DOM/Css/CSSProperty.cs
@@ -608,26 +608,36 @@
                         WithArgs(WithNumber(), WithPercent(), WithPercent(), WithNumber().Constraint(m => m >= 0f && m <= 1f), m => Color.FromHsla(hnorm * m.Item1, m.Item2.NormalizedValue, m.Item3.NormalizedValue, m.Item4))));
         }

+        /// <summary>
+        /// Represents a transform function.
+        /// http://dev.w3.org/csswg/css-transforms/#two-d-transform-functions
+        /// </summary>
+        /// <returns>The value converter.</returns>
         public static IValueConverter<ITransform> WithTransform()
         {
             return new FunctionValueConverter<ITransform>(FunctionNames.Matrix,
                         WithArgs(WithNumber(), 6, m => (ITransform)new MatrixTransform(m[0], m[1], m[2], m[3], m[4], m[5]))).
                 Or(new FunctionValueConverter<ITransform>(FunctionNames.Matrix3d,
                         WithArgs(WithNumber(), 12, m => (ITransform)new Matrix3DTransform(m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8], m[9], m[10], m[11])))).
-                Or(new FunctionValueConverter<ITransform>(FunctionNames.Translate, //TODO 2nd arg. optional => Length.Zero
-                        WithArgs(WithDistance(), 2, m => (ITransform)new TranslateTransform(m[0], m[1])))).
-                Or(new FunctionValueConverter<ITransform>(FunctionNames.Translate3d, //TODO 2nd and 3rd arg. optional => Length.Zero
-                        WithArgs(WithDistance(), 3, m => (ITransform)new Translate3DTransform(m[0], m[1], m[2])))).
+                Or(new FunctionValueConverter<ITransform>(FunctionNames.Translate,
+                        WithDistance().To(m => (ITransform)new TranslateTransform(m, Length.Zero)).Or(
+                        WithArgs(WithDistance(), 2, m => (ITransform)new TranslateTransform(m[0], m[1]))))).
+                Or(new FunctionValueConverter<ITransform>(FunctionNames.Translate3d,
+                        WithDistance().To(m => (ITransform)new Translate3DTransform(m, Length.Zero, Length.Zero)).Or(
+                        WithArgs(WithDistance(), 2, m => (ITransform)new Translate3DTransform(m[0], m[1], Length.Zero))).Or(
+                        WithArgs(WithDistance(), 3, m => (ITransform)new Translate3DTransform(m[0], m[1], m[2]))))).
                 Or(new FunctionValueConverter<ITransform>(FunctionNames.TranslateX,
                         WithDistance().To(m => (ITransform)new TranslateXTransform(m)))).
                 Or(new FunctionValueConverter<ITransform>(FunctionNames.TranslateY,
                         WithDistance().To(m => (ITransform)new TranslateYTransform(m)))).
                 Or(new FunctionValueConverter<ITransform>(FunctionNames.TranslateZ,
                         WithDistance().To(m => (ITransform)new TranslateZTransform(m)))).
-                Or(new FunctionValueConverter<ITransform>(FunctionNames.Scale, //TODO 2nd arg. optional => same as 1st
-                        WithArgs(WithNumber(), 2, m => (ITransform)new ScaleTransform(m[0], m[1])))).
-                Or(new FunctionValueConverter<ITransform>(FunctionNames.Scale3d, //TODO if only 1 arg. => all three same
-                        WithArgs(WithNumber(), 3, m => (ITransform)new Scale3DTransform(m[0], m[1], m[2])))).
+                Or(new FunctionValueConverter<ITransform>(FunctionNames.Scale,
+                        WithNumber().To(m => (ITransform)new ScaleTransform(m, m)).Or(
+                        WithArgs(WithNumber(), 2, m => (ITransform)new ScaleTransform(m[0], m[1]))))).
+                Or(new FunctionValueConverter<ITransform>(FunctionNames.Scale3d,
+                        WithNumber().To(m => (ITransform)new Scale3DTransform(m, m, m)).Or(
+                        WithArgs(WithNumber(), 3, m => (ITransform)new Scale3DTransform(m[0], m[1], m[2]))))).
                 Or(new FunctionValueConverter<ITransform>(FunctionNames.ScaleX,
                         WithNumber().To(m => (ITransform)new ScaleXTransform(m)))).
                 Or(new FunctionValueConverter<ITransform>(FunctionNames.ScaleY,


Fixed position when creating the stairs, now it's local

--- Assets/BoxStairsTool/BoxStairs.cs
+++ Assets/BoxStairsTool/BoxStairs.cs
@@ -64,7 +64,7 @@
                 Step.name = "Step " + i;
                 Step.transform.SetParent(Root.transform);
                 Step.transform.localScale = new Vector3(StairsWidth, stepHeight, StairsDepth - (i * stepDepth));
-                Step.transform.position = new Vector3(0, i * stepHeight, i * (stepDepth / 2));
+                Step.transform.localPosition = new Vector3(0, i * stepHeight, i * (stepDepth / 2));

                 if (StairsMaterial != null)
                 {


enemy shroom attack direction fix

enemy shroom attack direction fix

--- Assets/Scripts/EnemyController.cs
+++ Assets/Scripts/EnemyController.cs
@@ -30,6 +30,7 @@
 					cooldown = hitSpeed;
 				}
 			} else {
+				_FixedUpdate();
 				Move();
 			}
 		}


Show extra info when -speedrun command argument is set

--- Assets/Scripts/Room/RoomLoader.cs
+++ Assets/Scripts/Room/RoomLoader.cs
@@ -813,6 +813,7 @@
 			ProcessKey(KeyCode.Mouse2); //reset camera zoom
 			ProcessKey(KeyCode.D); //camera perspective
 			ProcessKey(KeyCode.C); //camera areas for current room
+			ProcessKey(KeyCode.E); //extra info
 		}
 	}


Allow to set spawn interval public

Allow to set spawn interval public

--- Assets/Scripts/SpawnController.cs
+++ Assets/Scripts/SpawnController.cs
@@ -6,11 +6,13 @@
 	public GameObject enemiesFolder;
 	public GameObject originalEnemy;
 	public int enemiesToSpawn;
+	public float spawnInterval;
+
     private int enemiesSpawned;

 	void Start () {
         enemiesSpawned = 0;
-        InvokeRepeating("SpawnEnemy", 0, 2f);
+		InvokeRepeating("SpawnEnemy", 0, spawnInterval);
 	}

     void SpawnEnemy() {


Added stop to shoot functionality

Added stop to shoot functionality

--- Assets/Scripts/SwimmerBehavior.cs
+++ Assets/Scripts/SwimmerBehavior.cs
@@ -245,12 +245,28 @@
 	#region Update Helpers
 	void UpdateMovement () {

+		if(state == SwimmerState.Stunned) {
+			return;
+		}
+
+		var horizontalInput = Input.GetAxis (HorizontalAxisName);
+		var verticalInput = Input.GetAxis (VerticalAxisName);
+		var userHeading = new Vector3 (horizontalInput, 0f, verticalInput);
+
+
+		if(CurrentlyShooting) {
+			rigidbody.velocity = Vector3.MoveTowards (rigidbody.velocity, Vector3.zero, 20 * Time.deltaTime);
+
+			if(userHeading != Vector3.zero) {
+				heading = userHeading;
+			}
+			var newRotationAroundY = Mathf.Rad2Deg * Mathf.Atan2 (heading.x, heading.z);
+			var newRotation = Quaternion.Euler(new Vector3(0, newRotationAroundY, 0));
+			transform.rotation = newRotation;
+		}
 		//Update velocity
-		if (state != SwimmerState.Stunned) {
-			var horizontalInput = Input.GetAxis (HorizontalAxisName);
-			var verticalInput = Input.GetAxis (VerticalAxisName);
-
-			var userHeading = new Vector3 (horizontalInput, 0f, verticalInput);
+		else {
+
 			targetHeading = userHeading;

 			headingDelta = targetHeading - heading;
@@ -337,6 +353,7 @@

 		if(PreviouslyShooting == false && CurrentlyShooting){//start the timer
 			ShotTimer = Time.time;
+			rigidbody.velocity = Vector3.zero;
 			return;
 		}
     }


Fix check for existing game installation.

--- Assets/Scripts/System/GameSync.cs
+++ Assets/Scripts/System/GameSync.cs
@@ -68,7 +68,6 @@

                 foreach (Game game in games) {
                     GM.dbug.Log(this, "Downloading: " + game.title);
-

                     //Start the downloadin'!

@@ -160,6 +159,8 @@
             foreach (string dir_full_path in installed) {
                 string directory = new DirectoryInfo(dir_full_path).Name;

+                //Debug.Log("checking " + directory + " for deletion...");
+
                 if (SluggedItem.directoryIsDeletable(directory, keepers)) {
                     Debug.Log("deleting " + dir_full_path);
                     Directory.Delete(dir_full_path, true);
@@ -211,6 +212,7 @@
                 }

                 if (!game.alreadyInstalled() || game.lastModified > installModified) {
+                    Debug.Log("Gonna install " + game.title);
                     toInstall.Add(game);
                 }
             }
@@ -254,7 +256,7 @@
             imageURL = data["image_url"];

             if (alreadyInstalled()) {
-                string json = System.IO.File.ReadAllText(installDirectory + "winnitron_metadata.json");
+                string json = File.ReadAllText(installDirectory + "winnitron_metadata.json");
                 installationMetadata = JSON.Parse(json);
             } else {
                 installationMetadata = new JSONClass();
@@ -263,8 +265,8 @@

         public bool alreadyInstalled() {
-            Debug.Log(installDirectory);
-            return Directory.Exists(installDirectory);
+            //Debug.Log("checking for installation: " + installDirectory);
+            return File.Exists(installDirectory + "winnitron_metadata.json");
         }

         public void writeMetadataFile() {


Output .bat files for each action

Output .bat files for each action

--- AverageTest-IM-console/Program.cs
+++ AverageTest-IM-console/Program.cs
@@ -30,11 +30,10 @@
         // and the output name of the bat files for consistency.

         public int setStartNumber(int newnr)
-            {
-
+        {
             startNumber = newnr;
             return newnr;
-            }
+        }

         public int getStartNumber()
         {
@@ -84,7 +83,7 @@

         public void writePFinalstring()
         {
-            Console.WriteLine(finalstring);
+           // Console.WriteLine(finalstring); // not required as the console string is written to the .bat files
         }

@@ -94,18 +93,18 @@
         public void createBatchfile()
         {
             // string with the current output
-            string curStr = finalstring;
+            string currentStr = finalstring;

             //create file with the correct name
             // getStartNumber() returns the correct number.
-
-
-            // Put the curStr into the file
-
+            TextWriter tw = new StreamWriter(getStartNumber()+".bat");
+
+            // Put the currentStr into the file
+            tw.WriteLine(currentStr);

             // close the file
-
+            tw.Close();

         }

@@ -236,7 +235,7 @@
                         p.writePFinalstring();

-                        // p.createBatchfile(); Commented out as it currently does nothing
+                        p.createBatchfile();
                         p.clearPFinalString();

                         //Console.WriteLine(p.getConsoleString() + p.setOutputFilenameString(p.numberOfRounds.ToString(padding))); // Writes a line with the current consolestring,


Fixed so the hook use the same colors for the one using the hook and the people seeing the hook.

--- SkylinesMultiplayer/Player/PlayerRemote.cs
+++ SkylinesMultiplayer/Player/PlayerRemote.cs
@@ -14,8 +14,11 @@
         {
             var obj = new GameObject("Hook Linerender");
             m_hookLineRender = obj.AddComponent<LineRenderer>();
-            m_hookLineRender.material = new Material(Shader.Find(" Diffuse"));
-            m_hookLineRender.SetWidth(0.5f, 0.5f);
+            m_hookLineRender.material = new Material(Shader.Find("Sprites/Default"));
+            m_hookLineRender.SetWidth(1, 0.4f);
+            Color startColor = new Color(0.55f, 0, 0);
+            Color endColor = new Color(0.15f, 0, 0);
+            m_hookLineRender.SetColors(startColor, endColor);
             m_hookLineRender.enabled = false;
         }


ScrapeService: Fix syntax error in scrape constructor

--- Snowflake.Service/Service/ScrapeService.cs
+++ Snowflake.Service/Service/ScrapeService.cs
@@ -23,7 +23,7 @@
             this.ScrapePlatform = scrapePlatform;
             this.ScraperPlugin = CoreService.LoadedCore.PluginManager.LoadedScrapers[scraperName];
         }
-        public ScrapeService(IPlatformInfo scrapePlatform) : this(scrapePlatform, CoreService.LoadedCore.PlatformPreferenceDatabase.GetPreferences(this.ScrapePlatform).Scraper)
+        public ScrapeService(IPlatformInfo scrapePlatform) : this (scrapePlatform, CoreService.LoadedCore.PlatformPreferenceDatabase.GetPreferences(scrapePlatform).Scraper)
         {
         }


fixing landblock leak (#1751)

fixing landblock leak (#1751)

* interim fix

* full fix

* fixing exception

* commenting out debug msg

* reverting radius

--- Source/ACE.Server/Physics/Common/LScape.cs
+++ Source/ACE.Server/Physics/Common/LScape.cs
@@ -2,11 +2,16 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Numerics;
+using ACE.Entity;
+using ACE.Server.Managers;
+using log4net;

 namespace ACE.Server.Physics.Common
 {
     public static class LScape
     {
+        private static readonly ILog log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
         public static int MidRadius = 5;
         public static int MidWidth = 11;

@@ -79,7 +84,18 @@
                 // if not, load into cache
                 landblock = new Landblock(DBObj.GetCellLandblock(landblockID));
                 if (Landblocks.TryAdd(landblockID, landblock))
+                {
                     landblock.PostInit();
+
+                    // ensure landblock manager loaded
+                    var lbid = new LandblockId(landblockID);
+                    if (!LandblockManager.IsLoaded(lbid))
+                    {
+                        // this can happen from encounter spawns sliding down walkable slopes...
+                        //log.Debug($"{landblockID:X8} requested from LScape, but not loaded from LandblockManager, adding");
+                        LandblockManager.GetLandblock(lbid, false, false);
+                    }
+                }
                 else
                     Landblocks.TryGetValue(landblockID, out landblock);


Fixed typo

Fixed typo

--- Source/EasyNetQ/QueueingConsumerFactory.cs
+++ Source/EasyNetQ/QueueingConsumerFactory.cs
@@ -121,7 +121,7 @@

         private void DoAck(BasicDeliverEventArgs basicDeliverEventArgs, SubscriptionInfo subscriptionInfo)
         {
-            const string failedToAckMessage = "Basic ack failed because chanel was closed with message {0}." +
+            const string failedToAckMessage = "Basic ack failed because channel was closed with message {0}." +
                                               " Message remains on RabbitMQ and will be retried.";

             try


QbservableServiceOptions.Unrestricted defined.

--- Source/Qactive/QbservableServiceOptions.cs
+++ Source/Qactive/QbservableServiceOptions.cs
@@ -10,6 +10,15 @@
     public static readonly QbservableServiceOptions Default = new QbservableServiceOptions()
     {
       frozen = true,
+      evaluationContext = new ServiceEvaluationContext()
+    };
+
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes", Justification = "It's immutable due to the frozen flag.")]
+    public static readonly QbservableServiceOptions Unrestricted = new QbservableServiceOptions()
+    {
+      frozen = true,
+      allowExpressionsUnrestricted = true,
+      enableDuplex = true,
       evaluationContext = new ServiceEvaluationContext()
     };


Added tests demonstrating InvalidCastException deserializing a class implementing IEnumerable<T> with a converter

--- Src/Newtonsoft.Json.Tests/JsonConvertTest.cs
+++ Src/Newtonsoft.Json.Tests/JsonConvertTest.cs
@@ -50,6 +50,7 @@
 using Assert = Newtonsoft.Json.Tests.XUnitAssert;
 #else
 using NUnit.Framework;
+using System.Collections;

 #endif

@@ -1630,5 +1631,113 @@
         public class NonGenericChildClass : GenericIntermediateClass<int>
         {
         }
+
+        [Test]
+        public void ShouldNotPopulateReadOnlyEnumerableObjectWithNonDefaultConstructor()
+        {
+            object actual = JsonConvert.DeserializeObject<HasReadOnlyEnumerableObject>("{\"foo\":{}}");
+            Assert.NotNull(actual);
+        }
+
+        [Test]
+        public void ShouldNotPopulateReadOnlyEnumerableObjectWithDefaultConstructor()
+        {
+            object actual = JsonConvert.DeserializeObject<HasReadOnlyEnumerableObjectAndDefaultConstructor>("{\"foo\":{}}");
+            Assert.NotNull(actual);
+        }
+
+        [Test]
+        public void ShouldNotPopulateContructorArgumentEnumerableObject()
+        {
+            object actual = JsonConvert.DeserializeObject<AcceptsEnumerableObjectToConstructor>("{\"foo\":{}}");
+            Assert.NotNull(actual);
+        }
+
+        [Test]
+        public void ShouldNotPopulateEnumerableObjectProperty()
+        {
+            object actual = JsonConvert.DeserializeObject<HasEnumerableObject>("{\"foo\":{}}");
+            Assert.NotNull(actual);
+        }
+
+        public sealed class HasReadOnlyEnumerableObject
+        {
+            [JsonProperty("foo")]
+            public EnumerableWithConverter Foo { get; } = new EnumerableWithConverter();
+
+            [JsonConstructor]
+            public HasReadOnlyEnumerableObject([JsonProperty("bar")] int bar)
+            {
+
+            }
+        }
+
+        public sealed class HasReadOnlyEnumerableObjectAndDefaultConstructor
+        {
+            [JsonProperty("foo")]
+            public EnumerableWithConverter Foo { get; } = new EnumerableWithConverter();
+
+            [JsonConstructor]
+            public HasReadOnlyEnumerableObjectAndDefaultConstructor()
+            {
+
+            }
+        }
+
+        public sealed class AcceptsEnumerableObjectToConstructor
+        {
+            [JsonConstructor]
+            public AcceptsEnumerableObjectToConstructor
+            (
+                [JsonProperty("foo")] EnumerableWithConverter foo,
+                [JsonProperty("bar")] int bar
+            )
+            {
+
+            }
+        }
+
+        public sealed class HasEnumerableObject
+        {
+            [JsonProperty("foo")]
+            public EnumerableWithConverter Foo { get; set; } = new EnumerableWithConverter();
+
+            [JsonConstructor]
+            public HasEnumerableObject([JsonProperty("bar")] int bar)
+            {
+
+            }
+        }
+
+        [JsonConverter(typeof(Converter))]
+        public sealed class EnumerableWithConverter : IEnumerable<int>
+        {
+            public sealed class Converter : JsonConverter
+            {
+                public override bool CanConvert(Type objectType)
+                    => objectType == typeof(Foo);
+
+                public override object ReadJson
+                    (JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+                {
+                    reader.Skip();
+                    return new EnumerableWithConverter();
+                }
+
+                public override void WriteJson
+                    (JsonWriter writer, object value, JsonSerializer serializer)
+                {
+                    writer.WriteStartObject();
+                    writer.WriteEndObject();
+                }
+            }
+
+            public IEnumerator<int> GetEnumerator()
+            {
+                yield break;
+            }
+
+            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        }
     }
 }


Fixing SemaphoreSlimTests for .NET 4.0

Fixing SemaphoreSlimTests for .NET 4.0

.NET 4.0 does not have SemaphoreSlim.WaitAsync

--- Tests/System/Threading/SemaphoreSlimTests.cs
+++ Tests/System/Threading/SemaphoreSlimTests.cs
@@ -70,6 +70,8 @@
                (10, 10, new TimeSpan(0, 0, Int32.MaxValue), true, typeof(ArgumentOutOfRangeException));
         }

+#if !NET40
+
         [Test]
         public static void RunSemaphoreSlimTest1_WaitAsync()
         {
@@ -97,6 +99,8 @@
                (10, 10, new TimeSpan(0, 0, Int32.MaxValue), true, typeof(ArgumentOutOfRangeException));
         }

+#endif
+
         [Test]
         public static void RunSemaphoreSlimTest2_Release()
         {
@@ -118,6 +122,8 @@
             RunSemaphoreSlimTest2_Release(5, 10, 6, typeof(SemaphoreFullException));
             RunSemaphoreSlimTest2_Release(int.MaxValue - 1, int.MaxValue, 10, typeof(SemaphoreFullException));
         }
+
+#if !NET40

         [Test]
         public static void RunSemaphoreSlimTest4_Dispose()
@@ -159,6 +165,8 @@
             RunSemaphoreSlimTest7_AvailableWaitHandle(0, 10, SemaphoreSlimActions.Release, true);
         }

+#endif
+
         /// <summary>
         /// Test SemaphoreSlim constructor
         /// </summary>
@@ -222,6 +230,8 @@
             }
         }

+#if !NET40
+
         /// <summary>
         /// Test SemaphoreSlim WaitAsync
         /// </summary>
@@ -300,6 +310,8 @@
             Assert.False(nonZeroObserved, "RunSemaphoreSlimTest1_WaitAsync2:  FAILED.  SemaphoreSlim.Release() seems to have synchronously invoked a continuation.");
         }

+#endif
+
         /// <summary>
         /// Test SemaphoreSlim Release
         /// </summary>
@@ -326,6 +338,8 @@
             }
         }

+#if !NET40
+
         /// <summary>
         /// Call specific SemaphoreSlim method or property
         /// </summary>
@@ -449,6 +463,8 @@
             Assert.NotNull(semaphore.AvailableWaitHandle);
             Assert.AreEqual(state, semaphore.AvailableWaitHandle.WaitOne(0));
         }
+
+#endif

         [Test]
         [Category("RaceCondition")] // This test creates a race condition
@@ -510,6 +526,8 @@
             Assert.AreEqual(finalCount, semaphore.CurrentCount);
         }

+#if !NET40
+
         [Test]
         [Category("RaceCondition")] // This test creates a race condition
         public static void RunSemaphoreSlimTest8_ConcWaitAsyncAndRelease()
@@ -547,7 +565,7 @@
                 }
                 else
                 {
-                    tasks[i] = Task.Run(delegate
+                    tasks[i] = TaskEx.Run(delegate
                     {
                         mre.WaitOne();
                         semaphore.Release();
@@ -583,7 +601,7 @@
             int randSeed = unchecked((int)DateTime.Now.Ticks);
             for (int i = 0; i < syncWaiters; i++)
             {
-                tasks[i] = Task.Run(delegate
+                tasks[i] = TaskEx.Run(delegate
                 {
                     //Random rand = new Random(Interlocked.Increment(ref randSeed));
                     for (int iter = 0; iter < ITERS; iter++)
@@ -609,5 +627,7 @@
             semaphore.Release(totalWaiters / 2);
             Task.WaitAll(tasks);
         }
+
+#endif
     }
 }


pffffffffffffffffff

pffffffffffffffffff

--- The_Binding_Of_ROB/The_Binding_Of_ROB/Map.cs
+++ The_Binding_Of_ROB/The_Binding_Of_ROB/Map.cs
@@ -35,17 +35,17 @@
             }

             tiles1 = new Sprite[mapWidth, mapHeight];
-            StreamReader readLayer1 = new StreamReader(@"C:\Users\Robbert\SkyDrive\The_Binding_Of_ROB\The_Binding_Of_ROB\The_Binding_Of_ROB\Maps\TestMap_Tilelaag 1.csv");
+            StreamReader readLayer1 = new StreamReader(@"Maps\TestMap_Tilelaag 1.csv");
             reading(readLayer1, tilemap, tileSize, tiles1);
             readLayer1.Close();

             tiles2 = new Sprite[mapWidth, mapHeight];
-            StreamReader readLayer2 = new StreamReader(@"C:\Users\Robbert\SkyDrive\The_Binding_Of_ROB\The_Binding_Of_ROB\The_Binding_Of_ROB\Maps\TestMap_Tilelaag 2.csv");
+            StreamReader readLayer2 = new StreamReader(@"Maps\TestMap_Tilelaag 2.csv");
             reading(readLayer2, tilemap, tileSize, tiles2);
             readLayer2.Close();

             tiles3 = new Sprite[mapWidth, mapHeight];
-            StreamReader readLayer3 = new StreamReader(@"C:\Users\Robbert\SkyDrive\The_Binding_Of_ROB\The_Binding_Of_ROB\The_Binding_Of_ROB\Maps\TestMap_Tilelaag 3.csv");
+            StreamReader readLayer3 = new StreamReader(@"Maps\TestMap_Tilelaag 3.csv");
             reading(readLayer3, tilemap, tileSize, tiles3);
             readLayer2.Close();
         }