Depenancy upgrades and movign to dep. (#8630)
Этот коммит содержится в:
Christopher Speller
коммит произвёл
Joram Wilander
Joram Wilander
родитель
bf24f51c4e
Коммит
6e2cb00008
14
vendor/github.com/hashicorp/go-msgpack/README.md
сгенерированный
поставляемый
14
vendor/github.com/hashicorp/go-msgpack/README.md
сгенерированный
поставляемый
@@ -1,14 +0,0 @@
|
||||
# go
|
||||
|
||||
Collection of Open-Source Go libraries and tools.
|
||||
|
||||
## Codec
|
||||
|
||||
[Codec](https://github.com/ugorji/go/tree/master/codec#readme) is a High Performance and Feature-Rich Idiomatic encode/decode and rpc library for [msgpack](http://msgpack.org) and [Binc](https://github.com/ugorji/binc).
|
||||
|
||||
Online documentation is at [http://godoc.org/github.com/ugorji/go/codec].
|
||||
|
||||
Install using:
|
||||
|
||||
go get github.com/ugorji/go/codec
|
||||
|
||||
319
vendor/github.com/hashicorp/go-msgpack/codec/bench_test.go
сгенерированный
поставляемый
319
vendor/github.com/hashicorp/go-msgpack/codec/bench_test.go
сгенерированный
поставляемый
@@ -1,319 +0,0 @@
|
||||
// Copyright (c) 2012, 2013 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style license found in the LICENSE file.
|
||||
|
||||
package codec
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/gob"
|
||||
"encoding/json"
|
||||
"flag"
|
||||
"fmt"
|
||||
"reflect"
|
||||
"runtime"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Sample way to run:
|
||||
// go test -bi -bv -bd=1 -benchmem -bench=.
|
||||
|
||||
var (
|
||||
_ = fmt.Printf
|
||||
benchTs *TestStruc
|
||||
|
||||
approxSize int
|
||||
|
||||
benchDoInitBench bool
|
||||
benchVerify bool
|
||||
benchUnscientificRes bool = false
|
||||
//depth of 0 maps to ~400bytes json-encoded string, 1 maps to ~1400 bytes, etc
|
||||
//For depth>1, we likely trigger stack growth for encoders, making benchmarking unreliable.
|
||||
benchDepth int
|
||||
benchInitDebug bool
|
||||
benchCheckers []benchChecker
|
||||
)
|
||||
|
||||
type benchEncFn func(interface{}) ([]byte, error)
|
||||
type benchDecFn func([]byte, interface{}) error
|
||||
type benchIntfFn func() interface{}
|
||||
|
||||
type benchChecker struct {
|
||||
name string
|
||||
encodefn benchEncFn
|
||||
decodefn benchDecFn
|
||||
}
|
||||
|
||||
func benchInitFlags() {
|
||||
flag.BoolVar(&benchInitDebug, "bg", false, "Bench Debug")
|
||||
flag.IntVar(&benchDepth, "bd", 1, "Bench Depth: If >1, potential unreliable results due to stack growth")
|
||||
flag.BoolVar(&benchDoInitBench, "bi", false, "Run Bench Init")
|
||||
flag.BoolVar(&benchVerify, "bv", false, "Verify Decoded Value during Benchmark")
|
||||
flag.BoolVar(&benchUnscientificRes, "bu", false, "Show Unscientific Results during Benchmark")
|
||||
}
|
||||
|
||||
func benchInit() {
|
||||
benchTs = newTestStruc(benchDepth, true)
|
||||
approxSize = approxDataSize(reflect.ValueOf(benchTs))
|
||||
bytesLen := 1024 * 4 * (benchDepth + 1) * (benchDepth + 1)
|
||||
if bytesLen < approxSize {
|
||||
bytesLen = approxSize
|
||||
}
|
||||
|
||||
benchCheckers = append(benchCheckers,
|
||||
benchChecker{"msgpack", fnMsgpackEncodeFn, fnMsgpackDecodeFn},
|
||||
benchChecker{"binc-nosym", fnBincNoSymEncodeFn, fnBincNoSymDecodeFn},
|
||||
benchChecker{"binc-sym", fnBincSymEncodeFn, fnBincSymDecodeFn},
|
||||
benchChecker{"simple", fnSimpleEncodeFn, fnSimpleDecodeFn},
|
||||
benchChecker{"gob", fnGobEncodeFn, fnGobDecodeFn},
|
||||
benchChecker{"json", fnJsonEncodeFn, fnJsonDecodeFn},
|
||||
)
|
||||
if benchDoInitBench {
|
||||
runBenchInit()
|
||||
}
|
||||
}
|
||||
|
||||
func runBenchInit() {
|
||||
logT(nil, "..............................................")
|
||||
logT(nil, "BENCHMARK INIT: %v", time.Now())
|
||||
logT(nil, "To run full benchmark comparing encodings (MsgPack, Binc, Simple, JSON, GOB, etc), "+
|
||||
"use: \"go test -bench=.\"")
|
||||
logT(nil, "Benchmark: ")
|
||||
logT(nil, "\tStruct recursive Depth: %d", benchDepth)
|
||||
if approxSize > 0 {
|
||||
logT(nil, "\tApproxDeepSize Of benchmark Struct: %d bytes", approxSize)
|
||||
}
|
||||
if benchUnscientificRes {
|
||||
logT(nil, "Benchmark One-Pass Run (with Unscientific Encode/Decode times): ")
|
||||
} else {
|
||||
logT(nil, "Benchmark One-Pass Run:")
|
||||
}
|
||||
for _, bc := range benchCheckers {
|
||||
doBenchCheck(bc.name, bc.encodefn, bc.decodefn)
|
||||
}
|
||||
logT(nil, "..............................................")
|
||||
if benchInitDebug {
|
||||
logT(nil, "<<<<====>>>> depth: %v, ts: %#v\n", benchDepth, benchTs)
|
||||
}
|
||||
}
|
||||
|
||||
func fnBenchNewTs() interface{} {
|
||||
return new(TestStruc)
|
||||
}
|
||||
|
||||
func doBenchCheck(name string, encfn benchEncFn, decfn benchDecFn) {
|
||||
runtime.GC()
|
||||
tnow := time.Now()
|
||||
buf, err := encfn(benchTs)
|
||||
if err != nil {
|
||||
logT(nil, "\t%10s: **** Error encoding benchTs: %v", name, err)
|
||||
}
|
||||
encDur := time.Now().Sub(tnow)
|
||||
encLen := len(buf)
|
||||
runtime.GC()
|
||||
if !benchUnscientificRes {
|
||||
logT(nil, "\t%10s: len: %d bytes\n", name, encLen)
|
||||
return
|
||||
}
|
||||
tnow = time.Now()
|
||||
if err = decfn(buf, new(TestStruc)); err != nil {
|
||||
logT(nil, "\t%10s: **** Error decoding into new TestStruc: %v", name, err)
|
||||
}
|
||||
decDur := time.Now().Sub(tnow)
|
||||
logT(nil, "\t%10s: len: %d bytes, encode: %v, decode: %v\n", name, encLen, encDur, decDur)
|
||||
}
|
||||
|
||||
func fnBenchmarkEncode(b *testing.B, encName string, ts interface{}, encfn benchEncFn) {
|
||||
runtime.GC()
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
_, err := encfn(ts)
|
||||
if err != nil {
|
||||
logT(b, "Error encoding benchTs: %s: %v", encName, err)
|
||||
b.FailNow()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func fnBenchmarkDecode(b *testing.B, encName string, ts interface{},
|
||||
encfn benchEncFn, decfn benchDecFn, newfn benchIntfFn,
|
||||
) {
|
||||
buf, err := encfn(ts)
|
||||
if err != nil {
|
||||
logT(b, "Error encoding benchTs: %s: %v", encName, err)
|
||||
b.FailNow()
|
||||
}
|
||||
runtime.GC()
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
ts = newfn()
|
||||
if err = decfn(buf, ts); err != nil {
|
||||
logT(b, "Error decoding into new TestStruc: %s: %v", encName, err)
|
||||
b.FailNow()
|
||||
}
|
||||
if benchVerify {
|
||||
if vts, vok := ts.(*TestStruc); vok {
|
||||
verifyTsTree(b, vts)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func verifyTsTree(b *testing.B, ts *TestStruc) {
|
||||
var ts0, ts1m, ts2m, ts1s, ts2s *TestStruc
|
||||
ts0 = ts
|
||||
|
||||
if benchDepth > 0 {
|
||||
ts1m, ts1s = verifyCheckAndGet(b, ts0)
|
||||
}
|
||||
|
||||
if benchDepth > 1 {
|
||||
ts2m, ts2s = verifyCheckAndGet(b, ts1m)
|
||||
}
|
||||
for _, tsx := range []*TestStruc{ts0, ts1m, ts2m, ts1s, ts2s} {
|
||||
if tsx != nil {
|
||||
verifyOneOne(b, tsx)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func verifyCheckAndGet(b *testing.B, ts0 *TestStruc) (ts1m *TestStruc, ts1s *TestStruc) {
|
||||
// if len(ts1m.Ms) <= 2 {
|
||||
// logT(b, "Error: ts1m.Ms len should be > 2. Got: %v", len(ts1m.Ms))
|
||||
// b.FailNow()
|
||||
// }
|
||||
if len(ts0.Its) == 0 {
|
||||
logT(b, "Error: ts0.Islice len should be > 0. Got: %v", len(ts0.Its))
|
||||
b.FailNow()
|
||||
}
|
||||
ts1m = ts0.Mtsptr["0"]
|
||||
ts1s = ts0.Its[0]
|
||||
if ts1m == nil || ts1s == nil {
|
||||
logT(b, "Error: At benchDepth 1, No *TestStruc found")
|
||||
b.FailNow()
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func verifyOneOne(b *testing.B, ts *TestStruc) {
|
||||
if ts.I64slice[2] != int64(3) {
|
||||
logT(b, "Error: Decode failed by checking values")
|
||||
b.FailNow()
|
||||
}
|
||||
}
|
||||
|
||||
func fnMsgpackEncodeFn(ts interface{}) (bs []byte, err error) {
|
||||
err = NewEncoderBytes(&bs, testMsgpackH).Encode(ts)
|
||||
return
|
||||
}
|
||||
|
||||
func fnMsgpackDecodeFn(buf []byte, ts interface{}) error {
|
||||
return NewDecoderBytes(buf, testMsgpackH).Decode(ts)
|
||||
}
|
||||
|
||||
func fnBincEncodeFn(ts interface{}, sym AsSymbolFlag) (bs []byte, err error) {
|
||||
tSym := testBincH.AsSymbols
|
||||
testBincH.AsSymbols = sym
|
||||
err = NewEncoderBytes(&bs, testBincH).Encode(ts)
|
||||
testBincH.AsSymbols = tSym
|
||||
return
|
||||
}
|
||||
|
||||
func fnBincDecodeFn(buf []byte, ts interface{}, sym AsSymbolFlag) (err error) {
|
||||
tSym := testBincH.AsSymbols
|
||||
testBincH.AsSymbols = sym
|
||||
err = NewDecoderBytes(buf, testBincH).Decode(ts)
|
||||
testBincH.AsSymbols = tSym
|
||||
return
|
||||
}
|
||||
|
||||
func fnBincNoSymEncodeFn(ts interface{}) (bs []byte, err error) {
|
||||
return fnBincEncodeFn(ts, AsSymbolNone)
|
||||
}
|
||||
|
||||
func fnBincNoSymDecodeFn(buf []byte, ts interface{}) error {
|
||||
return fnBincDecodeFn(buf, ts, AsSymbolNone)
|
||||
}
|
||||
|
||||
func fnBincSymEncodeFn(ts interface{}) (bs []byte, err error) {
|
||||
return fnBincEncodeFn(ts, AsSymbolAll)
|
||||
}
|
||||
|
||||
func fnBincSymDecodeFn(buf []byte, ts interface{}) error {
|
||||
return fnBincDecodeFn(buf, ts, AsSymbolAll)
|
||||
}
|
||||
|
||||
func fnSimpleEncodeFn(ts interface{}) (bs []byte, err error) {
|
||||
err = NewEncoderBytes(&bs, testSimpleH).Encode(ts)
|
||||
return
|
||||
}
|
||||
|
||||
func fnSimpleDecodeFn(buf []byte, ts interface{}) error {
|
||||
return NewDecoderBytes(buf, testSimpleH).Decode(ts)
|
||||
}
|
||||
|
||||
func fnGobEncodeFn(ts interface{}) ([]byte, error) {
|
||||
bbuf := new(bytes.Buffer)
|
||||
err := gob.NewEncoder(bbuf).Encode(ts)
|
||||
return bbuf.Bytes(), err
|
||||
}
|
||||
|
||||
func fnGobDecodeFn(buf []byte, ts interface{}) error {
|
||||
return gob.NewDecoder(bytes.NewBuffer(buf)).Decode(ts)
|
||||
}
|
||||
|
||||
func fnJsonEncodeFn(ts interface{}) ([]byte, error) {
|
||||
return json.Marshal(ts)
|
||||
}
|
||||
|
||||
func fnJsonDecodeFn(buf []byte, ts interface{}) error {
|
||||
return json.Unmarshal(buf, ts)
|
||||
}
|
||||
|
||||
func Benchmark__Msgpack____Encode(b *testing.B) {
|
||||
fnBenchmarkEncode(b, "msgpack", benchTs, fnMsgpackEncodeFn)
|
||||
}
|
||||
|
||||
func Benchmark__Msgpack____Decode(b *testing.B) {
|
||||
fnBenchmarkDecode(b, "msgpack", benchTs, fnMsgpackEncodeFn, fnMsgpackDecodeFn, fnBenchNewTs)
|
||||
}
|
||||
|
||||
func Benchmark__Binc_NoSym_Encode(b *testing.B) {
|
||||
fnBenchmarkEncode(b, "binc", benchTs, fnBincNoSymEncodeFn)
|
||||
}
|
||||
|
||||
func Benchmark__Binc_NoSym_Decode(b *testing.B) {
|
||||
fnBenchmarkDecode(b, "binc", benchTs, fnBincNoSymEncodeFn, fnBincNoSymDecodeFn, fnBenchNewTs)
|
||||
}
|
||||
|
||||
func Benchmark__Binc_Sym___Encode(b *testing.B) {
|
||||
fnBenchmarkEncode(b, "binc", benchTs, fnBincSymEncodeFn)
|
||||
}
|
||||
|
||||
func Benchmark__Binc_Sym___Decode(b *testing.B) {
|
||||
fnBenchmarkDecode(b, "binc", benchTs, fnBincSymEncodeFn, fnBincSymDecodeFn, fnBenchNewTs)
|
||||
}
|
||||
|
||||
func Benchmark__Simple____Encode(b *testing.B) {
|
||||
fnBenchmarkEncode(b, "simple", benchTs, fnSimpleEncodeFn)
|
||||
}
|
||||
|
||||
func Benchmark__Simple____Decode(b *testing.B) {
|
||||
fnBenchmarkDecode(b, "simple", benchTs, fnSimpleEncodeFn, fnSimpleDecodeFn, fnBenchNewTs)
|
||||
}
|
||||
|
||||
func Benchmark__Gob________Encode(b *testing.B) {
|
||||
fnBenchmarkEncode(b, "gob", benchTs, fnGobEncodeFn)
|
||||
}
|
||||
|
||||
func Benchmark__Gob________Decode(b *testing.B) {
|
||||
fnBenchmarkDecode(b, "gob", benchTs, fnGobEncodeFn, fnGobDecodeFn, fnBenchNewTs)
|
||||
}
|
||||
|
||||
func Benchmark__Json_______Encode(b *testing.B) {
|
||||
fnBenchmarkEncode(b, "json", benchTs, fnJsonEncodeFn)
|
||||
}
|
||||
|
||||
func Benchmark__Json_______Decode(b *testing.B) {
|
||||
fnBenchmarkDecode(b, "json", benchTs, fnJsonEncodeFn, fnJsonDecodeFn, fnBenchNewTs)
|
||||
}
|
||||
1002
vendor/github.com/hashicorp/go-msgpack/codec/codecs_test.go
сгенерированный
поставляемый
1002
vendor/github.com/hashicorp/go-msgpack/codec/codecs_test.go
сгенерированный
поставляемый
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
75
vendor/github.com/hashicorp/go-msgpack/codec/ext_dep_test.go
сгенерированный
поставляемый
75
vendor/github.com/hashicorp/go-msgpack/codec/ext_dep_test.go
сгенерированный
поставляемый
@@ -1,75 +0,0 @@
|
||||
// //+build ignore
|
||||
|
||||
// Copyright (c) 2012, 2013 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style license found in the LICENSE file.
|
||||
|
||||
package codec
|
||||
|
||||
// This file includes benchmarks which have dependencies on 3rdparty
|
||||
// packages (bson and vmihailenco/msgpack) which must be installed locally.
|
||||
//
|
||||
// To run the benchmarks including these 3rdparty packages, first
|
||||
// - Uncomment first line in this file (put // // in front of it)
|
||||
// - Get those packages:
|
||||
// go get github.com/vmihailenco/msgpack
|
||||
// go get labix.org/v2/mgo/bson
|
||||
// - Run:
|
||||
// go test -bi -bench=.
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
vmsgpack "gopkg.in/vmihailenco/msgpack.v2"
|
||||
"labix.org/v2/mgo/bson"
|
||||
)
|
||||
|
||||
func init() {
|
||||
benchCheckers = append(benchCheckers,
|
||||
benchChecker{"v-msgpack", fnVMsgpackEncodeFn, fnVMsgpackDecodeFn},
|
||||
benchChecker{"bson", fnBsonEncodeFn, fnBsonDecodeFn},
|
||||
)
|
||||
}
|
||||
|
||||
func fnVMsgpackEncodeFn(ts interface{}) ([]byte, error) {
|
||||
return vmsgpack.Marshal(ts)
|
||||
}
|
||||
|
||||
func fnVMsgpackDecodeFn(buf []byte, ts interface{}) error {
|
||||
return vmsgpack.Unmarshal(buf, ts)
|
||||
}
|
||||
|
||||
func fnBsonEncodeFn(ts interface{}) ([]byte, error) {
|
||||
return bson.Marshal(ts)
|
||||
}
|
||||
|
||||
func fnBsonDecodeFn(buf []byte, ts interface{}) error {
|
||||
return bson.Unmarshal(buf, ts)
|
||||
}
|
||||
|
||||
func Benchmark__Bson_______Encode(b *testing.B) {
|
||||
fnBenchmarkEncode(b, "bson", benchTs, fnBsonEncodeFn)
|
||||
}
|
||||
|
||||
func Benchmark__Bson_______Decode(b *testing.B) {
|
||||
fnBenchmarkDecode(b, "bson", benchTs, fnBsonEncodeFn, fnBsonDecodeFn, fnBenchNewTs)
|
||||
}
|
||||
|
||||
func Benchmark__VMsgpack___Encode(b *testing.B) {
|
||||
fnBenchmarkEncode(b, "v-msgpack", benchTs, fnVMsgpackEncodeFn)
|
||||
}
|
||||
|
||||
func Benchmark__VMsgpack___Decode(b *testing.B) {
|
||||
fnBenchmarkDecode(b, "v-msgpack", benchTs, fnVMsgpackEncodeFn, fnVMsgpackDecodeFn, fnBenchNewTs)
|
||||
}
|
||||
|
||||
func TestMsgpackPythonGenStreams(t *testing.T) {
|
||||
doTestMsgpackPythonGenStreams(t)
|
||||
}
|
||||
|
||||
func TestMsgpackRpcSpecGoClientToPythonSvc(t *testing.T) {
|
||||
doTestMsgpackRpcSpecGoClientToPythonSvc(t)
|
||||
}
|
||||
|
||||
func TestMsgpackRpcSpecPythonClientToGoSvc(t *testing.T) {
|
||||
doTestMsgpackRpcSpecPythonClientToGoSvc(t)
|
||||
}
|
||||
103
vendor/github.com/hashicorp/go-msgpack/codec/z_helper_test.go
сгенерированный
поставляемый
103
vendor/github.com/hashicorp/go-msgpack/codec/z_helper_test.go
сгенерированный
поставляемый
@@ -1,103 +0,0 @@
|
||||
// Copyright (c) 2012, 2013 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style license found in the LICENSE file.
|
||||
|
||||
package codec
|
||||
|
||||
// All non-std package dependencies related to testing live in this file,
|
||||
// so porting to different environment is easy (just update functions).
|
||||
//
|
||||
// Also, this file is called z_helper_test, to give a "hint" to compiler
|
||||
// that its init() function should be called last. (not guaranteed by spec)
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"reflect"
|
||||
"flag"
|
||||
"testing"
|
||||
)
|
||||
|
||||
var (
|
||||
testLogToT = true
|
||||
failNowOnFail = true
|
||||
)
|
||||
|
||||
func init() {
|
||||
testInitFlags()
|
||||
benchInitFlags()
|
||||
flag.Parse()
|
||||
testInit()
|
||||
benchInit()
|
||||
}
|
||||
|
||||
func checkErrT(t *testing.T, err error) {
|
||||
if err != nil {
|
||||
logT(t, err.Error())
|
||||
failT(t)
|
||||
}
|
||||
}
|
||||
|
||||
func checkEqualT(t *testing.T, v1 interface{}, v2 interface{}, desc string) (err error) {
|
||||
if err = deepEqual(v1, v2); err != nil {
|
||||
logT(t, "Not Equal: %s: %v. v1: %v, v2: %v", desc, err, v1, v2)
|
||||
failT(t)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func logT(x interface{}, format string, args ...interface{}) {
|
||||
if t, ok := x.(*testing.T); ok && t != nil && testLogToT {
|
||||
t.Logf(format, args...)
|
||||
} else if b, ok := x.(*testing.B); ok && b != nil && testLogToT {
|
||||
b.Logf(format, args...)
|
||||
} else {
|
||||
debugf(format, args...)
|
||||
}
|
||||
}
|
||||
|
||||
func failT(t *testing.T) {
|
||||
if failNowOnFail {
|
||||
t.FailNow()
|
||||
} else {
|
||||
t.Fail()
|
||||
}
|
||||
}
|
||||
|
||||
func deepEqual(v1, v2 interface{}) (err error) {
|
||||
if !reflect.DeepEqual(v1, v2) {
|
||||
err = errors.New("Not Match")
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func approxDataSize(rv reflect.Value) (sum int) {
|
||||
switch rk := rv.Kind(); rk {
|
||||
case reflect.Invalid:
|
||||
case reflect.Ptr, reflect.Interface:
|
||||
sum += int(rv.Type().Size())
|
||||
sum += approxDataSize(rv.Elem())
|
||||
case reflect.Slice:
|
||||
sum += int(rv.Type().Size())
|
||||
for j := 0; j < rv.Len(); j++ {
|
||||
sum += approxDataSize(rv.Index(j))
|
||||
}
|
||||
case reflect.String:
|
||||
sum += int(rv.Type().Size())
|
||||
sum += rv.Len()
|
||||
case reflect.Map:
|
||||
sum += int(rv.Type().Size())
|
||||
for _, mk := range rv.MapKeys() {
|
||||
sum += approxDataSize(mk)
|
||||
sum += approxDataSize(rv.MapIndex(mk))
|
||||
}
|
||||
case reflect.Struct:
|
||||
//struct size already includes the full data size.
|
||||
//sum += int(rv.Type().Size())
|
||||
for j := 0; j < rv.NumField(); j++ {
|
||||
sum += approxDataSize(rv.Field(j))
|
||||
}
|
||||
default:
|
||||
//pure value types
|
||||
sum += int(rv.Type().Size())
|
||||
}
|
||||
return
|
||||
}
|
||||
47
vendor/github.com/hashicorp/go-msgpack/msgpack.org.md
сгенерированный
поставляемый
47
vendor/github.com/hashicorp/go-msgpack/msgpack.org.md
сгенерированный
поставляемый
@@ -1,47 +0,0 @@
|
||||
**MessagePack and [Binc](http://github.com/ugorji/binc) Codec for [Go](http://golang.org) Language.**
|
||||
|
||||
*A High Performance, Feature-Rich, Idiomatic encode/decode and rpc library*.
|
||||
|
||||
To install:
|
||||
|
||||
go get github.com/ugorji/go/codec
|
||||
|
||||
Source: [http://github.com/ugorji/go]
|
||||
Online documentation: [http://godoc.org/github.com/ugorji/go/codec]
|
||||
|
||||
Typical usage:
|
||||
|
||||
```go
|
||||
// create and use decoder/encoder
|
||||
var (
|
||||
v interface{} // value to decode/encode into
|
||||
r io.Reader
|
||||
w io.Writer
|
||||
b []byte
|
||||
mh codec.MsgpackHandle
|
||||
)
|
||||
|
||||
dec = codec.NewDecoder(r, &mh)
|
||||
dec = codec.NewDecoderBytes(b, &mh)
|
||||
err = dec.Decode(&v)
|
||||
|
||||
enc = codec.NewEncoder(w, &mh)
|
||||
enc = codec.NewEncoderBytes(&b, &mh)
|
||||
err = enc.Encode(v)
|
||||
|
||||
//RPC Server
|
||||
go func() {
|
||||
for {
|
||||
conn, err := listener.Accept()
|
||||
rpcCodec := codec.GoRpc.ServerCodec(conn, h)
|
||||
//OR rpcCodec := codec.MsgpackSpecRpc.ServerCodec(conn, h)
|
||||
rpc.ServeCodec(rpcCodec)
|
||||
}
|
||||
}()
|
||||
|
||||
//RPC Communication (client side)
|
||||
conn, err = net.Dial("tcp", "localhost:5555")
|
||||
rpcCodec := codec.GoRpc.ClientCodec(conn, h)
|
||||
//OR rpcCodec := codec.MsgpackSpecRpc.ClientCodec(conn, h)
|
||||
client := rpc.NewClientWithCodec(rpcCodec)
|
||||
```
|
||||
Ссылка в новой задаче
Block a user