github.com/iEvan-lhr/exciting-tool@v0.0.0-20230504054234-8e983f73cdd2/errors.go (about)

     1  package tools
     2  
     3  import (
     4  	"log"
     5  	"reflect"
     6  )
     7  
     8  type ParseError struct {
     9  	values []reflect.Value
    10  	err    error
    11  	isErr  bool
    12  }
    13  
    14  func ReturnValue(v ...interface{}) interface{} {
    15  	if v[len(v)-1] != nil {
    16  		log.Println(v[len(v)-1])
    17  	}
    18  	return v[0]
    19  }
    20  
    21  func ReturnValueByTwo(v ...interface{}) interface{} {
    22  	if v[len(v)-1] != nil {
    23  		panic(v[len(v)-1])
    24  	}
    25  	return v[0]
    26  }
    27  
    28  func PanicError(f ...func() error) {
    29  	for _, fun := range f {
    30  		if err := fun(); err != nil {
    31  			panic(err)
    32  		}
    33  	}
    34  }
    35  
    36  // ExecGoFunc       方法                参数
    37  func ExecGoFunc(exec interface{}, args ...interface{}) {
    38  	go func() {
    39  		defer func() {
    40  			if e := recover(); e != nil {
    41  				panic(e)
    42  			}
    43  		}()
    44  		var values []reflect.Value
    45  		for _, arg := range args {
    46  			values = append(values, reflect.ValueOf(arg))
    47  		}
    48  		reflect.ValueOf(exec).Call(values)
    49  	}()
    50  }
    51  
    52  func ExecError(err error) {
    53  	if err != nil {
    54  		panic(err)
    55  	}
    56  }
    57  
    58  func Error(e interface{}) {
    59  	switch e.(type) {
    60  	case error:
    61  		if e.(error) != nil {
    62  			panic(e.(error))
    63  		}
    64  	case []error:
    65  		for _, err := range e.([]error) {
    66  			if err != nil {
    67  				panic(err)
    68  			}
    69  		}
    70  	}
    71  }
    72  
    73  func LogError(err error) {
    74  	if err != nil {
    75  		log.Println(err)
    76  	}
    77  }
    78  
    79  func eatError(err error) {
    80  
    81  }
    82  
    83  func DeferError(err error, exec interface{}, args ...interface{}) {
    84  	defer func() {
    85  		var values []reflect.Value
    86  		for _, arg := range args {
    87  			values = append(values, reflect.ValueOf(arg))
    88  		}
    89  		reflect.ValueOf(exec).Call(values)
    90  	}()
    91  	if err != nil {
    92  		panic(err)
    93  	}
    94  }
    95  
    96  func ReturnError(err error, succ func(...interface{}) *ParseError, fail func(...interface{}) *ParseError, args ...interface{}) (vars *ParseError) {
    97  	if err != nil {
    98  		return fail(args...)
    99  	}
   100  	return succ(args...)
   101  }
   102  
   103  func F(args ...interface{}) (vars *ParseError) {
   104  	vars = &ParseError{}
   105  	vars.isErr = true
   106  	var values []reflect.Value
   107  	for _, arg := range args[1:] {
   108  		values = append(values, reflect.ValueOf(arg))
   109  	}
   110  	vars.values = append(vars.values, reflect.ValueOf(args[0]).Call(values)...)
   111  	return
   112  }
   113  
   114  func S(args ...interface{}) (vars *ParseError) {
   115  	vars = &ParseError{}
   116  	vars.isErr = false
   117  	var values []reflect.Value
   118  	for _, arg := range args[1:] {
   119  		values = append(values, reflect.ValueOf(arg))
   120  	}
   121  	vars.values = append(vars.values, reflect.ValueOf(args[0]).Call(values)...)
   122  	return
   123  }
   124  
   125  func (p *ParseError) Unmarshal(args ...interface{}) {
   126  	switch args[0].(type) {
   127  	case []interface{}:
   128  		if p.isErr {
   129  			if len(args[1].([]interface{})) == 0 {
   130  				panic("ParseErrorFail:error message:" + p.err.Error())
   131  			}
   132  			for i, v := range args[1].([]interface{}) {
   133  				reflect.ValueOf(v).Elem().Set(p.values[i])
   134  			}
   135  		} else {
   136  			for i, v := range args[0].([]interface{}) {
   137  				reflect.ValueOf(v).Elem().Set(p.values[i])
   138  			}
   139  		}
   140  	default:
   141  		for i, v := range args {
   142  			reflect.ValueOf(v).Elem().Set(p.values[i])
   143  		}
   144  	}
   145  }