Enum pgdo::runtime::strategy::Strategy

pub enum Strategy {
    Chain(VecDeque<Strategy>),
    Delegated(Box<dyn StrategyLike>),
    Single(Runtime),
}

Compose strategies for finding PostgreSQL runtimes.

Variants

Chain(VecDeque<Strategy>)

Each strategy is consulted in turn.

Delegated(Box<dyn StrategyLike>)

Delegate to another strategy; needed when implementing StrategyLike.

Single(Runtime)

A single runtime; it always picks itself.

Implementations

impl Strategy

pub fn push_front<S: Into<Strategy>>(self, strategy: S) -> Self

Push the given strategy to the front of the chain.

If this isn’t already, it is converted into a Strategy::Chain.

pub fn push_back<S: Into<Strategy>>(self, strategy: S) -> Self

Push the given strategy to the back of the chain.

If this isn’t already, it is converted into a Strategy::Chain.

Trait Implementations

impl Default for Strategy

fn default() -> Self

Select runtimes from on PATH followed by platform-specific runtimes.

impl From<Runtime> for Strategy

fn from(runtime: Runtime) -> Self

Converts the given runtime into a Strategy::Single.

impl From<RuntimesOnPath> for Strategy

fn from(strategy: RuntimesOnPath) -> Self

Converts the given strategy into a Strategy::Delegated.

impl From<RuntimesOnPathEnv> for Strategy

fn from(strategy: RuntimesOnPathEnv) -> Self

Converts the given strategy into a Strategy::Delegated.

impl From<RuntimesOnPlatform> for Strategy

fn from(strategy: RuntimesOnPlatform) -> Self

Converts the given strategy into a Strategy::Delegated.

impl StrategyLike for Strategy

fn runtimes(&self) -> Runtimes<'_>

• For a Strategy::Chain, yields runtimes known to all strategies, in the same order as each strategy returns them.
• For a Strategy::Delegated, calls through to the wrapped strategy.
• For a Strategy::Single, yields the runtime it’s holding.

Note that for the first two, runtimes are deduplicated by version number, i.e. if a runtime with the same version number is yielded by multiple strategies, or is yielded multiple times by a single strategy, it will only be returned the first time it is seen.

fn select(&self, constraint: &Constraint) -> Option<Runtime>

• For a Strategy::Chain, asks each strategy in turn to select a runtime. The first non-None answer is selected.
• For a Strategy::Delegated, calls through to the wrapped strategy.
• For a Strategy::Single, returns the runtime if it’s compatible.

fn fallback(&self) -> Option<Runtime>

• For a Strategy::Chain, asks each strategy in turn for a fallback runtime. The first non-None answer is selected.
• For a Strategy::Delegated, calls through to the wrapped strategy.
• For a Strategy::Single, returns the runtime it’s holding.