Enum atefs::opts::SubCommand

pub enum SubCommand {
    User(OptsUser),
    Domain(OptsDomain),
    Db(OptsDatabase),
    Token(OptsToken),
    Service(OptsService),
    Contract(OptsContract),
    Wallet(OptsWallet),
    Login(OptsLogin),
    Logout(OptsLogout),
    Mount(OptsMount),
}

Variants

User(OptsUser)

Users are personal accounts and services that have an authentication context. Every user comes with a personal wallet that can hold commodities.

Domain(OptsDomain)

Domain groups are collections of users that share something together in association with an internet domain name. Every group has a built in wallet(s) that you can use instead of a personal wallet. In order to claim a domain group you will need DNS access to an owned internet domain that can be validated.

Db(OptsDatabase)

Databases are chains of data that make up a particular shard. These databases can be use for application data persistance, file systems and web sites.

Token(OptsToken)

Tokens are stored authentication and authorization secrets used by other processes. Using this command you may generate a custom token however the usual method for authentication is to use the login command instead.

Service(OptsService)

Services offered by Tokera (and other 3rd parties) are accessible via this sub command menu, including viewing the available services and subscribing to them.

Contract(OptsContract)

Contracts represent all the subscriptions you have made to specific services you personally consume or a group consume that you act on your authority on behalf of. This sub-menu allows you to perform actions such as cancel said contracts.

Wallet(OptsWallet)

Wallets are directly attached to groups and users - they hold a balance, store transaction history and facilitate transfers, deposits and withdraws.

Login(OptsLogin)

Login to an account and store the token locally for reuse.

Logout(OptsLogout)

Logout of the account by deleting the local token.

Mount(OptsMount)

Mounts a local or a remote file system (e.g. ws://tokera.sh/db). When using a Tokera remote you can either use the default free hosting or subscribe to the service which will consume funds from the wallet.

Trait Implementations

impl CommandFactory for SubCommand

fn into_app<'b>() -> Command<'b>

👎 Deprecated since 3.1.0:

Replaced with `CommandFactory::command

Deprecated, replaced with CommandFactory::command

fn into_app_for_update<'b>() -> Command<'b>

👎 Deprecated since 3.1.0:

Replaced with `CommandFactory::command_for_update

Deprecated, replaced with CommandFactory::command_for_update

fn command<'help>() -> App<'help>

Build an Command that can instantiate Self.

fn command_for_update<'help>() -> App<'help>

Build an Command that can update self.

impl FromArgMatches for SubCommand

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches<'b>(
    &mut self,
    __clap_arg_matches: &ArgMatches
) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Parser for SubCommand

fn parse() -> Self

Parse from std::env::args_os(), exit on error

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self where
    I: IntoIterator<Item = T>,
    T: Into<OsString> + Clone, 

Parse from iterator, exit on error

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error> where
    I: IntoIterator<Item = T>,
    T: Into<OsString> + Clone, 

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I) where
    I: IntoIterator<Item = T>,
    T: Into<OsString> + Clone, 

Update from iterator, exit on error

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error> where
    I: IntoIterator<Item = T>,
    T: Into<OsString> + Clone, 

Update from iterator, return Err on error.

impl Subcommand for SubCommand

fn augment_subcommands<'b>(__clap_app: Command<'b>) -> Command<'b>

Append to Command so it can instantiate Self.

fn augment_subcommands_for_update<'b>(__clap_app: Command<'b>) -> Command<'b>

Append to Command so it can update self.

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand