Struct crossref::WorksQuery

pub struct WorksQuery {
    pub free_form_queries: Vec<String>,
    pub field_queries: Vec<FieldQuery>,
    pub filter: Vec<WorksFilter>,
    pub sort: Option<Sort>,
    pub order: Option<Order>,
    pub facets: Vec<FacetCount>,
    pub result_control: Option<WorkResultControl>,
    pub sample: Option<usize>,
}

Used to construct a query that targets crossref Works elements

Example

use crossref::{Order, WorksQuery};

// create a new query for topcis machine+learning ordered desc
let query = WorksQuery::new().query("machine learning").order(Order::Desc);

Each query parameter is ANDed

Fields

free_form_queries: Vec<String>

search by non specific query

field_queries: Vec<FieldQuery>

match only particular fields of metadata

filter: Vec<WorksFilter>

filter to apply while querying

sort: Option<Sort>

sort results by a certain field and

order: Option<Order>

set the sort order to asc or desc

facets: Vec<FacetCount>

enable facet information in responses

result_control: Option<WorkResultControl>

deep page through /works result sets

sample: Option<usize>

request random dois if set all other parameters are ignored

Methods

impl WorksQuery

pub fn empty() -> Self

alias for creating an empty default element

pub fn random(len: usize) -> Self

creates an new WorksQuery with the desired sample size that will result in a request for random dois

pub fn new() -> Self

alias for creating an new default element

pub fn sample(self, len: usize) -> Self

add a new free form query

pub fn query(self, query: &str) -> Self

add a new free form query

pub fn queries<T: ToString>(self, queries: &[T]) -> Self

Create a new query for the topics renear+ontologies

Example

use crossref::WorksQuery;

let query = WorksQuery::new().queries(&["renear", "ontologies"]);

add a bunch of free form query terms

pub fn field_query(self, query: FieldQuery) -> Self

add a new field query form query

pub fn field_queries(self, queries: Vec<FieldQuery>) -> Self

use crossref::{FieldQuery,WorksQuery};

let query = WorksQuery::new().field_queries(vec![FieldQuery::title("room at the bottom"), FieldQuery::author("richard feynman")]);

add a bunch of free form query terms

pub fn filter(self, filter: WorksFilter) -> Self

add a new filter to the query

pub fn sort(self, sort: Sort) -> Self

set sort option to the query

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

set order option to query

pub fn facet(self, facet: FacetCount) -> Self

add another facet to query

pub fn next_cursor(self, cursor: &str) -> Self

set the cursor for result control deep paging

pub fn new_cursor(self) -> Self

set an empty cursor

pub fn result_control(self, result_control: WorkResultControl) -> Self

set result control option to query

Trait Implementations

impl CrossrefParams for WorksQuery

type Filter = WorksFilter

the filter applied

fn query_terms(&self) -> &[String]

all string queries

fn filters(&self) -> &[Self::Filter]

the filters this object can use

fn sort(&self) -> Option<&Sort>

the sort if set

fn order(&self) -> Option<&Order>

the order if set

fn facets(&self) -> &[FacetCount]

all facets this objects addresses

fn result_control(&self) -> Option<&ResultControl>

the configured result control, if any

impl CrossrefRoute for WorksQuery

fn route(&self) -> Result<String>

constructs the route for the crossref api

impl Default for WorksQuery

fn default() -> WorksQuery

Returns the "default value" for a type.

impl Clone for WorksQuery

fn clone(&self) -> WorksQuery

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for WorksQuery

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

Formats the value using the given formatter.

impl Serialize for WorksQuery

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for WorksQuery

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.