Struct msq::Filter

pub struct Filter { /* private fields */ }

Filter builder - Construct your filter to filter out server results

• Intended to be used with: MSQClient and MSQClientBlock
• NOTE: Some filters may or may not work as expected depending on appid/games you try it on. The filter builder methods and string construction generally follows close to the reference listed out in the Valve developer wiki.
• Reference: https://developer.valvesoftware.com/wiki/Master_Server_Query_Protocol#Filter

Quick Start

use msq::Filter;

let filter = Filter::new()      // Create a Filter builder
        .appid(240)             // appid of 240 (CS:S)
        .nand()                 // Start of NAND special filter
            .map("de_dust2")        // Map is de_dust2
            .empty(true)            // Server is empty
        .end()                  // End of NAND special filter
        .gametype(&vec!["friendlyfire", "alltalk"]);

Implementations

impl Filter

pub fn as_str(&self) -> String

👎 Deprecated since 0.2.0:

Replaced with as_string (name change)

Returns a string representing the filters

pub fn as_string(&self) -> String

Returns a string representing the filters

pub fn new() -> Filter

Returns a new Filter struct, used for string builder

Examples

// Filter
use msq::Filter;
let filter = Filter::new()
    .appid(240)
    .full(false)
    .map("de_dust2");

pub fn nor(self) -> Filter

A special filter, specifies that servers matching any of the following [x] conditions should not be returned. See end method to see examples on usage.

pub fn nand(self) -> Filter

A special filter, specifies that servers matching all of the following [x] conditions should not be returned. See end method to see examples on usage.

pub fn end(self) -> Filter

End the special filter (nor, nand) You must use this method after each nor/nand special filter method being used

Examples

Using the NAND filter:

use msq::Filter;
let filter = Filter::new()
    .appid(240)
    .nand()     // Exclude servers that has de_dust2 AND is empty
        .map("de_dust2")
        .empty(true)
    .end()      // Ends the NAND special filter
    .gametype(&vec!["friendlyfire", "alltalk"]);

Using the NOR filter:

use msq::Filter;
let filter = Filter::new()
    .appid(240)
    .nor()      // Exclude servers that has de_dust2 OR is empty
        .map("de_dust2")
        .empty(true)
    .end()      // Ends the NOR special filter
    .gametype(&vec!["friendlyfire", "alltalk"]);

pub fn dedicated(self, is_dedicated: bool) -> Filter

Filters if the servers running dedicated

Arguments

• is_dedicated - true = dedicated, false = not dedicated

pub fn secure(self, hasac: bool) -> Filter

Servers using anti-cheat technology (VAC, but potentially others as well)

Arguments

• hasac - true = secure, false = not secure

pub fn gamedir(self, modg: &str) -> Filter

Servers running the specified modification (ex: cstrike)

Arguments

• modg - The modification name (ex: cstrike)

pub fn map(self, mapn: &str) -> Filter

Servers running the specified map (ex: cs_italy)

Arguments

• mapn - The current map it’s playing (ex: cs_italy)

pub fn linux(self, runslinux: bool) -> Filter

Servers running on a Linux platform

Arguments

• runslinux - true = Runs on Linux, false = Does not runs on Linux

pub fn password(self, protected: bool) -> Filter

Servers that are password protected

Arguments

• protected - true = Password protected, false = Not password protected

pub fn full(self, is_full: bool) -> Filter

Servers that are full

Arguments

• is_full - true = Server’s full, false = Server’s not full

pub fn proxy(self, specprox: bool) -> Filter

Servers that are spectator proxies

Arguments

• specprox - true = A spectator proxies, false = Not a spectator proxies

pub fn appid(self, appid: u32) -> Filter

Servers that are running game [appid]

Arguments

• appid - The appid of the server: (EX: 240 (for CS:S))

pub fn napp(self, appid: u32) -> Filter

Servers that are NOT running game [appid]

Arguments

• appid - The appid of the server: (EX: 240 (for CS:S))

pub fn empty(self, is_empty: bool) -> Filter

Servers that are empty

Arguments

• is_empty - true = Empty, false = Not empty

pub fn whitelisted(self, white: bool) -> Filter

Servers that are whitelisted

Arguments

• white - true = Whitelisted, false = Not whitelisted

pub fn gametype(self, tags: &Vec<&str>) -> Filter

Servers with all of the given tag(s) in sv_tags

Arguments

• tags - A vector of strings which represents a tag from sv_tags

Example

use msq::Filter;
let filter = Filter::new()
    .appid(240)
    .gametype(&vec!["friendlyfire", "alltalk"]);

If you put in an empty vector, it will return nothing

pub fn gamedata(self, tags: &Vec<&str>) -> Filter

Servers with all of the given tag(s) in their ‘hidden’ tags (L4D2)

Arguments

• tags - A vector of strings which represents a tag from sv_tags

pub fn gamedataor(self, tags: &Vec<&str>) -> Filter

Servers with any of the given tag(s) in their ‘hidden’ tags (L4D2)

Arguments

• tags - A vector of strings which represents a tag from sv_tags

pub fn name_match(self, hostname: &str) -> Filter

Servers with their hostname matching [hostname] (can use * as a wildcard)

Arguments

• hostname - String of matching hostname (EX: 1.2.*)

pub fn version_match(self, ver: &str) -> Filter

Servers running version [version] (can use * as a wildcard)

Arguments

• ver - String of matching version

pub fn collapse_addr_hash(self, one_server: bool) -> Filter

Return only one server for each unique IP address matched

Arguments

• one_server - true = Return one server

pub fn gameaddr(self, ipaddr: &str) -> Filter

Return only servers on the specified IP address (port supported and optional)

Arguments

• ipaddr - String of the IP address to match