Struct SearchRequest

Source

pub struct SearchRequest<'a> {
    pub query: &'a str,
    pub order_by: OrderBy,
    pub categories: Vec<Category>,
    pub number_of_results: usize,
}

Expand description

Represents a search request to be sent to torrent providers.

Fields§

§query: &'a str

The query string to search for.

§order_by: OrderBy

The order by which results are sorted.

§categories: Vec<Category>

Categories to filter results by. Empty means all categories are searched.

§number_of_results: usize

The number of results to retrieve.

Implementations§

Source §

impl<'a> SearchRequest<'a>

Source

pub fn new(query: &'a str) -> Self

Creates a new SearchRequest with the specified query.

Remaining fields get the following default values:

order_by: OrderBy::Seeders
categories: An empty Vec<Category>
number_of_results: 50

§Parameters

query: The search term or phrase.

§Returns

A new SearchRequest instance.

§Example

use magneto::SearchRequest;

let request = SearchRequest::new("example query");

Examples found in repository ?

examples/search.rs (line 9)

4async fn main() {
5    // Only use Knaben provider
6    let magneto = Magneto::default().add_provider(Box::new(Knaben::new()));
7
8    // You can add categories which your search are filtered by.
9    let request = SearchRequest::new("Ubuntu")
10        .add_category(Category::Software)
11        .add_categories(vec![Category::Audio, Category::Movies]);
12
13    // Or initialize the request like this for more customization.
14    let _request = SearchRequest {
15        query: "Debian",
16        order_by: OrderBy::Seeders,
17        categories: vec![Category::Movies],
18        number_of_results: 10,
19    };
20
21    match magneto.search(request).await {
22        Ok(results) => {
23            for torrent in results {
24                println!(
25                    "found: {} from {} with magnet link {} (seeders: {}, peers: {})",
26                    torrent.name,
27                    torrent.provider,
28                    torrent.magnet_link,
29                    torrent.seeders,
30                    torrent.peers,
31                );
32            }
33        }
34        Err(e) => eprintln!("error during search: {:?}", e),
35    }
36}

Source

pub fn add_category(self, category: Category) -> Self

Adds a single category to the SearchRequest.

This method consumes the current instance and returns a new SearchRequest with the added category.

§Parameters

category: The Category to add.

§Returns

Self: A new SearchRequest instance with the updated category.

§Example

use magneto::{Category, SearchRequest};

let request = SearchRequest::new("example query")
    .add_category(Category::Movies)
    .add_category(Category::Movies); // duplicates are filtered
assert_eq!(request.categories, vec![Category::Movies]);

Examples found in repository ?

examples/search.rs (line 10)

4async fn main() {
5    // Only use Knaben provider
6    let magneto = Magneto::default().add_provider(Box::new(Knaben::new()));
7
8    // You can add categories which your search are filtered by.
9    let request = SearchRequest::new("Ubuntu")
10        .add_category(Category::Software)
11        .add_categories(vec![Category::Audio, Category::Movies]);
12
13    // Or initialize the request like this for more customization.
14    let _request = SearchRequest {
15        query: "Debian",
16        order_by: OrderBy::Seeders,
17        categories: vec![Category::Movies],
18        number_of_results: 10,
19    };
20
21    match magneto.search(request).await {
22        Ok(results) => {
23            for torrent in results {
24                println!(
25                    "found: {} from {} with magnet link {} (seeders: {}, peers: {})",
26                    torrent.name,
27                    torrent.provider,
28                    torrent.magnet_link,
29                    torrent.seeders,
30                    torrent.peers,
31                );
32            }
33        }
34        Err(e) => eprintln!("error during search: {:?}", e),
35    }
36}

Source

pub fn add_categories(self, categories: Vec<Category>) -> Self

Adds multiple categories to the SearchRequest.

This method consumes the current instance and returns a new SearchRequest with the added categories.

§Parameters

categories: A vector of Category values to add.

§Returns

Self: A new SearchRequest instance with the updated categories.

§Example

use magneto::{Category, SearchRequest};

let request = SearchRequest::new("example query").add_categories(vec![
    Category::Movies,
    Category::Anime,
    Category::Anime, // duplicates are filtered
]);
assert_eq!(request.categories, vec![Category::Movies, Category::Anime]);

Examples found in repository ?

examples/search.rs (line 11)

4async fn main() {
5    // Only use Knaben provider
6    let magneto = Magneto::default().add_provider(Box::new(Knaben::new()));
7
8    // You can add categories which your search are filtered by.
9    let request = SearchRequest::new("Ubuntu")
10        .add_category(Category::Software)
11        .add_categories(vec![Category::Audio, Category::Movies]);
12
13    // Or initialize the request like this for more customization.
14    let _request = SearchRequest {
15        query: "Debian",
16        order_by: OrderBy::Seeders,
17        categories: vec![Category::Movies],
18        number_of_results: 10,
19    };
20
21    match magneto.search(request).await {
22        Ok(results) => {
23            for torrent in results {
24                println!(
25                    "found: {} from {} with magnet link {} (seeders: {}, peers: {})",
26                    torrent.name,
27                    torrent.provider,
28                    torrent.magnet_link,
29                    torrent.seeders,
30                    torrent.peers,
31                );
32            }
33        }
34        Err(e) => eprintln!("error during search: {:?}", e),
35    }
36}