flag_generated.go

Documentation: github.com/urfave/cli/v2/altsrc

     1  // WARNING: this file is generated. DO NOT EDIT
     2  
     3  package altsrc
     4  
     5  import (
     6  	"flag"
     7  
     8  	"github.com/urfave/cli/v2"
     9  )
    10  
    11  // BoolFlag is the flag type that wraps cli.BoolFlag to allow
    12  // for other values to be specified
    13  type BoolFlag struct {
    14  	*cli.BoolFlag
    15  	set *flag.FlagSet
    16  }
    17  
    18  // NewBoolFlag creates a new BoolFlag
    19  func NewBoolFlag(fl *cli.BoolFlag) *BoolFlag {
    20  	return &BoolFlag{BoolFlag: fl, set: nil}
    21  }
    22  
    23  // Apply saves the flagSet for later usage calls, then calls
    24  // the wrapped BoolFlag.Apply
    25  func (f *BoolFlag) Apply(set *flag.FlagSet) error {
    26  	f.set = set
    27  	return f.BoolFlag.Apply(set)
    28  }
    29  
    30  // DurationFlag is the flag type that wraps cli.DurationFlag to allow
    31  // for other values to be specified
    32  type DurationFlag struct {
    33  	*cli.DurationFlag
    34  	set *flag.FlagSet
    35  }
    36  
    37  // NewDurationFlag creates a new DurationFlag
    38  func NewDurationFlag(fl *cli.DurationFlag) *DurationFlag {
    39  	return &DurationFlag{DurationFlag: fl, set: nil}
    40  }
    41  
    42  // Apply saves the flagSet for later usage calls, then calls
    43  // the wrapped DurationFlag.Apply
    44  func (f *DurationFlag) Apply(set *flag.FlagSet) error {
    45  	f.set = set
    46  	return f.DurationFlag.Apply(set)
    47  }
    48  
    49  // Float64Flag is the flag type that wraps cli.Float64Flag to allow
    50  // for other values to be specified
    51  type Float64Flag struct {
    52  	*cli.Float64Flag
    53  	set *flag.FlagSet
    54  }
    55  
    56  // NewFloat64Flag creates a new Float64Flag
    57  func NewFloat64Flag(fl *cli.Float64Flag) *Float64Flag {
    58  	return &Float64Flag{Float64Flag: fl, set: nil}
    59  }
    60  
    61  // Apply saves the flagSet for later usage calls, then calls
    62  // the wrapped Float64Flag.Apply
    63  func (f *Float64Flag) Apply(set *flag.FlagSet) error {
    64  	f.set = set
    65  	return f.Float64Flag.Apply(set)
    66  }
    67  
    68  // Float64SliceFlag is the flag type that wraps cli.Float64SliceFlag to allow
    69  // for other values to be specified
    70  type Float64SliceFlag struct {
    71  	*cli.Float64SliceFlag
    72  	set *flag.FlagSet
    73  }
    74  
    75  // NewFloat64SliceFlag creates a new Float64SliceFlag
    76  func NewFloat64SliceFlag(fl *cli.Float64SliceFlag) *Float64SliceFlag {
    77  	return &Float64SliceFlag{Float64SliceFlag: fl, set: nil}
    78  }
    79  
    80  // Apply saves the flagSet for later usage calls, then calls
    81  // the wrapped Float64SliceFlag.Apply
    82  func (f *Float64SliceFlag) Apply(set *flag.FlagSet) error {
    83  	f.set = set
    84  	return f.Float64SliceFlag.Apply(set)
    85  }
    86  
    87  // GenericFlag is the flag type that wraps cli.GenericFlag to allow
    88  // for other values to be specified
    89  type GenericFlag struct {
    90  	*cli.GenericFlag
    91  	set *flag.FlagSet
    92  }
    93  
    94  // NewGenericFlag creates a new GenericFlag
    95  func NewGenericFlag(fl *cli.GenericFlag) *GenericFlag {
    96  	return &GenericFlag{GenericFlag: fl, set: nil}
    97  }
    98  
    99  // Apply saves the flagSet for later usage calls, then calls
   100  // the wrapped GenericFlag.Apply
   101  func (f *GenericFlag) Apply(set *flag.FlagSet) error {
   102  	f.set = set
   103  	return f.GenericFlag.Apply(set)
   104  }
   105  
   106  // IntFlag is the flag type that wraps cli.IntFlag to allow
   107  // for other values to be specified
   108  type IntFlag struct {
   109  	*cli.IntFlag
   110  	set *flag.FlagSet
   111  }
   112  
   113  // NewIntFlag creates a new IntFlag
   114  func NewIntFlag(fl *cli.IntFlag) *IntFlag {
   115  	return &IntFlag{IntFlag: fl, set: nil}
   116  }
   117  
   118  // Apply saves the flagSet for later usage calls, then calls
   119  // the wrapped IntFlag.Apply
   120  func (f *IntFlag) Apply(set *flag.FlagSet) error {
   121  	f.set = set
   122  	return f.IntFlag.Apply(set)
   123  }
   124  
   125  // Int64Flag is the flag type that wraps cli.Int64Flag to allow
   126  // for other values to be specified
   127  type Int64Flag struct {
   128  	*cli.Int64Flag
   129  	set *flag.FlagSet
   130  }
   131  
   132  // NewInt64Flag creates a new Int64Flag
   133  func NewInt64Flag(fl *cli.Int64Flag) *Int64Flag {
   134  	return &Int64Flag{Int64Flag: fl, set: nil}
   135  }
   136  
   137  // Apply saves the flagSet for later usage calls, then calls
   138  // the wrapped Int64Flag.Apply
   139  func (f *Int64Flag) Apply(set *flag.FlagSet) error {
   140  	f.set = set
   141  	return f.Int64Flag.Apply(set)
   142  }
   143  
   144  // Int64SliceFlag is the flag type that wraps cli.Int64SliceFlag to allow
   145  // for other values to be specified
   146  type Int64SliceFlag struct {
   147  	*cli.Int64SliceFlag
   148  	set *flag.FlagSet
   149  }
   150  
   151  // NewInt64SliceFlag creates a new Int64SliceFlag
   152  func NewInt64SliceFlag(fl *cli.Int64SliceFlag) *Int64SliceFlag {
   153  	return &Int64SliceFlag{Int64SliceFlag: fl, set: nil}
   154  }
   155  
   156  // Apply saves the flagSet for later usage calls, then calls
   157  // the wrapped Int64SliceFlag.Apply
   158  func (f *Int64SliceFlag) Apply(set *flag.FlagSet) error {
   159  	f.set = set
   160  	return f.Int64SliceFlag.Apply(set)
   161  }
   162  
   163  // IntSliceFlag is the flag type that wraps cli.IntSliceFlag to allow
   164  // for other values to be specified
   165  type IntSliceFlag struct {
   166  	*cli.IntSliceFlag
   167  	set *flag.FlagSet
   168  }
   169  
   170  // NewIntSliceFlag creates a new IntSliceFlag
   171  func NewIntSliceFlag(fl *cli.IntSliceFlag) *IntSliceFlag {
   172  	return &IntSliceFlag{IntSliceFlag: fl, set: nil}
   173  }
   174  
   175  // Apply saves the flagSet for later usage calls, then calls
   176  // the wrapped IntSliceFlag.Apply
   177  func (f *IntSliceFlag) Apply(set *flag.FlagSet) error {
   178  	f.set = set
   179  	return f.IntSliceFlag.Apply(set)
   180  }
   181  
   182  // PathFlag is the flag type that wraps cli.PathFlag to allow
   183  // for other values to be specified
   184  type PathFlag struct {
   185  	*cli.PathFlag
   186  	set *flag.FlagSet
   187  }
   188  
   189  // NewPathFlag creates a new PathFlag
   190  func NewPathFlag(fl *cli.PathFlag) *PathFlag {
   191  	return &PathFlag{PathFlag: fl, set: nil}
   192  }
   193  
   194  // Apply saves the flagSet for later usage calls, then calls
   195  // the wrapped PathFlag.Apply
   196  func (f *PathFlag) Apply(set *flag.FlagSet) error {
   197  	f.set = set
   198  	return f.PathFlag.Apply(set)
   199  }
   200  
   201  // StringFlag is the flag type that wraps cli.StringFlag to allow
   202  // for other values to be specified
   203  type StringFlag struct {
   204  	*cli.StringFlag
   205  	set *flag.FlagSet
   206  }
   207  
   208  // NewStringFlag creates a new StringFlag
   209  func NewStringFlag(fl *cli.StringFlag) *StringFlag {
   210  	return &StringFlag{StringFlag: fl, set: nil}
   211  }
   212  
   213  // Apply saves the flagSet for later usage calls, then calls
   214  // the wrapped StringFlag.Apply
   215  func (f *StringFlag) Apply(set *flag.FlagSet) error {
   216  	f.set = set
   217  	return f.StringFlag.Apply(set)
   218  }
   219  
   220  // StringSliceFlag is the flag type that wraps cli.StringSliceFlag to allow
   221  // for other values to be specified
   222  type StringSliceFlag struct {
   223  	*cli.StringSliceFlag
   224  	set *flag.FlagSet
   225  }
   226  
   227  // NewStringSliceFlag creates a new StringSliceFlag
   228  func NewStringSliceFlag(fl *cli.StringSliceFlag) *StringSliceFlag {
   229  	return &StringSliceFlag{StringSliceFlag: fl, set: nil}
   230  }
   231  
   232  // Apply saves the flagSet for later usage calls, then calls
   233  // the wrapped StringSliceFlag.Apply
   234  func (f *StringSliceFlag) Apply(set *flag.FlagSet) error {
   235  	f.set = set
   236  	return f.StringSliceFlag.Apply(set)
   237  }
   238  
   239  // UintFlag is the flag type that wraps cli.UintFlag to allow
   240  // for other values to be specified
   241  type UintFlag struct {
   242  	*cli.UintFlag
   243  	set *flag.FlagSet
   244  }
   245  
   246  // NewUintFlag creates a new UintFlag
   247  func NewUintFlag(fl *cli.UintFlag) *UintFlag {
   248  	return &UintFlag{UintFlag: fl, set: nil}
   249  }
   250  
   251  // Apply saves the flagSet for later usage calls, then calls
   252  // the wrapped UintFlag.Apply
   253  func (f *UintFlag) Apply(set *flag.FlagSet) error {
   254  	f.set = set
   255  	return f.UintFlag.Apply(set)
   256  }
   257  
   258  // Uint64Flag is the flag type that wraps cli.Uint64Flag to allow
   259  // for other values to be specified
   260  type Uint64Flag struct {
   261  	*cli.Uint64Flag
   262  	set *flag.FlagSet
   263  }
   264  
   265  // NewUint64Flag creates a new Uint64Flag
   266  func NewUint64Flag(fl *cli.Uint64Flag) *Uint64Flag {
   267  	return &Uint64Flag{Uint64Flag: fl, set: nil}
   268  }
   269  
   270  // Apply saves the flagSet for later usage calls, then calls
   271  // the wrapped Uint64Flag.Apply
   272  func (f *Uint64Flag) Apply(set *flag.FlagSet) error {
   273  	f.set = set
   274  	return f.Uint64Flag.Apply(set)
   275  }
   276  
   277  // vim:ro
   278
View as plain text