feat: 第3版

baseclass.go

@@ -0,0 +1,17 @@
+package errors
+
+const UnknownError = "UNKNOWN"
+
+var BaseError = NewClass("base", "unknown error reason")
+
+func Errorf(format string, a ...any) WTError {
+	return BaseError.Errorf(format, a...)
+}
+
+func Warp(err error, format string, a ...any) WTError {
+	return BaseError.Warp(err, format, a...)
+}
+
+func WarpQuick(err error) WTError {
+	return BaseError.WarpQuick(err)
+}

errorclass.go

@@ -0,0 +1,113 @@
+package errors
+
+import (
+	"errors"
+	"fmt"
+)
+
+type WTErrorClass interface {
+	WTErrorClass()
+
+	Code() string
+	Msg() string
+
+	New() WTError
+	Errorf(format string, a ...any) WTError
+	Warp(err error, format string, a ...any) WTError
+	WarpQuick(err error) WTError
+}
+
+type wtErrorClass struct {
+	code string
+	msg  string
+}
+
+func (c *wtErrorClass) WTErrorClass() {}
+
+func (c *wtErrorClass) Code() string {
+	return c.code
+}
+
+func (c *wtErrorClass) Msg() string {
+	return c.msg
+}
+
+func (c *wtErrorClass) New() WTError {
+	msg := c.msg
+	code := c.code
+	cause := error(nil)
+	stack := getStack()
+
+	return &wtError{
+		class: c,
+		cause: cause,
+		msg:   msg,
+		code:  code,
+		stack: stack,
+	}
+}
+
+func (c *wtErrorClass) Errorf(format string, a ...any) WTError {
+	msg := fmt.Sprintf(format, a...)
+	code := c.code
+	cause := error(nil)
+	stack := getStack()
+
+	return &wtError{
+		class: c,
+		cause: cause,
+		msg:   msg,
+		code:  code,
+		stack: stack,
+	}
+}
+
+func (c *wtErrorClass) Warp(err error, format string, a ...any) WTError {
+	if err == nil {
+		return nil
+	}
+
+	msg := fmt.Sprintf(format, a...)
+	code := c.code
+	cause := err
+	stack := ""
+
+	var wtErr WTError
+	if errors.As(err, &wtErr) {
+		stack = wtErr.Stack()
+	} else {
+		stack = getStack()
+	}
+
+	return &wtError{
+		class: c,
+		cause: cause,
+		msg:   msg,
+		code:  code,
+		stack: stack,
+	}
+}
+
+func (c *wtErrorClass) WarpQuick(err error) WTError {
+	if err == nil {
+		return nil
+	}
+
+	var wtErr WTError
+	if errors.As(err, &wtErr) && wtErr.Code() == c.code {
+		return wtErr
+	}
+
+	msg := c.msg
+	code := c.code
+	cause := err
+	stack := getStack()
+
+	return &wtError{
+		class: c,
+		cause: cause,
+		msg:   msg,
+		code:  code,
+		stack: stack,
+	}
+}

errors.go

@@ -1,20 +1,19 @@
 package errors
 
 import (
-	"errors"
 	"fmt"
 )
 
-const UnknownError = "UNKNOWN"
-
 type WTError interface {
 	/* 标记类操作 */
 	error
 	WTError() // 标记
 
 	/* 访问类操作 */
+	Class() WTErrorClass
 	Code() string
 	Message() string
+	MessageWithStack() string
 	Stack() string
 	Cause() error
 
@@ -31,10 +30,15 @@ type wtError struct {
 	msg   string
 	code  string
 	stack string
+	class WTErrorClass
 }
 
 func (*wtError) WTError() {}
 
+func (w *wtError) Class() WTErrorClass {
+	return w.class
+}
+
 func (w *wtError) Code() string {
 	return w.code
 }
@@ -45,7 +49,7 @@ func (w *wtError) Message() string {
 	}
 
 	var cause *wtError
-	ok := errors.As(w.cause, &cause)
+	ok := As(w.cause, &cause)
 	if ok {
 		return fmt.Sprintf("[%s] %s: %s", w.code, w.msg, cause.Message())
 	}
@@ -53,6 +57,20 @@ func (w *wtError) Message() string {
 	return fmt.Sprintf("[%s] %s: %s", w.code, w.msg, w.cause.Error())
 }
 
+func (w *wtError) MessageWithStack() string {
+	if w.cause == nil {
+		return fmt.Sprintf("[%s]%s\n%s", w.code, w.msg, w.stack)
+	}
+
+	var cause *wtError
+	ok := As(w.cause, &cause)
+	if ok {
+		return fmt.Sprintf("[%s]%s: %s\n%s", w.code, w.msg, cause.Message(), w.stack)
+	}
+
+	return fmt.Sprintf("[%s]%s: %s\n%s", w.code, w.msg, w.cause.Error(), w.stack)
+}
+
 func (w *wtError) Stack() string {
 	return w.stack
 }
@@ -67,7 +85,7 @@ func (w *wtError) Cause() error {
 
 func (w *wtError) SetCode(code string) WTError {
 	if w.code == UnknownError {
-		w.code = code
+		return w.SetCodeForce(code)
 	}
 	return w
 }
@@ -79,8 +97,7 @@ func (w *wtError) SetCodeForce(code string) WTError {
 
 func (w *wtError) SetCause(cause error) WTError {
 	if w.cause == nil {
-		w.cause = cause
-		_ = w.SetCode(getErrorName(cause))
+		return w.SetCauseForce(cause)
 	}
 	return w
 }
@@ -88,6 +105,12 @@ func (w *wtError) SetCause(cause error) WTError {
 func (w *wtError) SetCauseForce(cause error) WTError {
 	w.cause = cause
 	_ = w.SetCode(getErrorName(cause))
+
+	var wtErr WTError
+	if As(cause, &wtErr) {
+		w.stack = wtErr.Stack()
+	}
+
 	return w
 }
 

utils.go

@@ -2,63 +2,50 @@ package errors
 
 import (
 	"errors"
-	"fmt"
+	"strings"
 )
 
-func Errorf(format string, a ...any) WTError {
-	msg := fmt.Sprintf(format, a...)
-	code := UnknownError
-	cause := error(nil)
-	stack := getStack()
-
-	return &wtError{
-		cause: cause,
-		msg:   msg,
-		code:  code,
-		stack: stack,
+func NewClass(code string, msgList ...string) WTErrorClass {
+	var msg string
+	if len(msgList) == 0 {
+		msg = strings.Replace(code, "_", " ", -1)
+	} else {
+		msg = msgList[0]
 	}
-}
 
-func Warp(err error, format string, a ...any) WTError {
-	msg := fmt.Sprintf(format, a...)
-	code := getErrorName(err)
-	cause := err
-	stack := getStack()
-
-	return &wtError{
-		cause: cause,
-		msg:   msg,
-		code:  code,
-		stack: stack,
+	return &wtErrorClass{
+		msg:  msg,
+		code: code,
 	}
 }
 
-func WarpQuick(err error) WTError {
-	msg := "error"
-	code := getErrorName(err)
-	cause := err
-	stack := getStack()
+func Is(err error, target any) bool {
+	var wtErr WTError
+	var normalErr error
 
-	return &wtError{
-		cause: cause,
-		msg:   msg,
-		code:  code,
-		stack: stack,
-	}
-}
+	if errors.As(err, &wtErr) {
+		errClass, isClass := target.(WTErrorClass)
+		if isClass {
+			return errClass.Code() == wtErr.Code()
+		}
+
+		wtTarget, isTarget := target.(WTError)
+		if isTarget {
+			if wtTarget == wtErr {
+				return true
+			}
 
-func Is(err error, target error) bool {
-	var wtErr, wtTarget WTError
+			if wtTarget.Code() == wtErr.Code() {
+				return true
+			}
 
-	if errors.As(err, &wtErr) && errors.As(target, &wtTarget) {
-		if wtErr.Code() == wtTarget.Code() {
-			return true
-		} else if wtErr == wtTarget {
-			return true
+			return errors.Is(err, wtTarget)
 		}
+	} else if errors.As(err, &normalErr) {
+		return errors.Is(err, normalErr)
 	}
 
-	return errors.Is(err, target)
+	return false
 }
 
 func As(err error, target any) bool {