87 lines
2.0 KiB
Go
87 lines
2.0 KiB
Go
// I like things to be easy. Why can't the standard language be like this?
|
|
|
|
package main
|
|
|
|
import (
|
|
"os"
|
|
golog "log"
|
|
"reflect"
|
|
"github.com/davecgh/go-spew/spew"
|
|
// "net"
|
|
)
|
|
|
|
/*
|
|
sleep() # you know what this does? sleeps for 1 second. yep. dump. easy.
|
|
sleep(.1) # you know what this does? yes, it sleeps for 1/10th of a second
|
|
*/
|
|
func sleep(a ...any) {
|
|
log("sleep", a)
|
|
}
|
|
|
|
/*
|
|
exit() # yep. exits. I guess everything must be fine
|
|
exit(3) # I guess 3 it is then
|
|
exit("dont like apples") # ok. I'll make a note of that
|
|
*/
|
|
func exit(a ...any) {
|
|
log("exit", a)
|
|
//if (a) {
|
|
// os.Exit(a)
|
|
//}
|
|
os.Exit(0)
|
|
}
|
|
|
|
/*
|
|
I've spent, am spending, too much time thinking about 'logging'. 'log', 'logrus', 'zap', whatever.
|
|
I'm not twitter. i don't give a fuck about how many nanoseconds it takes to log. Anyway, this
|
|
implementation is probably faster than all of those because you just set one bool to FALSE
|
|
and it all stops.
|
|
Sometimes I need to capture to stdout, sometimes stdout can't
|
|
work because it doesn't exist for the user. This whole thing is a PITA. Then it's spread over 8 million references in every .go file. I'm tapping out and putting
|
|
it in one place. here it is. Also, this makes having debug levels really fucking easy. You can define whatever level of logging you want from anywhere (command line)
|
|
etc.
|
|
|
|
log() # doesn't do anything
|
|
log(stuff) # sends it to whatever log you define in a single place. here is the place
|
|
*/
|
|
|
|
var LOGOFF bool // turn this off, all logging stops
|
|
var WARN bool
|
|
var INFO bool
|
|
|
|
type spewt struct {
|
|
a bool
|
|
}
|
|
|
|
var SPEW spewt
|
|
|
|
func log(a ...any) {
|
|
if (LOGOFF) {
|
|
return
|
|
}
|
|
|
|
if (a == nil) {
|
|
return
|
|
}
|
|
var blah bool
|
|
if (reflect.TypeOf(a[0]) == reflect.TypeOf(blah)) {
|
|
// golog.Println("\t a[0] = bool")
|
|
if (a[0] == false) {
|
|
return
|
|
}
|
|
a = a[1:]
|
|
}
|
|
|
|
if (reflect.TypeOf(a[0]) == reflect.TypeOf(SPEW)) {
|
|
a = a[1:]
|
|
spew.Dump(a)
|
|
return
|
|
}
|
|
|
|
golog.Println(a...)
|
|
// golog.Println("\t a[0] =", a[0])
|
|
// for argNum, arg := range a {
|
|
// golog.Println("\t", argNum, arg)
|
|
// }
|
|
}
|