new: parsing BLE flags and company identifiers from advertisements

vendor/github.com/chzyer/logex/logex.go

@@ -0,0 +1,271 @@
+package logex
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	goLog "log"
+	"os"
+	"path"
+	"runtime"
+	"strconv"
+	"strings"
+)
+
+var DebugLevel = 1
+
+type Logger struct {
+	depth  int
+	reqid  string
+	Logger *goLog.Logger
+}
+
+func NewLogger(l int) *Logger {
+	return &Logger{l, "", goLogStd}
+}
+
+func NewLoggerEx(w io.Writer) *Logger {
+	return &Logger{0, "", NewGoLog(w)}
+}
+
+func NewGoLog(w io.Writer) *goLog.Logger {
+	return goLog.New(w, "", goLog.LstdFlags)
+}
+
+var goLogStd = goLog.New(os.Stderr, "", goLog.LstdFlags)
+var std = NewLogger(1)
+var ShowCode = true
+var (
+	Println    = std.Println
+	Infof      = std.Infof
+	Info       = std.Info
+	Debug      = std.Debug
+	Debugf     = std.Debugf
+	Error      = std.Error
+	Errorf     = std.Errorf
+	Warn       = std.Warn
+	PrintStack = std.PrintStack
+	Stack      = std.Stack
+	Panic      = std.Panic
+	Fatal      = std.Fatal
+	Struct     = std.Struct
+	Pretty     = std.Pretty
+	Todo       = std.Todo
+)
+
+func SetStd(l *Logger) {
+	std = l
+	Println = std.Println
+	Infof = std.Infof
+	Info = std.Info
+	Debug = std.Debug
+	Error = std.Error
+	Warn = std.Warn
+	PrintStack = std.PrintStack
+	Stack = std.Stack
+	Panic = std.Panic
+	Fatal = std.Fatal
+	Struct = std.Struct
+	Pretty = std.Pretty
+	Todo = std.Todo
+}
+
+var (
+	INFO   = "[INFO] "
+	ERROR  = "[ERROR] "
+	PANIC  = "[PANIC] "
+	DEBUG  = "[DEBUG] "
+	WARN   = "[WARN] "
+	FATAL  = "[FATAL] "
+	STRUCT = "[STRUCT] "
+	PRETTY = "[PRETTY] "
+	TODO   = "[TODO] "
+)
+
+func color(col, s string) string {
+	if col == "" {
+		return s
+	}
+	return "\x1b[0;" + col + "m" + s + "\x1b[0m"
+}
+
+func init() {
+	if os.Getenv("DEBUG") != "" {
+		DebugLevel = 0
+		ERROR = color("32", ERROR)
+	}
+}
+
+func DownLevel(i int) Logger {
+	return std.DownLevel(i - 1)
+}
+
+// decide to show which level's stack
+func (l Logger) DownLevel(i int) Logger {
+	return Logger{l.depth + i, l.reqid, l.Logger}
+}
+
+// output objects to json format
+func (l Logger) Pretty(os ...interface{}) {
+	content := ""
+	for i := range os {
+		if ret, err := json.MarshalIndent(os[i], "", "\t"); err == nil {
+			content += string(ret) + "\n"
+		}
+	}
+	l.Output(2, PRETTY+content)
+}
+
+// just print
+func (l Logger) Print(o ...interface{}) {
+	l.Output(2, sprint(o))
+}
+
+// just print by format
+func (l Logger) Printf(layout string, o ...interface{}) {
+	l.Output(2, sprintf(layout, o))
+}
+
+// just println
+func (l Logger) Println(o ...interface{}) {
+	l.Output(2, " "+sprint(o))
+}
+
+func (l Logger) Info(o ...interface{}) {
+	l.Output(2, INFO+sprint(o))
+}
+func (l Logger) Infof(f string, o ...interface{}) {
+	l.Output(2, INFO+sprintf(f, o))
+}
+
+func (l Logger) Debug(o ...interface{}) {
+	if DebugLevel > 0 {
+		return
+	}
+	l.Output(2, DEBUG+sprint(o))
+}
+
+func (l Logger) Debugf(f string, o ...interface{}) {
+	if DebugLevel > 0 {
+		return
+	}
+	l.Output(2, DEBUG+sprintf(f, o))
+}
+
+func (l Logger) Todo(o ...interface{}) {
+	l.Output(2, TODO+sprint(o))
+}
+
+func (l Logger) Error(o ...interface{}) {
+	l.Output(2, ERROR+sprint(o))
+}
+
+func (l Logger) Errorf(f string, o ...interface{}) {
+	l.Output(2, ERROR+sprintf(f, o))
+}
+
+func (l Logger) Warn(o ...interface{}) {
+	l.Output(2, WARN+sprint(o))
+}
+func (l Logger) Warnf(f string, o ...interface{}) {
+	l.Output(2, WARN+sprintf(f, o))
+}
+
+func (l Logger) Panic(o ...interface{}) {
+	l.Output(2, PANIC+sprint(o))
+	panic(o)
+}
+func (l Logger) Panicf(f string, o ...interface{}) {
+	info := sprintf(f, o)
+	l.Output(2, PANIC+info)
+	panic(info)
+}
+
+func (l Logger) Fatal(o ...interface{}) {
+	l.Output(2, FATAL+sprint(o))
+	os.Exit(1)
+}
+
+func (l Logger) Fatalf(f string, o ...interface{}) {
+	l.Output(2, FATAL+sprintf(f, o))
+	os.Exit(1)
+}
+
+func (l Logger) Struct(o ...interface{}) {
+	items := make([]interface{}, 0, len(o)*2)
+	for _, item := range o {
+		items = append(items, item, item)
+	}
+	layout := strings.Repeat(", %T(%+v)", len(o))
+	if len(layout) > 0 {
+		layout = layout[2:]
+	}
+	l.Output(2, STRUCT+sprintf(layout, items))
+}
+
+func (l Logger) PrintStack() {
+	Info(string(l.Stack()))
+}
+
+func (l Logger) Stack() []byte {
+	a := make([]byte, 1024*1024)
+	n := runtime.Stack(a, true)
+	return a[:n]
+}
+
+func (l Logger) Output(calldepth int, s string) error {
+	calldepth += l.depth + 1
+	if l.Logger == nil {
+		l.Logger = goLogStd
+	}
+	return l.Logger.Output(calldepth, l.makePrefix(calldepth)+s)
+}
+
+func (l Logger) makePrefix(calldepth int) string {
+	if !ShowCode {
+		return ""
+	}
+	pc, f, line, _ := runtime.Caller(calldepth)
+	name := runtime.FuncForPC(pc).Name()
+	name = path.Base(name) // only use package.funcname
+	f = path.Base(f)       // only use filename
+
+	tags := make([]string, 0, 3)
+
+	pos := name + ":" + f + ":" + strconv.Itoa(line)
+	tags = append(tags, pos)
+	if l.reqid != "" {
+		tags = append(tags, l.reqid)
+	}
+	return "[" + strings.Join(tags, "][") + "]"
+}
+
+func sprint(o []interface{}) string {
+	decodeTraceError(o)
+	return joinInterface(o, " ")
+}
+func sprintf(f string, o []interface{}) string {
+	decodeTraceError(o)
+	return fmt.Sprintf(f, o...)
+}
+
+func DecodeError(e error) string {
+	if e == nil {
+		return ""
+	}
+	if e1, ok := e.(*traceError); ok {
+		return e1.StackError()
+	}
+	return e.Error()
+}
+
+func decodeTraceError(o []interface{}) {
+	if !ShowCode {
+		return
+	}
+	for idx, obj := range o {
+		if te, ok := obj.(*traceError); ok {
+			o[idx] = te.StackError()
+		}
+	}
+}