run: cargo clippy --verbose

        run: cargo clippy --verbose -- -D warnings -D clippy::dbg_macro -D clippy::todo

* Add flag `--session` which allows to filter entries by the given session. The
session of a history entry can be found using `--show-session`.

* Add flag `--session`. Allows to filter entries by the given
  session. The session of a history entry can be found using
  `--show-session`.
* Add flag `--filter-failed`. Enables filtering of failed commands
  when listing the history. Will filter out all commands that had a
  return code that is not 0.
* Add option `--find-status`. When specified will find all commands
  with the given return code.

codegen-units = 1
lto = true
panic = 'abort'

lto = "fat"
panic = "abort"
opt-level = 3

    pub result: usize,

    pub result: u16,

    pub result: usize,

    pub result: u16,

    /// Filter out failed commands (return code not 0)
    #[structopt(long)]
    filter_failed: bool,
    /// Find commands with the given return code
    #[structopt(long)]
    find_status: Option<u16>,

        let filter_failed = self.default_args.filter_failed;
        let find_status = self.default_args.find_status;

                    .session(session_filter);

                    .session(session_filter)
                    .filter_failed(filter_failed)
                    .find_status(find_status);

        result: usize,

        result: u16,

    let mut acc_result: Option<usize> = None;

    let mut acc_result: Option<u16> = None;

    hostname: Option<String>,
    directory: Option<PathBuf>,
    command: Option<String>,
    no_subdirs: bool,
    command_text: Option<Regex>,
    count: usize,
    session: Option<Regex>,

    pub hostname: Option<String>,
    pub directory: Option<PathBuf>,
    pub command: Option<String>,
    pub no_subdirs: bool,
    pub command_text: Option<Regex>,
    pub count: usize,
    pub session: Option<Regex>,
    pub filter_failed: bool,
    pub find_status: Option<u16>,

            })
            .filter(|entry| !self.filter_failed || entry.result == 0)
            .filter(|entry| {
                self.find_status
                    .and_then(|find_status| {
                        if find_status == entry.result {
                            None
                        } else {
                            Some(())
                        }
                    })
                    .is_none()

    pub fn filter_failed(self, filter_failed: bool) -> Self {
        Self {
            filter_failed,
            ..self
        }
    }

    }
    pub fn find_status(self, find_status: Option<u16>) -> Self {
        Self {
            find_status,
            ..self
        }