<a name="Struct-Utilities"></a>
Struct Utilities

ScanStructMethods
Scan struct methods

ProcessStruct
Scan struct fields

<a name="Function-Utilities"></a>
Function Utilities
<a name="TimeUtilities"></a>
Time Utilities	
	
DateFormatToLayout

Java date format style to go date layout conversion.

TimeAt

Provide dynamic semantic for creating time object

TimeDiff
Provide dynamic semantic for creating time object based on time dif

lastyear, _ := time.Parse(DateFormatToLayout("yyyy-MM-dd"), "2017-01-01") ts1, e := TimeDiff(lastyear, "50 hours earlier") ts2, e := TimeDiff(lastyear, "3 days before in Poland")

DayElapsed

t0, _ := time.Parse(DateFormatToLayout("yyyy-MM-dd hh:mm:ss"), "2017-01-01 12:00:00") dayElapsedInT0, err := ElapsedDay(t0) //0.5

ElapsedToday

elapscedInLocalTz, err := ElapsedTodayInPct("") elapscedInUTC, err := ElapsedToday("UTC")

RemainingToday

elapscedInLocalTz, err := RemainingTodayInPct("") elapscedInUTC, err := RemainingToday("UTC")

AtTime

<a name="storage"></a>

Storage
Storage API provides unified way of accessing local or remote storage system.
This API has been deprecated, please consider using Abstract Storage
Example

<a name="tet"></a>
Text utilities
Text Case Format
You can format with format.Case.Format(text, destCase)

<a name="Tokenizer"></a>
Tokenizer

<a name="ServiceRouter"></a>
ServiceRouter

This ServiceRouter provides simple WebService Endpoint abstractin and RESET Client utilities.
Take as example of a ReverseService defined as follow

type ReverseService interface { Reverse(values []int) []int }

type reverseService struct{}

func (r *reverseService) Reverse(values []int) []int { var result = make([]int, 0) for i := len(values) - 1; i >= 0; i-- { result = append(result, values[i]) }

return result }

In order to define Endpoint for this service,  define a server, a router with the service routes;

type Server struct { service ReverseService port string }

func (s *Server) Start() { router := toolbox.NewServiceRouter( toolbox.ServiceRouting{ HTTPMethod: "GET", URI: "/v1/reverse/{ids}", Handler: s.service.Reverse, Parameters: []string{"ids"}, }, toolbox.ServiceRouting{ HTTPMethod: "POST", URI: "/v1/reverse/", Handler: s.service.Reverse, Parameters: []string{"ids"}, }) http.HandleFunc("/v1/", func(writer http.ResponseWriter, reader *http.Request) { err := router.Route(writer, reader) if err != nil { response.WriteHeader(http.StatusInternalServerError) } }) fmt.Printf("Started test server on port %v\n", port) log.Fatal(http.ListenAndServe(":"+port, nil)) }

ServiceRouting parameters define handler parameters that can be extracted from URI, QueryString, or from Post Body (json payload)
In addition two special parameter names are supported: @httpRequest, @httpResponseWriter  to pass in request, and response object respectively.
The REST client utility invoking our reverse service may look as follow

var result = make([]int, 0) err := toolbox.RouteToService("get", "http://127.0.0.1:8082/v1/reverse/1,7,3", nil, &result) //... err := toolbox.RouteToService("post", "http://127.0.0.1:8082/v1/reverse/", []int{1, 7, 3}, &result)

By default a service router uses reflection to call the matched routes handler, it is possible to avoid reflection overhead by providing the custom handler invoker.

var ReverseInvoker = func(serviceRouting toolbox.ServiceRouting, request http.Request, response http.ResponseWriter, uriParameters map[string]interface{}) error {
	var function = serviceRouting.Handler.(func(values []int) []int)
	idsParam := uriParameters["ids"]
	ids := idsParam.([]string)
	values := make([]int, 0)
	for _, item := range ids {
		values = append(values, toolbox.AsInt(item))
	}
	var result = function(values)
	err := toolbox.WriteServiceRoutingResponse(response, request, serviceRouting, result)
	if err != nil {
		return err
	}
	return nil
}
//...
router := toolbox.NewServiceRouter(
		toolbox.ServiceRouting{
			HTTPMethod: "GET",
			URI:        "/v1/reverse/{ids}",
			Handler:    s.service.Reverse,
			Parameters: []string{"ids"},
			HandlerInvoker: ReverseInvoker,
		})
//...

Decoder and Encoder

Decoder

This library defines DecoderFactory interface to delegate decoder creation, This library comes with standard JSON and UnMarshaler (protobuf) factory implementation.

Example

factory :=toolbox.NewJsonDecoderFactory()
    ....
    
    decoder := factory.Create(reader)
    foo := &Foo{}
    err = decoder.Decode(foo)

marshalerFactory := toolbox.NewUnMarshalerDecoderFactory()
    decoder := marshalerFactory.Create(reader)
    foo := &Foo{}
    err = decoder.Decode(foo)

Encoder

This library defines EncoderFactory interface to delegate encoder creation, This library comes with standard JSON and Marshaler (protobuf) factory implementation.

Example

factory :=toolbox.NewJsonEncoderFactory()
        ....
        buffer := new(bytes.Buffer)
        
        
        decoder := factory.Create(buffer)
        err = decoder.Encode(foo)
    
    
    
        marshalerFactory := toolbox.NewMarshalerEncoderFactory()
        decoder := marshalerFactory.Create(buffer)
        err = decoder.Encode(foo)

Logger

This library provides a file logger implementation that optimizes writes. Log messages are queues until max queue size or flush frequency are met. On top of that Ctrl-C also forces immediate log messages flush to disk.

File template support java style time format to manage rotation on the file name level.

logger, err := toolbox.NewFileLogger(toolbox.FileLoggerConfig{
		LogType:           "test",
		FileTemplate:      "/tmp/test[yyyyMMdd-hhmm].log",
		QueueFlashCount:   250,
		MaxQueueSize:      500,
		FlushFrequencyInMs: 2000,
		MaxIddleTimeInSec: 1,
	}, toolbox.FileLoggerConfig{
       		LogType:           "transaction",
       		FileTemplate:      "/tmp/transaction[yyyyMMdd-hhmm].log",
       		QueueFlashCount:   250,
       		MaxQueueSize:      500,
       		FlushFrequencyInMs:2000,
       		MaxIddleTimeInSec: 1,
       	},
	)
logger.Log(&toolbox.LogMessage{
        MessageType: "test",
        Message:     message
    })
    
    logger.Log(&toolbox.LogMessage{
            MessageType: "transaction",
            Message:     message
        })

BatchLimiter

This library provides a batch limiter, that enables controling number of active go routines.

var tasks []*Task
     var batchSize = 4
	 limiter:= toolbox.NewBatchLimiter(batchSize, len(tasks))
   	 for i, _ :=  range tasks {
            go func(task *Task) {
                    limiter.Acquire()
                    defer limiter.Done()
                    task.Run();
        	}(tasks[i])
	}
	limiter.Wait()

AST Based FileSetInfo

pkgPath := ""
	source := path.Join(pkgPath)
	filesetInfo, err :=toolbox.NewFileSetInfo(source)
    myType := fileSetInfo.Type("MyType")
    fields := myType.Fields()
    method := myType.Receivers

GoCover

License