// Get displays a prompt to, and reads in a password from /dev/tty
// (/dev/cons). Get turns off character echoing while reading the
// password. The calling process should zero the password as soon
// as possible.
426748
func Get(prompt string) ([]byte, error) {
	if passFunc == nil {
		return nil, ErrUnsupportedOS
	}
	return passFunc(prompt)
}
453313
func (po *Po) Get(str string, vars ...interface{}) string {
	// Sync read
	po.RLock()
	defer po.RUnlock()

	if po.translations != nil {
		if _, ok := po.translations[str]; ok {
			return Printf(po.translations[str].Get(), vars...)
		}
	}

	// Return the same we received by default
	return Printf(str, vars...)
}
1234072
func GetPassphrase(in *bufio.Reader) ([]byte, error) {
	var (
		passphrase []byte
		err        error
	)

	if terminal.IsTerminal(int(os.Stdin.Fd())) {
		passphrase, err = terminal.ReadPassword(int(os.Stdin.Fd()))
	} else {
		passphrase, err = in.ReadBytes('\n')
	}

	return passphrase, err
}
426402
func (a StringA) Get(vals ...interface{}) (val string) {
	v := get(a("").arg(), vals)
	switch v := v.(type) {
	case *string:
		return *v
	case string:
		return v
	}
	return
}
376723
func (c *Client) Get(key string) (string, error) {
	var s string
	err := c.command(&s,
		[]byte("GET"),
		[]byte(key),
	)
	return s, err
}
218721
func (m *MockIngressInterface) Get(arg0 string, arg1 v1.GetOptions) (*v1beta1.Ingress, error) {
	ret := m.ctrl.Call(m, "Get", arg0, arg1)
	ret0, _ := ret[0].(*v1beta1.Ingress)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
446377
func (tx *Tx) Get(dest interface{}, query string, args ...interface{}) error {
	return Get(tx, dest, query, args...)
}
324135
func (yfast *YFastTrie) Get(key uint64) Entry {
	entry := yfast.get(key)
	if entry == nil {
		return nil
	}

	return entry
}
204313
func (s Store) Get(key string) (KVPair, error) {
	s.RLock()
	kv, ok := s.m[key]
	s.RUnlock()
	if !ok {
		return kv, &KeyError{key, ErrNotExist}
	}
	return kv, nil
}
719381
func (k macOSXKeychain) Get(service, username string) (string, error) {
	out, err := exec.Command(
		execPathKeychain,
		"find-generic-password",
		"-s", service,
		"-wa", username).CombinedOutput()
	if err != nil {
		if strings.Contains(fmt.Sprintf("%s", out), "could not be found") {
			err = ErrNotFound
		}
		return "", err
	}
	// if the added secret has multiple lines, osx will hex encode it
	trimStr := strings.TrimSpace(string(out[:]))
	dec, err := hex.DecodeString(trimStr)
	// if there was an error hex decoding the string, assume it's not encoded
	if err != nil {
		return fmt.Sprintf("%s", trimStr), nil
	}
	return fmt.Sprintf("%s", dec), err
}
656561
func (h *syncHandler) Get(key string, args ...interface{}) (interface{}, error) {
	defer h.mutex.RUnlock()
	h.mutex.RLock()
	return h.handler.Get(key, args...)
}
802017
func (h *envHandler) Get(key string, args ...interface{}) (interface{}, error) {
	if len(args) != 0 {
		return "", cfg.ErrArgsNotSupported
	}
	val := os.Getenv(key)
	if val == "" {
		return val, cfg.ErrKeyNotFound
	}
	return val, nil
}
1266257
func (c *Config) Get(key string) (Value, error) {
	val, ok := (*c)[key]
	if !ok {
		return val, ErrNoSuchKey
	}
	return val, nil
}
530779
func (a Uint64A) Get(vals ...interface{}) (val uint64) {
	v := get(a(0).arg(), vals)
	switch v := v.(type) {
	case *uint64:
		return *v
	case uint64:
		return v
	}
	return
}
596980
func (u Uint32) Get() (uint32, error) {
	if !u.Present() {
		var zero uint32
		return zero, errors.New("value not present")
	}
	return *u.value, nil
}
1242259
func (v Uint32) Get(deflt uint32) uint32 {
	if !v.Defined {
		return deflt
	}
	return v.V
}
206604
func (e *Error) Get() error {
	e.lock.RLock()
	defer e.lock.RUnlock()

	return e.err
}