Struct Overflow 

pub struct Overflow<'a> { /* private fields */ }

Overflow Menu

This is like a cross between a button and a select menu - when a user clicks on this overflow button, they will be presented with a list of options to choose from.

Unlike the select menu, there is no typeahead field, and the button always appears with an ellipsis (“…”), rather than customisable text.

slack api docs 🔗

Works in blocks 🔗: Section, Actions

Implementations

impl<'a> Overflow<'a>

pub fn builder() -> OverflowBuilderInit<'a>

Construct a new Overflow Menu.

Example

See example of build::OverflowBuilder

pub fn validate(&self) -> Result<(), ValidationErrors>

Available on crate feature validation only.

Validate that this select element agrees with Slack’s model requirements

Errors

• length of action_id greater than 255
• length of options less than 2 or greater than 5
• one or more of options is invalid (TODO)
• confirm is set and an invalid Confirm

Example

use slack_blocks::{compose::Opt, elems::Overflow};

fn repeat<T: Copy>(el: T, n: usize) -> impl Iterator<Item = T> {
  std::iter::repeat(el).take(n)
}

let long_string: String = repeat('a', 256).collect();

let opt = Opt::builder().text_plain("foo")
                        .value("bar")
                        .no_url()
                        .build();

let opts: Vec<Opt<_, _>> = repeat(&opt, 6).map(|o| o.clone()).collect();

let input = Overflow::builder().action_id(long_string) // invalid
                               .options(opts) // also invalid
                               .build();

assert!(matches!(input.validate(), Err(_)))

Trait Implementations

impl<'a> Clone for Overflow<'a>

fn clone(&self) -> Overflow<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Overflow<'a>

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

Formats the value using the given formatter.

impl<'de, 'a> Deserialize<'de> for Overflow<'a>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> From<Overflow<'a>> for BlockElement<'a>

fn from(src: Overflow<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<Overflow<'a>> for SupportedElement<'a>

fn from(src: Overflow<'a>) -> Self

Converts to this type from the input type.

impl<'a> Hash for Overflow<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for Overflow<'a>

fn eq(&self, other: &Overflow<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> Serialize for Overflow<'a>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Validate for Overflow<'a>

fn validate(&self) -> Result<(), ValidationErrors>

impl<'a> StructuralPartialEq for Overflow<'a>