Struct Diff 

pub struct Diff<M = Unselected> { /* private fields */ }

p4 [g-opts] diff [-doptions] [-f -t -Od] [-m max] [-soptions] [file[rev] ...]

p4 [g-opts] diff [-doptions] -As [streamname[@change]]

Diff utility for comparing workspace content to depot content. (For comparing two depot paths, see p4 diff2.) Also for stream spec comparison.

The M type parameter tracks the command mode at compile time. The default Unselected state offers neither the workspace content options nor -As; Self::force, Self::differing_only, and Self::diff_nontext transition to the WorkspaceMode state, while Self::stream_spec_mode transitions to the StreamSpecMode state.

Implementations

impl Diff<Unselected>

pub fn new(bin: impl Into<PathBuf>, global_opts: GlobalOpts) -> Self

Creates a new p4 diff command.

bin is the path to the Perforce command-line executable.

pub fn force(self, v: bool) -> Diff<WorkspaceMode<Unselected>>

Description

-f

Force the diff (if no revision is specified, against the head revision), even when the client file is not open for edit.

Transitions this command to the WorkspaceMode state with -f set according to v.

Examples found in repository

examples/diff.rs (line 37)

fn main() -> std::io::Result<()> {
    let p4 = P4Cli::default();

    // Workspace mode: force a diff against head, use the unified format with
    // whitespace-insensitive comparison, and limit output to the first 10
    // files. `force(true)` transitions the command into `WorkspaceMode`, and
    // `limit(10)` further transitions it into `WorkspaceRegularMode` (where
    // `-soptions` is unavailable).
    let mut diff = p4
        .diff()
        .force(true)
        .diff_options(DiffOptionsBuilder::unified(None).ignore_all_whitespace())
        .limit(10);

    let files = [OsStr::new("//depot/project/src/...")];
    let output = diff.output_with(&files)?;
    println!("{}", String::from_utf8_lossy(&output.stdout));

    // Display mode: instead of full diffs, list only the unopened files that
    // differ from the depot. `display_options` transitions `WorkspaceMode`
    // into `WorkspaceDisplayMode`, where `-m max` is unavailable.
    let mut list_changed = p4
        .diff()
        .force(true)
        .display_options(DisplayOptions::UnopenedChanged);

    let output = list_changed.output_with(&files)?;
    println!("{}", String::from_utf8_lossy(&output.stdout));

    // Stream-spec mode: diff a privately edited stream spec against the head
    // version of another stream. `stream_spec_mode` transitions the command
    // into `StreamSpecMode`; the stream spec is passed to `spawn_with`.
    let mut stream_diff = p4.diff().stream_spec_mode();
    let mut child = stream_diff.spawn_with(Some("//streams/main@head"))?;
    child.wait()?;

    Ok(())
}

pub fn differing_only(self, v: bool) -> Diff<WorkspaceMode<Unselected>>

Description

-Od

Limit output to only those files that differ.

Transitions this command to the WorkspaceMode state with -Od set according to v.

pub fn diff_nontext(self, v: bool) -> Diff<WorkspaceMode<Unselected>>

Description

-t

Diff the revisions even if the files are not of type text.

Transitions this command to the WorkspaceMode state with -t set according to v.

pub fn stream_spec_mode(self) -> Diff<StreamSpecMode>

Description

-As

Allows two arbitrary stream specs to be diffed against each other. Can be used with a streamname, or with a streamname at a specific changelist number.

Although this option requires the user have at least the list access to the stream path, it ignores any other entry in the protections table, including any minus sign (-) that would otherwise block the operation.

Transitions this command to the StreamSpecMode state. The stream spec to compare against is passed as the argument of the spawned command (ParameterizedSpawn::spawn_with); without one, the opened stream spec is diffed against its have version.

Examples found in repository

examples/diff.rs (line 59)

fn main() -> std::io::Result<()> {
    let p4 = P4Cli::default();

    // Workspace mode: force a diff against head, use the unified format with
    // whitespace-insensitive comparison, and limit output to the first 10
    // files. `force(true)` transitions the command into `WorkspaceMode`, and
    // `limit(10)` further transitions it into `WorkspaceRegularMode` (where
    // `-soptions` is unavailable).
    let mut diff = p4
        .diff()
        .force(true)
        .diff_options(DiffOptionsBuilder::unified(None).ignore_all_whitespace())
        .limit(10);

    let files = [OsStr::new("//depot/project/src/...")];
    let output = diff.output_with(&files)?;
    println!("{}", String::from_utf8_lossy(&output.stdout));

    // Display mode: instead of full diffs, list only the unopened files that
    // differ from the depot. `display_options` transitions `WorkspaceMode`
    // into `WorkspaceDisplayMode`, where `-m max` is unavailable.
    let mut list_changed = p4
        .diff()
        .force(true)
        .display_options(DisplayOptions::UnopenedChanged);

    let output = list_changed.output_with(&files)?;
    println!("{}", String::from_utf8_lossy(&output.stdout));

    // Stream-spec mode: diff a privately edited stream spec against the head
    // version of another stream. `stream_spec_mode` transitions the command
    // into `StreamSpecMode`; the stream spec is passed to `spawn_with`.
    let mut stream_diff = p4.diff().stream_spec_mode();
    let mut child = stream_diff.spawn_with(Some("//streams/main@head"))?;
    child.wait()?;

    Ok(())
}

impl<M> Diff<M>

pub fn get_diff_options(&self) -> Option<&DiffOptions>

Description

-doptions

Pass options to the underlying diff routine (see Usage notes for details).

pub fn set_diff_options(&mut self, v: impl Into<DiffOptions>) -> &mut Self

Description

-doptions

Pass options to the underlying diff routine (see Usage notes for details).

pub fn diff_options(self, v: impl Into<DiffOptions>) -> Self

Description

-doptions

Pass options to the underlying diff routine (see Usage notes for details).

Examples found in repository

examples/diff.rs (line 38)

fn main() -> std::io::Result<()> {
    let p4 = P4Cli::default();

    // Workspace mode: force a diff against head, use the unified format with
    // whitespace-insensitive comparison, and limit output to the first 10
    // files. `force(true)` transitions the command into `WorkspaceMode`, and
    // `limit(10)` further transitions it into `WorkspaceRegularMode` (where
    // `-soptions` is unavailable).
    let mut diff = p4
        .diff()
        .force(true)
        .diff_options(DiffOptionsBuilder::unified(None).ignore_all_whitespace())
        .limit(10);

    let files = [OsStr::new("//depot/project/src/...")];
    let output = diff.output_with(&files)?;
    println!("{}", String::from_utf8_lossy(&output.stdout));

    // Display mode: instead of full diffs, list only the unopened files that
    // differ from the depot. `display_options` transitions `WorkspaceMode`
    // into `WorkspaceDisplayMode`, where `-m max` is unavailable.
    let mut list_changed = p4
        .diff()
        .force(true)
        .display_options(DisplayOptions::UnopenedChanged);

    let output = list_changed.output_with(&files)?;
    println!("{}", String::from_utf8_lossy(&output.stdout));

    // Stream-spec mode: diff a privately edited stream spec against the head
    // version of another stream. `stream_spec_mode` transitions the command
    // into `StreamSpecMode`; the stream spec is passed to `spawn_with`.
    let mut stream_diff = p4.diff().stream_spec_mode();
    let mut child = stream_diff.spawn_with(Some("//streams/main@head"))?;
    child.wait()?;

    Ok(())
}

impl<M: ExclusiveOption> Diff<M>

pub fn get_global_opts(&self) -> &GlobalOpts

Description

g-opts

See Global options.

pub fn set_global_opts(&mut self, v: GlobalOpts) -> &mut Self

Description

g-opts

See Global options.

pub fn global_opts(self, v: GlobalOpts) -> Self

Description

g-opts

See Global options.

impl<M> Diff<WorkspaceMode<M>>

pub fn get_force(&self) -> bool

Description

-f

Force the diff (if no revision is specified, against the head revision), even when the client file is not open for edit.

pub fn set_force(&mut self, v: bool) -> &mut Self

Description

-f

Force the diff (if no revision is specified, against the head revision), even when the client file is not open for edit.

pub fn force(self, v: bool) -> Self

Description

-f

Force the diff (if no revision is specified, against the head revision), even when the client file is not open for edit.

pub fn get_differing_only(&self) -> bool

Description

-Od

Limit output to only those files that differ.

pub fn set_differing_only(&mut self, v: bool) -> &mut Self

Description

-Od

Limit output to only those files that differ.

pub fn differing_only(self, v: bool) -> Self

Description

-Od

Limit output to only those files that differ.

pub fn get_diff_nontext(&self) -> bool

Description

-t

Diff the revisions even if the files are not of type text.

pub fn set_diff_nontext(&mut self, v: bool) -> &mut Self

Description

-t

Diff the revisions even if the files are not of type text.

pub fn diff_nontext(self, v: bool) -> Self

Description

-t

Diff the revisions even if the files are not of type text.

impl Diff<WorkspaceMode<Unselected>>

pub fn display_options( self, v: DisplayOptions, ) -> Diff<WorkspaceMode<WorkspaceDisplayMode>>

Description

-soptions

Pass display options to the underlying diff routine (see Usage notes for details).

Transitions this command to the WorkspaceDisplayMode state with the display options set; -m max is unavailable in this state.

Examples found in repository

examples/diff.rs (line 51)

fn main() -> std::io::Result<()> {
    let p4 = P4Cli::default();

    // Workspace mode: force a diff against head, use the unified format with
    // whitespace-insensitive comparison, and limit output to the first 10
    // files. `force(true)` transitions the command into `WorkspaceMode`, and
    // `limit(10)` further transitions it into `WorkspaceRegularMode` (where
    // `-soptions` is unavailable).
    let mut diff = p4
        .diff()
        .force(true)
        .diff_options(DiffOptionsBuilder::unified(None).ignore_all_whitespace())
        .limit(10);

    let files = [OsStr::new("//depot/project/src/...")];
    let output = diff.output_with(&files)?;
    println!("{}", String::from_utf8_lossy(&output.stdout));

    // Display mode: instead of full diffs, list only the unopened files that
    // differ from the depot. `display_options` transitions `WorkspaceMode`
    // into `WorkspaceDisplayMode`, where `-m max` is unavailable.
    let mut list_changed = p4
        .diff()
        .force(true)
        .display_options(DisplayOptions::UnopenedChanged);

    let output = list_changed.output_with(&files)?;
    println!("{}", String::from_utf8_lossy(&output.stdout));

    // Stream-spec mode: diff a privately edited stream spec against the head
    // version of another stream. `stream_spec_mode` transitions the command
    // into `StreamSpecMode`; the stream spec is passed to `spawn_with`.
    let mut stream_diff = p4.diff().stream_spec_mode();
    let mut child = stream_diff.spawn_with(Some("//streams/main@head"))?;
    child.wait()?;

    Ok(())
}

pub fn limit(self, max: u64) -> Diff<WorkspaceMode<WorkspaceRegularMode>>

Description

-m max

Limit output to diffs (or status) of only the first max files, unless the -s option is used, in which case the -m option is ignored.

Transitions this command to the WorkspaceRegularMode state with the limit set to max; -soptions is unavailable in this state.

Examples found in repository

examples/diff.rs (line 39)

fn main() -> std::io::Result<()> {
    let p4 = P4Cli::default();

    // Workspace mode: force a diff against head, use the unified format with
    // whitespace-insensitive comparison, and limit output to the first 10
    // files. `force(true)` transitions the command into `WorkspaceMode`, and
    // `limit(10)` further transitions it into `WorkspaceRegularMode` (where
    // `-soptions` is unavailable).
    let mut diff = p4
        .diff()
        .force(true)
        .diff_options(DiffOptionsBuilder::unified(None).ignore_all_whitespace())
        .limit(10);

    let files = [OsStr::new("//depot/project/src/...")];
    let output = diff.output_with(&files)?;
    println!("{}", String::from_utf8_lossy(&output.stdout));

    // Display mode: instead of full diffs, list only the unopened files that
    // differ from the depot. `display_options` transitions `WorkspaceMode`
    // into `WorkspaceDisplayMode`, where `-m max` is unavailable.
    let mut list_changed = p4
        .diff()
        .force(true)
        .display_options(DisplayOptions::UnopenedChanged);

    let output = list_changed.output_with(&files)?;
    println!("{}", String::from_utf8_lossy(&output.stdout));

    // Stream-spec mode: diff a privately edited stream spec against the head
    // version of another stream. `stream_spec_mode` transitions the command
    // into `StreamSpecMode`; the stream spec is passed to `spawn_with`.
    let mut stream_diff = p4.diff().stream_spec_mode();
    let mut child = stream_diff.spawn_with(Some("//streams/main@head"))?;
    child.wait()?;

    Ok(())
}

impl Diff<WorkspaceMode<WorkspaceDisplayMode>>

pub fn get_display_options(&self) -> &DisplayOptions

Description

-soptions

Pass display options to the underlying diff routine (see Usage notes for details).

pub fn set_display_options(&mut self, v: DisplayOptions) -> &mut Self

Description

-soptions

Pass display options to the underlying diff routine (see Usage notes for details).

impl Diff<WorkspaceMode<WorkspaceRegularMode>>

pub fn get_limit(&self) -> u64

Description

-m max

Limit output to diffs (or status) of only the first max files, unless the -s option is used, in which case the -m option is ignored.

pub fn set_limit(&mut self, v: u64) -> &mut Self

Description

-m max

Limit output to diffs (or status) of only the first max files, unless the -s option is used, in which case the -m option is ignored.

Trait Implementations

impl<M: Clone> Clone for Diff<M>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: Debug> Debug for Diff<M>

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

Formats the value using the given formatter.

impl<M: Default> Default for Diff<M>

fn default() -> Self

Returns the “default value” for a type.

impl ParameterizedSpawn for Diff<Unselected>

fn spawn_with<'a>( &mut self, files: Self::Input<'a>, ) -> Result<Self::Output<'a>, Self::Error>

Spawns p4 diff for the given file arguments as a child process with piped standard output and error streams; use the returned Child handle to wait for it or interact with it.

type Input<'a> = &'a [&'a OsStr]

type Output<'a> = Child

type Error = Error

impl<M: ExclusiveOption> ParameterizedSpawn for Diff<WorkspaceMode<M>>

fn spawn_with<'a>( &mut self, files: Self::Input<'a>, ) -> Result<Self::Output<'a>, Self::Error>

Spawns p4 diff for the given file arguments as a child process with piped standard output and error streams; use the returned Child handle to wait for it or interact with it.

type Input<'a> = &'a [&'a OsStr]

type Output<'a> = Child

type Error = Error

impl ParameterizedSpawn for Diff<StreamSpecMode>

fn spawn_with<'a>( &mut self, stream_spec: Self::Input<'a>, ) -> Result<Self::Output<'a>, Self::Error>

Spawns p4 diff -As as a child process with piped standard output and error streams; use the returned Child handle to wait for it or interact with it.

Pass Some(stream_spec) to diff against the given stream spec — a streamname, optionally at a specific changelist number (@head selects the head version, @change the version at a specific change, and @=change the shelved version at a specific change) — or None to diff the opened stream spec against its have version.

type Input<'a> = Option<&'a str>

type Output<'a> = Child

type Error = Error

impl SpawnExt for Diff<StreamSpecMode>

fn spawn<'a>(&mut self) -> Result<Self::Output<'a>, Self::Error>

Spawns p4 diff -As without a stream spec as a child process with piped standard output and error streams; the opened stream spec is diffed against its have version. Use the returned Child handle to wait for it or interact with it.

impl<M: ExclusiveOption> SubCommand for Diff<M>

fn name(&self) -> &str

fn inject_local_args(&self, command: &mut Command)

fn global_opts(&self) -> Option<&GlobalOpts>

fn inject_args(&self, command: &mut Command)

fn setup_command<S: AsRef<OsStr>>(&self, bin: S) -> Command