registerFixedArrayType method

LegacyBCS registerFixedArrayType(String typeName)

Register custom fixed array type inside the bcs.

bcs.registerFixedArrayType('array<T>'); // generic registration
final array = bcs.de('array<u8, 6>', '06010203040506', Encoding.hex); // [1,2,3,4,5,6];
final again = bcs.ser('array<u8>', [1,2,3,4,5,6]).hex();

Implementation

LegacyBCS registerFixedArrayType(String typeName) {
  final (name, params) = parseTypeName(typeName);
  if (params.length > 1) {
    throw ArgumentError("Vector can have only one type parameter; got " + name);
  }

  return registerType(
    typeName,
    (writer, data, typeParams, typeMap) {
      int? size = typeParams.length > 1 ? int.parse(typeParams[1].toString()) : null;
      return writer.writeFixedArray(data, size, (writer, el, _, __) {
        if (typeParams.isEmpty) {
          throw ArgumentError(
            "Incorrect number of type parameters passed a to vector '$typeName'"
          );
        }

        final elementType = typeParams[0];
        final (name, params) = parseTypeName(elementType);
        if (hasType(name)) {
          return getTypeInterface(name).encodeRaw(
            writer,
            el,
            params,
            typeMap
          );
        }

        if (!(typeMap.containsKey(name))) {
          throw ArgumentError(
            "Unable to find a matching type definition for $name in vector; make sure you passed a generic"
          );
        }

        final (innerName, innerParams) = parseTypeName(
          typeMap[name]
        );

        return getTypeInterface(innerName).encodeRaw(
          writer,
          el,
          innerParams,
          typeMap
        );
      });
    },
    (reader, typeParams, typeMap) {
      final size = int.parse(typeParams[1].toString());
      return reader.readFixedArray(size, (reader, _, __) {
        if (typeParams.isEmpty) {
          throw ArgumentError(
            "Incorrect number of type parameters passed to a vector '$typeName'"
          );
        }

        final elementType = typeParams[0];
        final (name, params) = parseTypeName(elementType);
        if (hasType(name)) {
          return getTypeInterface(name).decodeRaw(
            reader,
            params,
            typeMap
          );
        }

        if (!(typeMap.containsKey(name))) {
          throw ArgumentError(
            "Unable to find a matching type definition for $name in vector; make sure you passed a generic"
          );
        }

        final (innerName, innerParams) = parseTypeName(
          typeMap[name]
        );
        getTypeInterface(innerName).decodeRaw(
          reader,
          innerParams,
          typeMap
        );
      });
    }
  );
}