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