deserialize method

@override AbstractMessage? deserialize(Uint8List? msgPack)

Converts a uint8 msgpack message into a WAMP message object

Implementation

@override
AbstractMessage? deserialize(Uint8List? msgPack) {
  if (msgPack == null) {
    return null;
  }
  final fastPathMessage = _deserializeFastPathMessage(msgPack);
  if (fastPathMessage != null) {
    return fastPathMessage;
  }
  Object? message = msgpack_dart.deserialize(msgPack);
  if (message is List) {
    int messageId = message[0];
    if (messageId == MessageTypes.codeHello) {
      return Hello(
        message[1] as String?,
        _decodeDetailsMap(
          Map<dynamic, dynamic>.from(message[2] as Map<dynamic, dynamic>),
        ),
      );
    }
    if (messageId == MessageTypes.codeChallenge) {
      return Challenge(
        message[1],
        _decodeChallengeExtraMap(
          Map<dynamic, dynamic>.from(message[2] as Map<dynamic, dynamic>),
        ),
      );
    }
    if (messageId == MessageTypes.codeAuthenticate) {
      return Authenticate(signature: message[1] as String?)
        ..extra = message[2] is Map
            ? Map<String, Object?>.from(
                _normalizeDynamicMap(
                  Map<dynamic, dynamic>.from(
                    message[2] as Map<dynamic, dynamic>,
                  ),
                ),
              )
            : <String, Object?>{};
    }
    if (messageId == MessageTypes.codeWelcome) {
      return Welcome(
        message[1],
        _decodeWelcomeDetailsMap(
          Map<dynamic, dynamic>.from(message[2] as Map<dynamic, dynamic>),
        ),
      );
    }
    if (messageId == MessageTypes.codeRegister) {
      return Register(
        message[1],
        message[3],
        options: _decodeRegisterOptions(
          message[2] is Map
              ? _normalizeDynamicMap(
                  Map<dynamic, dynamic>.from(
                    message[2] as Map<dynamic, dynamic>,
                  ),
                )
              : null,
        ),
      );
    }
    if (messageId == MessageTypes.codeUnregister) {
      return Unregister(message[1], message[2]);
    }
    if (messageId == MessageTypes.codeCall) {
      return _addPayload(
        Call(
          message[1],
          message[3],
          options: _decodeCallOptions(
            message[2] is Map
                ? _normalizeDynamicMap(
                    Map<dynamic, dynamic>.from(
                      message[2] as Map<dynamic, dynamic>,
                    ),
                  )
                : null,
          ),
        ),
        message,
        4,
      );
    }
    if (messageId == MessageTypes.codeYield) {
      return _addPayload(
        Yield(
          message[1],
          options: _decodeYieldOptions(
            message[2] is Map
                ? _normalizeDynamicMap(
                    Map<dynamic, dynamic>.from(
                      message[2] as Map<dynamic, dynamic>,
                    ),
                  )
                : null,
          ),
        ),
        message,
        3,
      );
    }
    if (messageId == MessageTypes.codePublish) {
      return _addPayload(
        Publish(
          message[1],
          message[3],
          options: _decodePublishOptions(
            message[2] is Map
                ? _normalizeDynamicMap(
                    Map<dynamic, dynamic>.from(
                      message[2] as Map<dynamic, dynamic>,
                    ),
                  )
                : null,
          ),
        ),
        message,
        4,
      );
    }
    if (messageId == MessageTypes.codeRegistered) {
      return Registered(message[1], message[2]);
    }
    if (messageId == MessageTypes.codeUnregistered) {
      return Unregistered(message[1]);
    }
    if (messageId == MessageTypes.codeInvocation) {
      final detailsMap = message[3] as Map<dynamic, dynamic>;
      final caller = detailsMap['caller'];
      final procedure = detailsMap['procedure'];
      final progress = detailsMap['progress'];
      final receiveProgress = detailsMap['receive_progress'];
      final pptScheme = detailsMap['ppt_scheme'];
      final pptSerializer = detailsMap['ppt_serializer'];
      final pptCipher = detailsMap['ppt_cipher'];
      final pptKeyId = detailsMap['ppt_keyid'];
      return _addPayload(
        Invocation(
          message[1],
          message[2],
          InvocationDetails(
              caller,
              procedure,
              receiveProgress,
              pptScheme,
              pptSerializer,
              pptCipher,
              pptKeyId,
              _extractCustomDetails(detailsMap, _invocationDetailKeys),
            )
            ..progress = progress
            ..timeout = _coerceInt(detailsMap['timeout']),
        ),
        message,
        4,
      );
    }
    if (messageId == MessageTypes.codeInterrupt) {
      final optionsMap = message.length > 2 && message[2] is Map
          ? Map<dynamic, dynamic>.from(message[2] as Map<dynamic, dynamic>)
          : null;
      return interrupt_msg.Interrupt(
        message[1],
        options: optionsMap == null
            ? null
            : (() {
                final options = interrupt_msg.InterruptOptions();
                options.mode = optionsMap['mode'] as String?;
                return options;
              })(),
      );
    }
    if (messageId == MessageTypes.codeCancel) {
      final optionsMap = message.length > 2 && message[2] is Map
          ? Map<dynamic, dynamic>.from(message[2] as Map<dynamic, dynamic>)
          : null;
      return cancel_msg.Cancel(
        message[1],
        options: optionsMap == null
            ? null
            : (() {
                final options = cancel_msg.CancelOptions();
                options.mode = optionsMap['mode'] as String?;
                return options;
              })(),
      );
    }
    if (messageId == MessageTypes.codeResult) {
      final detailsMap = message[2] as Map<dynamic, dynamic>;
      final progress = detailsMap['progress'];
      final pptScheme = detailsMap['ppt_scheme'];
      final pptSerializer = detailsMap['ppt_serializer'];
      final pptCipher = detailsMap['ppt_cipher'];
      final pptKeyId = detailsMap['ppt_keyid'];
      return _addPayload(
        Result(
          message[1],
          ResultDetails(
            progress: progress,
            pptScheme: pptScheme,
            pptSerializer: pptSerializer,
            pptCipher: pptCipher,
            pptKeyId: pptKeyId,
            custom: _extractCustomDetails(detailsMap, _resultDetailKeys),
          ),
        ),
        message,
        3,
      );
    }
    if (messageId == MessageTypes.codePublished) {
      return Published(message[1], message[2]);
    }
    if (messageId == MessageTypes.codeSubscribe) {
      return Subscribe(
        message[1],
        message[3],
        options: _decodeSubscribeOptions(
          message[2] is Map
              ? _normalizeDynamicMap(
                  Map<dynamic, dynamic>.from(
                    message[2] as Map<dynamic, dynamic>,
                  ),
                )
              : null,
        ),
      );
    }
    if (messageId == MessageTypes.codeSubscribed) {
      return Subscribed(message[1], message[2]);
    }
    if (messageId == MessageTypes.codeUnsubscribe) {
      return Unsubscribe(message[1], message[2]);
    }
    if (messageId == MessageTypes.codeUnsubscribed) {
      return Unsubscribed(
        message[1],
        message.length == 2
            ? null
            : _decodeUnsubscribedDetailsMap(
                Map<dynamic, dynamic>.from(
                  message[2] as Map<dynamic, dynamic>,
                ),
              ),
      );
    }
    if (messageId == MessageTypes.codeEvent) {
      final detailsMap = message[3] as Map<dynamic, dynamic>;
      final publisher = detailsMap['publisher'];
      final trustlevel = detailsMap['trustlevel'];
      final topic = detailsMap['topic'];
      final pptScheme = detailsMap['ppt_scheme'];
      final pptSerializer = detailsMap['ppt_serializer'];
      final pptCipher = detailsMap['ppt_cipher'];
      final pptKeyId = detailsMap['ppt_keyid'];
      return _addPayload(
        Event(
          message[1],
          message[2],
          EventDetails(
            publisher: publisher,
            trustlevel: trustlevel,
            topic: topic,
            pptScheme: pptScheme,
            pptSerializer: pptSerializer,
            pptCipher: pptCipher,
            pptKeyid: pptKeyId,
            custom: _extractCustomDetails(detailsMap, _eventDetailKeys),
          ),
        ),
        message,
        4,
      );
    }
    if (messageId == MessageTypes.codeError) {
      return _addPayload(
        Error(
          message[1],
          message[2],
          Map<String, Object>.from(message[3]),
          message[4],
        ),
        message,
        5,
      );
    }
    if (messageId == MessageTypes.codeAbort) {
      return Abort(
        message[2],
        message: _decodeAbortMessageMap(
          message[1] is Map
              ? Map<dynamic, dynamic>.from(
                  message[1] as Map<dynamic, dynamic>,
                )
              : null,
        ),
      );
    }
    if (messageId == MessageTypes.codeGoodbye) {
      return Goodbye(
        _decodeGoodbyeMessageMap(
          message[1] is Map
              ? Map<dynamic, dynamic>.from(
                  message[1] as Map<dynamic, dynamic>,
                )
              : null,
        ),
        message[2],
      );
    }
  }
  _logger.shout('Could not deserialize the message: $msgPack');
  // TODO respond with an error
  return null;
}