Struct primitives::sentry::channel_list::ChannelListQuery

pub struct ChannelListQuery {
    pub page: u64,
    pub validator: Option<ValidatorId>,
    pub chains: Vec<ChainId>,
}

GET /v5/channel/list query

Examples

use primitives::{
    sentry::channel_list::ChannelListQuery,
    test_util::{IDS, LEADER},
    ChainId,
};

fn main() {
    // An empty query
    {
        let empty = "";
        let empty_expected = ChannelListQuery {
            page: 0,
            validator: None,
            chains: vec![],
        };

        assert_eq!(empty_expected, serde_qs::from_str(empty).unwrap());
    }

    // Query with `page`
    {
        let only_page = "page=14";
        let only_page_expected = ChannelListQuery {
            page: 14,
            validator: None,
            chains: vec![],
        };

        assert_eq!(only_page_expected, serde_qs::from_str(only_page).unwrap());
    }

    // Query with `validator`
    {
        let only_validator = "validator=0x80690751969B234697e9059e04ed72195c3507fa";
        let only_validator_expected = ChannelListQuery {
            page: 0,
            validator: Some(IDS[&LEADER]),
            chains: vec![],
        };

        assert_eq!(
            only_validator_expected,
            serde_qs::from_str(only_validator).unwrap()
        );
    }

    // Query with `chains`
    {
        let chains_query = "chains[]=1&chains[]=1337";
        let chains_expected = ChannelListQuery {
            page: 0,
            validator: None,
            chains: vec![ChainId::new(1), ChainId::new(1337)],
        };

        assert_eq!(chains_expected, serde_qs::from_str(chains_query).unwrap());
    }

    // Query with all parameters
    {
        let all_query =
            "page=14&validator=0x80690751969B234697e9059e04ed72195c3507fa&chains[]=1&chains[]=1337";
        let all_expected = ChannelListQuery {
            page: 14,
            validator: Some(IDS[&LEADER]),
            chains: vec![ChainId::new(1), ChainId::new(1337)],
        };

        assert_eq!(all_expected, serde_qs::from_str(all_query).unwrap());
    }
}

Fields

page: u64

default is u64::default() = 0

validator: Option<ValidatorId>

Returns only the Channels containing a specified validator if provided.

chains: Vec<ChainId>

Returns only the Channels from the specified ChainIds.

Trait Implementations

impl Debug for ChannelListQuery

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ChannelListQuery

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

Deserialize this value from the given Serde deserializer.

impl PartialEq<ChannelListQuery> for ChannelListQuery

fn eq(&self, other: &ChannelListQuery) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ChannelListQuery

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

Serialize this value into the given Serde serializer.

impl Eq for ChannelListQuery

impl StructuralEq for ChannelListQuery

impl StructuralPartialEq for ChannelListQuery