Enum TrackRule 

pub enum TrackRule {
    Id {
        id: Vec<TrackId>,
        op: EqOp,
    },
    SourceDir {
        source_dir: Vec<PathBuf>,
        op: EqOp,
    },
    LibraryDir {
        library_dir: Vec<PathBuf>,
        op: EqOp,
    },
    Format {
        format: Vec<ContainerFormat>,
        op: EqOp,
    },
    Duration {
        duration: f64,
        op: OrdOp,
    },
    ChannelCount {
        count: usize,
        op: OrdOp,
    },
    Title {
        regex: Vec<String>,
        op: EqOp,
    },
    Single,
    Album {
        albums: Vec<AlbumId>,
        op: EqOp,
    },
    Artist {
        artists: Vec<ArtistId>,
        op: EqOp,
    },
    Date {
        date: DateTime<Utc>,
        op: OrdOp,
    },
    Genre {
        genres: Vec<String>,
        op: EqOp,
    },
    HasLyrics,
    HasSyncedLyrics,
    HasPlainLyrics,
    Instrumental,
    MetadataOther {
        key: String,
        value: Vec<String>,
        op: EqOp,
    },
}

Variants

Id

Succeeds if the track id matches the EqOp of the input ids

Fields

id: Vec<TrackId>

op: EqOp

SourceDir

Succeeds if the track source dir matches the EqOp of the input paths

Fields

source_dir: Vec<PathBuf>

op: EqOp

LibraryDir

Succeeds if the track library dir matches the EqOp of the input paths

Fields

library_dir: Vec<PathBuf>

op: EqOp

Format

Succeeds if the format matches the EqOp of the input formats

Fields

format: Vec<ContainerFormat>

op: EqOp

Duration

Succeeds if the track duration matches the OrdOp

Fields

duration: f64

op: OrdOp

ChannelCount

Succeeds if the track channel count matches the OrdOp

Fields

count: usize

op: OrdOp

Title

Succeeds if the track title DOES/DOES NOT match ALL/ANY of the input regexes

Fields

regex: Vec<String>

op: EqOp

Single

Succeeds if the track has no album

Album

Succeeds if the track album matches the EqOp of the input albums

Fields

albums: Vec<AlbumId>

op: EqOp

Artist

Succeeds if the track artists match the input artists using the EqOp

Fields

artists: Vec<ArtistId>

op: EqOp

Date

Succeeds if the track date matches the OrdOp

Fields

date: DateTime<Utc>

op: OrdOp

Genre

Succeeds if the track genres match the input genres using the EqOp

Fields

genres: Vec<String>

op: EqOp

HasLyrics

Succeeds if the track has any type of lyrics

HasSyncedLyrics

Succeeds if the track has synced lyrics

HasPlainLyrics

Succeeds if the track has plain lyrics

Instrumental

Succeeds if the track is instrumental

MetadataOther

Succeeds if the ‘other’ metadata at the given key matches the EqOp of the input value

Fields

key: String

value: Vec<String>

op: EqOp

Trait Implementations

impl Clone for TrackRule

fn clone(&self) -> TrackRule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TrackRule

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TrackRule

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Rule for TrackRule

type Item = Track

fn matches(&self, item: &Self::Item) -> bool

impl Serialize for TrackRule

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

where __S: Serializer,

Serialize this value into the given Serde serializer.