Struct django_query::filtering::OperatorSet

pub struct OperatorSet<R> { /* private fields */ }

A collection of filters for a particular type.

A OperatorSet can be created for any type which implements Filterable. Its constructor supplies a visitor to the type’s Meta type, and constructs the necessary FilterClass objects. It can be used directly to convert incoming query pairs from Django-style query URLs into appropriate Filter objects.

Implementations

impl<R: Filterable> OperatorSet<R>

pub fn new() -> Self

Create a new OperatorSet, by obtaining the Meta record from the target type, and visiting its fields and their operators.

pub fn create_filter(
    &self,
    field: &str,
    operator: Option<&str>,
    rhs: &str
) -> Result<Box<dyn Filter<R>>, FilterError>

Create a new filter from a decomposed URL. Note that the decomposition is ambiguous, so create_filter_from_query_pair is often preferable. The ambiguity arises because there may be no operator part, and the field part may have arbitrarily many parts. Since everything is separated with double underscores there is no way without additional information to distinguish an expression with an explicit operator from an expression on a nested field with an implicit operator. Here

• field is the field specification part of the string, including any nested fields.
• operator is the operator specification, if any.
• rhs is the argument part, after the = in the URL section.

pub fn create_filter_from_query_pair(
    &self,
    lhs: &str,
    rhs: &str
) -> Result<Box<dyn Filter<R>>, FilterError>

Create a new filter from a fragment of query URL. The expected input is a lhs=rhs pair from a query string, with lhs and rhs given separately. The output will either be an error, or a Filter which can apply the specified to test to objects of the target type, returning either true (include) or false (exclude).

pub fn create_filter_from_query(
    &self,
    expr: &str
) -> Result<Box<dyn Filter<R>>, FilterError>

Create a new filter from a fragment of query URL. The expected input is a lhs=rhs pair from a query string, with lhs and rhs given together in a single string. The output will either be an error, or a Filter which can apply the specified to test to objects of the target type, returning either true (include) or false (exclude).

Trait Implementations

impl<R: Filterable> Default for OperatorSet<R>

fn default() -> Self

Returns the “default value” for a type.

impl<R> MetaVisitor<R> for OperatorSet<R>

fn visit_member<F, O, T>(&mut self, name: &str, field: &F, defop: O) where
    F: Member<R, Value = T> + Clone + 'static,
    O: OperatorClass<<T as Operable>::Base> + 'static,
    <O as OperatorClass<<T as Operable>::Base>>::Instance: 'static,
    T: Operable, 

This should be called by Meta for each exposed structure field which is Operable. Here:

fn visit_record<F, T, U>(&mut self, name: &str, field: &F, inner_record: &T) where
    F: Field<R, Value = U> + Clone + 'static,
    T: Meta<U> + 'static,
    U: 'static, 

This should be called by Meta for each exposed structure field which can be traversed, that is where the type of the field is itself a structured type, for example when modelling foreign keys. Here: