parse static method

List<int> parse(
  1. String uuid, {
  2. List<int>? buffer,
  3. int offset = 0,
  4. bool validate = true,
  5. ValidationMode validationMode = ValidationMode.strictRFC4122,
  6. bool noDashes = false,
})

Parses the provided uuid into a list of byte values as a List. Can optionally be provided a buffer to write into and a positional offset for where to start inputting into the buffer.

Returns the buffer containing the bytes. If no buffer was provided, a new buffer is created and returned. If a buffer was provided, it is returned (even if the uuid bytes are not placed at the beginning of that buffer).

Throws FormatException if the UUID is invalid. Optionally you can set validate to false to disable validation of the UUID before parsing.

Throws RangeError if a buffer is provided and it is too small. It is also thrown if a non-zero offset is provided without providing a buffer.

Implementation

static List<int> parse(String uuid,
    {List<int>? buffer,
    int offset = 0,
    bool validate = true,
    ValidationMode validationMode = ValidationMode.strictRFC4122,
    bool noDashes = false}) {
  if (validate) {
    UuidValidation.isValidOrThrow(
        fromString: uuid, validationMode: validationMode, noDashes: noDashes);
  }
  var i = offset, ii = 0;

  // Get buffer to store the result
  if (buffer == null) {
    // Buffer not provided: create a 16 item buffer
    if (offset != 0) {
      throw RangeError('non-zero offset without providing a buffer');
    }
    buffer = Uint8List(16);
  } else {
    // Buffer provided: check it is large enough
    if (buffer.length - offset < 16) {
      throw RangeError('buffer too small: need 16: length=${buffer.length}'
          '${offset != 0 ? ', offset=$offset' : ''}');
    }
  }

  // Convert to lowercase and replace all hex with bytes then
  // string.replaceAll() does a lot of work that I don't need, and a manual
  // regex gives me more control.
  final regex = RegExp('[0-9a-f]{2}');
  for (Match match in regex.allMatches(uuid.toLowerCase())) {
    if (ii < 16) {
      var hex = uuid.toLowerCase().substring(match.start, match.end);
      buffer[i + ii++] = int.parse(hex, radix: 16);
    }
  }

  // Zero out any left over bytes if the string was too short.
  while (ii < 16) {
    buffer[i + ii++] = 0;
  }

  return buffer;
}