github.com/tursom/GoCollections@v0.3.10/exceptions/Exception.go (about)

     1  /*
     2   * Copyright (c) 2022 tursom. All rights reserved.
     3   * Use of this source code is governed by a GPL-3
     4   * license that can be found in the LICENSE file.
     5   */
     6  
     7  package exceptions
     8  
     9  import (
    10  	"fmt"
    11  	"io"
    12  	"os"
    13  	"strings"
    14  
    15  	"github.com/tursom/GoCollections/lang"
    16  )
    17  
    18  type Exception = lang.Exception
    19  
    20  func PrintStackTraceByArray(writer io.Writer, trace []lang.StackTrace) {
    21  	if trace == nil {
    22  		return
    23  	}
    24  	builder := &strings.Builder{}
    25  	for _, stackTrace := range trace {
    26  		stackTrace.WriteTo(builder)
    27  	}
    28  	bytes := []byte(builder.String())
    29  	writeBytes := 0
    30  	for writeBytes < len(bytes) {
    31  		write, err := writer.Write(bytes[writeBytes:])
    32  		if err != nil {
    33  			Print(err)
    34  			return
    35  		}
    36  		writeBytes += write
    37  	}
    38  }
    39  
    40  func BuildStackTraceByArray(builder *strings.Builder, trace []lang.StackTrace) {
    41  	if trace == nil {
    42  		return
    43  	}
    44  	for _, stackTrace := range trace {
    45  		stackTrace.WriteTo(builder)
    46  	}
    47  }
    48  
    49  func BuildStackTrace(builder *strings.Builder, e Exception) {
    50  	builder.WriteString(e.Error())
    51  	builder.WriteString("\n")
    52  	if e.StackTrace() == nil {
    53  		return
    54  	}
    55  	for _, stackTrace := range e.StackTrace() {
    56  		stackTrace.WriteTo(builder)
    57  	}
    58  }
    59  
    60  func GetStackTraceString(e Exception) string {
    61  	builder := &strings.Builder{}
    62  	BuildStackTrace(builder, e)
    63  	return builder.String()
    64  }
    65  
    66  func Try[R any](
    67  	f func() (ret R, err Exception),
    68  	catch func(panic any) (ret R, err Exception),
    69  ) (ret R, err Exception) {
    70  	defer func() {
    71  		if r := recover(); r != nil {
    72  			ret, err = catch(r)
    73  		}
    74  	}()
    75  	ret, err = f()
    76  	if err != nil {
    77  		ret, err = catch(err)
    78  	}
    79  	return
    80  }
    81  
    82  func Print(err error) {
    83  	if err == nil {
    84  		return
    85  	}
    86  	switch err.(type) {
    87  	case Exception:
    88  		err.(Exception).PrintStackTrace()
    89  	default:
    90  		_, _ = fmt.Fprintln(os.Stderr, err)
    91  		PrintStackTraceByArray(os.Stderr, lang.GetStackTrace())
    92  	}
    93  }
    94  
    95  func Package(err error) Exception {
    96  	if err == nil {
    97  		return nil
    98  	}
    99  	switch err.(type) {
   100  	case Exception:
   101  		return err.(Exception)
   102  	}
   103  	return NewRuntimeException("", DefaultExceptionConfig().SetCause(err))
   104  }
   105  
   106  func PackageAny(err any) Exception {
   107  	if err == nil {
   108  		return nil
   109  	}
   110  	switch err.(type) {
   111  	case error:
   112  		return Package(err.(error))
   113  	default:
   114  		return NewRuntimeException("", DefaultExceptionConfig())
   115  	}
   116  }
   117  
   118  func PackagePanic(panic any, exceptionMessage string) Exception {
   119  	if panic == nil {
   120  		return nil
   121  	}
   122  	switch panic.(type) {
   123  	case error:
   124  		return NewRuntimeException(exceptionMessage, DefaultExceptionConfig().SetCause(panic))
   125  	default:
   126  		return NewPackageException(panic, nil)
   127  	}
   128  }