public String saveProfilePicture(String userId, Path path) {
    UploadRequest request = UploadRequest.fromPath(path, userId); // (1)
    UploadResponse<?> response = objectStorage.upload(request); // (2)
    return response.getKey(); // (3)
}

open fun saveProfilePicture(userId: String, path: Path): String? {
    val request = UploadRequest.fromPath(path, userId) // (1)
    val response = objectStorage.upload(request) // (2)
    return response.key // (3)
}

String saveProfilePicture(String userId, Path path) {
    UploadRequest request = UploadRequest.fromPath(path, userId) // (1)
    UploadResponse response = objectStorage.upload(request) // (2)
    response.key // (3)
}

UploadResponse<PutObjectResponse> response = objectStorage.upload(objectStorageUpload, builder -> {
    builder.acl(ObjectCannedACL.PUBLIC_READ);
});

val response = objectStorage.upload(objectStorageUpload) { builder: PutObjectRequest.Builder ->
    builder.acl(ObjectCannedACL.PUBLIC_READ)
}

UploadResponse<PutObjectResponse> response = objectStorage.upload(objectStorageUpload, { builder ->
    builder.acl(ObjectCannedACL.PUBLIC_READ)
})

@Post(uri = "/stream", consumes = MediaType.MULTIPART_FORM_DATA, produces = MediaType.TEXT_PLAIN)
public HttpResponse<String> streamingUpload(StreamingFileUpload fileUpload) {
    UploadRequest objectStorageUpload = UploadRequest.fromStreamingFileUpload(fileUpload, "uploads/" + fileUpload.getFilename());
    UploadResponse<PutObjectResponse> response = objectStorage.upload(objectStorageUpload);
    return HttpResponse
        .created(response.getKey())
        .header("ETag", response.getNativeResponse().eTag());
}

@Post(uri = "/stream", consumes = [MediaType.MULTIPART_FORM_DATA], produces = [MediaType.TEXT_PLAIN])
open fun streamingUpload(fileUpload: StreamingFileUpload): HttpResponse<String>? {
    val objectStorageUpload = UploadRequest.fromStreamingFileUpload(fileUpload, "uploads/${fileUpload.filename}")
    val response: io.micronaut.objectstorage.response.UploadResponse<PutObjectResponse> = objectStorage.upload(objectStorageUpload)
    return HttpResponse
        .created(response.key)
        .header("ETag", response.nativeResponse.eTag())
}

@Post(uri = "/stream", consumes = MediaType.MULTIPART_FORM_DATA, produces = MediaType.TEXT_PLAIN)
HttpResponse<String> streamingUpload(StreamingFileUpload fileUpload) {
    UploadRequest objectStorageUpload = UploadRequest.fromStreamingFileUpload(fileUpload, "uploads/${fileUpload.filename}")
    UploadResponse<PutObjectResponse> response = objectStorage.upload(objectStorageUpload)
    return HttpResponse
            .created(response.key)
            .header("ETag", response.getNativeResponse().eTag())
}

public Optional<Path> retrieveProfilePicture(String userId, String fileName) {
    Path destination = null;
    try {
        String key = userId + "/" + fileName;
        Optional<InputStream> stream = objectStorage.retrieve(key) // (1)
            .map(ObjectStorageEntry::getInputStream);
        if (stream.isPresent()) {
            destination = File.createTempFile(userId, "temp").toPath();
            Files.copy(stream.get(), destination, StandardCopyOption.REPLACE_EXISTING);
            return Optional.of(destination);
        } else {
            return Optional.empty();
        }
    } catch (IOException e) {
        LOG.error("Error while trying to save profile picture to the local file [{}]: {}", destination, e.getMessage());
        return Optional.empty();
    }
}

open fun retrieveProfilePicture(userId: String, fileName: String): Path? {
    val key = "$userId/$fileName"
    val stream = objectStorage.retrieve<ObjectStorageEntry<*>>(key) // (1)
        .map { obj: ObjectStorageEntry<*> -> obj.inputStream }

    return if (stream.isPresent) {
        val destination = File.createTempFile(userId, "temp").toPath()
        Files.copy(stream.get(), destination, StandardCopyOption.REPLACE_EXISTING)
        destination
    } else {
        null
    }
}

Optional<Path> retrieveProfilePicture(String userId, String fileName) {
    String key = "${userId}/${fileName}"
    Optional<InputStream> stream = objectStorage.retrieve(key) // (1)
            .map(ObjectStorageEntry::getInputStream)
    if (stream.isPresent()) {
        Path destination = File.createTempFile(userId, "temp").toPath()
        Files.copy(stream.get(), destination, StandardCopyOption.REPLACE_EXISTING)
        return Optional.of(destination)
    } else {
        return Optional.empty()
    }
}

public void deleteProfilePicture(String userId, String fileName) {
    String key = userId + "/" + fileName;
    objectStorage.delete(key); // (1)
}

open fun deleteProfilePicture(userId: String, fileName: String) {
    val key = "$userId/$fileName"
    objectStorage.delete(key) // (1)
}

void deleteProfilePicture(String userId, String fileName) {
    String key = "${userId}/${fileName}"
    objectStorage.delete(key) // (1)
}

@Post(uri = "/signed", consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON)
public HttpResponse<PresignedUploadResponse> create(@Body CreateUploadCommand command) {
    CreatePresignedUploadRequest request =
        new CreatePresignedUploadRequest("profiles/" + command.userId() + ".png", Duration.ofMinutes(5)); // (1)
    request.setContentType(MediaType.IMAGE_PNG);
    request.setMetadata(Map.of("owner", command.userId()));

    PresignedUpload signedUpload = objectStorage.createPresignedUpload(request)
        .orElseThrow(() -> new IllegalStateException("This provider does not support pre-signed uploads"));

    return HttpResponse.ok(new PresignedUploadResponse( // (2)
        signedUpload.getUri().toString(),
        signedUpload.getMethod(),
        signedUpload.getHeaders(),
        signedUpload.getExpiration()
    ));
}

@Post(uri = "/signed", consumes = [MediaType.APPLICATION_JSON], produces = [MediaType.APPLICATION_JSON])
open fun create(@Body command: CreateUploadCommand): HttpResponse<PresignedUploadResponse> {
    val request = CreatePresignedUploadRequest("profiles/${command.userId}.png", Duration.ofMinutes(5)) // (1)
    request.setContentType(MediaType.IMAGE_PNG)
    request.setMetadata(mapOf("owner" to command.userId))

    val signedUpload = objectStorage.createPresignedUpload(request)
        .orElseThrow { IllegalStateException("This provider does not support pre-signed uploads") }

    return HttpResponse.ok(
        PresignedUploadResponse( // (2)
            signedUpload.uri.toString(),
            signedUpload.method,
            signedUpload.headers,
            signedUpload.expiration
        )
    )
}

@Post(uri = '/signed', consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON)
HttpResponse<PresignedUploadResponse> create(@Body CreateUploadCommand command) {
    CreatePresignedUploadRequest request =
        new CreatePresignedUploadRequest("profiles/${command.userId}.png", Duration.ofMinutes(5)) // (1)
    request.contentType = MediaType.IMAGE_PNG
    request.metadata = [owner: command.userId]

    PresignedUpload signedUpload = objectStorage.createPresignedUpload(request)
        .orElseThrow(() -> new IllegalStateException('This provider does not support pre-signed uploads'))

    HttpResponse.ok(new PresignedUploadResponse( // (2)
        signedUpload.uri.toString(),
        signedUpload.method,
        signedUpload.headers,
        signedUpload.expiration
    ))
}

public void listProfilePicturesByPage(String userId) {
    String prefix = userId + "/"; // raw prefix filtering
    String continuation = null;
    do {
        ListObjectsRequest request = new ListObjectsRequest(2, prefix, continuation); // (1)
        ListObjectsResponse response = objectStorage.listObjects(request);

        // Process the keys in this page
        response.getKeys().forEach(key -> System.out.println("Found: " + key)); // (2)

        // Replay the continuation token returned by the provider for the next page
        continuation = response.getContinuationToken().orElse(null); // (3)
    } while (continuation != null);
}

open fun listProfilePicturesByPage(userId: String) {
    val prefix = "$userId/" // raw prefix filtering
    var continuation: String? = null
    do {
        val request = ListObjectsRequest(2, prefix, continuation) // (1)
        val response: ListObjectsResponse = objectStorage.listObjects(request)

        // Process the keys in this page
        response.keys.forEach { key -> println("Found: $key") } // (2)

        // Replay the continuation token returned by the provider for the next page
        continuation = response.continuationToken.orElse(null) // (3)
    } while (continuation != null)
}

void listProfilePicturesByPage(String userId) {
    String prefix = userId + "/" // raw prefix filtering
    String continuation = null
    do {
        ListObjectsRequest request = new ListObjectsRequest(2, prefix, continuation) // (1)
        ListObjectsResponse response = objectStorage.listObjects(request)

        // Process the keys in this page
        response.keys.forEach { key -> println("Found: $key") } // (2)

        // Replay the continuation token returned by the provider for the next page
        continuation = response.continuationToken.orElse(null) // (3)
    } while (continuation != null)
}

@Singleton
public class BucketService {

    private final BucketOperations<?> bucketOperations;
    private final ReactiveBucketOperations<?> reactiveBucketOperations;

    public BucketService(@Named("default") BucketOperations<?> bucketOperations,
                         @Named("default") ReactiveBucketOperations<?> reactiveBucketOperations) {
        this.bucketOperations = bucketOperations;
        this.reactiveBucketOperations = reactiveBucketOperations;
    }

}

@Singleton
open class BucketService(
    @param:Named("default") private val bucketOperations: BucketOperations<*>,
    @param:Named("default") private val reactiveBucketOperations: ReactiveBucketOperations<*>
) {

}

@Singleton
class BucketService {

    final BucketOperations<?> bucketOperations
    final ReactiveBucketOperations<?> reactiveBucketOperations

    BucketService(@Named("default") BucketOperations<?> bucketOperations,
                  @Named("default") ReactiveBucketOperations<?> reactiveBucketOperations) {
        this.bucketOperations = bucketOperations
        this.reactiveBucketOperations = reactiveBucketOperations
    }

}

public void manageBucket(String name) {
    bucketOperations.create(name);
    boolean exists = bucketOperations.exists(name);
    bucketOperations.retrieve(name).ifPresent(bucket -> {
        System.out.println(bucket.name());
    });
    if (exists) {
        bucketOperations.delete(name);
    }
}

open fun manageBucket(name: String) {
    bucketOperations.create(name)
    val exists = bucketOperations.exists(name)
    bucketOperations.retrieve(name).ifPresent { bucket -> println(bucket.name()) }
    if (exists) {
        bucketOperations.delete(name)
    }
}

void manageBucket(String name) {
    bucketOperations.create(name)
    boolean exists = bucketOperations.exists(name)
    bucketOperations.retrieve(name).ifPresent { bucket -> println(bucket.name()) }
    if (exists) {
        bucketOperations.delete(name)
    }
}

public void manageBucketReactive(String name) {
    Publisher<Void> create = reactiveBucketOperations.create(name);
    Publisher<Boolean> exists = reactiveBucketOperations.exists(name);
}

open fun manageBucketReactive(name: String) {
    val create: Publisher<Void> = reactiveBucketOperations.create(name)
    val exists: Publisher<Boolean> = reactiveBucketOperations.exists(name)
}

void manageBucketReactive(String name) {
    Publisher<Void> create = reactiveBucketOperations.create(name)
    Publisher<Boolean> exists = reactiveBucketOperations.exists(name)
}