Struct SearchList 

pub struct SearchList { /* private fields */ }

request struct for the search endpoint

Implementations

impl SearchList

pub fn new(key: ApiKey) -> Self

create struct with an ApiKey

Examples found in repository

examples/complex_search.rs (line 15)

fn main() -> Result<(), Error> {
	futures::executor::block_on(async {
		// take api key from enviroment variable
		let key = ApiKey::new(&env::var("YT_API_KEY").expect("YT_API_KEY env-var not found"));

		// create the SearchList struct for the query "rust lang"
		let result = SearchList::new(key)
			.q("rust lang")
			.max_results(1)
			.item_type(ItemType::Video)
			.location(VideoLocation::new(40.73061, -73.93524))
			.location_radius("100km")
			.video_embeddable()
			.await?;

		// outputs the video_id of the first search result
		println!(
			"Title: \"{}\"",
			result.items[0].snippet.title.as_ref().unwrap()
		);
		println!(
			"https://youtube.com/watch?v={}",
			result.items[0].id.video_id.as_ref().unwrap()
		);

		Ok(())
	})
}

examples/search.rs (line 15)

fn main() -> Result<(), Error> {
	futures::executor::block_on(async {
		// take api key from enviroment variable
		let key = ApiKey::new(&env::var("YT_API_KEY").expect("YT_API_KEY env-var not found"));

		// create the SearchList struct for the query "rust lang"
		let result = SearchList::new(key)
			.q("rust lang")
			.item_type(ItemType::Video)
			.await?;

		// outputs the title of the first search result
		println!(
			"Title: \"{}\"",
			result.items[0].snippet.title.as_ref().unwrap()
		);
		// outputs the video id of the first search result
		println!(
			"https://youtube.com/watch?v={}",
			result.items[0].id.video_id.as_ref().unwrap()
		);

		println!(
			"Default thumbnail: {}",
			result.items[0]
				.snippet
				.thumbnails
				.as_ref()
				.unwrap()
				.default
				.as_ref()
				.unwrap()
				.url
		);

		Ok(())
	})
}

pub fn for_content_owner(self) -> Self

pub fn for_developer(self) -> Self

pub fn for_mine(self) -> Self

pub fn related_to_video_id(self, related_to_video_id: impl Into<String>) -> Self

pub fn channel_id(self, channel_id: impl Into<String>) -> Self

pub fn channel_type(self, channel_type: impl Into<ChannelType>) -> Self

pub fn event_type(self, event_type: impl Into<EventType>) -> Self

pub fn location(self, location: impl Into<VideoLocation>) -> Self

Examples found in repository

examples/complex_search.rs (line 19)

fn main() -> Result<(), Error> {
	futures::executor::block_on(async {
		// take api key from enviroment variable
		let key = ApiKey::new(&env::var("YT_API_KEY").expect("YT_API_KEY env-var not found"));

		// create the SearchList struct for the query "rust lang"
		let result = SearchList::new(key)
			.q("rust lang")
			.max_results(1)
			.item_type(ItemType::Video)
			.location(VideoLocation::new(40.73061, -73.93524))
			.location_radius("100km")
			.video_embeddable()
			.await?;

		// outputs the video_id of the first search result
		println!(
			"Title: \"{}\"",
			result.items[0].snippet.title.as_ref().unwrap()
		);
		println!(
			"https://youtube.com/watch?v={}",
			result.items[0].id.video_id.as_ref().unwrap()
		);

		Ok(())
	})
}

pub fn location_radius(self, location_radius: impl Into<String>) -> Self

Examples found in repository

examples/complex_search.rs (line 20)

fn main() -> Result<(), Error> {
	futures::executor::block_on(async {
		// take api key from enviroment variable
		let key = ApiKey::new(&env::var("YT_API_KEY").expect("YT_API_KEY env-var not found"));

		// create the SearchList struct for the query "rust lang"
		let result = SearchList::new(key)
			.q("rust lang")
			.max_results(1)
			.item_type(ItemType::Video)
			.location(VideoLocation::new(40.73061, -73.93524))
			.location_radius("100km")
			.video_embeddable()
			.await?;

		// outputs the video_id of the first search result
		println!(
			"Title: \"{}\"",
			result.items[0].snippet.title.as_ref().unwrap()
		);
		println!(
			"https://youtube.com/watch?v={}",
			result.items[0].id.video_id.as_ref().unwrap()
		);

		Ok(())
	})
}

pub fn max_results(self, max_results: impl Into<u8>) -> Self

Examples found in repository

examples/complex_search.rs (line 17)

fn main() -> Result<(), Error> {
	futures::executor::block_on(async {
		// take api key from enviroment variable
		let key = ApiKey::new(&env::var("YT_API_KEY").expect("YT_API_KEY env-var not found"));

		// create the SearchList struct for the query "rust lang"
		let result = SearchList::new(key)
			.q("rust lang")
			.max_results(1)
			.item_type(ItemType::Video)
			.location(VideoLocation::new(40.73061, -73.93524))
			.location_radius("100km")
			.video_embeddable()
			.await?;

		// outputs the video_id of the first search result
		println!(
			"Title: \"{}\"",
			result.items[0].snippet.title.as_ref().unwrap()
		);
		println!(
			"https://youtube.com/watch?v={}",
			result.items[0].id.video_id.as_ref().unwrap()
		);

		Ok(())
	})
}

pub fn on_behalf_of_content_owner( self, on_behalf_of_content_owner: impl Into<String>, ) -> Self

pub fn order(self, order: impl Into<Order>) -> Self

pub fn page_token(self, page_token: impl Into<String>) -> Self

pub fn published_after(self, published_after: impl Into<DateTime<Utc>>) -> Self

pub fn published_before( self, published_before: impl Into<DateTime<Utc>>, ) -> Self

pub fn q(self, q: impl Into<String>) -> Self

Examples found in repository

examples/complex_search.rs (line 16)

fn main() -> Result<(), Error> {
	futures::executor::block_on(async {
		// take api key from enviroment variable
		let key = ApiKey::new(&env::var("YT_API_KEY").expect("YT_API_KEY env-var not found"));

		// create the SearchList struct for the query "rust lang"
		let result = SearchList::new(key)
			.q("rust lang")
			.max_results(1)
			.item_type(ItemType::Video)
			.location(VideoLocation::new(40.73061, -73.93524))
			.location_radius("100km")
			.video_embeddable()
			.await?;

		// outputs the video_id of the first search result
		println!(
			"Title: \"{}\"",
			result.items[0].snippet.title.as_ref().unwrap()
		);
		println!(
			"https://youtube.com/watch?v={}",
			result.items[0].id.video_id.as_ref().unwrap()
		);

		Ok(())
	})
}

examples/search.rs (line 16)

fn main() -> Result<(), Error> {
	futures::executor::block_on(async {
		// take api key from enviroment variable
		let key = ApiKey::new(&env::var("YT_API_KEY").expect("YT_API_KEY env-var not found"));

		// create the SearchList struct for the query "rust lang"
		let result = SearchList::new(key)
			.q("rust lang")
			.item_type(ItemType::Video)
			.await?;

		// outputs the title of the first search result
		println!(
			"Title: \"{}\"",
			result.items[0].snippet.title.as_ref().unwrap()
		);
		// outputs the video id of the first search result
		println!(
			"https://youtube.com/watch?v={}",
			result.items[0].id.video_id.as_ref().unwrap()
		);

		println!(
			"Default thumbnail: {}",
			result.items[0]
				.snippet
				.thumbnails
				.as_ref()
				.unwrap()
				.default
				.as_ref()
				.unwrap()
				.url
		);

		Ok(())
	})
}

pub fn region_code(self, region_code: impl Into<String>) -> Self

pub fn relevance_language(self, relevance_language: impl Into<String>) -> Self

pub fn safe_search(self, safe_search: impl Into<SafeSearch>) -> Self

pub fn topic_id(self, topic_id: impl Into<String>) -> Self

pub fn item_type(self, item_type: impl Into<ItemType>) -> Self

Examples found in repository

examples/complex_search.rs (line 18)

fn main() -> Result<(), Error> {
	futures::executor::block_on(async {
		// take api key from enviroment variable
		let key = ApiKey::new(&env::var("YT_API_KEY").expect("YT_API_KEY env-var not found"));

		// create the SearchList struct for the query "rust lang"
		let result = SearchList::new(key)
			.q("rust lang")
			.max_results(1)
			.item_type(ItemType::Video)
			.location(VideoLocation::new(40.73061, -73.93524))
			.location_radius("100km")
			.video_embeddable()
			.await?;

		// outputs the video_id of the first search result
		println!(
			"Title: \"{}\"",
			result.items[0].snippet.title.as_ref().unwrap()
		);
		println!(
			"https://youtube.com/watch?v={}",
			result.items[0].id.video_id.as_ref().unwrap()
		);

		Ok(())
	})
}

examples/search.rs (line 17)

fn main() -> Result<(), Error> {
	futures::executor::block_on(async {
		// take api key from enviroment variable
		let key = ApiKey::new(&env::var("YT_API_KEY").expect("YT_API_KEY env-var not found"));

		// create the SearchList struct for the query "rust lang"
		let result = SearchList::new(key)
			.q("rust lang")
			.item_type(ItemType::Video)
			.await?;

		// outputs the title of the first search result
		println!(
			"Title: \"{}\"",
			result.items[0].snippet.title.as_ref().unwrap()
		);
		// outputs the video id of the first search result
		println!(
			"https://youtube.com/watch?v={}",
			result.items[0].id.video_id.as_ref().unwrap()
		);

		println!(
			"Default thumbnail: {}",
			result.items[0]
				.snippet
				.thumbnails
				.as_ref()
				.unwrap()
				.default
				.as_ref()
				.unwrap()
				.url
		);

		Ok(())
	})
}

pub fn video_caption(self, video_caption: impl Into<String>) -> Self

pub fn video_category_id(self, video_category_id: impl Into<String>) -> Self

pub fn video_definition( self, video_definition: impl Into<VideoDefinition>, ) -> Self

pub fn video_dimension(self, video_dimension: impl Into<VideoDimension>) -> Self

pub fn video_embeddable(self) -> Self

Examples found in repository

examples/complex_search.rs (line 21)

fn main() -> Result<(), Error> {
	futures::executor::block_on(async {
		// take api key from enviroment variable
		let key = ApiKey::new(&env::var("YT_API_KEY").expect("YT_API_KEY env-var not found"));

		// create the SearchList struct for the query "rust lang"
		let result = SearchList::new(key)
			.q("rust lang")
			.max_results(1)
			.item_type(ItemType::Video)
			.location(VideoLocation::new(40.73061, -73.93524))
			.location_radius("100km")
			.video_embeddable()
			.await?;

		// outputs the video_id of the first search result
		println!(
			"Title: \"{}\"",
			result.items[0].snippet.title.as_ref().unwrap()
		);
		println!(
			"https://youtube.com/watch?v={}",
			result.items[0].id.video_id.as_ref().unwrap()
		);

		Ok(())
	})
}

pub fn video_license(self, video_license: impl Into<VideoLicense>) -> Self

pub fn video_syndicated(self) -> Self

pub fn video_type(self, video_type: impl Into<VideoType>) -> Self

Trait Implementations

impl Future for SearchList

type Output = Result<Response, Error>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.