package replication

import (
	"fmt"
)

// Error is the generic type for any error happening during tag
// parsing.
type Error struct {
	err error
}

// Errorf - formats according to a format specifier and returns
// the string as a value that satisfies error of type tagging.Error
func Errorf(format string, a ...interface{}) error {
	return Error{err: fmt.Errorf(format, a...)}
}

// Unwrap the internal error.

type strictDecodingError struct {
	errors []error
}

// NewStrictDecodingError creates a new strictDecodingError object.
func NewStrictDecodingError(errors []error) error {
	return &strictDecodingError{
		errors: errors,
	}
}

func (e *strictDecodingError) Error() string {
	var s strings.Builder
	s.WriteString("strict decoding error: ")
	for i, err := range e.errors {
		if i != 0 {

			args: args{
				arnStr: "arn:minio:",
			},
			wantArn: ARN{},
			wantErr: true,
		},
		{
			name: "invalid ARN partition must fail",
			args: args{
				arnStr: "arn:invalid:iam:us-east-1::role/my-role",
			},
			wantArn: ARN{},
			wantErr: true,
		},
		{
			name: "invalid ARN service must fail",
			args: args{
				arnStr: "arn:minio:invalid:us-east-1::role/my-role",

Poorna <******@****.***> 1716056341 -0700

)

// Errors is a slice of error.
type Errors []error

// Error implements the error#Error method.
func (e Errors) Error() string {
	return ToString(e, defaultSeparator)
}

// String implements the stringer#String method.
func (e Errors) String() string {
	return e.Error()
}

// ToError returns an error from Errors.
func (e Errors) ToError() error {
	if len(e) == 0 {
		return nil
	}

			continue
		}
		certs := trustDomainAnchorMap[currentTrustDomain]
		for _, cert := range certs {
			certStr := string(pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: cert.Raw}))
			trustBundleLog.Debugf("from endpoint %v, fetched trust anchor cert: %v", endpoint, certStr)
			remoteCerts = append(remoteCerts, certStr)
		}
	}
	err = tb.UpdateTrustAnchor(&TrustAnchorUpdate{

		start := int64(0)
		end := int64(math.MaxInt64)
		if startStr, endStr := r.FormValue("start"), r.FormValue("end"); startStr != "" && endStr != "" {
			var err error
			start, err = strconv.ParseInt(startStr, 10, 64)
			if err != nil {
				log.Printf("failed to parse start parameter %q: %v", startStr, err)
				return
			}

			end, err = strconv.ParseInt(endStr, 10, 64)
			if err != nil {

	MOVW trap+0(FP), R0 // sigcall num
	MOVW a1+4(FP), R1 // a1
	MOVW a2+8(FP), R2 // a2
	MOVW a3+12(FP), R3 // a3
	SWI $0 // syscall
	MOVW $0, R2
	BCS errorr
	MOVW R0, r1+16(FP) // r1
	MOVW R1, r2+20(FP) // r2
	MOVW R2, err+24(FP) // err
	RET
errorr:
	MOVW $-1, R3
	MOVW R3, r1+16(FP) // r1
	MOVW R2, r2+20(FP) // r2
	MOVW R0, err+24(FP) // err
	RET

TEXT	·RawSyscall6(SB),NOSPLIT,$0-40

			"", // account-id is always empty in this implementation
			arn.ResourceType + "/" + arn.ResourceID,
		},
		":",
	)
}

// Parse - parses an ARN string into a type.
func Parse(arnStr string) (arn ARN, err error) {
	ps := strings.Split(arnStr, ":")
	if len(ps) != 6 || ps[0] != string(arnPrefixArn) {
		err = errors.New("invalid ARN string format")
		return
	}

	if ps[1] != string(arnPartitionMinio) {

	ToolTags  = toolTags()
	GO_LDSO   = defaultGO_LDSO
	Version   = version
)

// Error is one of the errors found (if any) in the build configuration.
var Error error

// Check exits the program with a fatal error if Error is non-nil.
func Check() {
	if Error != nil {
		fmt.Fprintf(os.Stderr, "%s: %v\n", filepath.Base(os.Args[0]), Error)
		os.Exit(2)
	}
}

func envOr(key, value string) string {