# 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;
    }