certusone
/
tendermint
mirror of https://github.com/certusone/tendermint.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Responses/Requests -> Value

This commit is contained in:
Ethan Buchman 2016-05-17 20:06:24 -04:00
parent 32f83f9494
commit 5dc7bee57b
8 changed files with 253 additions and 245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
client/remote_client.go
View File

@ -79,7 +79,7 @@ func (cli *remoteClient) OnStart() (err error) {
continue RETRY_LOOP continue RETRY_LOOP
} }
} }
go cli.sendRequestsRoutine(conn) go cli.sendValueRoutine(conn)
go cli.recvResponseRoutine(conn) go cli.recvResponseRoutine(conn)
close(doneCh) // OnStart() will return no error. close(doneCh) // OnStart() will return no error.
return return
@ -122,7 +122,7 @@ func (cli *remoteClient) Error() error {
//---------------------------------------- //----------------------------------------
func (cli *remoteClient) sendRequestsRoutine(conn net.Conn) { func (cli *remoteClient) sendValueRoutine(conn net.Conn) {
w := bufio.NewWriter(conn) w := bufio.NewWriter(conn)
for { for {
select { select {
@ -142,7 +142,7 @@ func (cli *remoteClient) sendRequestsRoutine(conn net.Conn) {
return return
} }
// log.Debug("Sent request", "requestType", reflect.TypeOf(reqres.Request), "request", reqres.Request) // log.Debug("Sent request", "requestType", reflect.TypeOf(reqres.Request), "request", reqres.Request)
if _, ok := reqres.Request.Requests.(*types.Request_Flush); ok { if _, ok := reqres.Request.Value.(*types.Request_Flush); ok {
err = w.Flush() err = w.Flush()
if err != nil { if err != nil {
cli.StopForError(err) cli.StopForError(err)
@ -162,7 +162,7 @@ func (cli *remoteClient) recvResponseRoutine(conn net.Conn) {
cli.StopForError(err) cli.StopForError(err)
return return
} }
switch r := res.Responses.(type) { switch r := res.Value.(type) {
case *types.Response_Exception: case *types.Response_Exception:
// XXX After setting cli.err, release waiters (e.g. reqres.Done()) // XXX After setting cli.err, release waiters (e.g. reqres.Done())
cli.StopForError(errors.New(r.Exception.Error)) cli.StopForError(errors.New(r.Exception.Error))
@ -189,12 +189,12 @@ func (cli *remoteClient) didRecvResponse(res *types.Response) error {
// Get the first ReqRes // Get the first ReqRes
next := cli.reqSent.Front() next := cli.reqSent.Front()
if next == nil { if next == nil {
return fmt.Errorf("Unexpected result type %v when nothing expected", reflect.TypeOf(res.Responses)) return fmt.Errorf("Unexpected result type %v when nothing expected", reflect.TypeOf(res.Value))
} }
reqres := next.Value.(*ReqRes) reqres := next.Value.(*ReqRes)
if !resMatchesReq(reqres.Request, res) { if !resMatchesReq(reqres.Request, res) {
return fmt.Errorf("Unexpected result type %v when response to %v expected", return fmt.Errorf("Unexpected result type %v when response to %v expected",
reflect.TypeOf(res.Responses), reflect.TypeOf(reqres.Request.Requests)) reflect.TypeOf(res.Value), reflect.TypeOf(reqres.Request.Value))
} }
reqres.Response = res // Set response reqres.Response = res // Set response
@ -372,7 +372,7 @@ func (cli *remoteClient) queueRequest(req *types.Request) *ReqRes {
cli.reqQueue <- reqres cli.reqQueue <- reqres
// Maybe auto-flush, or unset auto-flush // Maybe auto-flush, or unset auto-flush
switch req.Requests.(type) { switch req.Value.(type) {
case *types.Request_Flush: case *types.Request_Flush:
cli.flushTimer.Unset() cli.flushTimer.Unset()
default: default:
@ -385,27 +385,27 @@ func (cli *remoteClient) queueRequest(req *types.Request) *ReqRes {
//---------------------------------------- //----------------------------------------
func resMatchesReq(req *types.Request, res *types.Response) (ok bool) { func resMatchesReq(req *types.Request, res *types.Response) (ok bool) {
switch req.Requests.(type) { switch req.Value.(type) {
case *types.Request_Echo: case *types.Request_Echo:
_, ok = res.Responses.(*types.Response_Echo) _, ok = res.Value.(*types.Response_Echo)
case *types.Request_Flush: case *types.Request_Flush:
_, ok = res.Responses.(*types.Response_Flush) _, ok = res.Value.(*types.Response_Flush)
case *types.Request_Info: case *types.Request_Info:
_, ok = res.Responses.(*types.Response_Info) _, ok = res.Value.(*types.Response_Info)
case *types.Request_SetOption: case *types.Request_SetOption:
_, ok = res.Responses.(*types.Response_SetOption) _, ok = res.Value.(*types.Response_SetOption)
case *types.Request_AppendTx: case *types.Request_AppendTx:
_, ok = res.Responses.(*types.Response_AppendTx) _, ok = res.Value.(*types.Response_AppendTx)
case *types.Request_CheckTx: case *types.Request_CheckTx:
_, ok = res.Responses.(*types.Response_CheckTx) _, ok = res.Value.(*types.Response_CheckTx)
case *types.Request_Commit: case *types.Request_Commit:
_, ok = res.Responses.(*types.Response_Commit) _, ok = res.Value.(*types.Response_Commit)
case *types.Request_Query: case *types.Request_Query:
_, ok = res.Responses.(*types.Response_Query) _, ok = res.Value.(*types.Response_Query)
case *types.Request_InitChain: case *types.Request_InitChain:
_, ok = res.Responses.(*types.Response_InitChain) _, ok = res.Value.(*types.Response_InitChain)
case *types.Request_EndBlock: case *types.Request_EndBlock:
_, ok = res.Responses.(*types.Response_EndBlock) _, ok = res.Value.(*types.Response_EndBlock)
} }
return ok return ok
} }

4
example/dummy/dummy_test.go
View File

@ -40,7 +40,7 @@ func TestStream(t *testing.T) {
} }
// Process response // Process response
switch r := res.Responses.(type) { switch r := res.Value.(type) {
case *types.Response_AppendTx: case *types.Response_AppendTx:
counter += 1 counter += 1
if r.AppendTx.Code != types.CodeType_OK { if r.AppendTx.Code != types.CodeType_OK {
@ -59,7 +59,7 @@ func TestStream(t *testing.T) {
case *types.Response_Flush: case *types.Response_Flush:
// ignore // ignore
default: default:
t.Error("Unexpected response type", reflect.TypeOf(res.Responses)) t.Error("Unexpected response type", reflect.TypeOf(res.Value))
} }
} }
}() }()

4
example/nil/nil_test.go
View File

@ -40,7 +40,7 @@ func TestStream(t *testing.T) {
} }
// Process response // Process response
switch r := res.Responses.(type) { switch r := res.Value.(type) {
case *types.Response_AppendTx: case *types.Response_AppendTx:
counter += 1 counter += 1
if r.AppendTx.Code != types.CodeType_OK { if r.AppendTx.Code != types.CodeType_OK {
@ -59,7 +59,7 @@ func TestStream(t *testing.T) {
case *types.Response_Flush: case *types.Response_Flush:
// ignore // ignore
default: default:
t.Error("Unexpected response type", reflect.TypeOf(res.Responses)) t.Error("Unexpected response type", reflect.TypeOf(res.Value))
} }
} }
}() }()

10
server/server.go
View File

@ -113,7 +113,7 @@ func (s *Server) handleRequests(closeConn chan error, conn net.Conn, responses c
if err == io.EOF { if err == io.EOF {
closeConn <- fmt.Errorf("Connection closed by client") closeConn <- fmt.Errorf("Connection closed by client")
} else { } else {
closeConn <- fmt.Errorf("Error in handleRequests: %v", err.Error()) closeConn <- fmt.Errorf("Error in handleValue: %v", err.Error())
} }
return return
} }
@ -125,7 +125,7 @@ func (s *Server) handleRequests(closeConn chan error, conn net.Conn, responses c
} }
func (s *Server) handleRequest(req *types.Request, responses chan<- *types.Response) { func (s *Server) handleRequest(req *types.Request, responses chan<- *types.Response) {
switch r := req.Requests.(type) { switch r := req.Value.(type) {
case *types.Request_Echo: case *types.Request_Echo:
responses <- types.ToResponseEcho(r.Echo.Message) responses <- types.ToResponseEcho(r.Echo.Message)
case *types.Request_Flush: case *types.Request_Flush:
@ -176,13 +176,13 @@ func (s *Server) handleResponses(closeConn chan error, responses <-chan *types.R
var res = <-responses var res = <-responses
err := types.WriteMessage(res, bufWriter) err := types.WriteMessage(res, bufWriter)
if err != nil { if err != nil {
closeConn <- fmt.Errorf("Error in handleResponses: %v", err.Error()) closeConn <- fmt.Errorf("Error in handleValue: %v", err.Error())
return return
} }
if _, ok := res.Responses.(*types.Response_Flush); ok { if _, ok := res.Value.(*types.Response_Flush); ok {
err = bufWriter.Flush() err = bufWriter.Flush()
if err != nil { if err != nil {
closeConn <- fmt.Errorf("Error in handleResponses: %v", err.Error()) closeConn <- fmt.Errorf("Error in handleValue: %v", err.Error())
return return
} }
} }

2
tests/benchmarks/simple/simple.go
View File

@ -62,7 +62,7 @@ func makeRequest(conn net.Conn, req *types.Request) (*types.Response, error) {
if err != nil { if err != nil {
return nil, err return nil, err
} }
if _, ok := resFlush.Responses.(*types.Response_Flush); !ok { if _, ok := resFlush.Value.(*types.Response_Flush); !ok {
return nil, errors.New(Fmt("Expected flush response but got something else: %v", reflect.TypeOf(resFlush))) return nil, errors.New(Fmt("Expected flush response but got something else: %v", reflect.TypeOf(resFlush)))
} }

46
types/messages.go
View File

@ -9,67 +9,67 @@ import (
func ToRequestEcho(message string) *Request { func ToRequestEcho(message string) *Request {
return &Request{ return &Request{
Requests: &Request_Echo{&RequestEcho{message}}, Value: &Request_Echo{&RequestEcho{message}},
} }
} }
func ToRequestFlush() *Request { func ToRequestFlush() *Request {
return &Request{ return &Request{
Requests: &Request_Flush{&RequestFlush{}}, Value: &Request_Flush{&RequestFlush{}},
} }
} }
func ToRequestInfo() *Request { func ToRequestInfo() *Request {
return &Request{ return &Request{
Requests: &Request_Info{&RequestInfo{}}, Value: &Request_Info{&RequestInfo{}},
} }
} }
func ToRequestSetOption(key string, value string) *Request { func ToRequestSetOption(key string, value string) *Request {
return &Request{ return &Request{
Requests: &Request_SetOption{&RequestSetOption{key, value}}, Value: &Request_SetOption{&RequestSetOption{key, value}},
} }
} }
func ToRequestAppendTx(txBytes []byte) *Request { func ToRequestAppendTx(txBytes []byte) *Request {
return &Request{ return &Request{
Requests: &Request_AppendTx{&RequestAppendTx{txBytes}}, Value: &Request_AppendTx{&RequestAppendTx{txBytes}},
} }
} }
func ToRequestCheckTx(txBytes []byte) *Request { func ToRequestCheckTx(txBytes []byte) *Request {
return &Request{ return &Request{
Requests: &Request_CheckTx{&RequestCheckTx{txBytes}}, Value: &Request_CheckTx{&RequestCheckTx{txBytes}},
} }
} }
func ToRequestCommit() *Request { func ToRequestCommit() *Request {
return &Request{ return &Request{
Requests: &Request_Commit{&RequestCommit{}}, Value: &Request_Commit{&RequestCommit{}},
} }
} }
func ToRequestQuery(queryBytes []byte) *Request { func ToRequestQuery(queryBytes []byte) *Request {
return &Request{ return &Request{
Requests: &Request_Query{&RequestQuery{queryBytes}}, Value: &Request_Query{&RequestQuery{queryBytes}},
} }
} }
func ToRequestInitChain(validators []*Validator) *Request { func ToRequestInitChain(validators []*Validator) *Request {
return &Request{ return &Request{
Requests: &Request_InitChain{&RequestInitChain{validators}}, Value: &Request_InitChain{&RequestInitChain{validators}},
} }
} }
func ToRequestBeginBlock(height uint64) *Request { func ToRequestBeginBlock(height uint64) *Request {
return &Request{ return &Request{
Requests: &Request_BeginBlock{&RequestBeginBlock{height}}, Value: &Request_BeginBlock{&RequestBeginBlock{height}},
} }
} }
func ToRequestEndBlock(height uint64) *Request { func ToRequestEndBlock(height uint64) *Request {
return &Request{ return &Request{
Requests: &Request_EndBlock{&RequestEndBlock{height}}, Value: &Request_EndBlock{&RequestEndBlock{height}},
} }
} }
@ -77,73 +77,73 @@ func ToRequestEndBlock(height uint64) *Request {
func ToResponseException(errStr string) *Response { func ToResponseException(errStr string) *Response {
return &Response{ return &Response{
Responses: &Response_Exception{&ResponseException{errStr}}, Value: &Response_Exception{&ResponseException{errStr}},
} }
} }
func ToResponseEcho(message string) *Response { func ToResponseEcho(message string) *Response {
return &Response{ return &Response{
Responses: &Response_Echo{&ResponseEcho{message}}, Value: &Response_Echo{&ResponseEcho{message}},
} }
} }
func ToResponseFlush() *Response { func ToResponseFlush() *Response {
return &Response{ return &Response{
Responses: &Response_Flush{&ResponseFlush{}}, Value: &Response_Flush{&ResponseFlush{}},
} }
} }
func ToResponseInfo(info string) *Response { func ToResponseInfo(info string) *Response {
return &Response{ return &Response{
Responses: &Response_Info{&ResponseInfo{info}}, Value: &Response_Info{&ResponseInfo{info}},
} }
} }
func ToResponseSetOption(log string) *Response { func ToResponseSetOption(log string) *Response {
return &Response{ return &Response{
Responses: &Response_SetOption{&ResponseSetOption{log}}, Value: &Response_SetOption{&ResponseSetOption{log}},
} }
} }
func ToResponseAppendTx(code CodeType, data []byte, log string) *Response { func ToResponseAppendTx(code CodeType, data []byte, log string) *Response {
return &Response{ return &Response{
Responses: &Response_AppendTx{&ResponseAppendTx{code, data, log}}, Value: &Response_AppendTx{&ResponseAppendTx{code, data, log}},
} }
} }
func ToResponseCheckTx(code CodeType, data []byte, log string) *Response { func ToResponseCheckTx(code CodeType, data []byte, log string) *Response {
return &Response{ return &Response{
Responses: &Response_CheckTx{&ResponseCheckTx{code, data, log}}, Value: &Response_CheckTx{&ResponseCheckTx{code, data, log}},
} }
} }
func ToResponseCommit(code CodeType, data []byte, log string) *Response { func ToResponseCommit(code CodeType, data []byte, log string) *Response {
return &Response{ return &Response{
Responses: &Response_Commit{&ResponseCommit{code, data, log}}, Value: &Response_Commit{&ResponseCommit{code, data, log}},
} }
} }
func ToResponseQuery(code CodeType, data []byte, log string) *Response { func ToResponseQuery(code CodeType, data []byte, log string) *Response {
return &Response{ return &Response{
Responses: &Response_Query{&ResponseQuery{code, data, log}}, Value: &Response_Query{&ResponseQuery{code, data, log}},
} }
} }
func ToResponseInitChain() *Response { func ToResponseInitChain() *Response {
return &Response{ return &Response{
Responses: &Response_InitChain{&ResponseInitChain{}}, Value: &Response_InitChain{&ResponseInitChain{}},
} }
} }
func ToResponseBeginBlock() *Response { func ToResponseBeginBlock() *Response {
return &Response{ return &Response{
Responses: &Response_BeginBlock{&ResponseBeginBlock{}}, Value: &Response_BeginBlock{&ResponseBeginBlock{}},
} }
} }
func ToResponseEndBlock(validators []*Validator) *Response { func ToResponseEndBlock(validators []*Validator) *Response {
return &Response{ return &Response{
Responses: &Response_EndBlock{&ResponseEndBlock{validators}}, Value: &Response_EndBlock{&ResponseEndBlock{validators}},
} }
} }

388
types/types.pb.go
View File

@ -51,6 +51,10 @@ var _ = math.Inf
// is compatible with the proto package it is being compiled against. // is compatible with the proto package it is being compiled against.
const _ = proto.ProtoPackageIsVersion1 const _ = proto.ProtoPackageIsVersion1
// Not being used
// Could be added to request/response
// so we don't have to type switch
// (would be twice as fast, but we're talking about 15ns)
type MessageType int32 type MessageType int32
const ( const (
@ -214,7 +218,7 @@ func (x CodeType) String() string {
func (CodeType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } func (CodeType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
type Request struct { type Request struct {
// Types that are valid to be assigned to Requests: // Types that are valid to be assigned to Value:
// *Request_Echo // *Request_Echo
// *Request_Flush // *Request_Flush
// *Request_Info // *Request_Info
@ -226,7 +230,7 @@ type Request struct {
// *Request_InitChain // *Request_InitChain
// *Request_BeginBlock // *Request_BeginBlock
// *Request_EndBlock // *Request_EndBlock
Requests isRequest_Requests `protobuf_oneof:"requests"` Value isRequest_Value `protobuf_oneof:"value"`
} }
func (m *Request) Reset() { *m = Request{} } func (m *Request) Reset() { *m = Request{} }
@ -234,8 +238,8 @@ func (m *Request) String() string { return proto.CompactTextString(m)
func (*Request) ProtoMessage() {} func (*Request) ProtoMessage() {}
func (*Request) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } func (*Request) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
type isRequest_Requests interface { type isRequest_Value interface {
isRequest_Requests() isRequest_Value()
} }
type Request_Echo struct { type Request_Echo struct {
@ -272,97 +276,97 @@ type Request_EndBlock struct {
EndBlock *RequestEndBlock `protobuf:"bytes,11,opt,name=end_block,json=endBlock,oneof"` EndBlock *RequestEndBlock `protobuf:"bytes,11,opt,name=end_block,json=endBlock,oneof"`
} }
func (*Request_Echo) isRequest_Requests() {} func (*Request_Echo) isRequest_Value() {}
func (*Request_Flush) isRequest_Requests() {} func (*Request_Flush) isRequest_Value() {}
func (*Request_Info) isRequest_Requests() {} func (*Request_Info) isRequest_Value() {}
func (*Request_SetOption) isRequest_Requests() {} func (*Request_SetOption) isRequest_Value() {}
func (*Request_AppendTx) isRequest_Requests() {} func (*Request_AppendTx) isRequest_Value() {}
func (*Request_CheckTx) isRequest_Requests() {} func (*Request_CheckTx) isRequest_Value() {}
func (*Request_Commit) isRequest_Requests() {} func (*Request_Commit) isRequest_Value() {}
func (*Request_Query) isRequest_Requests() {} func (*Request_Query) isRequest_Value() {}
func (*Request_InitChain) isRequest_Requests() {} func (*Request_InitChain) isRequest_Value() {}
func (*Request_BeginBlock) isRequest_Requests() {} func (*Request_BeginBlock) isRequest_Value() {}
func (*Request_EndBlock) isRequest_Requests() {} func (*Request_EndBlock) isRequest_Value() {}
func (m *Request) GetRequests() isRequest_Requests { func (m *Request) GetValue() isRequest_Value {
if m != nil { if m != nil {
return m.Requests return m.Value
} }
return nil return nil
} }
func (m *Request) GetEcho() *RequestEcho { func (m *Request) GetEcho() *RequestEcho {
if x, ok := m.GetRequests().(*Request_Echo); ok { if x, ok := m.GetValue().(*Request_Echo); ok {
return x.Echo return x.Echo
} }
return nil return nil
} }
func (m *Request) GetFlush() *RequestFlush { func (m *Request) GetFlush() *RequestFlush {
if x, ok := m.GetRequests().(*Request_Flush); ok { if x, ok := m.GetValue().(*Request_Flush); ok {
return x.Flush return x.Flush
} }
return nil return nil
} }
func (m *Request) GetInfo() *RequestInfo { func (m *Request) GetInfo() *RequestInfo {
if x, ok := m.GetRequests().(*Request_Info); ok { if x, ok := m.GetValue().(*Request_Info); ok {
return x.Info return x.Info
} }
return nil return nil
} }
func (m *Request) GetSetOption() *RequestSetOption { func (m *Request) GetSetOption() *RequestSetOption {
if x, ok := m.GetRequests().(*Request_SetOption); ok { if x, ok := m.GetValue().(*Request_SetOption); ok {
return x.SetOption return x.SetOption
} }
return nil return nil
} }
func (m *Request) GetAppendTx() *RequestAppendTx { func (m *Request) GetAppendTx() *RequestAppendTx {
if x, ok := m.GetRequests().(*Request_AppendTx); ok { if x, ok := m.GetValue().(*Request_AppendTx); ok {
return x.AppendTx return x.AppendTx
} }
return nil return nil
} }
func (m *Request) GetCheckTx() *RequestCheckTx { func (m *Request) GetCheckTx() *RequestCheckTx {
if x, ok := m.GetRequests().(*Request_CheckTx); ok { if x, ok := m.GetValue().(*Request_CheckTx); ok {
return x.CheckTx return x.CheckTx
} }
return nil return nil
} }
func (m *Request) GetCommit() *RequestCommit { func (m *Request) GetCommit() *RequestCommit {
if x, ok := m.GetRequests().(*Request_Commit); ok { if x, ok := m.GetValue().(*Request_Commit); ok {
return x.Commit return x.Commit
} }
return nil return nil
} }
func (m *Request) GetQuery() *RequestQuery { func (m *Request) GetQuery() *RequestQuery {
if x, ok := m.GetRequests().(*Request_Query); ok { if x, ok := m.GetValue().(*Request_Query); ok {
return x.Query return x.Query
} }
return nil return nil
} }
func (m *Request) GetInitChain() *RequestInitChain { func (m *Request) GetInitChain() *RequestInitChain {
if x, ok := m.GetRequests().(*Request_InitChain); ok { if x, ok := m.GetValue().(*Request_InitChain); ok {
return x.InitChain return x.InitChain
} }
return nil return nil
} }
func (m *Request) GetBeginBlock() *RequestBeginBlock { func (m *Request) GetBeginBlock() *RequestBeginBlock {
if x, ok := m.GetRequests().(*Request_BeginBlock); ok { if x, ok := m.GetValue().(*Request_BeginBlock); ok {
return x.BeginBlock return x.BeginBlock
} }
return nil return nil
} }
func (m *Request) GetEndBlock() *RequestEndBlock { func (m *Request) GetEndBlock() *RequestEndBlock {
if x, ok := m.GetRequests().(*Request_EndBlock); ok { if x, ok := m.GetValue().(*Request_EndBlock); ok {
return x.EndBlock return x.EndBlock
} }
return nil return nil
@ -387,8 +391,8 @@ func (*Request) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error
func _Request_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { func _Request_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Request) m := msg.(*Request)
// requests // value
switch x := m.Requests.(type) { switch x := m.Value.(type) {
case *Request_Echo: case *Request_Echo:
b.EncodeVarint(1<<3 | proto.WireBytes) b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Echo); err != nil { if err := b.EncodeMessage(x.Echo); err != nil {
@ -446,7 +450,7 @@ func _Request_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
} }
case nil: case nil:
default: default:
return fmt.Errorf("Request.Requests has unexpected type %T", x) return fmt.Errorf("Request.Value has unexpected type %T", x)
} }
return nil return nil
} }
@ -454,93 +458,93 @@ func _Request_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
func _Request_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { func _Request_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Request) m := msg.(*Request)
switch tag { switch tag {
case 1: // requests.echo case 1: // value.echo
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(RequestEcho) msg := new(RequestEcho)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Requests = &Request_Echo{msg} m.Value = &Request_Echo{msg}
return true, err return true, err
case 2: // requests.flush case 2: // value.flush
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(RequestFlush) msg := new(RequestFlush)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Requests = &Request_Flush{msg} m.Value = &Request_Flush{msg}
return true, err return true, err
case 3: // requests.info case 3: // value.info
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(RequestInfo) msg := new(RequestInfo)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Requests = &Request_Info{msg} m.Value = &Request_Info{msg}
return true, err return true, err
case 4: // requests.set_option case 4: // value.set_option
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(RequestSetOption) msg := new(RequestSetOption)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Requests = &Request_SetOption{msg} m.Value = &Request_SetOption{msg}
return true, err return true, err
case 5: // requests.append_tx case 5: // value.append_tx
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(RequestAppendTx) msg := new(RequestAppendTx)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Requests = &Request_AppendTx{msg} m.Value = &Request_AppendTx{msg}
return true, err return true, err
case 6: // requests.check_tx case 6: // value.check_tx
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(RequestCheckTx) msg := new(RequestCheckTx)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Requests = &Request_CheckTx{msg} m.Value = &Request_CheckTx{msg}
return true, err return true, err
case 7: // requests.commit case 7: // value.commit
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(RequestCommit) msg := new(RequestCommit)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Requests = &Request_Commit{msg} m.Value = &Request_Commit{msg}
return true, err return true, err
case 8: // requests.query case 8: // value.query
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(RequestQuery) msg := new(RequestQuery)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Requests = &Request_Query{msg} m.Value = &Request_Query{msg}
return true, err return true, err
case 9: // requests.init_chain case 9: // value.init_chain
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(RequestInitChain) msg := new(RequestInitChain)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Requests = &Request_InitChain{msg} m.Value = &Request_InitChain{msg}
return true, err return true, err
case 10: // requests.begin_block case 10: // value.begin_block
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(RequestBeginBlock) msg := new(RequestBeginBlock)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Requests = &Request_BeginBlock{msg} m.Value = &Request_BeginBlock{msg}
return true, err return true, err
case 11: // requests.end_block case 11: // value.end_block
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(RequestEndBlock) msg := new(RequestEndBlock)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Requests = &Request_EndBlock{msg} m.Value = &Request_EndBlock{msg}
return true, err return true, err
default: default:
return false, nil return false, nil
@ -549,8 +553,8 @@ func _Request_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer
func _Request_OneofSizer(msg proto.Message) (n int) { func _Request_OneofSizer(msg proto.Message) (n int) {
m := msg.(*Request) m := msg.(*Request)
// requests // value
switch x := m.Requests.(type) { switch x := m.Value.(type) {
case *Request_Echo: case *Request_Echo:
s := proto.Size(x.Echo) s := proto.Size(x.Echo)
n += proto.SizeVarint(1<<3 | proto.WireBytes) n += proto.SizeVarint(1<<3 | proto.WireBytes)
@ -718,7 +722,7 @@ func (*RequestEndBlock) ProtoMessage() {}
func (*RequestEndBlock) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } func (*RequestEndBlock) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
type Response struct { type Response struct {
// Types that are valid to be assigned to Responses: // Types that are valid to be assigned to Value:
// *Response_Exception // *Response_Exception
// *Response_Echo // *Response_Echo
// *Response_Flush // *Response_Flush
@ -731,7 +735,7 @@ type Response struct {
// *Response_InitChain // *Response_InitChain
// *Response_BeginBlock // *Response_BeginBlock
// *Response_EndBlock // *Response_EndBlock
Responses isResponse_Responses `protobuf_oneof:"responses"` Value isResponse_Value `protobuf_oneof:"value"`
} }
func (m *Response) Reset() { *m = Response{} } func (m *Response) Reset() { *m = Response{} }
@ -739,8 +743,8 @@ func (m *Response) String() string { return proto.CompactTextString(m
func (*Response) ProtoMessage() {} func (*Response) ProtoMessage() {}
func (*Response) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } func (*Response) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
type isResponse_Responses interface { type isResponse_Value interface {
isResponse_Responses() isResponse_Value()
} }
type Response_Exception struct { type Response_Exception struct {
@ -780,105 +784,105 @@ type Response_EndBlock struct {
EndBlock *ResponseEndBlock `protobuf:"bytes,12,opt,name=end_block,json=endBlock,oneof"` EndBlock *ResponseEndBlock `protobuf:"bytes,12,opt,name=end_block,json=endBlock,oneof"`
} }
func (*Response_Exception) isResponse_Responses() {} func (*Response_Exception) isResponse_Value() {}
func (*Response_Echo) isResponse_Responses() {} func (*Response_Echo) isResponse_Value() {}
func (*Response_Flush) isResponse_Responses() {} func (*Response_Flush) isResponse_Value() {}
func (*Response_Info) isResponse_Responses() {} func (*Response_Info) isResponse_Value() {}
func (*Response_SetOption) isResponse_Responses() {} func (*Response_SetOption) isResponse_Value() {}
func (*Response_AppendTx) isResponse_Responses() {} func (*Response_AppendTx) isResponse_Value() {}
func (*Response_CheckTx) isResponse_Responses() {} func (*Response_CheckTx) isResponse_Value() {}
func (*Response_Commit) isResponse_Responses() {} func (*Response_Commit) isResponse_Value() {}
func (*Response_Query) isResponse_Responses() {} func (*Response_Query) isResponse_Value() {}
func (*Response_InitChain) isResponse_Responses() {} func (*Response_InitChain) isResponse_Value() {}
func (*Response_BeginBlock) isResponse_Responses() {} func (*Response_BeginBlock) isResponse_Value() {}
func (*Response_EndBlock) isResponse_Responses() {} func (*Response_EndBlock) isResponse_Value() {}
func (m *Response) GetResponses() isResponse_Responses { func (m *Response) GetValue() isResponse_Value {
if m != nil { if m != nil {
return m.Responses return m.Value
} }
return nil return nil
} }
func (m *Response) GetException() *ResponseException { func (m *Response) GetException() *ResponseException {
if x, ok := m.GetResponses().(*Response_Exception); ok { if x, ok := m.GetValue().(*Response_Exception); ok {
return x.Exception return x.Exception
} }
return nil return nil
} }
func (m *Response) GetEcho() *ResponseEcho { func (m *Response) GetEcho() *ResponseEcho {
if x, ok := m.GetResponses().(*Response_Echo); ok { if x, ok := m.GetValue().(*Response_Echo); ok {
return x.Echo return x.Echo
} }
return nil return nil
} }
func (m *Response) GetFlush() *ResponseFlush { func (m *Response) GetFlush() *ResponseFlush {
if x, ok := m.GetResponses().(*Response_Flush); ok { if x, ok := m.GetValue().(*Response_Flush); ok {
return x.Flush return x.Flush
} }
return nil return nil
} }
func (m *Response) GetInfo() *ResponseInfo { func (m *Response) GetInfo() *ResponseInfo {
if x, ok := m.GetResponses().(*Response_Info); ok { if x, ok := m.GetValue().(*Response_Info); ok {
return x.Info return x.Info
} }
return nil return nil
} }
func (m *Response) GetSetOption() *ResponseSetOption { func (m *Response) GetSetOption() *ResponseSetOption {
if x, ok := m.GetResponses().(*Response_SetOption); ok { if x, ok := m.GetValue().(*Response_SetOption); ok {
return x.SetOption return x.SetOption
} }
return nil return nil
} }
func (m *Response) GetAppendTx() *ResponseAppendTx { func (m *Response) GetAppendTx() *ResponseAppendTx {
if x, ok := m.GetResponses().(*Response_AppendTx); ok { if x, ok := m.GetValue().(*Response_AppendTx); ok {
return x.AppendTx return x.AppendTx
} }
return nil return nil
} }
func (m *Response) GetCheckTx() *ResponseCheckTx { func (m *Response) GetCheckTx() *ResponseCheckTx {
if x, ok := m.GetResponses().(*Response_CheckTx); ok { if x, ok := m.GetValue().(*Response_CheckTx); ok {
return x.CheckTx return x.CheckTx
} }
return nil return nil
} }
func (m *Response) GetCommit() *ResponseCommit { func (m *Response) GetCommit() *ResponseCommit {
if x, ok := m.GetResponses().(*Response_Commit); ok { if x, ok := m.GetValue().(*Response_Commit); ok {
return x.Commit return x.Commit
} }
return nil return nil
} }
func (m *Response) GetQuery() *ResponseQuery { func (m *Response) GetQuery() *ResponseQuery {
if x, ok := m.GetResponses().(*Response_Query); ok { if x, ok := m.GetValue().(*Response_Query); ok {
return x.Query return x.Query
} }
return nil return nil
} }
func (m *Response) GetInitChain() *ResponseInitChain { func (m *Response) GetInitChain() *ResponseInitChain {
if x, ok := m.GetResponses().(*Response_InitChain); ok { if x, ok := m.GetValue().(*Response_InitChain); ok {
return x.InitChain return x.InitChain
} }
return nil return nil
} }
func (m *Response) GetBeginBlock() *ResponseBeginBlock { func (m *Response) GetBeginBlock() *ResponseBeginBlock {
if x, ok := m.GetResponses().(*Response_BeginBlock); ok { if x, ok := m.GetValue().(*Response_BeginBlock); ok {
return x.BeginBlock return x.BeginBlock
} }
return nil return nil
} }
func (m *Response) GetEndBlock() *ResponseEndBlock { func (m *Response) GetEndBlock() *ResponseEndBlock {
if x, ok := m.GetResponses().(*Response_EndBlock); ok { if x, ok := m.GetValue().(*Response_EndBlock); ok {
return x.EndBlock return x.EndBlock
} }
return nil return nil
@ -904,8 +908,8 @@ func (*Response) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) erro
func _Response_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { func _Response_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Response) m := msg.(*Response)
// responses // value
switch x := m.Responses.(type) { switch x := m.Value.(type) {
case *Response_Exception: case *Response_Exception:
b.EncodeVarint(1<<3 | proto.WireBytes) b.EncodeVarint(1<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Exception); err != nil { if err := b.EncodeMessage(x.Exception); err != nil {
@ -968,7 +972,7 @@ func _Response_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
} }
case nil: case nil:
default: default:
return fmt.Errorf("Response.Responses has unexpected type %T", x) return fmt.Errorf("Response.Value has unexpected type %T", x)
} }
return nil return nil
} }
@ -976,101 +980,101 @@ func _Response_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
func _Response_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { func _Response_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Response) m := msg.(*Response)
switch tag { switch tag {
case 1: // responses.exception case 1: // value.exception
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(ResponseException) msg := new(ResponseException)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Responses = &Response_Exception{msg} m.Value = &Response_Exception{msg}
return true, err return true, err
case 2: // responses.echo case 2: // value.echo
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(ResponseEcho) msg := new(ResponseEcho)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Responses = &Response_Echo{msg} m.Value = &Response_Echo{msg}
return true, err return true, err
case 3: // responses.flush case 3: // value.flush
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(ResponseFlush) msg := new(ResponseFlush)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Responses = &Response_Flush{msg} m.Value = &Response_Flush{msg}
return true, err return true, err
case 4: // responses.info case 4: // value.info
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(ResponseInfo) msg := new(ResponseInfo)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Responses = &Response_Info{msg} m.Value = &Response_Info{msg}
return true, err return true, err
case 5: // responses.set_option case 5: // value.set_option
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(ResponseSetOption) msg := new(ResponseSetOption)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Responses = &Response_SetOption{msg} m.Value = &Response_SetOption{msg}
return true, err return true, err
case 6: // responses.append_tx case 6: // value.append_tx
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(ResponseAppendTx) msg := new(ResponseAppendTx)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Responses = &Response_AppendTx{msg} m.Value = &Response_AppendTx{msg}
return true, err return true, err
case 7: // responses.check_tx case 7: // value.check_tx
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(ResponseCheckTx) msg := new(ResponseCheckTx)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Responses = &Response_CheckTx{msg} m.Value = &Response_CheckTx{msg}
return true, err return true, err
case 8: // responses.commit case 8: // value.commit
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(ResponseCommit) msg := new(ResponseCommit)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Responses = &Response_Commit{msg} m.Value = &Response_Commit{msg}
return true, err return true, err
case 9: // responses.query case 9: // value.query
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(ResponseQuery) msg := new(ResponseQuery)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Responses = &Response_Query{msg} m.Value = &Response_Query{msg}
return true, err return true, err
case 10: // responses.init_chain case 10: // value.init_chain
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(ResponseInitChain) msg := new(ResponseInitChain)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Responses = &Response_InitChain{msg} m.Value = &Response_InitChain{msg}
return true, err return true, err
case 11: // responses.begin_block case 11: // value.begin_block
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(ResponseBeginBlock) msg := new(ResponseBeginBlock)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Responses = &Response_BeginBlock{msg} m.Value = &Response_BeginBlock{msg}
return true, err return true, err
case 12: // responses.end_block case 12: // value.end_block
if wire != proto.WireBytes { if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType return true, proto.ErrInternalBadWireType
} }
msg := new(ResponseEndBlock) msg := new(ResponseEndBlock)
err := b.DecodeMessage(msg) err := b.DecodeMessage(msg)
m.Responses = &Response_EndBlock{msg} m.Value = &Response_EndBlock{msg}
return true, err return true, err
default: default:
return false, nil return false, nil
@ -1079,8 +1083,8 @@ func _Response_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffe
func _Response_OneofSizer(msg proto.Message) (n int) { func _Response_OneofSizer(msg proto.Message) (n int) {
m := msg.(*Response) m := msg.(*Response)
// responses // value
switch x := m.Responses.(type) { switch x := m.Value.(type) {
case *Response_Exception: case *Response_Exception:
s := proto.Size(x.Exception) s := proto.Size(x.Exception)
n += proto.SizeVarint(1<<3 | proto.WireBytes) n += proto.SizeVarint(1<<3 | proto.WireBytes)
@ -1310,83 +1314,83 @@ func init() {
} }
var fileDescriptor0 = []byte{ var fileDescriptor0 = []byte{
// 1244 bytes of a gzipped FileDescriptorProto // 1235 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x57, 0xc9, 0x72, 0xdb, 0x46, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x57, 0xc9, 0x72, 0xdb, 0x46,
0x13, 0x36, 0xc4, 0xbd, 0x49, 0x51, 0xc3, 0x11, 0x65, 0xc3, 0x7f, 0xfd, 0x07, 0x07, 0xd9, 0xbc, 0x10, 0x35, 0xc4, 0xbd, 0x49, 0x51, 0xa3, 0x11, 0x65, 0xc3, 0xa9, 0x1c, 0x1c, 0x64, 0xb3, 0x6c,
0x95, 0x92, 0x92, 0x2b, 0xae, 0x28, 0xc9, 0xc5, 0x92, 0x69, 0x45, 0xe5, 0xb2, 0xa5, 0xd0, 0xcb, 0x97, 0x92, 0x92, 0x2b, 0xae, 0x28, 0xc9, 0xc5, 0x92, 0x69, 0x45, 0xe5, 0xb2, 0xa5, 0xd0, 0xcb,
0x21, 0x4b, 0xa9, 0x40, 0x70, 0x48, 0x22, 0xa2, 0x66, 0x60, 0x2c, 0xb6, 0x94, 0x77, 0xc8, 0xe3, 0x21, 0x4b, 0xa9, 0x40, 0x70, 0x48, 0x22, 0xa2, 0x66, 0x60, 0x2c, 0xb6, 0x94, 0x3f, 0xc8, 0x07,
0xe4, 0x92, 0x07, 0x48, 0x55, 0xf6, 0xe5, 0x89, 0x32, 0x3d, 0x33, 0x00, 0x09, 0x08, 0xca, 0x49, 0xe5, 0x92, 0x6b, 0x4e, 0xd9, 0x97, 0x2f, 0xca, 0xf4, 0xcc, 0x00, 0x24, 0x20, 0xc8, 0x27, 0xdd,
0xb7, 0x99, 0xee, 0xfe, 0x1a, 0x3d, 0xdd, 0x5f, 0x7f, 0x2c, 0x42, 0x3b, 0x3e, 0x0b, 0x58, 0xb4, 0x66, 0xba, 0xfb, 0x35, 0x7a, 0xba, 0x5f, 0x3f, 0x16, 0xa1, 0x1d, 0x9f, 0x05, 0x2c, 0xda, 0x0c,
0x19, 0x84, 0x22, 0x16, 0xb4, 0xa6, 0x2e, 0xce, 0x4f, 0x55, 0x68, 0x0c, 0xd9, 0xab, 0x84, 0x45, 0x42, 0x11, 0x0b, 0x5a, 0x53, 0x17, 0xe7, 0x97, 0x2a, 0x34, 0x06, 0xec, 0x65, 0xc2, 0xa2, 0x98,
0x31, 0xbd, 0x09, 0x55, 0xe6, 0xcd, 0x84, 0x6d, 0xdd, 0xb0, 0x6e, 0xb6, 0xb7, 0xe8, 0xa6, 0x0e, 0xde, 0x84, 0x2a, 0xf3, 0xa6, 0xc2, 0xb6, 0x6e, 0x58, 0x37, 0xdb, 0x5b, 0x74, 0x53, 0x87, 0x1b,
0x37, 0xde, 0x81, 0xf4, 0x7c, 0x7e, 0x65, 0xa8, 0x22, 0xe8, 0x1d, 0xa8, 0x4d, 0xe6, 0x49, 0x34, 0x6f, 0x5f, 0x7a, 0xbe, 0xbc, 0x32, 0x50, 0x11, 0xf4, 0x36, 0xd4, 0xc6, 0xb3, 0x24, 0x9a, 0xda,
0xb3, 0x57, 0x54, 0xe8, 0x7a, 0x3e, 0xf4, 0x11, 0xba, 0x64, 0xac, 0x8e, 0xc1, 0xb4, 0x3e, 0x9f, 0x4b, 0x2a, 0x74, 0x2d, 0x1f, 0xfa, 0x10, 0x5d, 0x32, 0x56, 0xc7, 0x60, 0x5a, 0x9f, 0x8f, 0x85,
0x08, 0xbb, 0x52, 0x96, 0x76, 0x5f, 0x7a, 0x30, 0x2d, 0x46, 0xd0, 0x8f, 0x01, 0x22, 0x16, 0x1f, 0x5d, 0x29, 0x4b, 0xbb, 0x2f, 0x3d, 0x98, 0x16, 0x23, 0xe8, 0xa7, 0x00, 0x11, 0x8b, 0x8f, 0x44,
0x89, 0x20, 0xf6, 0x05, 0xb7, 0xab, 0x2a, 0xfe, 0x5a, 0x3e, 0xfe, 0x19, 0x8b, 0x0f, 0x94, 0x5b, 0x10, 0xfb, 0x82, 0xdb, 0x55, 0x15, 0x7f, 0x2d, 0x1f, 0xff, 0x94, 0xc5, 0x07, 0xca, 0x2d, 0x41,
0x82, 0x5a, 0x51, 0x7a, 0xa1, 0x1f, 0x41, 0xcb, 0x0d, 0x02, 0xc6, 0xc7, 0x47, 0xf1, 0xa9, 0x5d, 0xad, 0x28, 0xbd, 0xd0, 0x4f, 0xa0, 0xe5, 0x06, 0x01, 0xe3, 0xa3, 0xa3, 0xf8, 0xd4, 0xae, 0x29,
0x53, 0xc0, 0xab, 0x79, 0xe0, 0x03, 0xe5, 0x7e, 0x7e, 0x2a, 0x71, 0x4d, 0xd7, 0x9c, 0xe9, 0x16, 0xe0, 0xd5, 0x3c, 0xf0, 0xbe, 0x72, 0x3f, 0x3b, 0x95, 0xb8, 0xa6, 0x6b, 0xce, 0x74, 0x0b, 0x9a,
0x34, 0xbd, 0x19, 0xf3, 0x8e, 0x11, 0x55, 0x57, 0xa8, 0x8d, 0x3c, 0x6a, 0x17, 0xbd, 0x0a, 0xd4, 0xde, 0x94, 0x79, 0xc7, 0x88, 0xaa, 0x2b, 0xd4, 0x7a, 0x1e, 0xb5, 0x8b, 0x5e, 0x05, 0x6a, 0x78,
0xf0, 0xf4, 0x91, 0x6e, 0x42, 0xdd, 0x13, 0x27, 0x27, 0x7e, 0x6c, 0x37, 0x14, 0xa2, 0x5f, 0x40, 0xfa, 0x48, 0x37, 0xa1, 0xee, 0x89, 0x93, 0x13, 0x3f, 0xb6, 0x1b, 0x0a, 0xd1, 0x2b, 0x20, 0x94,
0x28, 0x9f, 0x04, 0x98, 0x28, 0xec, 0x95, 0x74, 0x84, 0x67, 0x76, 0xb3, 0xac, 0x57, 0x5f, 0xa0, 0x4f, 0x02, 0x4c, 0x14, 0xf6, 0x4a, 0x3a, 0xc2, 0x33, 0xbb, 0x59, 0xd6, 0xab, 0xaf, 0xd0, 0x85,
0x0b, 0x7b, 0xa5, 0x62, 0xb0, 0x03, 0x3e, 0xf7, 0xe3, 0x23, 0x6f, 0xe6, 0xfa, 0xdc, 0x6e, 0x95, 0xbd, 0x52, 0x31, 0xd8, 0x01, 0x9f, 0xfb, 0xf1, 0x91, 0x37, 0x75, 0x7d, 0x6e, 0xb7, 0xca, 0x3a,
0x75, 0x60, 0x5f, 0xfa, 0x77, 0xd1, 0x8d, 0x1d, 0xf0, 0xd3, 0x0b, 0xfd, 0x14, 0xda, 0x23, 0x36, 0xb0, 0x2f, 0xfd, 0xbb, 0xe8, 0xc6, 0x0e, 0xf8, 0xe9, 0x85, 0x7e, 0x0e, 0xed, 0x21, 0x9b, 0xf8,
0xf5, 0xf9, 0xd1, 0x68, 0x2e, 0xbc, 0x63, 0x1b, 0x14, 0xd4, 0xce, 0x43, 0x77, 0x30, 0x60, 0x07, 0xfc, 0x68, 0x38, 0x13, 0xde, 0xb1, 0x0d, 0x0a, 0x6a, 0xe7, 0xa1, 0x3b, 0x18, 0xb0, 0x83, 0x7e,
0xfd, 0x12, 0x0b, 0xa3, 0xec, 0x86, 0xed, 0xc3, 0xde, 0x69, 0x68, 0xbb, 0xac, 0x7d, 0x03, 0x3e, 0x89, 0x85, 0x61, 0x76, 0xc3, 0xf6, 0x61, 0xef, 0x34, 0xb4, 0x5d, 0xd6, 0xbe, 0x3e, 0x1f, 0xa5,
0x4e, 0x81, 0x4d, 0x66, 0xce, 0x3b, 0x00, 0xcd, 0x50, 0xbb, 0x23, 0xe7, 0x7d, 0x68, 0x2f, 0x31, 0xc0, 0x26, 0x33, 0xe7, 0x9d, 0x06, 0xd4, 0x5e, 0xb9, 0xb3, 0x84, 0x39, 0x1f, 0x42, 0x7b, 0x81,
0x85, 0xda, 0xd0, 0x38, 0x61, 0x51, 0xe4, 0x4e, 0x99, 0xa2, 0x53, 0x6b, 0x98, 0x5e, 0x9d, 0x2e, 0x26, 0xd4, 0x86, 0xc6, 0x09, 0x8b, 0x22, 0x77, 0xc2, 0x14, 0x97, 0x5a, 0x83, 0xf4, 0xea, 0x74,
0x74, 0x96, 0x79, 0xe2, 0xac, 0x66, 0x40, 0xe4, 0x82, 0xf3, 0x09, 0x90, 0xe2, 0xa8, 0x29, 0x81, 0xa1, 0xb3, 0x48, 0x12, 0x67, 0x39, 0x03, 0x22, 0x11, 0x9c, 0xcf, 0x80, 0x14, 0xe7, 0x4c, 0x09,
0xca, 0x31, 0x3b, 0x33, 0x89, 0xf0, 0x48, 0xfb, 0x50, 0x7b, 0xed, 0xce, 0x13, 0xa6, 0x08, 0xd8, 0x54, 0x8e, 0xd9, 0x99, 0x49, 0x84, 0x47, 0xda, 0x33, 0x9f, 0x55, 0xec, 0x6b, 0x0d, 0x4c, 0x0d,
0x1a, 0xea, 0x8b, 0xf3, 0x16, 0xac, 0x15, 0xa6, 0x4d, 0xbb, 0xb0, 0x22, 0x67, 0x8b, 0xc8, 0xce, 0xef, 0xc0, 0x4a, 0x61, 0xd4, 0xb4, 0x0b, 0x4b, 0x72, 0xb0, 0x88, 0xec, 0x0c, 0xe4, 0xc9, 0xb9,
0x50, 0x9e, 0x9c, 0x1b, 0xd0, 0xcd, 0x8f, 0xf6, 0x5c, 0xc4, 0x3b, 0x59, 0x7d, 0x6a, 0x36, 0xf8, 0x01, 0xdd, 0xfc, 0x5c, 0xcf, 0x45, 0xbc, 0x97, 0xd5, 0xa7, 0x06, 0x83, 0x9f, 0xd2, 0xc3, 0xd3,
0x29, 0x3d, 0x3f, 0x1d, 0xa2, 0x2f, 0xce, 0x1a, 0xac, 0xe6, 0x06, 0xee, 0x3c, 0xcc, 0xea, 0xce, 0x21, 0xfa, 0xe2, 0xac, 0xc0, 0x72, 0x6e, 0xda, 0xce, 0x83, 0xac, 0xee, 0x6c, 0x3a, 0xf4, 0x63,
0x06, 0x44, 0x3f, 0x04, 0x90, 0x85, 0xf9, 0x63, 0x37, 0x16, 0x61, 0x24, 0xf1, 0x15, 0xd9, 0x57, 0x00, 0x59, 0x98, 0x3f, 0x72, 0x63, 0x11, 0x46, 0x12, 0x5f, 0x91, 0x4d, 0x25, 0xa6, 0xa9, 0x2f,
0x62, 0xfa, 0xfa, 0x32, 0x75, 0x0c, 0x97, 0x62, 0x9c, 0x3b, 0xd0, 0x3b, 0x37, 0x2b, 0x7a, 0x15, 0x52, 0xc7, 0x60, 0x21, 0xc6, 0xb9, 0x0d, 0xab, 0xe7, 0x06, 0x45, 0xaf, 0x42, 0x7d, 0xca, 0xfc,
0xea, 0x33, 0xe6, 0x4f, 0x67, 0xb1, 0x2a, 0xa1, 0x3a, 0x34, 0x37, 0xe7, 0x56, 0xf6, 0xdc, 0x74, 0xc9, 0x34, 0x56, 0x25, 0x54, 0x07, 0xe6, 0xe6, 0x6c, 0x64, 0xcf, 0x4d, 0x47, 0x73, 0x61, 0xe8,
0x3a, 0x17, 0x86, 0x7e, 0x5f, 0x83, 0xe6, 0x90, 0x45, 0x81, 0xe0, 0x11, 0x93, 0x24, 0x6b, 0xb1, 0x8f, 0x35, 0x68, 0x0e, 0x58, 0x14, 0x08, 0x1e, 0x31, 0xc9, 0xb0, 0x16, 0x3b, 0xf5, 0x98, 0x5e,
0x53, 0x8f, 0xe9, 0x2d, 0xb3, 0x0a, 0x44, 0xd1, 0x31, 0x83, 0xd4, 0x8f, 0x24, 0xcb, 0x82, 0xe9, 0x31, 0xab, 0xc0, 0x12, 0x1d, 0xd3, 0x4f, 0xfd, 0xc8, 0xb0, 0x2c, 0x98, 0x6e, 0x18, 0x79, 0x28,
0x2d, 0xa3, 0x10, 0xc5, 0xb5, 0x37, 0xa0, 0x65, 0x89, 0xb8, 0x9b, 0x4a, 0x44, 0xa5, 0xb0, 0x25, 0xee, 0xbc, 0x01, 0x2d, 0xea, 0xc3, 0x9d, 0x54, 0x1f, 0x2a, 0x85, 0x15, 0xd1, 0xb1, 0x05, 0x81,
0x3a, 0xb6, 0xa0, 0x11, 0xb7, 0x8c, 0x46, 0x54, 0x4b, 0x13, 0xe7, 0x44, 0x62, 0x3b, 0x27, 0x12, 0xd8, 0x30, 0x02, 0x51, 0x2d, 0x4d, 0x9c, 0x53, 0x88, 0xed, 0x9c, 0x42, 0xd4, 0x4a, 0xcb, 0xbf,
0xb5, 0xd2, 0xf2, 0x2f, 0x50, 0x89, 0xfb, 0xcb, 0x2a, 0x51, 0x2f, 0x2c, 0x97, 0x46, 0x96, 0xca, 0x40, 0x22, 0xee, 0x2d, 0x4a, 0x44, 0xbd, 0xb0, 0x59, 0x1a, 0x59, 0xaa, 0x11, 0x77, 0x17, 0x34,
0xc4, 0xbd, 0x25, 0x99, 0x68, 0x14, 0xb6, 0x43, 0xc3, 0x4a, 0x74, 0xe2, 0x83, 0x4c, 0x27, 0x9a, 0xa2, 0x51, 0x58, 0x0d, 0x0d, 0x2b, 0x11, 0x89, 0x8f, 0x32, 0x91, 0x68, 0x16, 0x64, 0xc5, 0x40,
0x05, 0x65, 0x31, 0x90, 0xa2, 0x50, 0xdc, 0x4d, 0x89, 0xd6, 0x2a, 0xed, 0x58, 0x41, 0x29, 0xb6, 0x8a, 0x2a, 0x71, 0x27, 0x25, 0x5a, 0xab, 0xb4, 0x63, 0x05, 0x99, 0xd8, 0xce, 0xc9, 0x04, 0x94,
0x73, 0x4a, 0x01, 0xa5, 0x6d, 0xb8, 0x40, 0x2a, 0x3e, 0xcb, 0x4b, 0x85, 0xde, 0xf7, 0xeb, 0x05, 0xb6, 0xe1, 0x02, 0x9d, 0xf8, 0x22, 0xaf, 0x13, 0x7a, 0xd9, 0xaf, 0x17, 0xb0, 0x17, 0x0a, 0xc5,
0xec, 0x85, 0x5a, 0x71, 0x7f, 0x59, 0x2b, 0x3a, 0xa5, 0x4d, 0x2c, 0x15, 0x8b, 0x36, 0xb4, 0x42, 0xbd, 0x45, 0xa1, 0xe8, 0x94, 0x36, 0xf1, 0xcd, 0x4a, 0xb1, 0x81, 0x1c, 0x2f, 0xd0, 0x0c, 0xb7,
0xe3, 0x8f, 0x24, 0x75, 0x7b, 0xe7, 0xa8, 0x86, 0x9b, 0xc6, 0xc2, 0x50, 0x84, 0x66, 0xd1, 0xf5, 0x8c, 0x85, 0xa1, 0x08, 0xcd, 0x92, 0xeb, 0x8b, 0x73, 0x13, 0x77, 0x71, 0x4e, 0xae, 0x37, 0xa8,
0xc5, 0xb9, 0x89, 0xfb, 0xb8, 0x20, 0xd8, 0x7f, 0x28, 0x8b, 0xda, 0xc9, 0x25, 0x7a, 0x39, 0xce, 0x8a, 0xda, 0xc7, 0x05, 0x6a, 0x39, 0xce, 0x1c, 0x8a, 0xf4, 0xa1, 0xd4, 0x30, 0x4c, 0xe3, 0xd4,
0x02, 0x8a, 0x14, 0xa2, 0xd4, 0xb0, 0x4c, 0xe3, 0xd4, 0xd9, 0x79, 0x77, 0x51, 0x49, 0x4e, 0x70, 0xd9, 0x79, 0x7f, 0x5e, 0x49, 0x4e, 0x6c, 0x66, 0x62, 0x92, 0x8a, 0x8d, 0x3c, 0x3a, 0xdf, 0xe1,
0xe6, 0x62, 0x9a, 0x0a, 0x8e, 0x3c, 0x3a, 0xdf, 0xe0, 0x7a, 0xe7, 0x29, 0x42, 0xdf, 0x86, 0xaa, 0x6a, 0xe7, 0xe9, 0x41, 0xdf, 0x85, 0xaa, 0x27, 0x46, 0xba, 0x8c, 0xee, 0xd6, 0x8a, 0x69, 0xc0,
0x27, 0xc6, 0xba, 0x8c, 0xee, 0xd6, 0x9a, 0x69, 0xc2, 0xae, 0x34, 0x3d, 0x97, 0xa7, 0xa1, 0x72, 0xae, 0x34, 0x3d, 0x93, 0xa7, 0x81, 0x72, 0xe2, 0x37, 0xe5, 0x5e, 0xbb, 0x6a, 0x5d, 0x3a, 0x03,
0xe2, 0x37, 0xe5, 0x6e, 0xbb, 0x6a, 0x65, 0x3a, 0x43, 0x75, 0x4e, 0xd3, 0x57, 0x16, 0xe9, 0xbf, 0x75, 0x4e, 0xd3, 0x57, 0xe6, 0xe9, 0xbf, 0xc5, 0x35, 0xce, 0xd1, 0xe8, 0x32, 0xb3, 0x7f, 0x3d,
0xc6, 0x55, 0xce, 0x51, 0xe9, 0x32, 0xb3, 0x7f, 0xb9, 0x68, 0x8c, 0xd6, 0xb4, 0x4b, 0xcc, 0xfd, 0x6f, 0x8c, 0xd6, 0xb3, 0x4b, 0xcc, 0xfd, 0x0d, 0x8a, 0xe9, 0x22, 0x9b, 0x2f, 0x33, 0xf9, 0xda,
0x15, 0x0a, 0xea, 0x32, 0xa3, 0x2f, 0x33, 0xf9, 0xfa, 0x62, 0x38, 0x19, 0x97, 0x9d, 0x3e, 0xd0, 0x7c, 0x38, 0x19, 0x8f, 0x9d, 0x1e, 0xd0, 0xf3, 0x04, 0xd5, 0xbf, 0x19, 0x79, 0xea, 0xd1, 0x0f,
0xf3, 0x24, 0xd5, 0xbf, 0x1b, 0x79, 0xfa, 0xd1, 0xf7, 0xa0, 0x36, 0xf6, 0x27, 0x93, 0x48, 0xca, 0xa0, 0x36, 0xf2, 0xc7, 0xe3, 0x48, 0x4a, 0x4a, 0xb9, 0xec, 0x6a, 0xb7, 0xb3, 0x0d, 0xad, 0xcc,
0x4a, 0xb9, 0xf4, 0x6a, 0xb7, 0xb3, 0x0d, 0xad, 0xcc, 0x86, 0x12, 0x1a, 0x24, 0xa3, 0xc7, 0x2c, 0x86, 0xf2, 0x19, 0x24, 0xc3, 0x47, 0x2c, 0x15, 0x7b, 0x73, 0x43, 0x76, 0x06, 0xe2, 0x35, 0x0b,
0x15, 0x7c, 0x73, 0x43, 0x76, 0x06, 0xe2, 0x0d, 0x0b, 0x55, 0xc9, 0xd5, 0xa1, 0xbe, 0xdc, 0xfe, 0x55, 0xc9, 0xd5, 0x81, 0xbe, 0xdc, 0xfa, 0xd9, 0x82, 0xf6, 0x63, 0xcd, 0x3f, 0x7c, 0x1d, 0x5d,
0xd1, 0x82, 0xf6, 0x13, 0xcd, 0x3f, 0x7c, 0x1d, 0x5d, 0x83, 0xf6, 0xd3, 0x64, 0x3e, 0x37, 0x26, 0x81, 0xf6, 0x93, 0x64, 0x36, 0x33, 0x26, 0x72, 0x85, 0x36, 0xa1, 0x8a, 0xb4, 0x25, 0x16, 0x6d,
0x72, 0x85, 0x36, 0xa1, 0x8a, 0xb4, 0x25, 0x16, 0x6d, 0x41, 0x4d, 0xd1, 0x92, 0xac, 0xa0, 0x11, 0x41, 0x4d, 0xd1, 0x92, 0x2c, 0xa1, 0x11, 0x09, 0x49, 0x2a, 0x74, 0x19, 0x5a, 0x19, 0xed, 0x48,
0x09, 0x49, 0x2a, 0x74, 0x15, 0x5a, 0x19, 0xed, 0x48, 0x15, 0xaf, 0xd9, 0x3e, 0x90, 0x1a, 0xed, 0x15, 0xaf, 0xd9, 0x3e, 0x90, 0x1a, 0xed, 0x40, 0x33, 0x65, 0x1b, 0x59, 0xa5, 0x6d, 0x68, 0x18,
0x40, 0x33, 0x65, 0x1b, 0xe9, 0xd1, 0x36, 0x34, 0x0c, 0x39, 0x88, 0xec, 0x1f, 0xd4, 0x75, 0xbf, 0x72, 0x10, 0xd9, 0x3f, 0xa8, 0xeb, 0x7e, 0x93, 0x35, 0xcc, 0xac, 0xe6, 0x4a, 0x7a, 0x98, 0x20,
0xc9, 0x3a, 0x66, 0x56, 0x73, 0x25, 0x7d, 0x4c, 0x90, 0x75, 0x8a, 0x6c, 0xc8, 0x1f, 0x37, 0x58, 0xeb, 0x14, 0x59, 0x97, 0x3f, 0x6c, 0x30, 0xef, 0x11, 0xb9, 0x8a, 0x09, 0xd3, 0xee, 0x90, 0x6b,
0xf4, 0x88, 0x5c, 0xc5, 0x84, 0x69, 0x77, 0xc8, 0xb5, 0xdb, 0x3f, 0xc8, 0x5f, 0x85, 0x74, 0x2e, 0xb7, 0x7e, 0x92, 0xbf, 0x08, 0xe9, 0x5c, 0x68, 0x1d, 0x96, 0x0e, 0x1e, 0xc9, 0x82, 0x57, 0x61,
0xb4, 0x0e, 0x2b, 0x07, 0x8f, 0x65, 0xc1, 0x3d, 0x58, 0xdd, 0xe7, 0x31, 0x0b, 0xb9, 0x3b, 0x1f, 0x79, 0x9f, 0xc7, 0x2c, 0xe4, 0xee, 0xac, 0x8f, 0x0b, 0x28, 0x2b, 0x97, 0xa6, 0x3e, 0x97, 0x63,
0xe0, 0x02, 0xca, 0xca, 0xa5, 0x69, 0xc0, 0xe5, 0xd8, 0x7c, 0x3e, 0xd5, 0xa6, 0x15, 0x4c, 0xb4, 0xf3, 0xf9, 0x44, 0x9b, 0x96, 0x30, 0xd1, 0x8e, 0x3b, 0x7a, 0x22, 0xb8, 0xc7, 0xe4, 0x2b, 0x08,
0xe3, 0x8e, 0x9f, 0x0a, 0xee, 0x31, 0xf9, 0x0a, 0x02, 0x9d, 0x17, 0xdc, 0x4d, 0xe2, 0x99, 0x08, 0x74, 0x9e, 0x73, 0x37, 0x89, 0xa7, 0x22, 0xf4, 0x7f, 0x60, 0x23, 0xf9, 0x90, 0x75, 0x58, 0xdd,
0xfd, 0xef, 0xd8, 0x58, 0x3e, 0x64, 0x03, 0x7a, 0xfb, 0x3c, 0x4a, 0x26, 0x13, 0xdf, 0xf3, 0x19, 0xe7, 0x51, 0x32, 0x1e, 0xfb, 0x9e, 0xcf, 0x78, 0xfc, 0x30, 0xe1, 0xa3, 0x48, 0x3e, 0x88, 0x42,
0x8f, 0x1f, 0x25, 0x7c, 0x1c, 0xc9, 0x07, 0x51, 0xe8, 0xbe, 0xe0, 0xc7, 0x5c, 0xbc, 0xe1, 0xe6, 0xf7, 0x39, 0x3f, 0xe6, 0xe2, 0x35, 0x37, 0xbf, 0x5a, 0xa4, 0x2e, 0x17, 0xba, 0xb7, 0xe3, 0x46,
0x97, 0x8b, 0xd4, 0xe5, 0x42, 0xf7, 0x77, 0xdc, 0x88, 0x3d, 0x4c, 0x82, 0xb9, 0xef, 0xb9, 0x31, 0xec, 0x41, 0x12, 0xcc, 0x7c, 0xcf, 0x8d, 0xd9, 0xfd, 0xd1, 0x28, 0x94, 0xed, 0x23, 0x0c, 0x93,
0x7b, 0x30, 0x1e, 0x4b, 0xa1, 0x88, 0x08, 0xc3, 0x24, 0xe8, 0xc9, 0x7f, 0x7b, 0x92, 0x02, 0x72, 0xa0, 0x27, 0xff, 0xed, 0x71, 0x0a, 0xc8, 0xe5, 0x67, 0x2c, 0x22, 0x13, 0x7a, 0x1d, 0xd6, 0xcf,
0xf9, 0x19, 0x8b, 0xc8, 0x94, 0x5e, 0x87, 0x8d, 0x73, 0x1e, 0xf5, 0xe5, 0x19, 0xfd, 0x3f, 0xd8, 0x79, 0xd4, 0x97, 0xa7, 0xf4, 0x6d, 0xb0, 0x8b, 0xae, 0x3d, 0x37, 0x3a, 0x0c, 0x7d, 0xf9, 0x00,
0x45, 0xd7, 0x9e, 0x1b, 0x1d, 0x86, 0xbe, 0x7c, 0x80, 0x2f, 0x87, 0x4b, 0xb4, 0x57, 0xfd, 0x16, 0x5f, 0x0e, 0x97, 0x68, 0xaf, 0xfa, 0x1d, 0xde, 0xe7, 0x41, 0x12, 0x93, 0xef, 0xd3, 0xef, 0x1b,
0xef, 0xf3, 0x20, 0x89, 0xc9, 0xb7, 0xe9, 0xf7, 0x8d, 0xf5, 0x20, 0x89, 0xd1, 0x7c, 0x5c, 0x30, 0xeb, 0x41, 0x12, 0xa3, 0xf9, 0xb8, 0x60, 0x3e, 0x54, 0xf4, 0x20, 0x33, 0x7a, 0x0d, 0xd6, 0x16,
0x1f, 0x2a, 0x7a, 0x90, 0x39, 0xbd, 0x06, 0xeb, 0x4b, 0xe6, 0x67, 0xf8, 0x3e, 0xec, 0xce, 0xc9, 0xcc, 0x4f, 0xf1, 0x7d, 0xd8, 0x9d, 0x93, 0x79, 0xbd, 0xda, 0xe1, 0x4f, 0xb8, 0x1b, 0x27, 0x21,
0xa2, 0x5e, 0xed, 0xf0, 0xa7, 0xdc, 0x8d, 0x93, 0x90, 0x11, 0x2e, 0xb9, 0x46, 0xd1, 0x63, 0x5a, 0x23, 0x5c, 0x72, 0x8d, 0xa2, 0xc7, 0xb4, 0x24, 0x7d, 0xb8, 0x48, 0xbf, 0x60, 0xec, 0xe6, 0x0b,
0x92, 0x3e, 0x5c, 0xa4, 0x5f, 0x30, 0x76, 0xf3, 0x85, 0xa0, 0x68, 0x9e, 0x27, 0x72, 0xb2, 0xe4, 0x41, 0xd1, 0x3c, 0x4b, 0xe4, 0x64, 0xc9, 0x4b, 0x69, 0x26, 0x7b, 0xe2, 0x95, 0xb1, 0xf6, 0x79,
0x95, 0x34, 0x93, 0x3d, 0xf1, 0xda, 0x58, 0x07, 0x3c, 0xf6, 0xe3, 0x33, 0xf2, 0xb3, 0x25, 0xdf, 0xec, 0xc7, 0x67, 0xe4, 0x57, 0x4b, 0xbe, 0x69, 0x65, 0x6e, 0xde, 0x0b, 0x45, 0x12, 0x90, 0xdf,
0xb4, 0xb6, 0x30, 0xef, 0x85, 0x22, 0x09, 0xc8, 0x2f, 0x96, 0xac, 0x92, 0x2e, 0xac, 0x87, 0xa1, 0x2c, 0x59, 0x25, 0x9d, 0x5b, 0x0f, 0x43, 0x11, 0x88, 0xc8, 0x9d, 0x91, 0xdf, 0x2d, 0x59, 0xcb,
0x08, 0x44, 0xe4, 0xce, 0xc9, 0xaf, 0x96, 0xac, 0xa5, 0x27, 0x1d, 0xd9, 0x14, 0x34, 0xe0, 0xb7, 0xaa, 0x74, 0x64, 0x53, 0xd0, 0x80, 0x3f, 0x52, 0x40, 0x66, 0x7f, 0xcc, 0x4e, 0x86, 0x2c, 0x24,
0x14, 0x90, 0xd9, 0x9f, 0xb0, 0x93, 0x11, 0x0b, 0xc9, 0xef, 0x96, 0x6c, 0x76, 0x7f, 0xd9, 0x91, 0x7f, 0x5a, 0xb2, 0xd9, 0xbd, 0x45, 0x47, 0x96, 0xeb, 0x2f, 0xcb, 0x54, 0x94, 0xb9, 0x5e, 0x88,
0xe5, 0xfa, 0xc3, 0x32, 0x15, 0x65, 0xae, 0x97, 0x22, 0x66, 0xe4, 0xcf, 0xd4, 0x6c, 0xfa, 0x60, 0x98, 0x91, 0xbf, 0x53, 0xb3, 0xe9, 0x83, 0x49, 0xf4, 0x8f, 0x45, 0xd7, 0xa0, 0x3b, 0x37, 0xab,
0x12, 0xfd, 0x65, 0xd1, 0x75, 0xe8, 0x2e, 0xcc, 0x2a, 0xf6, 0x6f, 0x8b, 0xfe, 0x0f, 0x36, 0x72, 0xd8, 0x7f, 0x2d, 0xfa, 0x16, 0xac, 0xe7, 0x8c, 0x72, 0xfe, 0x87, 0xb8, 0x71, 0xe4, 0x3f, 0x6b,
0x46, 0x39, 0xff, 0x43, 0xdc, 0x38, 0xf2, 0x8f, 0x35, 0xaa, 0xab, 0xbf, 0x30, 0xf7, 0xfe, 0x0d, 0x58, 0x57, 0xff, 0x5d, 0xee, 0xfe, 0x1f, 0x00, 0x00, 0xff, 0xff, 0xc3, 0x7d, 0xee, 0xf0, 0xca,
0x00, 0x00, 0xff, 0xff, 0x54, 0x89, 0x64, 0x9a, 0xd1, 0x0c, 0x00, 0x00, 0x0c, 0x00, 0x00,
} }

8
types/types.proto
View File

@ -6,6 +6,10 @@ package types;
//---------------------------------------- //----------------------------------------
// Message types // Message types
// Not being used
// Could be added to request/response
// so we don't have to type switch
// (would be twice as fast, but we're talking about 15ns)
enum MessageType { enum MessageType {
NullMessage = 0x00; NullMessage = 0x00;
@ -70,7 +74,7 @@ enum CodeType {
// Request types // Request types
message Request { message Request {
oneof requests{ oneof value{
RequestEcho echo = 1; RequestEcho echo = 1;
RequestFlush flush = 2; RequestFlush flush = 2;
RequestInfo info = 3; RequestInfo info = 3;
@ -132,7 +136,7 @@ message RequestEndBlock{
message Response { message Response {
oneof responses{ oneof value{
ResponseException exception = 1; ResponseException exception = 1;
ResponseEcho echo = 2; ResponseEcho echo = 2;
ResponseFlush flush = 3; ResponseFlush flush = 3;