1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
use headers::{ header_components::MediaType }; use ::{ iri::IRI }; #[cfg(feature="serde")] use serde::{Serialize, Deserialize}; /// POD containing the IRI which should be used to laod a resource well as /// an optional file name to use and a description about how the content type /// should be handled. #[derive(Debug, Clone)] #[cfg_attr(feature="serde", derive(Serialize, Deserialize))] pub struct Source { /// A International Resource Identifier pointing to a source /// from which the Resource can be loaded. Note that the interpretation /// of the IRI is left to the `ResourceLoader` implementation of the /// context. The `ResourceLoader` can decide to reject valid IRI's e.g. /// a (non local) http url is likely to be rejected by any implementation. pub iri: IRI, /// Allows specifying how the media type detection is done. #[cfg_attr(feature="serde", serde(default))] pub use_media_type: UseMediaType, /// Allows providing a explicit name overriding any inferred name. /// /// If a resource if loaded from a IRI it potentially can contain /// a inferred name e.g. for loading a file `secret_thing.png` it /// would be just that file name, but you potentially want to provide /// a name which differs from the name the file has in the file system /// in which case you can provide a name here. /// /// Note that file names are optional and don't need to be provided at all. /// But it is strongly recommended to provide them for anything used as /// attachment but normally irrelevant for anything else. #[cfg_attr(feature="serde", serde(default))] pub use_file_name: Option<String> } /// Specifies how the content type should be handled when loading the data. /// /// Depending on how the context implementation handles the loading it might /// already have a content type, but if not it might also need to "sniff" it, /// which can fail. Nevertheless how any of the aspects are handled in detail /// depends on the context implementation. /// #[derive(Debug, Clone)] #[cfg_attr(feature="serde", derive(Serialize, Deserialize))] pub enum UseMediaType { /// Sniff content type if no content type was given from any other place. Auto, /// Use this content type if no content type was given from any other place. /// /// As resources are loaded by IRI they could be loaded from any place and /// this place could be storing the data with the right content type, in which /// case that content type should be used. Default(MediaType), // /// Always use this content type even if it is known to have a different content type. // Override(MediaType) } impl Default for UseMediaType { fn default() -> Self { UseMediaType::Auto } }