github.com/containers/libpod@v1.9.4-0.20220419124438-4284fd425507/cmd/podman/cliconfig/commands.go (about)

     1  package cliconfig
     2  
     3  import (
     4  	"github.com/sirupsen/logrus"
     5  )
     6  
     7  // GlobalIsSet is a compatibility method for urfave
     8  func (p *PodmanCommand) GlobalIsSet(opt string) bool {
     9  	flag := p.PersistentFlags().Lookup(opt)
    10  	if flag == nil {
    11  		return false
    12  	}
    13  	return flag.Changed
    14  }
    15  
    16  // IsSet is a compatibility method for urfave
    17  func (p *PodmanCommand) IsSet(opt string) bool {
    18  	flag := p.Flags().Lookup(opt)
    19  	if flag == nil {
    20  		return false
    21  	}
    22  	return flag.Changed
    23  }
    24  
    25  // Bool is a compatibility method for urfave
    26  func (p *PodmanCommand) Bool(opt string) bool {
    27  	flag := p.Flags().Lookup(opt)
    28  	if flag == nil {
    29  		if !p.Remote {
    30  			logrus.Errorf("Could not find flag %s", opt)
    31  		}
    32  		return false
    33  	}
    34  	val, err := p.Flags().GetBool(opt)
    35  	if err != nil {
    36  		logrus.Errorf("Error getting flag %s: %v", opt, err)
    37  	}
    38  	return val
    39  }
    40  
    41  // String is a compatibility method for urfave
    42  func (p *PodmanCommand) String(opt string) string {
    43  	flag := p.Flags().Lookup(opt)
    44  	if flag == nil {
    45  		if !p.Remote {
    46  			logrus.Errorf("Could not find flag %s", opt)
    47  		}
    48  		return ""
    49  	}
    50  	val, err := p.Flags().GetString(opt)
    51  	if err != nil {
    52  		logrus.Errorf("Error getting flag %s: %v", opt, err)
    53  	}
    54  	return val
    55  }
    56  
    57  // StringArray is a compatibility method for urfave
    58  func (p *PodmanCommand) StringArray(opt string) []string {
    59  	flag := p.Flags().Lookup(opt)
    60  	if flag == nil {
    61  		if !p.Remote {
    62  			logrus.Errorf("Could not find flag %s", opt)
    63  		}
    64  		return []string{}
    65  	}
    66  	val, err := p.Flags().GetStringArray(opt)
    67  	if err != nil {
    68  		logrus.Errorf("Error getting flag %s: %v", opt, err)
    69  	}
    70  	return val
    71  }
    72  
    73  // StringSlice is a compatibility method for urfave
    74  func (p *PodmanCommand) StringSlice(opt string) []string {
    75  	flag := p.Flags().Lookup(opt)
    76  	if flag == nil {
    77  		if !p.Remote {
    78  			logrus.Errorf("Could not find flag %s", opt)
    79  		}
    80  		return []string{}
    81  	}
    82  	val, err := p.Flags().GetStringSlice(opt)
    83  	if err != nil {
    84  		logrus.Errorf("Error getting flag %s: %v", opt, err)
    85  	}
    86  	return val
    87  }
    88  
    89  // Int is a compatibility method for urfave
    90  func (p *PodmanCommand) Int(opt string) int {
    91  	flag := p.Flags().Lookup(opt)
    92  	if flag == nil {
    93  		if !p.Remote {
    94  			logrus.Errorf("Could not find flag %s", opt)
    95  		}
    96  		return 0
    97  	}
    98  	val, err := p.Flags().GetInt(opt)
    99  	if err != nil {
   100  		logrus.Errorf("Error getting flag %s: %v", opt, err)
   101  	}
   102  	return val
   103  }
   104  
   105  // Unt is a compatibility method for urfave
   106  func (p *PodmanCommand) Uint(opt string) uint {
   107  	flag := p.Flags().Lookup(opt)
   108  	if flag == nil {
   109  		if !p.Remote {
   110  			logrus.Errorf("Could not find flag %s", opt)
   111  		}
   112  		return 0
   113  	}
   114  	val, err := p.Flags().GetUint(opt)
   115  	if err != nil {
   116  		logrus.Errorf("Error getting flag %s: %v", opt, err)
   117  	}
   118  	return val
   119  }
   120  
   121  // Int64 is a compatibility method for urfave
   122  func (p *PodmanCommand) Int64(opt string) int64 {
   123  	flag := p.Flags().Lookup(opt)
   124  	if flag == nil {
   125  		if !p.Remote {
   126  			logrus.Errorf("Could not find flag %s", opt)
   127  		}
   128  		return 0
   129  	}
   130  	val, err := p.Flags().GetInt64(opt)
   131  	if err != nil {
   132  		logrus.Errorf("Error getting flag %s: %v", opt, err)
   133  	}
   134  	return val
   135  }
   136  
   137  // Unt64 is a compatibility method for urfave
   138  func (p *PodmanCommand) Uint64(opt string) uint64 {
   139  	flag := p.Flags().Lookup(opt)
   140  	if flag == nil {
   141  		if !p.Remote {
   142  			logrus.Errorf("Could not find flag %s", opt)
   143  		}
   144  		return 0
   145  	}
   146  	val, err := p.Flags().GetUint64(opt)
   147  	if err != nil {
   148  		logrus.Errorf("Error getting flag %s: %v", opt, err)
   149  	}
   150  	return val
   151  }
   152  
   153  // Float64 is a compatibility method for urfave
   154  func (p *PodmanCommand) Float64(opt string) float64 {
   155  	flag := p.Flags().Lookup(opt)
   156  	if flag == nil {
   157  		if !p.Remote {
   158  			logrus.Errorf("Could not find flag %s", opt)
   159  		}
   160  		return 0
   161  	}
   162  	val, err := p.Flags().GetFloat64(opt)
   163  	if err != nil {
   164  		logrus.Errorf("Error getting flag %s: %v", opt, err)
   165  	}
   166  	return val
   167  }