SYMBOL INDEX (379 symbols across 63 files)

FILE: build.rs
  function main (line 1) | fn main() {

FILE: src/action/debug.rs
  type Debug (line 14) | pub struct Debug<'a> {
  function new (line 20) | pub fn new(cmd_matches: &'a ArgMatches<'a>) -> Self {
  function invoke (line 26) | pub fn invoke(&self) -> Result<(), ActionError> {

FILE: src/action/delete.rs
  type Delete (line 13) | pub struct Delete<'a> {
  function new (line 19) | pub fn new(cmd_matches: &'a ArgMatches<'a>) -> Self {
  function invoke (line 25) | pub fn invoke(&self) -> Result<(), ActionError> {
  type Error (line 66) | pub enum Error {
    method from (line 82) | fn from(err: FileParseError) -> Error {
    method from (line 88) | fn from(err: DeleteError) -> Error {

FILE: src/action/download.rs
  type Download (line 33) | pub struct Download<'a> {
  function new (line 39) | pub fn new(cmd_matches: &'a ArgMatches<'a>) -> Self {
  function invoke (line 45) | pub fn invoke(&self) -> Result<(), Error> {
  function prepare_path (line 217) | fn prepare_path(
  function select_path (line 288) | fn select_path(target: &PathBuf, name_hint: &str) -> PathBuf {
  type Error (line 353) | pub enum Error {
    method from (line 387) | fn from(err: VersionError) -> Error {
    method from (line 393) | fn from(err: FileParseError) -> Error {
    method from (line 399) | fn from(err: ExistsError) -> Error {
    method from (line 405) | fn from(err: MetadataError) -> Error {
    method from (line 411) | fn from(err: DownloadError) -> Error {
    method from (line 418) | fn from(err: ExtractError) -> Error {
  type ExtractError (line 425) | pub enum ExtractError {

FILE: src/action/exists.rs
  type Exists (line 13) | pub struct Exists<'a> {
  function new (line 19) | pub fn new(cmd_matches: &'a ArgMatches<'a>) -> Self {
  function invoke (line 25) | pub fn invoke(&self) -> Result<(), ActionError> {
  type Error (line 65) | pub enum Error {
    method from (line 77) | fn from(err: FileParseError) -> Error {
    method from (line 83) | fn from(err: ExistsError) -> Error {

FILE: src/action/generate/completions.rs
  type Completions (line 10) | pub struct Completions<'a> {
  function new (line 16) | pub fn new(cmd_matches: &'a ArgMatches<'a>) -> Self {
  function invoke (line 22) | pub fn invoke(&self) -> Result<(), ActionError> {
  type Error (line 57) | pub enum Error {

FILE: src/action/generate/mod.rs
  type Generate (line 10) | pub struct Generate<'a> {
  function new (line 16) | pub fn new(cmd_matches: &'a ArgMatches<'a>) -> Self {
  function invoke (line 22) | pub fn invoke(&self) -> Result<(), ActionError> {

FILE: src/action/history.rs
  type History (line 11) | pub struct History<'a> {
  function new (line 17) | pub fn new(cmd_matches: &'a ArgMatches<'a>) -> Self {
  function invoke (line 23) | pub fn invoke(&self) -> Result<(), ActionError> {
  type Error (line 146) | pub enum Error {
  method from (line 153) | fn from(err: HistoryLoadError) -> ActionError {

FILE: src/action/info.rs
  type Info (line 19) | pub struct Info<'a> {
  function new (line 25) | pub fn new(cmd_matches: &'a ArgMatches<'a>) -> Self {
  function invoke (line 31) | pub fn invoke(&self) -> Result<(), Error> {
  type Error (line 164) | pub enum Error {
    method from (line 184) | fn from(err: FileParseError) -> Error {
    method from (line 190) | fn from(err: ExistsError) -> Error {
    method from (line 196) | fn from(err: InfoError) -> Error {

FILE: src/action/mod.rs
  function select_api_version (line 27) | fn select_api_version(

FILE: src/action/params.rs
  type Params (line 14) | pub struct Params<'a> {
  function new (line 20) | pub fn new(cmd_matches: &'a ArgMatches<'a>) -> Self {
  function invoke (line 26) | pub fn invoke(&self) -> Result<(), ActionError> {

FILE: src/action/password.rs
  type Password (line 14) | pub struct Password<'a> {
  function new (line 20) | pub fn new(cmd_matches: &'a ArgMatches<'a>) -> Self {
  function invoke (line 26) | pub fn invoke(&self) -> Result<(), ActionError> {

FILE: src/action/upload.rs
  type Upload (line 42) | pub struct Upload<'a> {
  function new (line 48) | pub fn new(cmd_matches: &'a ArgMatches<'a>) -> Self {
  function invoke (line 54) | pub fn invoke(&self) -> Result<(), Error> {
  function shared_dir (line 553) | fn shared_dir(paths: Vec<PathBuf>) -> Option<PathBuf> {
  type Error (line 604) | pub enum Error {
    method from (line 633) | fn from(err: VersionError) -> Error {
    method from (line 640) | fn from(err: ArchiveError) -> Error {
    method from (line 646) | fn from(err: UploadError) -> Error {
  type ArchiveError (line 653) | pub enum ArchiveError {

FILE: src/action/version.rs
  type Version (line 10) | pub struct Version<'a> {
  function new (line 16) | pub fn new(cmd_matches: &'a ArgMatches<'a>) -> Self {
  function invoke (line 22) | pub fn invoke(&self) -> Result<(), ActionError> {
  type Error (line 50) | pub enum Error {
    method from (line 57) | fn from(err: VersionError) -> Error {

FILE: src/archive/archive.rs
  type Result (line 6) | pub type Result<T> = ::std::result::Result<T, IoError>;
  type Archive (line 8) | pub struct Archive<R: Read> {
  function new (line 15) | pub fn new(reader: R) -> Archive<R> {
  function extract (line 22) | pub fn extract<P: AsRef<Path>>(&mut self, destination: P) -> Result<()> {

FILE: src/archive/archiver.rs
  type Result (line 7) | pub type Result<T> = ::std::result::Result<T, IoError>;
  type Archiver (line 9) | pub struct Archiver<W: Write> {
  function new (line 16) | pub fn new(writer: W) -> Archiver<W> {
  function append_path (line 28) | pub fn append_path<P, Q>(&mut self, path: P, src_path: Q) -> Result<()>
  function append_file (line 45) | pub fn append_file<P>(&mut self, path: P, file: &mut File) -> Result<()>
  function append_dir (line 54) | pub fn append_dir<P, Q>(&mut self, path: P, src_path: Q) -> Result<()>
  function finish (line 63) | pub fn finish(mut self) -> Result<()> {

FILE: src/client.rs
  function create_config (line 12) | pub fn create_config(matcher_main: &MainMatcher) -> ClientConfig {
  function to_duration (line 23) | pub fn to_duration(secs: u64) -> Option<Duration> {

FILE: src/cmd/arg/api.rs
  type ArgApi (line 9) | pub struct ArgApi {}
    type Value (line 35) | type Value = DesiredVersion;
    method value (line 37) | fn value<'b: 'a>(matches: &'a ArgMatches<'b>) -> Self::Value {
  method name (line 12) | fn name() -> &'static str {
  method build (line 16) | fn build<'b, 'c>() -> Arg<'b, 'c> {
  function is_auto (line 62) | fn is_auto(arg: &str) -> bool {

FILE: src/cmd/arg/basic_auth.rs
  type ArgBasicAuth (line 6) | pub struct ArgBasicAuth {}
    type Value (line 28) | type Value = Option<(String, Option<String>)>;
    method value (line 30) | fn value<'b: 'a>(matches: &'a ArgMatches<'b>) -> Self::Value {
  method name (line 9) | fn name() -> &'static str {
  method build (line 13) | fn build<'b, 'c>() -> Arg<'b, 'c> {

FILE: src/cmd/arg/download_limit.rs
  type ArgDownloadLimit (line 10) | pub struct ArgDownloadLimit {}
    method value_checked (line 13) | pub fn value_checked<'a>(
    type Value (line 79) | type Value = Option<usize>;
    method value (line 81) | fn value<'b: 'a>(matches: &'a ArgMatches<'b>) -> Self::Value {
  method name (line 60) | fn name() -> &'static str {
  method build (line 64) | fn build<'b, 'c>() -> Arg<'b, 'c> {
  function closest (line 88) | fn closest(values: &[usize], current: usize) -> usize {

FILE: src/cmd/arg/expiry_time.rs
  type ArgExpiryTime (line 14) | pub struct ArgExpiryTime {}
    method value_checked (line 17) | pub fn value_checked<'a>(
    type Value (line 86) | type Value = Option<usize>;
    method value (line 88) | fn value<'b: 'a>(matches: &'a ArgMatches<'b>) -> Self::Value {
  method name (line 67) | fn name() -> &'static str {
  method build (line 71) | fn build<'b, 'c>() -> Arg<'b, 'c> {

FILE: src/cmd/arg/gen_passphrase.rs
  type ArgGenPassphrase (line 7) | pub struct ArgGenPassphrase {}
    method gen_passphrase (line 12) | pub fn gen_passphrase() -> String {
  method name (line 18) | fn name() -> &'static str {
  method build (line 22) | fn build<'b, 'c>() -> Arg<'b, 'c> {

FILE: src/cmd/arg/host.rs
  type ArgHost (line 10) | pub struct ArgHost {}
    type Value (line 30) | type Value = Url;
    method value (line 32) | fn value<'b: 'a>(matches: &'a ArgMatches<'b>) -> Self::Value {
  method name (line 13) | fn name() -> &'static str {
  method build (line 17) | fn build<'b, 'c>() -> Arg<'b, 'c> {

FILE: src/cmd/arg/mod.rs
  type CmdArg (line 27) | pub trait CmdArg {
    method name (line 29) | fn name() -> &'static str;
    method build (line 32) | fn build<'a, 'b>() -> Arg<'a, 'b>;
  type CmdArgFlag (line 38) | pub trait CmdArgFlag: CmdArg {
    method is_present (line 40) | fn is_present<'a>(matches: &ArgMatches<'a>) -> bool {
  type CmdArgOption (line 47) | pub trait CmdArgOption<'a>: CmdArg {
    method value (line 52) | fn value<'b: 'a>(matches: &'a ArgMatches<'b>) -> Self::Value;
    method value_raw (line 55) | fn value_raw<'b: 'a>(matches: &'a ArgMatches<'b>) -> Option<&'a str> {

FILE: src/cmd/arg/owner.rs
  type ArgOwner (line 8) | pub struct ArgOwner {}
    type Value (line 30) | type Value = Option<String>;
    method value (line 32) | fn value<'b: 'a>(matches: &'a ArgMatches<'b>) -> Self::Value {
  method name (line 11) | fn name() -> &'static str {
  method build (line 15) | fn build<'b, 'c>() -> Arg<'b, 'c> {

FILE: src/cmd/arg/password.rs
  type ArgPassword (line 8) | pub struct ArgPassword {}
    type Value (line 29) | type Value = Option<String>;
    method value (line 31) | fn value<'b: 'a>(matches: &'a ArgMatches<'b>) -> Self::Value {
  method name (line 11) | fn name() -> &'static str {
  method build (line 15) | fn build<'b, 'c>() -> Arg<'b, 'c> {

FILE: src/cmd/arg/url.rs
  type ArgUrl (line 10) | pub struct ArgUrl {}
    type Value (line 26) | type Value = Url;
    method value (line 28) | fn value<'b: 'a>(matches: &'a ArgMatches<'b>) -> Self::Value {
  method name (line 13) | fn name() -> &'static str {
  method build (line 17) | fn build<'b, 'c>() -> Arg<'b, 'c> {

FILE: src/cmd/handler.rs
  type Handler (line 52) | pub struct Handler<'a> {
  function build (line 59) | pub fn build() -> App<'a, 'b> {
  function parse (line 202) | pub fn parse() -> Handler<'a> {
  function infer_subcommand (line 227) | fn infer_subcommand(args: &mut Vec<OsString>) {
  function matches (line 241) | pub fn matches(&'a self) -> &'a ArgMatches {
  function debug (line 246) | pub fn debug(&'a self) -> Option<DebugMatcher> {
  function delete (line 251) | pub fn delete(&'a self) -> Option<DeleteMatcher> {
  function download (line 256) | pub fn download(&'a self) -> Option<DownloadMatcher> {
  function exists (line 261) | pub fn exists(&'a self) -> Option<ExistsMatcher> {
  function generate (line 266) | pub fn generate(&'a self) -> Option<GenerateMatcher> {
  function history (line 272) | pub fn history(&'a self) -> Option<HistoryMatcher> {
  function info (line 277) | pub fn info(&'a self) -> Option<InfoMatcher> {
  function params (line 282) | pub fn params(&'a self) -> Option<ParamsMatcher> {
  function password (line 287) | pub fn password(&'a self) -> Option<PasswordMatcher> {
  function upload (line 292) | pub fn upload(&'a self) -> Option<UploadMatcher> {
  function version (line 297) | pub fn version(&'a self) -> Option<VersionMatcher> {

FILE: src/cmd/matcher/debug.rs
  type DebugMatcher (line 8) | pub struct DebugMatcher<'a> {
  function host (line 18) | pub fn host(&'a self) -> Url {
  function with (line 24) | fn with(matches: &'a ArgMatches) -> Option<Self> {

FILE: src/cmd/matcher/delete.rs
  type DeleteMatcher (line 8) | pub struct DeleteMatcher<'a> {
  function url (line 18) | pub fn url(&'a self) -> Url {
  function owner (line 23) | pub fn owner(&'a self) -> Option<String> {
  function with (line 30) | fn with(matches: &'a ArgMatches) -> Option<Self> {

FILE: src/cmd/matcher/download.rs
  type DownloadMatcher (line 12) | pub struct DownloadMatcher<'a> {
  function url (line 22) | pub fn url(&'a self) -> Url {
  function guess_host (line 29) | pub fn guess_host(&'a self, url: Option<Url>) -> Url {
  function password (line 39) | pub fn password(&'a self) -> Option<String> {
  function output (line 46) | pub fn output(&'a self) -> PathBuf {
  function extract (line 55) | pub fn extract(&self) -> bool {
  function with (line 61) | fn with(matches: &'a ArgMatches) -> Option<Self> {

FILE: src/cmd/matcher/exists.rs
  type ExistsMatcher (line 9) | pub struct ExistsMatcher<'a> {
  function url (line 19) | pub fn url(&'a self) -> Url {
  function with (line 25) | fn with(matches: &'a ArgMatches) -> Option<Self> {

FILE: src/cmd/matcher/generate/completions.rs
  type CompletionsMatcher (line 9) | pub struct CompletionsMatcher<'a> {
  function shells (line 15) | pub fn shells(&'a self) -> Vec<Shell> {
  function output (line 49) | pub fn output(&'a self) -> PathBuf {
  function with (line 58) | fn with(matches: &'a ArgMatches) -> Option<Self> {

FILE: src/cmd/matcher/generate/mod.rs
  type GenerateMatcher (line 9) | pub struct GenerateMatcher<'a> {
  function matcher_completions (line 16) | pub fn matcher_completions(&'a self) -> Option<CompletionsMatcher> {
  function with (line 22) | fn with(root: &'a ArgMatches) -> Option<Self> {

FILE: src/cmd/matcher/history.rs
  type HistoryMatcher (line 10) | pub struct HistoryMatcher<'a> {
  function clear (line 17) | pub fn clear(&self) -> bool {
  function rm (line 26) | pub fn rm(&'a self) -> Option<Url> {
  function with (line 42) | fn with(matches: &'a ArgMatches) -> Option<Self> {

FILE: src/cmd/matcher/info.rs
  type InfoMatcher (line 9) | pub struct InfoMatcher<'a> {
  function url (line 19) | pub fn url(&'a self) -> Url {
  function owner (line 24) | pub fn owner(&'a self) -> Option<String> {
  function password (line 31) | pub fn password(&'a self) -> Option<String> {
  function with (line 37) | fn with(matches: &'a ArgMatches) -> Option<Self> {

FILE: src/cmd/matcher/main.rs
  type MainMatcher (line 14) | pub struct MainMatcher<'a> {
  function force (line 20) | pub fn force(&self) -> bool {
  function no_interact (line 25) | pub fn no_interact(&self) -> bool {
  function assume_yes (line 30) | pub fn assume_yes(&self) -> bool {
  function api (line 35) | pub fn api(&'a self) -> DesiredVersion {
  function basic_auth (line 40) | pub fn basic_auth(&'a self) -> Option<(String, Option<String>)> {
  function history (line 46) | pub fn history(&self) -> PathBuf {
  function timeout (line 65) | pub fn timeout(&self) -> u64 {
  function transfer_timeout (line 73) | pub fn transfer_timeout(&self) -> u64 {
  function incognito (line 82) | pub fn incognito(&self) -> bool {
  function quiet (line 87) | pub fn quiet(&self) -> bool {
  function verbose (line 92) | pub fn verbose(&self) -> bool {
  function with (line 98) | fn with(matches: &'a ArgMatches) -> Option<Self> {

FILE: src/cmd/matcher/mod.rs
  type Matcher (line 32) | pub trait Matcher<'a>: Sized {
    method with (line 34) | fn with(matches: &'a ArgMatches) -> Option<Self>;

FILE: src/cmd/matcher/params.rs
  type ParamsMatcher (line 12) | pub struct ParamsMatcher<'a> {
  function url (line 22) | pub fn url(&'a self) -> Url {
  function owner (line 27) | pub fn owner(&'a self) -> Option<String> {
  function download_limit (line 36) | pub fn download_limit(
  function with (line 47) | fn with(matches: &'a ArgMatches) -> Option<Self> {

FILE: src/cmd/matcher/password.rs
  type PasswordMatcher (line 10) | pub struct PasswordMatcher<'a> {
  function url (line 20) | pub fn url(&'a self) -> Url {
  function owner (line 25) | pub fn owner(&'a self) -> Option<String> {
  function password (line 34) | pub fn password(&'a self) -> (String, bool) {
  function with (line 63) | fn with(matches: &'a ArgMatches) -> Option<Self> {

FILE: src/cmd/matcher/upload.rs
  type UploadMatcher (line 15) | pub struct UploadMatcher<'a> {
  function files (line 22) | pub fn files(&'a self) -> Vec<&'a str> {
  function name (line 33) | pub fn name(&'a self) -> Option<&'a str> {
  function host (line 58) | pub fn host(&'a self) -> Url {
  function password (line 69) | pub fn password(&'a self) -> Option<(String, bool)> {
  function download_limit (line 83) | pub fn download_limit(
  function expiry_time (line 100) | pub fn expiry_time(
  function archive (line 111) | pub fn archive(&self) -> bool {
  function open (line 116) | pub fn open(&self) -> bool {
  function delete (line 121) | pub fn delete(&self) -> bool {
  function copy (line 127) | pub fn copy(&self) -> Option<CopyMode> {
  function shorten (line 144) | pub fn shorten(&self) -> bool {
  function qrcode (line 150) | pub fn qrcode(&self) -> bool {
  function with (line 156) | fn with(matches: &'a ArgMatches) -> Option<Self> {
  type CopyMode (line 165) | pub enum CopyMode {
    method build (line 175) | pub fn build(&self, url: &str) -> String {

FILE: src/cmd/matcher/version.rs
  type VersionMatcher (line 9) | pub struct VersionMatcher<'a> {
  function host (line 19) | pub fn host(&'a self) -> Url {
  function with (line 25) | fn with(matches: &'a ArgMatches) -> Option<Self> {

FILE: src/cmd/subcmd/debug.rs
  type CmdDebug (line 6) | pub struct CmdDebug;
    method build (line 9) | pub fn build<'a, 'b>() -> App<'a, 'b> {

FILE: src/cmd/subcmd/delete.rs
  type CmdDelete (line 6) | pub struct CmdDelete;
    method build (line 9) | pub fn build<'a, 'b>() -> App<'a, 'b> {

FILE: src/cmd/subcmd/download.rs
  type CmdDownload (line 6) | pub struct CmdDownload;
    method build (line 9) | pub fn build<'a, 'b>() -> App<'a, 'b> {

FILE: src/cmd/subcmd/exists.rs
  type CmdExists (line 6) | pub struct CmdExists;
    method build (line 9) | pub fn build<'a, 'b>() -> App<'a, 'b> {

FILE: src/cmd/subcmd/generate/completions.rs
  type CmdCompletions (line 4) | pub struct CmdCompletions;
    method build (line 7) | pub fn build<'a, 'b>() -> App<'a, 'b> {

FILE: src/cmd/subcmd/generate/mod.rs
  type CmdGenerate (line 8) | pub struct CmdGenerate;
    method build (line 11) | pub fn build<'a, 'b>() -> App<'a, 'b> {

FILE: src/cmd/subcmd/history.rs
  type CmdHistory (line 4) | pub struct CmdHistory;
    method build (line 7) | pub fn build<'a, 'b>() -> App<'a, 'b> {

FILE: src/cmd/subcmd/info.rs
  type CmdInfo (line 6) | pub struct CmdInfo;
    method build (line 9) | pub fn build<'a, 'b>() -> App<'a, 'b> {

FILE: src/cmd/subcmd/params.rs
  type CmdParams (line 6) | pub struct CmdParams;
    method build (line 9) | pub fn build<'a, 'b>() -> App<'a, 'b> {

FILE: src/cmd/subcmd/password.rs
  type CmdPassword (line 6) | pub struct CmdPassword;
    method build (line 9) | pub fn build<'a, 'b>() -> App<'a, 'b> {

FILE: src/cmd/subcmd/upload.rs
  type CmdUpload (line 8) | pub struct CmdUpload;
    method build (line 11) | pub fn build<'a, 'b>() -> App<'a, 'b> {

FILE: src/cmd/subcmd/version.rs
  type CmdVersion (line 6) | pub struct CmdVersion;
    method build (line 9) | pub fn build<'a, 'b>() -> App<'a, 'b> {

FILE: src/config.rs
  constant CLIENT_TIMEOUT (line 7) | pub const CLIENT_TIMEOUT: u64 = 30;
  constant CLIENT_TRANSFER_TIMEOUT (line 11) | pub const CLIENT_TRANSFER_TIMEOUT: u64 = 24 * 60 * 60;
  constant API_VERSION_DESIRED_DEFAULT (line 14) | pub const API_VERSION_DESIRED_DEFAULT: DesiredVersion = DesiredVersion::...
  constant API_VERSION_ASSUME (line 18) | pub const API_VERSION_ASSUME: Version = Version::V3;
  constant API_VERSION_ASSUME (line 20) | pub const API_VERSION_ASSUME: Version = Version::V2;

FILE: src/error.rs
  type Error (line 16) | pub enum Error {
    method from (line 23) | fn from(err: CliDownloadError) -> Error {
    method from (line 29) | fn from(err: CliInfoError) -> Error {
    method from (line 35) | fn from(err: CliUploadError) -> Error {
    method from (line 41) | fn from(err: ActionError) -> Error {
  type ActionError (line 47) | pub enum ActionError {
    method from (line 96) | fn from(err: DeleteError) -> ActionError {
    method from (line 102) | fn from(err: ExistsError) -> ActionError {
    method from (line 108) | fn from(err: CliGenerateCompletionsError) -> ActionError {
    method from (line 115) | fn from(err: CliHistoryError) -> ActionError {
    method from (line 121) | fn from(err: ParamsError) -> ActionError {
    method from (line 127) | fn from(err: PasswordError) -> ActionError {
    method from (line 133) | fn from(err: VersionError) -> ActionError {
    method from (line 139) | fn from(err: FileParseError) -> ActionError {

FILE: src/history.rs
  constant VERSION_MIN (line 16) | const VERSION_MIN: &str = "0.0.1";
  constant VERSION_MAX (line 19) | const VERSION_MAX: &str = crate_version!();
  type History (line 22) | pub struct History {
    method new (line 42) | pub fn new(autosave: Option<PathBuf>) -> Self {
    method load (line 49) | pub fn load(path: PathBuf) -> Result<Self, LoadError> {
    method load_or_new (line 82) | pub fn load_or_new(file: PathBuf) -> Result<Self, LoadError> {
    method save (line 91) | pub fn save(&mut self) -> Result<(), SaveError> {
    method add (line 142) | pub fn add(&mut self, file: RemoteFile, overwrite: bool) {
    method remove (line 172) | pub fn remove(&mut self, id: &str) -> bool {
    method remove_url (line 197) | pub fn remove_url(&mut self, url: Url) -> Result<bool, FileParseError> {
    method files (line 202) | pub fn files(&self) -> &Vec<RemoteFile> {
    method get_file (line 210) | pub fn get_file(&self, file: &RemoteFile) -> Option<&RemoteFile> {
    method clear (line 217) | pub fn clear(&mut self) {
    method gc (line 228) | pub fn gc(&mut self) -> usize {
  method drop (line 253) | fn drop(&mut self) {
  method default (line 265) | fn default() -> Self {
  type Error (line 276) | pub enum Error {
    method from (line 287) | fn from(err: LoadError) -> Self {
    method from (line 293) | fn from(err: SaveError) -> Self {
  type LoadError (line 299) | pub enum LoadError {
    method from (line 310) | fn from(err: IoError) -> Self {
    method from (line 316) | fn from(err: DeError) -> Self {
  type SaveError (line 322) | pub enum SaveError {
    method from (line 346) | fn from(err: SerError) -> Self {
    method from (line 352) | fn from(err: IoError) -> Self {

FILE: src/history_tool.rs
  function add_error (line 16) | fn add_error(
  function add (line 41) | pub fn add(matcher_main: &MainMatcher, file: RemoteFile, overwrite: bool) {
  function remove_error (line 50) | fn remove_error(matcher_main: &MainMatcher, file: &RemoteFile) -> Result...
  function remove (line 66) | pub fn remove(matcher_main: &MainMatcher, file: &RemoteFile) -> bool {
  function derive_file_properties (line 90) | pub fn derive_file_properties(matcher_main: &MainMatcher, file: &mut Rem...

FILE: src/host.rs
  function parse_host (line 4) | pub fn parse_host(host: &str) -> Result<Url, HostError> {
  type HostError (line 27) | pub enum HostError {

FILE: src/main.rs
  function main (line 52) | fn main() {
  function invoke_action (line 69) | fn invoke_action(handler: &Handler) -> Result<(), Error> {
  function print_main_info (line 161) | pub fn print_main_info() -> ! {

FILE: src/progress.rs
  constant PROGRESS_BAR_FPS_MILLIS (line 8) | const PROGRESS_BAR_FPS_MILLIS: u64 = 200;
  type ProgressBar (line 11) | pub struct ProgressBar<'a> {
  function new (line 19) | pub fn new(msg_progress: &'a str, msg_finish: &'a str) -> ProgressBar<'a> {
  function new_upload (line 28) | pub fn new_upload() -> ProgressBar<'a> {
  function new_download (line 33) | pub fn new_download() -> ProgressBar<'a> {
  method start (line 40) | fn start(&mut self, total: u64) {
  method progress (line 51) | fn progress(&mut self, progress: u64) {
  method finish (line 59) | fn finish(&mut self) {

FILE: src/urlshorten.rs
  type Result (line 15) | type Result<T> = ::std::result::Result<T, Error>;
  function shorten (line 18) | pub fn shorten(client: &Client, url: &str) -> Result<String> {
  function shorten_url (line 24) | pub fn shorten_url(client: &Client, url: &Url) -> Result<Url> {
  function request (line 29) | fn request(client: &Client, req: Request) -> Result<String> {
  type Error (line 70) | pub enum Error {
    method from (line 89) | fn from(err: url::ParseError) -> Self {
    method from (line 95) | fn from(err: ResponseError) -> Self {

FILE: src/util.rs
  function print_success (line 49) | pub fn print_success(msg: &str) {
  function print_error (line 55) | pub fn print_error<E: Fail>(err: impl Borrow<E>) {
  function print_error_msg (line 84) | pub fn print_error_msg<S>(err: S)
  function print_warning (line 92) | pub fn print_warning<S>(err: S)
  function quit (line 100) | pub fn quit() -> ! {
  function quit_error (line 106) | pub fn quit_error<E: Fail>(err: E, hints: impl Borrow<ErrorHints>) -> ! {
  function quit_error_msg (line 119) | pub fn quit_error_msg<S>(err: S, hints: impl Borrow<ErrorHints>) -> !
  type ErrorHints (line 129) | pub struct ErrorHints {
    method any (line 161) | pub fn any(&self) -> bool {
    method print (line 177) | pub fn print(&self) {
  method default (line 240) | fn default() -> Self {
  method add_info (line 258) | pub fn add_info(mut self, info: String) -> Self {
  function highlight (line 274) | pub fn highlight(msg: &str) -> ColoredString {
  function highlight_error (line 279) | pub fn highlight_error(msg: &str) -> ColoredString {
  function highlight_warning (line 284) | pub fn highlight_warning(msg: &str) -> ColoredString {
  function highlight_info (line 289) | pub fn highlight_info(msg: &str) -> ColoredString {
  function open_url (line 295) | pub fn open_url(url: impl Borrow<Url>) -> Result<(), IoError> {
  function open_path (line 301) | pub fn open_path(path: &str) -> Result<(), IoError> {
  function set_clipboard (line 307) | pub fn set_clipboard(content: String) -> Result<(), ClipboardError> {
  type ClipboardType (line 325) | pub enum ClipboardType {
    method select (line 346) | pub fn select() -> Self {
    method set (line 370) | pub fn set(&self, content: String) -> Result<(), ClipboardError> {
    method native_set (line 385) | fn native_set(content: String) -> Result<(), ClipboardError> {
    method xclip_set (line 393) | fn xclip_set(path: Option<String>, content: &str) -> Result<(), Clipbo...
    method xsel_set (line 404) | fn xsel_set(path: Option<String>, content: &str) -> Result<(), Clipboa...
    method sys_cmd_set (line 413) | fn sys_cmd_set(
    method fmt (line 454) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type ClipboardError (line 474) | pub enum ClipboardError {
  function check_empty_password (line 507) | pub fn check_empty_password(password: &str, matcher_main: &MainMatcher) {
  function prompt_password (line 523) | pub fn prompt_password(main_matcher: &MainMatcher, optional: bool) -> Op...
  function ensure_password (line 576) | pub fn ensure_password(
  function prompt (line 626) | pub fn prompt(msg: &str, main_matcher: &MainMatcher) -> String {
  function prompt_yes (line 660) | pub fn prompt_yes(msg: &str, def: Option<bool>, main_matcher: &MainMatch...
  function derive_bool (line 713) | fn derive_bool(input: &str) -> Option<bool> {
  function prompt_owner_token (line 737) | pub fn prompt_owner_token(main_matcher: &MainMatcher, optional: bool) ->...
  function ensure_owner_token (line 759) | pub fn ensure_owner_token(
  function format_bytes (line 816) | pub fn format_bytes(bytes: u64) -> String {
  function parse_duration (line 842) | pub fn parse_duration(duration: &str) -> Result<usize, ParseDurationErro...
  type ParseDurationError (line 877) | pub enum ParseDurationError {
  function format_duration (line 911) | pub fn format_duration(duration: impl Borrow<Duration>) -> String {
  function format_bool (line 942) | pub fn format_bool(b: bool) -> &'static str {
  function bin_name (line 958) | pub fn bin_name() -> String {
  function ensure_enough_space (line 977) | pub fn ensure_enough_space<P: AsRef<Path>>(path: P, size: u64) {
  function app_project_dirs (line 1016) | pub fn app_project_dirs() -> ProjectDirs {
  function app_history_file_path (line 1023) | pub fn app_history_file_path() -> PathBuf {
  function app_history_file_path_string (line 1029) | pub fn app_history_file_path_string() -> String {
  function env_var_present (line 1036) | pub fn env_var_present(key: impl AsRef<OsStr>) -> bool {
  function features_list (line 1041) | pub fn features_list() -> Vec<&'static str> {
  function api_version_list (line 1078) | pub fn api_version_list() -> Vec<&'static str> {
  function follow_url (line 1097) | pub fn follow_url(client: &Client, url: &Url) -> Result<Url, FollowError> {
  type FollowError (line 1111) | pub enum FollowError {
    method from (line 1122) | fn from(err: ResponseError) -> Self {
  function rand_alphanum_string (line 1128) | pub fn rand_alphanum_string(len: usize) -> String {
  function stdin_read_file (line 1137) | pub fn stdin_read_file(prompt: bool) -> Result<Vec<u8>, StdinErr> {
  type StdinErr (line 1155) | pub enum StdinErr {