//                                                                       ============
    private static OptionalEntity<User> getEntity(final CreateForm form) {
        switch (form.crudMode) {
        case CrudMode.CREATE:
            return OptionalEntity.of(new User()).map(entity -> {
                entity.setId(Base64.getUrlEncoder().encodeToString(form.name.getBytes(Constants.CHARSET_UTF_8)));

    return fromArrayWithExpectedSize(elements, estimatedSizeForUnknownDuplication(elements.length));
  }

  private static <E> ImmutableSet<E> fromArrayWithExpectedSize(E[] elements, int expectedSize) {
    switch (elements.length) {
      case 0:
        return of();
      case 1:
        return of(elements[0]);
      default:
        SetBuilderImpl<E> builder = new RegularSetBuilderImpl<>(expectedSize);

        return 0;
    }

    @Override
    int readDataWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return switch (informationLevel) {
        case SMB_INFO_ALLOCATION -> readSmbInfoAllocationWireFormat(buffer, bufferIndex);
        case SMB_QUERY_FS_SIZE_INFO -> readSmbQueryFSSizeInfoWireFormat(buffer, bufferIndex);

     * @param errorKey the error key identifying the type of password validation error
     */
    protected void addPasswordValidationError(final FessMessages messages, final String errorKey) {
        switch (errorKey) {
        case "errors.password_length":
            messages.addErrorsPasswordLength(GLOBAL, String.valueOf(ComponentUtil.getFessConfig().getPasswordMinLengthAsInteger()));
            break;

      if (finishLine(cbuf[pos] == '\n')) {
        pos++;
      }
    }

    int start = pos;
    for (int end = off + len; pos < end; pos++) {
      switch (cbuf[pos]) {
        case '\r':
          line.append(cbuf, start, pos - start);
          sawReturn = true;
          if (pos + 1 < end) {
            if (finishLine(cbuf[pos + 1] == '\n')) {
              pos++;

            this.info = inf;
        }
        return bufferIndex - start;
    }

    private FileInformation createFileInformation() {
        FileInformation inf;
        switch (this.informationLevel) {
        case FileInformation.FILE_BASIC_INFO:
            inf = new FileBasicInfo();
            break;
        case FileInformation.FILE_STANDARD_INFO:
            inf = new FileStandardInfo();

	if err := dec.DecodeElement(&dest, &start); err != nil {
		return err
	}
	parsedDest, err := parseDestination(dest.Bucket)
	if err != nil {
		return err
	}
	if dest.StorageClass != "" {
		switch dest.StorageClass {
		case "STANDARD", "REDUCED_REDUNDANCY":
		default:
			return fmt.Errorf("unknown storage class %s", dest.StorageClass)
		}
	}
	parsedDest.StorageClass = dest.StorageClass
	*d = parsedDest

// only one of Prefix, And and Tag should be present in the output.
func (f Filter) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	if err := e.EncodeToken(start); err != nil {
		return err
	}

	switch {
	case !f.And.isEmpty():
		if err := e.EncodeElement(f.And, xml.StartElement{Name: xml.Name{Local: "And"}}); err != nil {
			return err
		}
	case !f.Tag.IsEmpty():

			break
		}

		// Manually deserialize the size since AWS specified
		// the chunk size to be of variable width. In particular,
		// a size of 16 is encoded as `10` while a size of 64 KB
		// is `10000`.
		switch {
		case b >= '0' && b <= '9':
			size = size<<4 | int(b-'0')
		case b >= 'a' && b <= 'f':
			size = size<<4 | int(b-('a'-10))
		case b >= 'A' && b <= 'F':
			size = size<<4 | int(b-('A'-10))
		default:

		copy(pathExpr[1:], e.PathExpr)
	}
	e.strippedTableAlias = tableAlias
	e.strippedPathExpr = pathExpr
	return e.strippedPathExpr
}

func (e *JSONPathElement) String() string {
	switch {
	case e.Key != nil:
		return e.Key.String()
	case e.Index != nil:
		return fmt.Sprintf("[%d]", *e.Index)
	case e.ObjectWildcard:
		return ".*"
	case e.ArrayWildcard:
		return "[*]"
	}
	return ""
}