Struct 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("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

Implementations

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<T: ToString>(query: T) -> Self

Convenience method to create a new WorksQuery with a term directly

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

add a new free form query

pub fn query<T: ToString>(self, query: T) -> 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::default().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::default().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

pub fn into_combined<W: WorksCombiner>(self, id: &str) -> W

Wrap the query in a combined query.

Example

Create a Funders Query that targets all works of a funder with id funder id.

let funders: Funders = WorksQuery::default().into_combined("funder id");

pub fn into_ident(self, id: &str) -> WorksIdentQuery

Bind the query to a specific id of a primary endpoint element

pub fn into_combined_query<W: WorksCombiner>(self, id: &str) -> WorkListQuery

wrap this query in new WorkListQuery that targets the /works route of a primary component with an id. The query will evaluate to the same as [into_combined]

Example

Create a query that targets all Works of a funder with id funder id

let query = WorksQuery::default()
    .into_combined_query::<Funders>("funder id");

Trait Implementations

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 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 Debug for WorksQuery

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

Formats the value using the given formatter.

impl Default for WorksQuery

fn default() -> WorksQuery

Returns the “default value” for a type.

impl Into<WorkListQuery> for WorksQuery

fn into(self) -> WorkListQuery

Converts this type into the (usually inferred) input type.