github.com/machinefi/w3bstream@v1.6.5-rc9.0.20240426031326-b8c7c4876e72/pkg/depends/conf/jwt/signing_method__generated.go (about)

     1  // This is a generated source file. DO NOT EDIT
     2  // Source: jwt/signing_method__generated.go
     3  
     4  package jwt
     5  
     6  import (
     7  	"bytes"
     8  	"database/sql/driver"
     9  	"errors"
    10  
    11  	"github.com/machinefi/w3bstream/pkg/depends/kit/enum"
    12  )
    13  
    14  var InvalidSigningMethod = errors.New("invalid SigningMethod type")
    15  
    16  func ParseSigningMethodFromString(s string) (SigningMethod, error) {
    17  	switch s {
    18  	default:
    19  		return SIGNING_METHOD_UNKNOWN, InvalidSigningMethod
    20  	case "":
    21  		return SIGNING_METHOD_UNKNOWN, nil
    22  	case "ECDSA256":
    23  		return SIGNING_METHOD__ECDSA256, nil
    24  	case "ECDSA384":
    25  		return SIGNING_METHOD__ECDSA384, nil
    26  	case "ECDSA512":
    27  		return SIGNING_METHOD__ECDSA512, nil
    28  	case "HMAC256":
    29  		return SIGNING_METHOD__HMAC256, nil
    30  	case "HMAC384":
    31  		return SIGNING_METHOD__HMAC384, nil
    32  	case "HMAC512":
    33  		return SIGNING_METHOD__HMAC512, nil
    34  	case "RSA256":
    35  		return SIGNING_METHOD__RSA256, nil
    36  	case "RSA384":
    37  		return SIGNING_METHOD__RSA384, nil
    38  	case "RSA512":
    39  		return SIGNING_METHOD__RSA512, nil
    40  	case "RSAPSS256":
    41  		return SIGNING_METHOD__RSAPSS256, nil
    42  	case "RSAPSS384":
    43  		return SIGNING_METHOD__RSAPSS384, nil
    44  	case "RSAPSS512":
    45  		return SIGNING_METHOD__RSAPSS512, nil
    46  	}
    47  }
    48  
    49  func ParseSigningMethodFromLabel(s string) (SigningMethod, error) {
    50  	switch s {
    51  	default:
    52  		return SIGNING_METHOD_UNKNOWN, InvalidSigningMethod
    53  	case "":
    54  		return SIGNING_METHOD_UNKNOWN, nil
    55  	case "ECDSA256":
    56  		return SIGNING_METHOD__ECDSA256, nil
    57  	case "ECDSA384":
    58  		return SIGNING_METHOD__ECDSA384, nil
    59  	case "ECDSA512":
    60  		return SIGNING_METHOD__ECDSA512, nil
    61  	case "HMAC256":
    62  		return SIGNING_METHOD__HMAC256, nil
    63  	case "HMAC384":
    64  		return SIGNING_METHOD__HMAC384, nil
    65  	case "HMAC512":
    66  		return SIGNING_METHOD__HMAC512, nil
    67  	case "RSA256":
    68  		return SIGNING_METHOD__RSA256, nil
    69  	case "RSA384":
    70  		return SIGNING_METHOD__RSA384, nil
    71  	case "RSA512":
    72  		return SIGNING_METHOD__RSA512, nil
    73  	case "RSAPSS256":
    74  		return SIGNING_METHOD__RSAPSS256, nil
    75  	case "RSAPSS384":
    76  		return SIGNING_METHOD__RSAPSS384, nil
    77  	case "RSAPSS512":
    78  		return SIGNING_METHOD__RSAPSS512, nil
    79  	}
    80  }
    81  
    82  func (v SigningMethod) Int() int {
    83  	return int(v)
    84  }
    85  
    86  func (v SigningMethod) String() string {
    87  	switch v {
    88  	default:
    89  		return "UNKNOWN"
    90  	case SIGNING_METHOD_UNKNOWN:
    91  		return ""
    92  	case SIGNING_METHOD__ECDSA256:
    93  		return "ECDSA256"
    94  	case SIGNING_METHOD__ECDSA384:
    95  		return "ECDSA384"
    96  	case SIGNING_METHOD__ECDSA512:
    97  		return "ECDSA512"
    98  	case SIGNING_METHOD__HMAC256:
    99  		return "HMAC256"
   100  	case SIGNING_METHOD__HMAC384:
   101  		return "HMAC384"
   102  	case SIGNING_METHOD__HMAC512:
   103  		return "HMAC512"
   104  	case SIGNING_METHOD__RSA256:
   105  		return "RSA256"
   106  	case SIGNING_METHOD__RSA384:
   107  		return "RSA384"
   108  	case SIGNING_METHOD__RSA512:
   109  		return "RSA512"
   110  	case SIGNING_METHOD__RSAPSS256:
   111  		return "RSAPSS256"
   112  	case SIGNING_METHOD__RSAPSS384:
   113  		return "RSAPSS384"
   114  	case SIGNING_METHOD__RSAPSS512:
   115  		return "RSAPSS512"
   116  	}
   117  }
   118  
   119  func (v SigningMethod) Label() string {
   120  	switch v {
   121  	default:
   122  		return "UNKNOWN"
   123  	case SIGNING_METHOD_UNKNOWN:
   124  		return ""
   125  	case SIGNING_METHOD__ECDSA256:
   126  		return "ECDSA256"
   127  	case SIGNING_METHOD__ECDSA384:
   128  		return "ECDSA384"
   129  	case SIGNING_METHOD__ECDSA512:
   130  		return "ECDSA512"
   131  	case SIGNING_METHOD__HMAC256:
   132  		return "HMAC256"
   133  	case SIGNING_METHOD__HMAC384:
   134  		return "HMAC384"
   135  	case SIGNING_METHOD__HMAC512:
   136  		return "HMAC512"
   137  	case SIGNING_METHOD__RSA256:
   138  		return "RSA256"
   139  	case SIGNING_METHOD__RSA384:
   140  		return "RSA384"
   141  	case SIGNING_METHOD__RSA512:
   142  		return "RSA512"
   143  	case SIGNING_METHOD__RSAPSS256:
   144  		return "RSAPSS256"
   145  	case SIGNING_METHOD__RSAPSS384:
   146  		return "RSAPSS384"
   147  	case SIGNING_METHOD__RSAPSS512:
   148  		return "RSAPSS512"
   149  	}
   150  }
   151  
   152  func (v SigningMethod) TypeName() string {
   153  	return "github.com/machinefi/w3bstream/pkg/depends/conf/jwt.SigningMethod"
   154  }
   155  
   156  func (v SigningMethod) ConstValues() []enum.IntStringerEnum {
   157  	return []enum.IntStringerEnum{SIGNING_METHOD__ECDSA256, SIGNING_METHOD__ECDSA384, SIGNING_METHOD__ECDSA512, SIGNING_METHOD__HMAC256, SIGNING_METHOD__HMAC384, SIGNING_METHOD__HMAC512, SIGNING_METHOD__RSA256, SIGNING_METHOD__RSA384, SIGNING_METHOD__RSA512, SIGNING_METHOD__RSAPSS256, SIGNING_METHOD__RSAPSS384, SIGNING_METHOD__RSAPSS512}
   158  }
   159  
   160  func (v SigningMethod) MarshalText() ([]byte, error) {
   161  	s := v.String()
   162  	if s == "UNKNOWN" {
   163  		return nil, InvalidSigningMethod
   164  	}
   165  	return []byte(s), nil
   166  }
   167  
   168  func (v *SigningMethod) UnmarshalText(data []byte) error {
   169  	s := string(bytes.ToUpper(data))
   170  	val, err := ParseSigningMethodFromString(s)
   171  	if err != nil {
   172  		return err
   173  	}
   174  	*(v) = val
   175  	return nil
   176  }
   177  
   178  func (v *SigningMethod) Scan(src interface{}) error {
   179  	offset := 0
   180  	o, ok := interface{}(v).(enum.ValueOffset)
   181  	if ok {
   182  		offset = o.Offset()
   183  	}
   184  	i, err := enum.ScanIntEnumStringer(src, offset)
   185  	if err != nil {
   186  		return err
   187  	}
   188  	*(v) = SigningMethod(i)
   189  	return nil
   190  }
   191  
   192  func (v SigningMethod) Value() (driver.Value, error) {
   193  	offset := 0
   194  	o, ok := interface{}(v).(enum.ValueOffset)
   195  	if ok {
   196  		offset = o.Offset()
   197  	}
   198  	return int64(v) + int64(offset), nil
   199  }