error.go

// Copyright 2022 schukai GmbH
// SPDX-License-Identifier: AGPL-3.0

package configuration

import (
	"errors"
	"reflect"
)

// ResetError is used to reset the error to nil
// After calling this function, the call HasErrors() will return false
func (s *Settings[C]) ResetErrors() *Settings[C] {
	s.errors = []error{}
	return s
}

// Check if the setting contains errors
func (s *Settings[C]) HasErrors() bool {
	return len(s.errors) > 0
}

// Get all errors
func (s *Settings[C]) Errors() []error {
	return s.errors
}

var FileNameEmptyError = errors.New("file name is empty")
var MnemonicEmptyError = errors.New("mnemonic is empty")
var NoFileImportedError = errors.New("no file imported")
var NoFilesToWatchError = errors.New("no files to watch")
var WatchAlreadyInitializedError = errors.New("watch already initialized")
var WatchAlreadyRunningError = errors.New("watch already running")
var WatchNotInitializedError = errors.New("watch not initialized")
var WatchNotRunningError = errors.New("watch not running")
var WatchListNotInitializedError = errors.New("watch list not initialized")

type FlagDoesNotExistError error

func newFlagDoesNotExistError(flag string) FlagDoesNotExistError {
	return FlagDoesNotExistError(errors.New("flag " + flag + " does not exist"))
}

// PathAlreadyExistsError is returned when a files already exists
type PathAlreadyExistsError error

func newPathAlreadyExistsError(path string) PathAlreadyExistsError {
	return PathAlreadyExistsError(errors.New("files " + path + " already exists"))
}

// PathDoesNotExistError is returned when a files do not exist
type PathDoesNotExistError error

func newPathDoesNotExistError(path string) PathDoesNotExistError {
	return PathDoesNotExistError(errors.New("files " + path + " does not exist"))
}

// FormatNotSupportedError is returned when the format is not supported
type FormatNotSupportedError error

func newFormatNotSupportedError(format Format) FormatNotSupportedError {
	return FormatNotSupportedError(errors.New("format " + format.String() + " is not supported"))
}

// UnsupportedTypeError is returned when the type is not supported
type UnsupportedTypeError error

func newUnsupportedTypeError(t reflect.Type) UnsupportedTypeError {
	return UnsupportedTypeError(errors.New("type " + t.String() + " is not supported"))
}

// At the reflect level, some types are not supported
type UnsupportedReflectKindError error

func newUnsupportedReflectKindError(t reflect.Type) UnsupportedReflectKindError {
	return UnsupportedReflectKindError(errors.New("type " + t.String() + " is not supported"))
}

// This error indicates that the flag is not found
type FlagNotFoundError error

func newFlagNotFoundError(name string) FlagNotFoundError {
	return FlagNotFoundError(errors.New("flag " + name + " not found"))
}

// MismatchedTypeError is used to indicate that the type is not matching
type MismatchedTypeError error

func newMismatchedTypeError(expected, actual reflect.Type) MismatchedTypeError {
	return MismatchedTypeError(errors.New("expected type " + expected.String() + " but got " + actual.String()))
}

type UnknownFileExtensionError error

func newUnknownFileExtensionError(extension, filename string) UnknownFileExtensionError {
	return UnknownFileExtensionError(errors.New("unknown file extension " + extension + " for file " + filename))
}