diff --git a/logger/ConsoleLogger.go b/logger/ConsoleLogger.go index ea8260a..59f48a2 100644 --- a/logger/ConsoleLogger.go +++ b/logger/ConsoleLogger.go @@ -5,11 +5,11 @@ import ( "time" ) -func (lgr *ConsoleLoggerimpl) init() { +func (lgr *ConsoleLoggerImpl) init() { lgr.messages = make(chan string, logbuffersize) } -func (logger *ConsoleLoggerimpl) StartLogger() { +func (logger *ConsoleLoggerImpl) StartLogger() { fmt.Println("Starting Logger") loggerlogonce.Do(func() { for msg := range logger.messages { @@ -18,15 +18,15 @@ func (logger *ConsoleLoggerimpl) StartLogger() { }) } -func (logger *ConsoleLoggerimpl) Write(message string) { +func (logger *ConsoleLoggerImpl) Write(message string) { logger.messages <- time.Now().Format(time.UnixDate) + " : " + message + "\n" } -func (logger *ConsoleLoggerimpl) Write_Request(message string, uuid string) { +func (logger *ConsoleLoggerImpl) WriteRequest(message string, uuid string) { logger.Write(uuid + " : " + message) } -func (logger *ConsoleLoggerimpl) WriteErr(err error) (errnum int) { +func (logger *ConsoleLoggerImpl) WriteErr(err error) (errnum int) { if err != nil { logger.Write("Error: " + err.Error()) errnum = 1 @@ -34,7 +34,7 @@ func (logger *ConsoleLoggerimpl) WriteErr(err error) (errnum int) { return errnum } -func (logger *ConsoleLoggerimpl) WriteErr_Request(err error, uuid string) (errnum int) { +func (logger *ConsoleLoggerImpl) WriteErrRequest(err error, uuid string) (errnum int) { if err != nil { logger.Write(uuid + " : Error: " + err.Error()) errnum = 1 @@ -42,29 +42,29 @@ func (logger *ConsoleLoggerimpl) WriteErr_Request(err error, uuid string) (errnu return errnum } -func (logger *ConsoleLoggerimpl) Write_DEBUG(message string) { +func (logger *ConsoleLoggerImpl) WriteDebug(message string) { if DEBUG { logger.Write(message) } } -func (logger *ConsoleLoggerimpl) Write_Request_DEBUG(message string, uuid string) { +func (logger *ConsoleLoggerImpl) WriteRequestDebug(message string, uuid string) { if DEBUG { - logger.Write_Request(message, uuid) + logger.WriteRequest(message, uuid) } } -func (logger *ConsoleLoggerimpl) WriteErr_DEBUG(err error) (errnum int) { +func (logger *ConsoleLoggerImpl) WriteErrDebug(err error) (errnum int) { if err != nil { - logger.Write_DEBUG("Error: " + err.Error()) + logger.WriteDebug("Error: " + err.Error()) errnum = 1 } return errnum } -func (logger *ConsoleLoggerimpl) WriteErr_Request_DEBUG(err error, uuid string) (errnum int) { +func (logger *ConsoleLoggerImpl) WriteErrRequestDebug(err error, uuid string) (errnum int) { if err != nil { - logger.Write_DEBUG(uuid + " : Error: " + err.Error()) + logger.WriteDebug(uuid + " : Error: " + err.Error()) errnum = 1 } return errnum diff --git a/logger/FileLogger.go b/logger/FileLogger.go index f5cb111..ea9e663 100644 --- a/logger/FileLogger.go +++ b/logger/FileLogger.go @@ -7,7 +7,7 @@ import ( "time" ) -func (lgr *FileLoggerimpl) init() { +func (lgr *FileLoggerImpl) init() { lgr.filepath = "./log" lgr.messages = make(chan string, logbuffersize) envfp, envexist := os.LookupEnv("LOGFILE_GO_LOGGER") @@ -15,10 +15,10 @@ func (lgr *FileLoggerimpl) init() { if len(envfp) > 0 { lgr.filepath = envfp } else { - Logger().Write_DEBUG(fmt.Sprintf("LOGFILE_GO_LOGGER env exist but has an empty value using default value: %s !\n", lgr.filepath)) + LoggerInstance().WriteDebug(fmt.Sprintf("LOGFILE_GO_LOGGER env exist but has an empty value using default value: %s !\n", lgr.filepath)) } } else { - Logger().Write_DEBUG(fmt.Sprintf("LOGFILE_GO_LOGGER env doesn't exist using default value: %s !\n", lgr.filepath)) + LoggerInstance().WriteDebug(fmt.Sprintf("LOGFILE_GO_LOGGER env doesn't exist using default value: %s !\n", lgr.filepath)) } f, err := os.OpenFile(lgr.filepath, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0660) if err != nil { @@ -29,7 +29,7 @@ func (lgr *FileLoggerimpl) init() { lgr.mutex = &sync.Mutex{} } -func (logger *FileLoggerimpl) StartLogger() { +func (logger *FileLoggerImpl) StartLogger() { fmt.Println("Starting FileLogger") loggerlogonce.Do(func() { for msg := range logger.messages { @@ -58,15 +58,15 @@ func (logger *FileLoggerimpl) StartLogger() { // logger.mutex.Unlock() } -func (logger *FileLoggerimpl) Write(message string) { +func (logger *FileLoggerImpl) Write(message string) { logger.messages <- time.Now().Format(time.UnixDate) + " : " + message + "\n" } -func (logger *FileLoggerimpl) Write_Request(message string, request string) { +func (logger *FileLoggerImpl) WriteRequest(message string, request string) { logger.Write(request + " : " + message) } -func (logger *FileLoggerimpl) WriteErr(err error) (errnum int) { +func (logger *FileLoggerImpl) WriteErr(err error) (errnum int) { if err != nil { logger.Write("Error: " + err.Error()) errnum = 1 @@ -74,7 +74,7 @@ func (logger *FileLoggerimpl) WriteErr(err error) (errnum int) { return errnum } -func (logger *FileLoggerimpl) WriteErr_Request(err error, uuid string) (errnum int) { +func (logger *FileLoggerImpl) WriteErrRequest(err error, uuid string) (errnum int) { if err != nil { logger.Write(uuid + " : Error: " + err.Error()) errnum = 1 @@ -82,29 +82,29 @@ func (logger *FileLoggerimpl) WriteErr_Request(err error, uuid string) (errnum i return errnum } -func (logger *FileLoggerimpl) Write_DEBUG(message string) { +func (logger *FileLoggerImpl) WriteDebug(message string) { if DEBUG { logger.Write(message) } } -func (logger *FileLoggerimpl) Write_Request_DEBUG(message string, uuid string) { +func (logger *FileLoggerImpl) WriteRequestDebug(message string, uuid string) { if DEBUG { - logger.Write_Request(message, uuid) + logger.WriteRequest(message, uuid) } } -func (logger *FileLoggerimpl) WriteErr_DEBUG(err error) (errnum int) { +func (logger *FileLoggerImpl) WriteErrDebug(err error) (errnum int) { if err != nil { - logger.Write_DEBUG("Error: " + err.Error()) + logger.WriteDebug("Error: " + err.Error()) errnum = 1 } return errnum } -func (logger *FileLoggerimpl) WriteErr_Request_DEBUG(err error, uuid string) (errnum int) { +func (logger *FileLoggerImpl) WriteErrRequestDebug(err error, uuid string) (errnum int) { if err != nil { - logger.Write_DEBUG(uuid + " : Error: " + err.Error()) + logger.WriteDebug(uuid + " : Error: " + err.Error()) errnum = 1 } return errnum diff --git a/logger/Logger.go b/logger/Logger.go index 4a39501..797d4b6 100644 --- a/logger/Logger.go +++ b/logger/Logger.go @@ -14,19 +14,19 @@ const logbuffersize int32 = 200 var DEBUG bool = true var ( - loggerInstance LGRImpl + loggerInstance Logger loggeronce sync.Once loggerlogonce sync.Once ) -func Create(instance LGRImpl) { +func Create(instance Logger) { loggeronce.Do(func() { loggerInstance = instance loggerInstance.init() }) } -func Logger() LGRImpl { +func LoggerInstance() Logger { return loggerInstance } @@ -42,7 +42,7 @@ func PrintJson[T any](entity *T) string { func ExampleLogMiddleware(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - Logger().Write_DEBUG(fmt.Sprintf("\tRequest from: %s to: Host: %s URL: %s \tWith HEADERS: %s \tWith BODY: %s", r.RemoteAddr, r.Host, r.URL, r.Header, r.Body)) + LoggerInstance().WriteDebug(fmt.Sprintf("\tRequest from: %s to: Host: %s URL: %s \tWith HEADERS: %s \tWith BODY: %s", r.RemoteAddr, r.Host, r.URL, r.Header, r.Body)) next.ServeHTTP(w, r) }) } diff --git a/logger/NullLogger.go b/logger/NullLogger.go index 6d0e125..8186055 100644 --- a/logger/NullLogger.go +++ b/logger/NullLogger.go @@ -1,39 +1,39 @@ package logger -func (lgr *NullLoggerimpl) init() {} +func (lgr *NullLoggerImpl) init() {} -func (logger *NullLoggerimpl) StartLogger() {} +func (logger *NullLoggerImpl) StartLogger() {} -func (logger *NullLoggerimpl) Write(message string) {} +func (logger *NullLoggerImpl) Write(message string) {} -func (logger *NullLoggerimpl) Write_Request(message string, request string) {} +func (logger *NullLoggerImpl) WriteRequest(message string, request string) {} -func (logger *NullLoggerimpl) WriteErr(err error) (errnum int) { +func (logger *NullLoggerImpl) WriteErr(err error) (errnum int) { if err != nil { errnum = 1 } return errnum } -func (logger *NullLoggerimpl) WriteErr_Request(err error, request string) (errnum int) { +func (logger *NullLoggerImpl) WriteErrRequest(err error, request string) (errnum int) { if err != nil { errnum = 1 } return errnum } -func (logger *NullLoggerimpl) Write_DEBUG(message string) {} +func (logger *NullLoggerImpl) WriteDebug(message string) {} -func (logger *NullLoggerimpl) Write_Request_DEBUG(message string, uuid string) {} +func (logger *NullLoggerImpl) WriteRequestDebug(message string, uuid string) {} -func (logger *NullLoggerimpl) WriteErr_DEBUG(err error) (errnum int) { +func (logger *NullLoggerImpl) WriteErrDebug(err error) (errnum int) { if err != nil { errnum = 1 } return errnum } -func (logger *NullLoggerimpl) WriteErr_Request_DEBUG(err error, uuid string) (errnum int) { +func (logger *NullLoggerImpl) WriteErrRequestDebug(err error, uuid string) (errnum int) { if err != nil { errnum = 1 } diff --git a/logger/interfaces.go b/logger/interfaces.go index aa4bb56..63cfd98 100644 --- a/logger/interfaces.go +++ b/logger/interfaces.go @@ -9,39 +9,39 @@ package logger // Unixdate : uuid : message\n // // Unixdate : uuid : Error: error\n -type LGRImpl interface { - LoggerI - DebugLoggerI +type Logger interface { + ReleaseLogger + DebugLogger } type ( - LoggerI interface { + ReleaseLogger interface { // Private, use it for member initialization etc init() // Start an infinite loop to write out messages from the channel StartLogger() Write(message string) - Write_Request(message string, uuid string) + WriteRequest(message string, uuid string) // If an error that is not nill passed in it logs the error and returns 1, otherwise 0 WriteErr(error) int - WriteErr_Request(err error, uuid string) int + WriteErrRequest(err error, uuid string) int } // Use _DEBUG prints to strip them out of release builds - DebugLoggerI interface { + DebugLogger interface { // Private, use it for member initialization etc init() // Start an infinite loop to write out messages from the channel StartLogger() - Write_DEBUG(message string) - Write_Request_DEBUG(message string, uuid string) - WriteErr_DEBUG(err error) (errnum int) - WriteErr_Request_DEBUG(err error, uuid string) int + WriteDebug(message string) + WriteRequestDebug(message string, uuid string) + WriteErrDebug(err error) (errnum int) + WriteErrRequestDebug(err error, uuid string) int } ) // Ensure all methods from LGRImpl are implemented ccompile time var ( - _ LGRImpl = (*NullLoggerimpl)(nil) - _ LGRImpl = (*ConsoleLoggerimpl)(nil) - _ LGRImpl = (*FileLoggerimpl)(nil) + _ Logger = (*NullLoggerImpl)(nil) + _ Logger = (*ConsoleLoggerImpl)(nil) + _ Logger = (*FileLoggerImpl)(nil) ) diff --git a/logger/types.go b/logger/types.go index f8ea9ac..d9460c9 100644 --- a/logger/types.go +++ b/logger/types.go @@ -6,14 +6,14 @@ import ( ) // A logger without logging functionality -type NullLoggerimpl struct{} +type NullLoggerImpl struct{} // A logger that logs to sdtout -type ConsoleLoggerimpl struct { +type ConsoleLoggerImpl struct { messages chan string } -type FileLoggerimpl struct { +type FileLoggerImpl struct { messages chan string mutex *sync.Mutex logFile *os.File diff --git a/main_test.go b/main_test.go index cf00beb..31fde74 100644 --- a/main_test.go +++ b/main_test.go @@ -11,26 +11,26 @@ import ( ) func TestTypes(t *testing.T) { - Create(&FileLoggerimpl{}) - go Logger().StartLogger() - Logger().Write("TEST MSG") + Create(&FileLoggerImpl{}) + go LoggerInstance().StartLogger() + LoggerInstance().Write("TEST MSG") time.Sleep(time.Second * 2) x := Some("Test") - AssertTrue(t, x.Is_some()) - AssertTrue(t, !x.Is_none()) + AssertTrue(t, x.IsSome()) + AssertTrue(t, !x.IsNone()) AssertEqual(t, x.Unwrap(), "Test") - AssertTrue(t, None_t(1).Is_none()) + AssertTrue(t, None_t(1).IsNone()) err := errors.New("Test") y := Err_t(err, "t") - AssertEqual(t, y.Unwrap_err(), err) - AssertError(t, y.Unwrap_err()) - z := x.Ok_or(err) - AssertTrue(t, z.Is_ok()) - AssertEqual(t, None[string]().Ok_or(err).Unwrap_err(), err) - AssertTrue(t, Has_value(x)) - AssertTrue(t, Has_value(y.Err())) - AssertTrue(t, Has_value(y.Err().Ok_or(err))) - AssertEqual(t, err, y.Err().Ok_or(err).Unwrap()) - AssertEqual(t, err, y.Err().Ok_or(errors.New("")).Unwrap()) - AssertNotEqual(t, err, Err[string](errors.New("asd")).Unwrap_err()) + AssertEqual(t, y.UnwrapErr(), err) + AssertError(t, y.UnwrapErr()) + z := x.OkOr(err) + AssertTrue(t, z.IsOk()) + AssertEqual(t, None[string]().OkOr(err).UnwrapErr(), err) + AssertTrue(t, HasValue(x)) + AssertTrue(t, HasValue(y.Err())) + AssertTrue(t, HasValue(y.Err().OkOr(err))) + AssertEqual(t, err, y.Err().OkOr(err).Unwrap()) + AssertEqual(t, err, y.Err().OkOr(errors.New("")).Unwrap()) + AssertNotEqual(t, err, Err[string](errors.New("asd")).UnwrapErr()) } diff --git a/typeutils/interfaces.go b/typeutils/interfaces.go index 28d767a..65460c5 100644 --- a/typeutils/interfaces.go +++ b/typeutils/interfaces.go @@ -2,34 +2,34 @@ package typeutils // Created to abstract over Is_some and Is_ok type ValueContainer interface { - Has_value() bool + HasValue() bool } type Unwrappable[T any] interface { - Expect(string) T // panics with a provided custom message - Unwrap() T // panics with a generic message - Unwrap_or(T) T // returns the provided default value - Unwrap_or_default() T // returns the default value of the type T - Unwrap_or_else(func() T) T // returns the result of evaluating the provided function + Expect(string) T // panics with a provided custom message + Unwrap() T // panics with a generic message + UnwrapOr(T) T // returns the provided default value + UnwrapOrDefault() T // returns the default value of the type T + UnwrapOrElse(func() T) T // returns the result of evaluating the provided function } -// Both an Optional and Result is an Option -type Option[T any] interface { +// Both an Optional and Result is an Optioner +type Optioner[T any] interface { ValueContainer Unwrappable[T] } -type OptionalI[T any] interface { - Is_some() bool - Is_none() bool - Ok_or(error) Result[T] - Ok_or_else(func() error) Result[T] +type Optionaler[T any] interface { + IsSome() bool + IsNone() bool + OkOr(error) Result[T] + OkOrElse(func() error) Result[T] Unwrappable[T] } -type ResultI[T any] interface { - Is_ok() bool - Is_err() bool +type Resulter[T any] interface { + IsOk() bool + IsErr() bool Ok() Optional[T] Err() Optional[error] Unwrappable[T] @@ -37,10 +37,10 @@ type ResultI[T any] interface { // Ensure compile time the interfaces are implemented var ( - _ Option[any] = (*Optional[any])(nil) - _ Option[any] = (*Result[any])(nil) - _ OptionalI[any] = (*Optional[any])(nil) - _ ResultI[any] = (*Result[any])(nil) - _ ValueContainer = (*Optional[any])(nil) - _ ValueContainer = (*Result[any])(nil) + _ Optioner[any] = (*Optional[any])(nil) + _ Optioner[any] = (*Result[any])(nil) + _ Optionaler[any] = (*Optional[any])(nil) + _ Resulter[any] = (*Result[any])(nil) + _ ValueContainer = (*Optional[any])(nil) + _ ValueContainer = (*Result[any])(nil) ) diff --git a/typeutils/optional.go b/typeutils/optional.go index 60ee9d9..d65b3da 100644 --- a/typeutils/optional.go +++ b/typeutils/optional.go @@ -16,10 +16,10 @@ func None_t[T any](T) Optional[T] { // CTORS END -func (opt Optional[T]) Is_some() bool { return opt.present } -func (opt Optional[T]) Is_none() bool { return !opt.present } +func (opt Optional[T]) IsSome() bool { return opt.present } +func (opt Optional[T]) IsNone() bool { return !opt.present } -func (opt Optional[T]) Has_value() bool { return opt.Is_some() } +func (opt Optional[T]) HasValue() bool { return opt.IsSome() } // UNWRAPPABLE INTERFACE BEGIN func (opt Optional[T]) Expect(msg string) T { @@ -36,14 +36,14 @@ func (opt Optional[T]) Unwrap() T { panic("Tried unwrapping an Optional that did not have a value!") } -func (opt Optional[T]) Unwrap_or(val T) T { +func (opt Optional[T]) UnwrapOr(val T) T { if opt.present { return opt.value } return val } -func (opt Optional[T]) Unwrap_or_default() T { +func (opt Optional[T]) UnwrapOrDefault() T { if opt.present { return opt.value } @@ -51,7 +51,7 @@ func (opt Optional[T]) Unwrap_or_default() T { return res } -func (opt Optional[T]) Unwrap_or_else(f func() T) T { +func (opt Optional[T]) UnwrapOrElse(f func() T) T { if opt.present { return opt.value } @@ -61,7 +61,7 @@ func (opt Optional[T]) Unwrap_or_else(f func() T) T { // UNWRAPPABLE INTERFACE END // transforms Some(v) to Ok(v), and None to Err(err) -func (opt Optional[T]) Ok_or(err error) Result[T] { +func (opt Optional[T]) OkOr(err error) Result[T] { if opt.present { return Ok(opt.value) } @@ -69,7 +69,7 @@ func (opt Optional[T]) Ok_or(err error) Result[T] { } // transforms Some(v) to Ok(v), and None to a value of Err using the provided function -func (opt Optional[T]) Ok_or_else(f func() error) Result[T] { +func (opt Optional[T]) OkOrElse(f func() error) Result[T] { if opt.present { return Ok(opt.value) } diff --git a/typeutils/result.go b/typeutils/result.go index 0c4d071..5bf9dec 100644 --- a/typeutils/result.go +++ b/typeutils/result.go @@ -15,10 +15,10 @@ func Err_t[T any](err error, x T) Result[T] { // CTORS END -func (res Result[T]) Is_ok() bool { return res.err == nil } -func (res Result[T]) Is_err() bool { return res.err != nil } +func (res Result[T]) IsOk() bool { return res.err == nil } +func (res Result[T]) IsErr() bool { return res.err != nil } -func (res Result[T]) Has_value() bool { return res.Is_ok() } +func (res Result[T]) HasValue() bool { return res.IsOk() } // UNWRAPPABLE INTERFACE func (res Result[T]) Expect(msg string) T { @@ -35,14 +35,14 @@ func (res Result[T]) Unwrap() T { panic("Tried unwrapping a Result that had an error value!") } -func (res Result[T]) Unwrap_or(val T) T { +func (res Result[T]) UnwrapOr(val T) T { if res.err == nil { return res.value } return val } -func (res Result[T]) Unwrap_or_default() T { +func (res Result[T]) UnwrapOrDefault() T { if res.err == nil { return res.value } @@ -50,7 +50,7 @@ func (res Result[T]) Unwrap_or_default() T { return ret } -func (res Result[T]) Unwrap_or_else(f func() T) T { +func (res Result[T]) UnwrapOrElse(f func() T) T { if res.err == nil { return res.value } @@ -60,7 +60,7 @@ func (res Result[T]) Unwrap_or_else(f func() T) T { // UNWRAPPABLE INTERFACE // This function panic on Ok instead of Err -func (res Result[T]) Expect_err(msg string) error { +func (res Result[T]) ExpectErr(msg string) error { if res.err != nil { return res.err } @@ -68,7 +68,7 @@ func (res Result[T]) Expect_err(msg string) error { } // This function panic on Ok instead of Err -func (res Result[T]) Unwrap_err() error { +func (res Result[T]) UnwrapErr() error { if res.err != nil { return res.err } diff --git a/typeutils/utils.go b/typeutils/utils.go index 84fe131..88afe07 100644 --- a/typeutils/utils.go +++ b/typeutils/utils.go @@ -8,21 +8,21 @@ func Unwrap[T any](val Unwrappable[T]) T { return val.Unwrap() } -func Unwrap_or[T any](val Unwrappable[T]) (def T) { - return val.Unwrap_or(def) +func UnwrapOr[T any](val Unwrappable[T]) (def T) { + return val.UnwrapOr(def) } -func Unwrap_or_default[T any](val Unwrappable[T]) T { - return val.Unwrap_or_default() +func UnwrapOrDefault[T any](val Unwrappable[T]) T { + return val.UnwrapOrDefault() } -func Unwrap_or_else[T any](val Unwrappable[T], f func() T) T { - return val.Unwrap_or_else(f) +func UnwrapOrElse[T any](val Unwrappable[T], f func() T) T { + return val.UnwrapOrElse(f) } // Returns if the underlying data has a Value (false in case of None or Error) -func Has_value(val ValueContainer) bool { - return val.Has_value() +func HasValue(val ValueContainer) bool { + return val.HasValue() } func ResultWrap[T any](val T, err error) Result[T] {