From 552c3197e8740cdd26d7b676a1dd0fc3d4aa6993 Mon Sep 17 00:00:00 2001 From: raj_mathe Date: Thu, 4 Nov 2021 11:06:16 +0100 Subject: [PATCH] master > master: code go - vereinfachte logging --- .../algorithms/search/binary/binary.go | 10 +- .../algorithms/search/interpol/interpol.go | 13 +- .../search/ith_element/ith_element.go | 12 +- .../internal/algorithms/search/jump/jump.go | 10 +- .../algorithms/search/poison/poison.go | 18 +-- .../search/sequential/sequential.go | 6 +- .../algorithms/sum/maxsubsum/maxsubsum.go | 10 +- code/golang/internal/core/logging/logging.go | 149 ++---------------- .../core/logging/logging_auxiliary.go | 45 ++++++ .../internal/core/logging/logging_prompt.go | 46 ++++++ .../internal/core/logging/logging_settings.go | 49 ++++++ code/golang/internal/endpoints/print/print.go | 14 +- code/golang/internal/endpoints/run/run.go | 8 +- .../endpoints/run/run_actions_algorithms.go | 22 +-- ...actions_basic+.go => run_actions_basic.go} | 10 +- .../endpoints/run/run_actions_settings.go | 8 +- code/golang/internal/menus/menus.go | 10 +- code/golang/internal/menus/menus_prompt.go | 4 +- code/golang/internal/setup/setup_display.go | 24 +-- code/golang/main.go | 2 +- 20 files changed, 235 insertions(+), 235 deletions(-) create mode 100644 code/golang/internal/core/logging/logging_auxiliary.go create mode 100644 code/golang/internal/core/logging/logging_prompt.go create mode 100644 code/golang/internal/core/logging/logging_settings.go rename code/golang/internal/endpoints/run/{run_actions_basic+.go => run_actions_basic.go} (84%) diff --git a/code/golang/internal/algorithms/search/binary/binary.go b/code/golang/internal/algorithms/search/binary/binary.go index 1e76a85..e51a0ef 100644 --- a/code/golang/internal/algorithms/search/binary/binary.go +++ b/code/golang/internal/algorithms/search/binary/binary.go @@ -5,8 +5,6 @@ package binary * ---------------------------------------------------------------- */ import ( - "fmt" - "ads/internal/core/logging" "ads/internal/core/metrics" ) @@ -30,20 +28,20 @@ Outputs: Position von x in L, sonst −1 wenn x nicht in L. */ func BinarySearch(L []int, x int) int { if len(L) == 0 { - logging.LogDebug(fmt.Sprintf("x nicht in L")) + logging.Debug("x nicht in L") return -1 } metrics.AddTimeCost() m := int(len(L) / 2) if L[m] == x { - logging.LogDebug(fmt.Sprintf("x in Position m gefunden")) + logging.Debug("x in Position m gefunden") return m } else if x < L[m] { - logging.LogDebug(fmt.Sprintf("Suche in linker Hälfte fortsetzen.")) + logging.Debug("Suche in linker Hälfte fortsetzen.") index := BinarySearch(L[:m], x) return index } else { // } else if x > L[m] { - logging.LogDebug(fmt.Sprintf("Suche in rechter Hälfte fortsetzen.")) + logging.Debug("Suche in rechter Hälfte fortsetzen.") index := BinarySearch(L[m+1:], x) if index >= 0 { index += (m + 1) // NOTE: muss Indexwert kompensieren diff --git a/code/golang/internal/algorithms/search/interpol/interpol.go b/code/golang/internal/algorithms/search/interpol/interpol.go index 6046201..d871f02 100644 --- a/code/golang/internal/algorithms/search/interpol/interpol.go +++ b/code/golang/internal/algorithms/search/interpol/interpol.go @@ -5,7 +5,6 @@ package interpol * ---------------------------------------------------------------- */ import ( - "fmt" "math" "ads/internal/core/logging" @@ -31,23 +30,23 @@ Outputs: Position von x in L, sonst −1 wenn x nicht in L. */ func InterpolationSearch(L []int, x int, u int, v int) int { if len(L) == 0 { - logging.LogDebug(fmt.Sprintf("Liste L leer, also x nicht in L")) + logging.Debug("Liste L leer, also x nicht in L") return -1 } else if !(L[u] <= x && x <= L[v]) { - logging.LogDebug(fmt.Sprintf("x liegt außerhalb der Grenzen von L")) + logging.Debug("x liegt außerhalb der Grenzen von L") return -1 } metrics.AddTimeCost() p := getSuchposition(L, x, u, v) - logging.LogDebug(fmt.Sprintf("Interpolante von x in (u, v)=(%[1]v, %[2]v) ist p = %[3]v.", u, v, p)) + logging.Debug("Interpolante von x in (u, v)=(%[1]v, %[2]v) ist p = %[3]v.", u, v, p) if L[p] == x { - logging.LogDebug(fmt.Sprintf("x in Position p gefunden")) + logging.Debug("x in Position p gefunden") return p } else if x < L[p] { - logging.LogDebug(fmt.Sprintf("Suche in linker Hälfte fortsetzen.")) + logging.Debug("Suche in linker Hälfte fortsetzen.") return InterpolationSearch(L, x, u, p-1) } else { // } else if x > L[p] { - logging.LogDebug(fmt.Sprintf("Suche in rechter Hälfte fortsetzen.")) + logging.Debug("Suche in rechter Hälfte fortsetzen.") return InterpolationSearch(L, x, p+1, v) } } diff --git a/code/golang/internal/algorithms/search/ith_element/ith_element.go b/code/golang/internal/algorithms/search/ith_element/ith_element.go index 3029d5c..acedda9 100644 --- a/code/golang/internal/algorithms/search/ith_element/ith_element.go +++ b/code/golang/internal/algorithms/search/ith_element/ith_element.go @@ -5,8 +5,6 @@ package ith_element * ---------------------------------------------------------------- */ import ( - "fmt" - "ads/internal/core/logging" "ads/internal/core/metrics" "ads/internal/core/utils" @@ -41,10 +39,10 @@ func FindIthSmallest(L []int, i int) int { minValue := L[index] // Falls i = 1, dann wird das Minimum gesucht, sonst Minimum entfernen und nach i-1. Element suchen if i == 1 { - logging.LogDebug("Das i. kleinste Element wurde gefunden.") + logging.Debug("Das i. kleinste Element wurde gefunden.") return minValue } else { - logging.LogDebug(fmt.Sprintf("Entferne Minimum: %[1]v.", minValue)) + logging.Debug("Entferne Minimum: %[1]v.", minValue) i = i - 1 L_ := utils.PopIndexListInt(L, index) // entferne Element mit Index = index return FindIthSmallest(L_, i) @@ -83,13 +81,13 @@ func FindIthSmallestDC(L []int, i int) int { } // Fallunterscheidung: if len(Ll) == i-1 { - logging.LogDebug(fmt.Sprintf("Es gibt i-1 Elemente vor p=%[1]v. ==> i. kleinste Element = p", p)) + logging.Debug("Es gibt i-1 Elemente vor p=%[1]v. ==> i. kleinste Element = p", p) return p } else if len(Ll) >= i { - logging.LogDebug(fmt.Sprintf("Es gibt >= i Elemente vor p=%[1]v. ==> Suche in linker Hälfte!", p)) + logging.Debug("Es gibt >= i Elemente vor p=%[1]v. ==> Suche in linker Hälfte!", p) return FindIthSmallestDC(Ll, i) } else { - logging.LogDebug(fmt.Sprintf("Es gibt < i-1 Elemente vor p=%[1]v. ==> Suche in rechter Hälfte!", p)) + logging.Debug("Es gibt < i-1 Elemente vor p=%[1]v. ==> Suche in rechter Hälfte!", p) i = i - (len(Ll) + 1) return FindIthSmallestDC(Lr, i) } diff --git a/code/golang/internal/algorithms/search/jump/jump.go b/code/golang/internal/algorithms/search/jump/jump.go index 2ee3c1a..6ea0746 100644 --- a/code/golang/internal/algorithms/search/jump/jump.go +++ b/code/golang/internal/algorithms/search/jump/jump.go @@ -5,8 +5,6 @@ package jump * ---------------------------------------------------------------- */ import ( - "fmt" - "ads/internal/algorithms/search/sequential" "ads/internal/core/logging" "ads/internal/core/metrics" @@ -44,14 +42,14 @@ func JumpSearchLinear(L []int, x int, m int) int { block := L[i0:i1] elementAfterBlock := block[len(block)-1] + 1 if x < elementAfterBlock { - logging.LogDebug(fmt.Sprintf("Element muss sich im Block [%[1]v, %[2]v) befinden.", i0, i1)) + logging.Debug("Element muss sich im Block [%[1]v, %[2]v) befinden.", i0, i1) index := sequential.SequentialSearch(block, x) if index >= 0 { index += i0 // NOTE: muss wegen Offset kompensieren } return index } - logging.LogDebug(fmt.Sprintf("Element befindet sich nicht im Block [%[1]v, %[2]v).", i0, i1)) + logging.Debug("Element befindet sich nicht im Block [%[1]v, %[2]v).", i0, i1) i0 = i1 i1 += m } @@ -83,14 +81,14 @@ func JumpSearchExponentiell(L []int, x int) int { block := L[i0:i1] elementAfterBlock := block[len(block)-1] + 1 if x < elementAfterBlock { - logging.LogDebug(fmt.Sprintf("Element muss sich im Block [%[1]v, %[2]v) befinden.", i0, i1)) + logging.Debug("Element muss sich im Block [%[1]v, %[2]v) befinden.", i0, i1) index := sequential.SequentialSearch(block, x) if index >= 0 { index += i0 // NOTE: muss wegen Offset kompensieren } return index } - logging.LogDebug(fmt.Sprintf("Element befindet sich nicht im Block [%[1]v, %[2]v).", i0, i1)) + logging.Debug("Element befindet sich nicht im Block [%[1]v, %[2]v).", i0, i1) i0 = i1 i1 *= 2 } diff --git a/code/golang/internal/algorithms/search/poison/poison.go b/code/golang/internal/algorithms/search/poison/poison.go index 0e8c81d..9373549 100644 --- a/code/golang/internal/algorithms/search/poison/poison.go +++ b/code/golang/internal/algorithms/search/poison/poison.go @@ -5,8 +5,6 @@ package poison * ---------------------------------------------------------------- */ import ( - "fmt" - "ads/internal/core/logging" "ads/internal/core/metrics" "ads/internal/core/utils" @@ -32,17 +30,17 @@ Outputs: Der Index des vergifteten Getränks, falls es eines gibt, ansonsten -1. NOTE: Zeitkosten hier messen nur die Anzahl der Vorkoster. */ func FindPoison(L []int) int { - logging.LogDebug("Bereite Vorkoster vor") + logging.Debug("Bereite Vorkoster vor") n := len(L) testers := [][]int{} for i := 0; i < n; i++ { metrics.AddSpaceCost() - logging.LogDebug(fmt.Sprintf("Füge Vorkoster hinzu, der nur Getränk %[1]v testet.", i)) + logging.Debug("Füge Vorkoster hinzu, der nur Getränk %[1]v testet.", i) testers = append(testers, []int{i}) } - logging.LogDebug("Warte auf Effekte") + logging.Debug("Warte auf Effekte") effects := waitForEffects(L, testers) - logging.LogDebug("Effekte auswerten, um vergiftete Getränke zu lokalisieren.") + logging.Debug("Effekte auswerten, um vergiftete Getränke zu lokalisieren.") poisened := evaluateEffects(testers, effects) if len(poisened) > 0 { return poisened[0] @@ -64,7 +62,7 @@ Outputs: Der Index des vergifteten Getränks, falls es eines gibt, ansonsten -1. NOTE: Zeitkosten hier messen nur die Anzahl der Vorkoster. */ func FindPoisonFast(L []int) int { - logging.LogDebug("Bereite Vorkoster vor") + logging.Debug("Bereite Vorkoster vor") n := len(L) p := utils.LengthOfBinary(n) testers := [][]int{} @@ -85,13 +83,13 @@ func FindPoisonFast(L []int) int { * Darum zählen wir nicht 2 sondern 1 Vorkoster. */ metrics.AddSpaceCost(1) - logging.LogDebug(fmt.Sprintf("Füge Vorkoster hinzu, der alle Getränke k testet mit %[1]v. Bit von k = 0.", i)) + logging.Debug("Füge Vorkoster hinzu, der alle Getränke k testet mit %[1]v. Bit von k = 0.", i) testers = append(testers, tester0) testers = append(testers, tester1) } - logging.LogDebug("Warte auf Effekte") + logging.Debug("Warte auf Effekte") effects := waitForEffects(L, testers) - logging.LogDebug("Effekte auswerten, um vergiftete Getränke zu lokalisieren.") + logging.Debug("Effekte auswerten, um vergiftete Getränke zu lokalisieren.") poisened := evaluateEffects(testers, effects) if len(poisened) > 0 { return poisened[0] diff --git a/code/golang/internal/algorithms/search/sequential/sequential.go b/code/golang/internal/algorithms/search/sequential/sequential.go index 7818467..40cfbe0 100644 --- a/code/golang/internal/algorithms/search/sequential/sequential.go +++ b/code/golang/internal/algorithms/search/sequential/sequential.go @@ -5,8 +5,6 @@ package sequential * ---------------------------------------------------------------- */ import ( - "fmt" - "ads/internal/core/logging" "ads/internal/core/metrics" ) @@ -30,10 +28,10 @@ func SequentialSearch(L []int, x int) int { for i := 0; i < n; i++ { metrics.AddTimeCost() if L[i] == x { - logging.LogDebug(fmt.Sprintf("Element in Position %[1]v gefunden.", i)) + logging.Debug("Element in Position %[1]v gefunden.", i) return i } - logging.LogDebug(fmt.Sprintf("Element nicht in Position %[1]v.", i)) + logging.Debug("Element nicht in Position %[1]v.", i) } return -1 } diff --git a/code/golang/internal/algorithms/sum/maxsubsum/maxsubsum.go b/code/golang/internal/algorithms/sum/maxsubsum/maxsubsum.go index 746e677..4b7b1e1 100644 --- a/code/golang/internal/algorithms/sum/maxsubsum/maxsubsum.go +++ b/code/golang/internal/algorithms/sum/maxsubsum/maxsubsum.go @@ -5,8 +5,6 @@ package maxsubsum * ---------------------------------------------------------------- */ import ( - "fmt" - "ads/internal/core/logging" "ads/internal/core/metrics" "ads/internal/core/utils" @@ -41,7 +39,7 @@ func MaxSubSum(L []int) (int, int, int) { if maxSum_ > maxSum { k += i // NOTE: muss wegen Offset kompensieren maxSum, u, v = maxSum_, i, k - logging.LogDebug(fmt.Sprintf("max Teilsumme aktualisiert: Summe L[i] von i=%[1]v .. %[2]v = %[3]v", u, v, maxSum)) + logging.Debug("max Teilsumme aktualisiert: Summe L[i] von i=%[1]v .. %[2]v = %[3]v", u, v, maxSum) } } return maxSum, u, v @@ -85,13 +83,13 @@ func MaxSubSumDC(L []int) (int, int, int) { maxSum = utils.MaxInt(maxSum1, maxSum2, maxSum3) if maxSum == maxSum1 { maxSum, u, v = maxSum1, u1, v1 - logging.LogDebug(fmt.Sprintf("max Teilsumme kommt in linker Partition vor: Summe L[i] von i=%[1]v .. %[2]v = %[3]v", u, v, maxSum)) + logging.Debug("max Teilsumme kommt in linker Partition vor: Summe L[i] von i=%[1]v .. %[2]v = %[3]v", u, v, maxSum) } else if maxSum == maxSum3 { maxSum, u, v = maxSum3, u3, v3 - logging.LogDebug(fmt.Sprintf("max Teilsumme kommt in Überschneidung vor: Summe L[i] von i=%[1]v .. %[2]v = %[3]v", u, v, maxSum)) + logging.Debug("max Teilsumme kommt in Überschneidung vor: Summe L[i] von i=%[1]v .. %[2]v = %[3]v", u, v, maxSum) } else { // } else if maxSum == maxSum2 { maxSum, u, v = maxSum2, u2, v2 - logging.LogDebug(fmt.Sprintf("max Teilsumme kommt in rechter Partition vor: Summe L[i] von i=%[1]v .. %[2]v = %[3]v", u, v, maxSum)) + logging.Debug("max Teilsumme kommt in rechter Partition vor: Summe L[i] von i=%[1]v .. %[2]v = %[3]v", u, v, maxSum) } } return maxSum, u, v diff --git a/code/golang/internal/core/logging/logging.go b/code/golang/internal/core/logging/logging.go index 1f64cde..b6c152d 100644 --- a/code/golang/internal/core/logging/logging.go +++ b/code/golang/internal/core/logging/logging.go @@ -5,160 +5,37 @@ package logging * ---------------------------------------------------------------- */ import ( - "bufio" - "fmt" - "io" "os" - - "ads/internal/core/utils" - "ads/pkg/re" ) /* ---------------------------------------------------------------- * - * GLOBAL VARIABLES + * MAIN METHODS logging * ---------------------------------------------------------------- */ -var quietmode bool = false -var debugmode bool = false -var ansimode bool = false -var loggingPrefix string = "" -var force bool = false -var tagAll bool = false -var promptSymb string = ">" - -func GetQuietMode() bool { - return quietmode +func Plain(line interface{}, args ...interface{}) { + logGeneric(os.Stdout, "", line, args...) } -func SetQuietMode(mode bool) { - quietmode = mode +func Info(line interface{}, args ...interface{}) { + logGeneric(os.Stdout, "[\033[94;1mINFO\033[0m]", line, args...) } -func GetDebugMode() bool { - return debugmode -} - -func SetDebugMode(mode bool) { - debugmode = mode -} - -func GetAnsiMode() bool { - return ansimode -} - -func SetAnsiMode(mode bool) { - ansimode = mode -} - -func GetForce() bool { - return force -} - -func SetForce(mode bool) { - force = mode -} - -func SetTagAll(mode bool) { - tagAll = mode -} - -/* ---------------------------------------------------------------- * - * METHODS logging - * ---------------------------------------------------------------- */ - -func logGeneric(pipe *os.File, tag string, lines ...interface{}) { - if !force && quietmode { - return - } - if !(tag == "") { - tag = tag + " " - } - for _, line := range lines { - fmt.Fprintln(pipe, StripAnsiIfNecessary(fmt.Sprintf("%[1]s%[2]s%[3]v", loggingPrefix, tag, line))) - if !tagAll { - tag = "" - } - } -} - -func LogPlain(lines ...interface{}) { - SetTagAll(false) - logGeneric(os.Stdout, "", lines...) -} - -func LogInfo(lines ...interface{}) { - SetTagAll(true) - logGeneric(os.Stdout, "[\033[94;1mINFO\033[0m]", lines...) -} - -func LogDebug(lines ...interface{}) { +func Debug(line interface{}, args ...interface{}) { if !debugmode { return } - SetTagAll(true) - logGeneric(os.Stdout, "[\033[96;1mDEBUG\033[0m]", lines...) + logGeneric(os.Stdout, "[\033[96;1mDEBUG\033[0m]", line, args...) } -func LogWarn(lines ...interface{}) { - SetTagAll(false) - logGeneric(os.Stdout, "[\033[93;1mWARNING\033[0m]", lines...) +func Warn(line interface{}, args ...interface{}) { + logGeneric(os.Stdout, "[\033[93;1mWARNING\033[0m]", line, args...) } -func LogError(lines ...interface{}) { - SetTagAll(false) - logGeneric(os.Stderr, "[\033[91;1mERROR\033[0m]", lines...) +func Error(line interface{}, args ...interface{}) { + logGeneric(os.Stderr, "[\033[91;1mERROR\033[0m]", line, args...) } -func LogFatal(lines ...interface{}) { - SetTagAll(false) - logGeneric(os.Stderr, "[\033[91;1mFATAL\033[0m]", lines...) +func Fatal(line interface{}, args ...interface{}) { + logGeneric(os.Stderr, "[\033[91;1mFATAL\033[0m]", line, args...) os.Exit(1) } - -/* ---------------------------------------------------------------- * - * AUXILIARY METHODS - * ---------------------------------------------------------------- */ - -func StripAnsiIfNecessary(line string) string { - if !ansimode { - line = utils.StripAnsi(line) - } - return line -} - -/* ---------------------------------------------------------------- * - * METHOD prompt - * ---------------------------------------------------------------- */ - -// Zeigt Prompt an und liest Usereingabe aus, erkennt auch ob Meta+D geklickt wurde -func Prompt(lines ...interface{}) (string, bool, error) { - pipe := os.Stdout - if len(lines) > 0 { - logGeneric(pipe, "", lines...) - logGeneric(pipe, "", "") - } - fmt.Fprintf(pipe, "%s ", promptSymb) - reader := bufio.NewReader(os.Stdin) - line, err := reader.ReadString('\n') - line = re.Sub(`\s+$`, "", line) - if err != nil && err == io.EOF { - fmt.Fprintln(pipe, "") - return line, true, err - } - return line, false, err -} - -func PromptAnyKeyToContinue() bool { - pipe := os.Stdout - fmt.Fprint(pipe, StripAnsiIfNecessary("\033[2;3mEingabetaste (Enter) zum Fortsetzen drücken:\033[0m ")) - _, exit, _ := Prompt() - return exit -} - -/* ---------------------------------------------------------------- * - * METHODS terminal - * ---------------------------------------------------------------- */ - -func ClearScreen() { - fmt.Print("\033[2J") -} diff --git a/code/golang/internal/core/logging/logging_auxiliary.go b/code/golang/internal/core/logging/logging_auxiliary.go new file mode 100644 index 0000000..16be7a0 --- /dev/null +++ b/code/golang/internal/core/logging/logging_auxiliary.go @@ -0,0 +1,45 @@ +package logging + +/* ---------------------------------------------------------------- * + * IMPORTS + * ---------------------------------------------------------------- */ + +import ( + "fmt" + "os" + + "ads/internal/core/utils" +) + +/* ---------------------------------------------------------------- * + * AUXILIARY METHODS + * ---------------------------------------------------------------- */ + +func logGeneric(pipe *os.File, tag string, line interface{}, args ...interface{}) { + if !force && quietmode { + return + } + if !(tag == "") { + tag = tag + " " + } + fmt.Fprintln(pipe, decorateLine(loggingPrefix, tag, expandLine(line, args))) +} + +func expandLine(line interface{}, args []interface{}) string { + return fmt.Sprintf(fmt.Sprintf("%s", line), args...) +} + +func decorateLine(loggingPrefix string, tag string, line string) string { + return stripAnsiIfNecessary(fmt.Sprintf("%[1]s%[2]s%[3]v", loggingPrefix, tag, line)) +} + +func stripAnsiIfNecessary(line string) string { + if !ansimode { + line = utils.StripAnsi(line) + } + return line +} + +func ClearScreen() { + fmt.Print("\033[2J") +} diff --git a/code/golang/internal/core/logging/logging_prompt.go b/code/golang/internal/core/logging/logging_prompt.go new file mode 100644 index 0000000..93c5fcc --- /dev/null +++ b/code/golang/internal/core/logging/logging_prompt.go @@ -0,0 +1,46 @@ +package logging + +/* ---------------------------------------------------------------- * + * IMPORTS + * ---------------------------------------------------------------- */ + +import ( + "bufio" + "fmt" + "io" + "os" + + "ads/pkg/re" +) + +/* ---------------------------------------------------------------- * + * METHOD prompts + * ---------------------------------------------------------------- */ + +// Zeigt Prompt an und liest Usereingabe aus, erkennt auch ob Meta+D geklickt wurde +func Prompt(lines ...interface{}) (string, bool, error) { + pipe := os.Stdout + if len(lines) > 0 { + tag := "" + for _, line := range lines { + logGeneric(pipe, tag, line) + } + logGeneric(pipe, tag, "") + } + fmt.Fprintf(pipe, "%s ", promptSymb) + reader := bufio.NewReader(os.Stdin) + line, err := reader.ReadString('\n') + line = re.Sub(`\s+$`, "", line) + if err != nil && err == io.EOF { + fmt.Fprintln(pipe, "") + return line, true, err + } + return line, false, err +} + +func PromptAnyKeyToContinue() bool { + pipe := os.Stdout + fmt.Fprint(pipe, stripAnsiIfNecessary("\033[2;3mEingabetaste (Enter) zum Fortsetzen drücken:\033[0m ")) + _, exit, _ := Prompt() + return exit +} diff --git a/code/golang/internal/core/logging/logging_settings.go b/code/golang/internal/core/logging/logging_settings.go new file mode 100644 index 0000000..25e6811 --- /dev/null +++ b/code/golang/internal/core/logging/logging_settings.go @@ -0,0 +1,49 @@ +package logging + +/* ---------------------------------------------------------------- * + * IMPORTS + * ---------------------------------------------------------------- */ + +/* ---------------------------------------------------------------- * + * GLOBAL VARIABLES + * ---------------------------------------------------------------- */ + +var quietmode bool = false +var debugmode bool = false +var ansimode bool = false +var loggingPrefix string = "" +var force bool = false +var tagAll bool = false +var promptSymb string = ">" + +func GetQuietMode() bool { + return quietmode +} + +func SetQuietMode(mode bool) { + quietmode = mode +} + +func GetDebugMode() bool { + return debugmode +} + +func SetDebugMode(mode bool) { + debugmode = mode +} + +func GetAnsiMode() bool { + return ansimode +} + +func SetAnsiMode(mode bool) { + ansimode = mode +} + +func GetForce() bool { + return force +} + +func SetForce(mode bool) { + force = mode +} diff --git a/code/golang/internal/endpoints/print/print.go b/code/golang/internal/endpoints/print/print.go index 4bd3b23..ab1cf57 100644 --- a/code/golang/internal/endpoints/print/print.go +++ b/code/golang/internal/endpoints/print/print.go @@ -16,7 +16,7 @@ import ( func Version() { logging.SetForce(true) - logging.LogPlain(setup.Version()) + logging.Plain(setup.Version()) } /* ---------------------------------------------------------------- * @@ -26,11 +26,9 @@ func Version() { func Help() { logging.SetForce(true) cli.ParseCli([]string{}) // <- generiere leere Instanz für Parser, um voll Hilfsanleitug zu zeigen - logging.LogPlain( - "", - setup.Logo(), - // setup.Help(), - cli.Parser.Usage(nil), - "", - ) + logging.Plain("") + logging.Plain(setup.Logo()) + // logging.Plain(setup.Help()) + logging.Plain(cli.Parser.Usage(nil)) + logging.Plain("") } diff --git a/code/golang/internal/endpoints/run/run.go b/code/golang/internal/endpoints/run/run.go index 79edb5b..463de90 100644 --- a/code/golang/internal/endpoints/run/run.go +++ b/code/golang/internal/endpoints/run/run.go @@ -26,9 +26,9 @@ import ( // Startet App im interaktiven Modus func RunInteractive() error { - logging.LogPlain(setup.Logo()) + logging.Plain(setup.Logo()) _, err := menuMain.ShowMenu() - logging.LogInfo("Programm terminiert.") + logging.Info("Programm terminiert.") return err } @@ -48,7 +48,7 @@ func RunNonInteractive(path string) error { return err } - logging.LogPlain(setup.Logo()) + logging.Plain(setup.Logo()) // Fälle extrahieren cases := []types.UserConfigCase{} @@ -157,7 +157,7 @@ func RunNonInteractive(path string) error { } } if err_case != nil { - logging.LogError(err_case) + logging.Error(err_case) } } setup.DisplayEndOfCase() diff --git a/code/golang/internal/endpoints/run/run_actions_algorithms.go b/code/golang/internal/endpoints/run/run_actions_algorithms.go index e9fc115..7b5ae7d 100644 --- a/code/golang/internal/endpoints/run/run_actions_algorithms.go +++ b/code/golang/internal/endpoints/run/run_actions_algorithms.go @@ -35,7 +35,7 @@ func actionAlgorithmSearchBinary() (bool, error) { setup.DisplayStartOfCaseBlank() _, err = algorithm_search_binary.FancyBinarySearch(input_L, input_x) if err != nil { - logging.LogError(err) + logging.Error(err) } setup.DisplayEndOfCase() return cancel, nil @@ -56,7 +56,7 @@ func actionAlgorithmSearchInterpolation() (bool, error) { setup.DisplayStartOfCaseBlank() _, err = algorithm_search_interpol.FancyInterpolationSearch(input_L, input_x, 0, len(input_L)-1) if err != nil { - logging.LogError(err) + logging.Error(err) } setup.DisplayEndOfCase() return cancel, nil @@ -76,7 +76,7 @@ func actionAlgorithmSearchIthElement() (bool, error) { setup.DisplayStartOfCaseBlank() _, err = algorithm_search_ith_element.FancyFindIthSmallest(input_L, input_i) if err != nil { - logging.LogError(err) + logging.Error(err) } setup.DisplayEndOfCase() return cancel, nil @@ -96,7 +96,7 @@ func actionAlgorithmSearchIthElementDc() (bool, error) { setup.DisplayStartOfCaseBlank() _, err = algorithm_search_ith_element.FancyFindIthSmallestDC(input_L, input_i) if err != nil { - logging.LogError(err) + logging.Error(err) } setup.DisplayEndOfCase() return cancel, nil @@ -124,7 +124,7 @@ func actionAlgorithmSearchJump() (bool, error) { setup.DisplayStartOfCaseBlank() _, err = algorithm_search_jump.FancyJumpSearchLinear(input_L, input_x, input_m) if err != nil { - logging.LogError(err) + logging.Error(err) } setup.DisplayEndOfCase() return cancel, nil @@ -146,7 +146,7 @@ func actionAlgorithmSearchJumpExp() (bool, error) { setup.DisplayStartOfCaseBlank() _, err = algorithm_search_jump.FancyJumpSearchExponentiell(input_L, input_x) if err != nil { - logging.LogError(err) + logging.Error(err) } setup.DisplayEndOfCase() return cancel, nil @@ -162,7 +162,7 @@ func actionAlgorithmSearchPoison() (bool, error) { setup.DisplayStartOfCaseBlank() _, err = algorithm_search_poison.FancyFindPoison(input_L) if err != nil { - logging.LogError(err) + logging.Error(err) } setup.DisplayEndOfCase() return cancel, nil @@ -178,7 +178,7 @@ func actionAlgorithmSearchPoisonFast() (bool, error) { setup.DisplayStartOfCaseBlank() _, err = algorithm_search_poison.FancyFindPoisonFast(input_L) if err != nil { - logging.LogError(err) + logging.Error(err) } setup.DisplayEndOfCase() return cancel, nil @@ -196,7 +196,7 @@ func actionAlgorithmSearchSequential() (bool, error) { setup.DisplayStartOfCaseBlank() _, err = algorithm_search_sequential.FancySequentialSearch(input_L, input_x) if err != nil { - logging.LogError(err) + logging.Error(err) } setup.DisplayEndOfCase() return cancel, nil @@ -210,7 +210,7 @@ func actionAlgorithmSumMaxsub() (bool, error) { setup.DisplayStartOfCaseBlank() _, _, _, err = algorithm_sum_maxsubsum.FancyMaxSubSum(input_L) if err != nil { - logging.LogError(err) + logging.Error(err) } setup.DisplayEndOfCase() return cancel, nil @@ -224,7 +224,7 @@ func actionAlgorithmSumMaxsubDc() (bool, error) { setup.DisplayStartOfCaseBlank() _, _, _, err = algorithm_sum_maxsubsum.FancyMaxSubSumDC(input_L) if err != nil { - logging.LogError(err) + logging.Error(err) } setup.DisplayEndOfCase() return cancel, nil diff --git a/code/golang/internal/endpoints/run/run_actions_basic+.go b/code/golang/internal/endpoints/run/run_actions_basic.go similarity index 84% rename from code/golang/internal/endpoints/run/run_actions_basic+.go rename to code/golang/internal/endpoints/run/run_actions_basic.go index 65cd27d..0c5d6d2 100644 --- a/code/golang/internal/endpoints/run/run_actions_basic+.go +++ b/code/golang/internal/endpoints/run/run_actions_basic.go @@ -14,12 +14,10 @@ import ( * ---------------------------------------------------------------- */ func actionShowVersion() (bool, error) { - logging.LogPlain( - "", - setup.Logo(), - setup.Version(), - "", - ) + logging.Plain("") + logging.Plain(setup.Logo()) + logging.Plain("Version: \033[1m%s\033[0m", setup.Version()) + logging.Plain("") return false, nil } diff --git a/code/golang/internal/endpoints/run/run_actions_settings.go b/code/golang/internal/endpoints/run/run_actions_settings.go index eb8af8e..de2e816 100644 --- a/code/golang/internal/endpoints/run/run_actions_settings.go +++ b/code/golang/internal/endpoints/run/run_actions_settings.go @@ -5,8 +5,6 @@ package run * ---------------------------------------------------------------- */ import ( - "fmt" - "ads/internal/core/logging" "ads/internal/setup" ) @@ -21,17 +19,17 @@ func actionShowSettings() (bool, error) { if logging.GetAnsiMode() { state = "ein" } - logging.LogInfo(fmt.Sprintf("Farbenmodus: %s", state)) + logging.Info("Farbenmodus: %s", state) state = "aus" if logging.GetDebugMode() { state = "ein" } - logging.LogInfo(fmt.Sprintf("Debugmodus: %s", state)) + logging.Info("Debugmodus: %s", state) state = "aus" if setup.AppConfigPerformChecks() { state = "ein" } - logging.LogInfo(fmt.Sprintf("Pre/Postchecking: %s", state)) + logging.Info("Pre/Postchecking: %s", state) return false, nil } diff --git a/code/golang/internal/menus/menus.go b/code/golang/internal/menus/menus.go index a3a0a02..0e76dac 100644 --- a/code/golang/internal/menus/menus.go +++ b/code/golang/internal/menus/menus.go @@ -110,7 +110,7 @@ func (menu Menu) ShowMenu() (bool, error) { } else if opt.Action != nil { cancel, err = opt.Action() if err != nil { - logging.LogError(err) + logging.Error(err) } // Falls ForceReturn, dann nach Ausführung der Action, -> return if menu.ForceReturn { @@ -127,7 +127,7 @@ func (menu Menu) ShowMenu() (bool, error) { } } } else { - logging.LogWarn("Option noch nicht implementiert.") + logging.Warn("Option noch nicht implementiert.") quit := logging.PromptAnyKeyToContinue() if quit { return true, nil @@ -188,13 +188,15 @@ func (query *PromptValueQuery) Prompt() (bool, error) { return true, nil } if err != nil { - logging.LogError(err, "") + logging.Error(err) + logging.Plain("") continue } line = fmt.Sprintf("\"response\": %s", line) err = yaml.Unmarshal([]byte(line), query.Response) if err != nil { - logging.LogError(err, "") + logging.Error(err) + logging.Plain("") continue } break diff --git a/code/golang/internal/menus/menus_prompt.go b/code/golang/internal/menus/menus_prompt.go index 503fdd9..23e4a94 100644 --- a/code/golang/internal/menus/menus_prompt.go +++ b/code/golang/internal/menus/menus_prompt.go @@ -63,7 +63,7 @@ func promptListOfOptions(messages []string, options [][2]string, breaks []int, d } if err != nil { logging.ClearScreen() - logging.LogError(err) + logging.Error(err) continue } if choice == "" { @@ -72,7 +72,7 @@ func promptListOfOptions(messages []string, options [][2]string, breaks []int, d } if _, ok := optionsMap[choice]; !ok { logging.ClearScreen() - logging.LogError("Ungültige eingabe") + logging.Error("Ungültige eingabe") continue } break diff --git a/code/golang/internal/setup/setup_display.go b/code/golang/internal/setup/setup_display.go index c788d20..18ca5a5 100644 --- a/code/golang/internal/setup/setup_display.go +++ b/code/golang/internal/setup/setup_display.go @@ -20,9 +20,9 @@ import ( func DisplayStartOfCase(index int, descr *string) { DisplayBar(80) if descr == nil || *descr == "" { - logging.LogPlain(fmt.Sprintf("\033[92;1mCASE %[1]v\033[0m.", index)) + logging.Plain("\033[92;1mCASE %[1]v\033[0m.", index) } else { - logging.LogPlain(fmt.Sprintf("\033[92;1mCASE %[1]v\033[0m (\033[1;2m%[2]s\033[0m).", index, *descr)) + logging.Plain("\033[92;1mCASE %[1]v\033[0m (\033[1;2m%[2]s\033[0m).", index, *descr) } } @@ -86,25 +86,25 @@ func RepresentValue(value interface{}) interface{} { * ---------------------------------------------------------------- */ func DisplayStartOfAlgorithm(name string, inputs map[string]interface{}) { - logging.LogPlain(fmt.Sprintf("Ausführung vom Algorithmus: \033[92;1m%[1]s\033[0m", name)) - logging.LogPlain("INPUTS") + logging.Plain("Ausführung vom Algorithmus: \033[92;1m%[1]s\033[0m", name) + logging.Plain("INPUTS") for varname, value := range inputs { - logging.LogPlain(fmt.Sprintf(" - %[1]s = %[2]v", varname, RepresentValue(value))) + logging.Plain(" - %[1]s = %[2]v", varname, RepresentValue(value)) } } func DisplayEndOfAlgorithm(outputs map[string]interface{}) { - logging.LogPlain("OUTPUTS:") + logging.Plain("OUTPUTS:") for varname, value := range outputs { - logging.LogPlain(fmt.Sprintf(" - %[1]s = %[2]v", varname, RepresentValue(value))) + logging.Plain(" - %[1]s = %[2]v", varname, RepresentValue(value)) } } func DisplayMetrics() { - // logging.LogPlain(fmt.Sprintf("Dauer der Ausführung: t = \033[1m%[1]v\033[0m", metrics.GetTimeElapsed())) - logging.LogPlain(fmt.Sprintf("Dauer der Ausführung: t = \033[1m%[1]v\033[0m", metrics.GetTimeElapsedLongFormat())) - logging.LogPlain(fmt.Sprintf("Kosten (Zeit): T(n) = \033[1m%[1]v\033[0m", metrics.GetTimeCost())) - logging.LogPlain(fmt.Sprintf("Kosten (Platz): S(n) = \033[1m%[1]v\033[0m", metrics.GetSpaceCost())) + // logging.Plain("Dauer der Ausführung: t = \033[1m%[1]v\033[0m", metrics.GetTimeElapsed()) + logging.Plain("Dauer der Ausführung: t = \033[1m%[1]v\033[0m", metrics.GetTimeElapsedLongFormat()) + logging.Plain("Kosten (Zeit): T(n) = \033[1m%[1]v\033[0m", metrics.GetTimeCost()) + logging.Plain("Kosten (Platz): S(n) = \033[1m%[1]v\033[0m", metrics.GetSpaceCost()) return } @@ -117,6 +117,6 @@ func DisplayBar(options ...int) { if len(options) > 0 { n = options[0] } - logging.LogPlain(fmt.Sprintf("+%[1]s+", strings.Repeat("-", n))) + logging.Plain("+%[1]s+", strings.Repeat("-", n)) return } diff --git a/code/golang/main.go b/code/golang/main.go index dc072ee..ee552ba 100644 --- a/code/golang/main.go +++ b/code/golang/main.go @@ -89,6 +89,6 @@ func main() { } if err != nil { - logging.LogFatal(err) + logging.Fatal(err) } }