Struct freedesktop_desktop_entry::DesktopEntry

pub struct DesktopEntry<'a> {
    pub appid: Cow<'a, str>,
    pub groups: Groups<'a>,
    pub path: Cow<'a, Path>,
    pub ubuntu_gettext_domain: Option<Cow<'a, str>>,
}

Fields

appid: Cow<'a, str>

groups: Groups<'a>

path: Cow<'a, Path>

ubuntu_gettext_domain: Option<Cow<'a, str>>

Implementations

impl<'a> DesktopEntry<'a>

pub fn from_str<L>( path: &'a Path, input: &'a str, locales: &[L], ) -> Result<DesktopEntry<'a>, DecodeError>

where L: AsRef<str>,

Examples found in repository

examples/all_files.rs (line 16)

fn main() {
    let locales = get_languages_from_env();

    for path in Iter::new(default_paths()) {
        let path_src = PathSource::guess_from(&path);
        if let Ok(bytes) = fs::read_to_string(&path) {
            if let Ok(entry) = DesktopEntry::from_str(&path, &bytes, &locales) {
                println!("{:?}: {}\n---\n{}", path_src, path.display(), entry);
            }
        }
    }
}

examples/bench.rs (line 29)

fn bench_borrowed(it: u32) {
    let mut total_time = Duration::ZERO;

    for _ in 0..it {
        let locale = get_languages_from_env();
        let paths = Iter::new(default_paths());

        let now = Instant::now();

        for path in paths {
            if let Ok(bytes) = fs::read_to_string(&path) {
                if let Ok(_entry) = DesktopEntry::from_str(&path, &bytes, &locale) {}
            }
        }

        total_time += now.elapsed();
    }

    println!("bench_borrowed: {:.2?}", total_time / it);
}

pub fn from_paths<'i, 'l: 'i, L>( paths: impl Iterator<Item = PathBuf> + 'i, locales: &'l [L], ) -> impl Iterator<Item = Result<DesktopEntry<'static>, DecodeError>> + 'i

where L: AsRef<str>,

Examples found in repository

examples/bench.rs (line 67)

fn bench_owned_optimized(it: u32) {
    let mut total_time = Duration::ZERO;

    for _ in 0..it {
        let locale = get_languages_from_env();
        let paths = Iter::new(default_paths());

        let now = Instant::now();

        let _ = DesktopEntry::from_paths(paths, &locale)
            .filter_map(|e| e.ok())
            .collect::<Vec<_>>();

        total_time += now.elapsed();
    }

    println!("bench_owned_optimized: {:.2?}", total_time / it);
}

pub fn from_path<L>( path: PathBuf, locales: &[L], ) -> Result<DesktopEntry<'static>, DecodeError>

where L: AsRef<str>,

Return an owned DesktopEntry

Examples found in repository

examples/bench.rs (line 49)

fn bench_owned(it: u32) {
    let mut total_time = Duration::ZERO;

    for _ in 0..it {
        let locale = get_languages_from_env();
        let paths = Iter::new(default_paths());

        let now = Instant::now();

        for path in paths {
            if let Ok(_entry) = DesktopEntry::from_path(path, &locale) {}
        }

        total_time += now.elapsed();
    }

    println!("bench_owned: {:.2?}", total_time / it);
}

examples/specific_file.rs (line 15)

fn main() {
    let path = Path::new("tests/org.mozilla.firefox.desktop");
    let locales = &["fr_FR", "en", "it"];

    // if let Ok(bytes) = fs::read_to_string(path) {
    //     if let Ok(entry) = DesktopEntry::decode_from_str(path, &bytes, locales) {
    //         println!("{}\n---\n{}", path.display(), entry);
    //     }
    // }

    if let Ok(entry) = DesktopEntry::from_path(path.to_path_buf(), locales) {
        println!("{}\n---\n{}", path.display(), entry);
    }
}

impl DesktopEntry<'_>

pub fn from_appid(appid: &str) -> DesktopEntry<'_>

Construct a new DesktopEntry from an appid. The name field will be set to that appid.

impl<'a> DesktopEntry<'a>

pub fn to_owned(&self) -> DesktopEntry<'static>

impl<'a> DesktopEntry<'a>

pub fn id(&'a self) -> &'a str

pub fn desktop_entry(&'a self, key: &str) -> Option<&'a str>

A desktop entry field if any field under the [Desktop Entry] section.

pub fn desktop_entry_localized<L: AsRef<str>>( &'a self, key: &str, locales: &[L], ) -> Option<Cow<'a, str>>

pub fn add_desktop_entry<'b>(&'b mut self, key: &'a str, value: &'a str)

where 'a: 'b,

Insert a new field to this DesktopEntry, in the [Desktop Entry] section, removing the previous value and locales in any.

pub fn name<L: AsRef<str>>(&'a self, locales: &[L]) -> Option<Cow<'a, str>>

pub fn generic_name<L: AsRef<str>>( &'a self, locales: &[L], ) -> Option<Cow<'a, str>>

pub fn icon(&'a self) -> Option<&'a str>

pub fn comment<L: AsRef<str>>(&'a self, locales: &[L]) -> Option<Cow<'a, str>>

This is an human readable description of the desktop file.

pub fn exec(&'a self) -> Option<&'a str>

pub fn categories(&'a self) -> Option<Vec<&'a str>>

Return categories

pub fn keywords<L: AsRef<str>>( &'a self, locales: &[L], ) -> Option<Vec<Cow<'a, str>>>

Return keywords

pub fn mime_type(&'a self) -> Option<Vec<&'a str>>

Return mime types

pub fn no_display(&'a self) -> bool

pub fn only_show_in(&'a self) -> Option<Vec<&'a str>>

pub fn not_show_in(&'a self) -> Option<Vec<&'a str>>

pub fn flatpak(&'a self) -> Option<&'a str>

pub fn prefers_non_default_gpu(&'a self) -> bool

pub fn startup_notify(&'a self) -> bool

pub fn startup_wm_class(&'a self) -> Option<&'a str>

pub fn terminal(&'a self) -> bool

pub fn type_(&'a self) -> Option<&'a str>

pub fn actions(&'a self) -> Option<Vec<&'a str>>

pub fn action_entry(&'a self, action: &str, key: &str) -> Option<&'a str>

An action is defined as [Desktop Action actions-name] where action-name is defined in the Actions field of [Desktop Entry]. Example: to get the Name field of this new-window action

[Desktop Action new-window]
Name=Open a New Window

you will need to call

entry.action_entry("new-window", "Name")

pub fn action_entry_localized<L: AsRef<str>>( &'a self, action: &str, key: &str, locales: &[L], ) -> Option<Cow<'a, str>>

pub fn action_name<L: AsRef<str>>( &'a self, action: &str, locales: &[L], ) -> Option<Cow<'a, str>>

pub fn action_exec(&'a self, action: &str) -> Option<&'a str>

pub fn localized_entry_splitted<L: AsRef<str>>( &self, group: Option<&'a KeyMap<'a>>, key: &str, locales: &[L], ) -> Option<Vec<Cow<'a, str>>>

Trait Implementations

impl<'a> Clone for DesktopEntry<'a>

fn clone(&self) -> DesktopEntry<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for DesktopEntry<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Display for DesktopEntry<'a>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for DesktopEntry<'_>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for DesktopEntry<'_>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for DesktopEntry<'a>