gsr

README

GSR

Go Standards Recommendations

Install

go get github.com/gookit/gsr

Interfaces

• logger
• cacher
• parser

Usage

Logger Interface

Std Logger

package main
import (
	"github.com/gookit/gsr"
)

type MyApp struct {
	logger gsr.StdLogger // std logger
}

func (ma *MyApp) SetLogger(logger gsr.StdLogger)  {
	ma.logger = logger
}

Full Logger

package main
import (
	"github.com/gookit/gsr"
)

type MyApp struct {
	logger gsr.Logger // full logger
}

func (ma *MyApp) SetLogger(logger gsr.Logger)  {
	ma.logger = logger
}

Cache Interface

Simple Cache

package main
import (
	"github.com/gookit/gsr"
)

type MyApp struct {
	cacher gsr.SimpleCacher
}

func (ma *MyApp) SetCacher(cacher gsr.SimpleCacher)  {
	ma.cacher = cacher
}

DataParser interface

// DataParser interface for Marshal/Unmarshal data
type DataParser interface {
	Marshal(v interface{}) ([]byte, error)
	Unmarshal(data []byte, ptr interface{}) error
}

LICENSE

MIT

Documentation

Overview

Package gsr is the Go standards recommendations interface definitions.

Source code and other details for the project are available at GitHub:

https://github.com/gookit/gsr

Index

• type CodedCacher
• type ContextCacher
• type ContextOpCacher
• type DataParser
• type GenLogger
• type Logger
• type MarshalFunc
  • func (m MarshalFunc) Marshal(v interface{}) ([]byte, error)
• type Marshaler
• type Printer
• type SimpleCacher
• type StdLogger
• type UnmarshalFunc
  • func (u UnmarshalFunc) Unmarshal(v []byte, ptr interface{}) error
• type Unmarshaler

Types

type CodedCacher

type CodedCacher interface {
	SimpleCacher

	// GetAs get and decode cache value to object ptr
	GetAs(key string, ptr interface{}) error
}

CodedCacher interface.

type ContextCacher

type ContextCacher interface {
	SimpleCacher
	// WithContext and clone new cacher
	WithContext(ctx context.Context) ContextCacher
}

ContextCacher interface.

type ContextOpCacher

type ContextOpCacher interface {
	SimpleCacher

	// HasWithCtx basic operation
	HasWithCtx(ctx context.Context, key string) bool
	DelWithCtx(ctx context.Context, key string) error
	GetWithCtx(ctx context.Context, key string) interface{}
	SetWithCtx(ctx context.Context, key string, val interface{}, ttl time.Duration) error

	// MGetWithCtx multi keys operation
	MGetWithCtx(ctx context.Context, keys []string) map[string]interface{}
	MSetWithCtx(ctx context.Context, values map[string]interface{}, ttl time.Duration) error
	MDelWithCtx(ctx context.Context, keys []string) error
}

ContextOpCacher interface.

type DataParser

type DataParser interface {
	Marshaler
	Unmarshaler
}

DataParser interface for Marshal/Unmarshal data

type GenLogger

type GenLogger interface {
	Debug(v ...interface{})
	Debugf(format string, v ...interface{})
	Info(v ...interface{})
	Infof(format string, v ...interface{})
	Warn(v ...interface{})
	Warnf(format string, v ...interface{})
	Error(v ...interface{})
	Errorf(format string, v ...interface{})
}

GenLogger generic logger interface definition

type Logger

type Logger interface {
	StdLogger
	GenLogger
}

Logger interface definition

type MarshalFunc

type MarshalFunc func(v interface{}) ([]byte, error)

MarshalFunc define

func (MarshalFunc) Marshal

func (m MarshalFunc) Marshal(v interface{}) ([]byte, error)

Marshal implements the Marshaler

type Marshaler

type Marshaler interface {
	Marshal(v interface{}) ([]byte, error)
}

Marshaler interface

type Printer

type Printer interface {
	Print(v ...interface{})
	Printf(format string, v ...interface{})
	Println(v ...interface{})
}

Printer interface definition

type SimpleCacher

type SimpleCacher interface {
	// Closer close cache handle
	io.Closer
	// Clear all cache data
	Clear() error

	// Has basic operation
	Has(key string) bool
	Del(key string) error
	Get(key string) interface{}
	Set(key string, val interface{}, ttl time.Duration) error

	// GetMulti multi operation
	GetMulti(keys []string) map[string]interface{}
	SetMulti(values map[string]interface{}, ttl time.Duration) error
	DelMulti(keys []string) error
}

SimpleCacher interface definition

type StdLogger

type StdLogger interface {
	Printer
	Fatal(v ...interface{})
	Fatalf(format string, v ...interface{})
	Fatalln(v ...interface{})
	Panic(v ...interface{})
	Panicf(format string, v ...interface{})
	Panicln(v ...interface{})
}

StdLogger interface definition. refer the go "log" package.

type UnmarshalFunc

type UnmarshalFunc func(v []byte, ptr interface{}) error

UnmarshalFunc define

func (UnmarshalFunc) Unmarshal

func (u UnmarshalFunc) Unmarshal(v []byte, ptr interface{}) error

Unmarshal implements the Unmarshaler

type Unmarshaler

type Unmarshaler interface {
	Unmarshal(v []byte, ptr interface{}) error
}

Unmarshaler interface