MediaType is a library that can be used to create Media Types in a type-safe manner.
Mainly intended – although not limited – to be used in server-side Swift applications.
Media types are represented by the MediaType Swift type.
You can create a media type in a type-safe manner using one of the possible cases. You can also create media type instances simply by using string literals.
let mediaType: MediaType = "application/json" // is equivalent to
MediaType.application(.json())It is also possible to create a MediaType instance from a string variable as shown in the following example.
let rawMediaType = "application/json"
let mediaType = MediaType(rawValue: rawMediaType)Media type Suffixes and Parameters are supported both via string literals and MediaType cases.
let mediaType: MediaType = "application/atom; charset=utf-8" // is equivalent to
MediaType.application(.atom(nil, ["charset": "utf-8"]))
let mediaType: MediaType = "application/atom+xml" // is equivalent to
MediaType.application(.atom(.xml))
let mediaType: MediaType = "application/atom+xml; charset=utf-8" // is equivalent to
MediaType.application(.atom(.xml, ["charset": "utf-8"]))You can create media type trees by using either the string literal syntax, or using the other case of a particular
media type.
let mediaType: MediaType = "application/vnd.efi.img" // is equivalent to
MediaType.application(.other("vnd.efi.img"))Using this library you can create all the registered media types. The library is versatile enough to allow you to create practically any media type, even ones that are not registered. A few examples of such cases:
let image: MediaType = "image/svg+gzip" // is equivalent to
MediaType.image(.svg(.gzip))
let application: MediaType = "application/myApp+json" // is equivalent to
MediaType.application(.other("myApp", .json))You can use regular switch statements to test for media types and get access to their components. The following example
shows various ways to treat a media type.
func isSupported(_ mediaType: MediaType) -> Bool {
switch mediaType {
case .application(.json(_, _)): return true
case .application(.atom("xml", _)): return true
case .application(let subtype):
switch subtype {
case .xml(_, _): return true
default: return false
}
default: return false
}
}
isSupported("application/json") // Returns: true
isSupported("application/json+xml") // Returns: true
isSupported("application/json;charset=utf-8") // Returns: true
isSupported("application/json+xml;charset=utf-8") // Returns: true
isSupported("application/atom+xml") // Returns: true
isSupported("application/atom+xml;charset=utf-8") // Returns: true
isSupported("application/atom") // Returns: false
isSupported("application/atom;charset=utf-8") // Returns: falseSince MediaType conforms to
the CustomStringConvertible protocol it is
pretty straightforward to turn an instance into a string.
You can either call the MediaType/description computed property or simply embed an instance into an interpolated
string.
For example, you can request the list of available products in JSON from an imaginary store.
var request = URLRequest(url: URL(string: "https://example-store.com/products")!)
let contentType: MediaType = "application/json"
// The following two statements are equivalent
request.setValue("Content-Type", forHTTPHeaderField: "\(contentType)")
request.setValue("Content-Type", forHTTPHeaderField: contentType.description)
let (_, response) = try await URLSession.shared.data(for: request)Media Types are Hashable
This means you can use MediaTypes in sets or dictionaries. For example, you can define the type of images your
application supports like so:
let supportedImages: Set<MediaType> = ["image/png", "image/gif", "image/jpeg"]You can also compare media type for equality using the MediaType/==(lhs:rhs:) operator.
func canHandle(response: URLResponse) -> Bool {
guard let mimeType = response.mimeType else { return false }
let mediaType = MediaType(rawValue: mimeType)
return mediaType == .application(.json())
}