Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

some initial ideas

  • Loading branch information...
commit f787ee0b6873c4b1d449b310e2588a458d010e02 0 parents
@carloscm authored
Showing with 39,036 additions and 0 deletions.
  1. +11 −0 README
  2. +17,946 −0 src/cassandra/Cassandra.go
  3. +8,122 −0 src/cassandra/ttypes.go
  4. +23 −0 src/drivers/map.go
  5. +11 −0 src/model/cassandra.go
  6. +31 −0 src/model/model.go
  7. +5 −0 src/model/serializer.go
  8. +58 −0 src/thrift/Makefile
  9. +68 −0 src/thrift/_testmain.go
  10. +169 −0 src/thrift/tapplication_exception.go
  11. +42 −0 src/thrift/tapplication_exception_test.go
  12. +66 −0 src/thrift/tbase.go
  13. +493 −0 src/thrift/tbinary_protocol.go
  14. +31 −0 src/thrift/tbinary_protocol_test.go
  15. +856 −0 src/thrift/tcompact_protocol.go
  16. +56 −0 src/thrift/tcompact_protocol_test.go
  17. +127 −0 src/thrift/tcompare.go
  18. +28 −0 src/thrift/tcontainer.go
  19. +56 −0 src/thrift/texception.go
  20. +38 −0 src/thrift/texception_test.go
  21. +281 −0 src/thrift/tfield.go
  22. +133 −0 src/thrift/tframed_transport.go
  23. +30 −0 src/thrift/tframed_transport_test.go
  24. +148 −0 src/thrift/thttp_client.go
  25. +38 −0 src/thrift/thttp_client_test.go
  26. +231 −0 src/thrift/tiostream_transport.go
  27. +31 −0 src/thrift/tiostream_transport_test.go
  28. +537 −0 src/thrift/tjson_protocol.go
  29. +674 −0 src/thrift/tjson_protocol_test.go
  30. +222 −0 src/thrift/tlist.go
  31. +763 −0 src/thrift/tmap.go
  32. +127 −0 src/thrift/tmemory_buffer.go
  33. +30 −0 src/thrift/tmemory_buffer_test.go
  34. +70 −0 src/thrift/tmessage.go
  35. +34 −0 src/thrift/tmessagetype.go
  36. +178 −0 src/thrift/tnonblocking_server.go
  37. +169 −0 src/thrift/tnonblocking_server_socket.go
  38. +192 −0 src/thrift/tnonblocking_socket.go
  39. +24 −0 src/thrift/tnonblocking_transport.go
  40. +88 −0 src/thrift/tnonblocking_transport_test.go
  41. +165 −0 src/thrift/tnumeric.go
  42. +33 −0 src/thrift/tprocessor.go
  43. +62 −0 src/thrift/tprocessor_factory.go
  44. +201 −0 src/thrift/tprotocol.go
  45. +130 −0 src/thrift/tprotocol_exception.go
  46. +28 −0 src/thrift/tprotocol_factory.go
  47. +1,825 −0 src/thrift/tprotocol_test.go
  48. +61 −0 src/thrift/tserver.go
  49. +194 −0 src/thrift/tserver_socket.go
  50. +28 −0 src/thrift/tserver_test.go
  51. +41 −0 src/thrift/tserver_transport.go
  52. +207 −0 src/thrift/tset.go
  53. +1,281 −0 src/thrift/tsimple_json_protocol.go
  54. +662 −0 src/thrift/tsimple_json_protocol_test.go
  55. +166 −0 src/thrift/tsimple_server.go
  56. +203 −0 src/thrift/tsocket.go
  57. +93 −0 src/thrift/tstruct.go
  58. +182 −0 src/thrift/ttransport.go
  59. +84 −0 src/thrift/ttransport_exception.go
  60. +47 −0 src/thrift/ttransport_factory.go
  61. +131 −0 src/thrift/ttransport_test.go
  62. +975 −0 src/thrift/ttype.go
11 README
@@ -0,0 +1,11 @@
+
+
+
+reflector
+
+key
+
+
+save
+
+interface{} goes
17,946 src/cassandra/Cassandra.go
17,946 additions, 0 deletions not shown
8,122 src/cassandra/ttypes.go
8,122 additions, 0 deletions not shown
23 src/drivers/map.go
@@ -0,0 +1,23 @@
+package drivers
+
+type MapRow struct {
+ id string
+}
+
+type MapEntity struct {
+ MapRow
+ columns map(string,string)
+}
+
+func (r MapRow) begin(id string) {
+ r.id = id
+ r.columns = make map(string, string)
+}
+
+func (r MapRow) pair(key string, value interface{}) {
+
+ r.columns[key] = value
+}
+
+func (r MapRow) end() {
+}
11 src/model/cassandra.go
@@ -0,0 +1,11 @@
+package model
+/*
+import (
+ "net"
+ "os"
+ "http"
+ "fmt"
+ "thrift"
+ Cassandra "cassandra"
+)
+*/
31 src/model/model.go
@@ -0,0 +1,31 @@
+package model
+
+// column types must implement io.Reader and io.Writer
+
+//type Bytes string // CQL blob
+//type Ascii string // CQL ascii
+type UTF8 string // CQL text
+//type Long int // CQL int, bigint
+//type UUID string // CQL uuid
+//type Float float // CQL float
+//type Double double // CQL double
+
+/*
+missing:
+IntegerType varint Arbitrary-precision integer
+UUIDType uuid Type 1 or type 4 UUID
+DateType timestamp Date plus time, encoded as 8 bytes since epoch
+BooleanType boolean true or false
+DecimalType decimal Variable-precision decimal
+CounterColumnType counter Distributed counter value (8-byte long)
+*/
+
+func (s *UTF8) Read(p []byte) (n int, err os.Error) {
+
+}
+
+type Entity interface {
+ begin(id string)
+ pair(key string, value ColumnType)
+ end()
+}
5 src/model/serializer.go
@@ -0,0 +1,5 @@
+package model
+
+func Serialize(v interface{}, m manifest) {
+
+}
58 src/thrift/Makefile
@@ -0,0 +1,58 @@
+# Copyright 2009 The Go Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+include $(GOROOT)/src/Make.inc
+
+TARG=thrift
+GOFILES=\
+ tapplication_exception.go\
+ tbase.go\
+ tbinary_protocol.go\
+ tcompact_protocol.go\
+ tcompare.go\
+ tcontainer.go\
+ texception.go\
+ tfield.go\
+ tframed_transport.go\
+ thttp_client.go\
+ tiostream_transport.go\
+ tlist.go\
+ tjson_protocol.go\
+ tmap.go\
+ tmemory_buffer.go\
+ tmessage.go\
+ tmessagetype.go\
+ tnonblocking_server.go\
+ tnonblocking_server_socket.go\
+ tnonblocking_socket.go\
+ tnonblocking_transport.go\
+ tnumeric.go\
+ tprocessor.go\
+ tprocessor_factory.go\
+ tprotocol.go\
+ tprotocol_exception.go\
+ tprotocol_factory.go\
+ tserver.go\
+ tserver_socket.go\
+ tserver_transport.go\
+ tset.go\
+ tsimple_server.go\
+ tsimple_json_protocol.go\
+ tsocket.go\
+ tstruct.go\
+ ttransport.go\
+ ttransport_exception.go\
+ ttransport_factory.go\
+ ttype.go
+
+DIRS=\
+
+include $(GOROOT)/src/Make.pkg
+
+check:
+ gomake test
+
+-include ../Make.deps
+
+
68 src/thrift/_testmain.go
@@ -0,0 +1,68 @@
+package main
+
+import "./_xtest_"
+import "testing"
+import __regexp__ "regexp"
+
+var tests = []testing.InternalTest{
+ {"thrift_test.TestTApplicationException", thrift_test.TestTApplicationException},
+ {"thrift_test.TestReadWriteBinaryProtocol", thrift_test.TestReadWriteBinaryProtocol},
+ {"thrift_test.TestReadWriteCompactProtocol", thrift_test.TestReadWriteCompactProtocol},
+ {"thrift_test.TestTException", thrift_test.TestTException},
+ {"thrift_test.TestFramedTransport", thrift_test.TestFramedTransport},
+ {"thrift_test.TestHttpClient", thrift_test.TestHttpClient},
+ {"thrift_test.TestIOStreamTransport", thrift_test.TestIOStreamTransport},
+ {"thrift_test.TestWriteJSONProtocolBool", thrift_test.TestWriteJSONProtocolBool},
+ {"thrift_test.TestReadJSONProtocolBool", thrift_test.TestReadJSONProtocolBool},
+ {"thrift_test.TestWriteJSONProtocolByte", thrift_test.TestWriteJSONProtocolByte},
+ {"thrift_test.TestReadJSONProtocolByte", thrift_test.TestReadJSONProtocolByte},
+ {"thrift_test.TestWriteJSONProtocolI16", thrift_test.TestWriteJSONProtocolI16},
+ {"thrift_test.TestReadJSONProtocolI16", thrift_test.TestReadJSONProtocolI16},
+ {"thrift_test.TestWriteJSONProtocolI32", thrift_test.TestWriteJSONProtocolI32},
+ {"thrift_test.TestReadJSONProtocolI32", thrift_test.TestReadJSONProtocolI32},
+ {"thrift_test.TestWriteJSONProtocolI64", thrift_test.TestWriteJSONProtocolI64},
+ {"thrift_test.TestReadJSONProtocolI64", thrift_test.TestReadJSONProtocolI64},
+ {"thrift_test.TestWriteJSONProtocolDouble", thrift_test.TestWriteJSONProtocolDouble},
+ {"thrift_test.TestReadJSONProtocolDouble", thrift_test.TestReadJSONProtocolDouble},
+ {"thrift_test.TestWriteJSONProtocolString", thrift_test.TestWriteJSONProtocolString},
+ {"thrift_test.TestReadJSONProtocolString", thrift_test.TestReadJSONProtocolString},
+ {"thrift_test.TestWriteJSONProtocolBinary", thrift_test.TestWriteJSONProtocolBinary},
+ {"thrift_test.TestReadJSONProtocolBinary", thrift_test.TestReadJSONProtocolBinary},
+ {"thrift_test.TestWriteJSONProtocolList", thrift_test.TestWriteJSONProtocolList},
+ {"thrift_test.TestWriteJSONProtocolSet", thrift_test.TestWriteJSONProtocolSet},
+ {"thrift_test.TestWriteJSONProtocolMap", thrift_test.TestWriteJSONProtocolMap},
+ {"thrift_test.TestReadWriteJSONStruct", thrift_test.TestReadWriteJSONStruct},
+ {"thrift_test.TestReadWriteJSONProtocol", thrift_test.TestReadWriteJSONProtocol},
+ {"thrift_test.TestMemoryBuffer", thrift_test.TestMemoryBuffer},
+ {"thrift_test.TestNonblockingTransportServerToClient", thrift_test.TestNonblockingTransportServerToClient},
+ {"thrift_test.TestNonblockingTransportClientToServer", thrift_test.TestNonblockingTransportClientToServer},
+ {"thrift_test.TestNothing", thrift_test.TestNothing},
+ {"thrift_test.TestWriteSimpleJSONProtocolBool", thrift_test.TestWriteSimpleJSONProtocolBool},
+ {"thrift_test.TestReadSimpleJSONProtocolBool", thrift_test.TestReadSimpleJSONProtocolBool},
+ {"thrift_test.TestWriteSimpleJSONProtocolByte", thrift_test.TestWriteSimpleJSONProtocolByte},
+ {"thrift_test.TestReadSimpleJSONProtocolByte", thrift_test.TestReadSimpleJSONProtocolByte},
+ {"thrift_test.TestWriteSimpleJSONProtocolI16", thrift_test.TestWriteSimpleJSONProtocolI16},
+ {"thrift_test.TestReadSimpleJSONProtocolI16", thrift_test.TestReadSimpleJSONProtocolI16},
+ {"thrift_test.TestWriteSimpleJSONProtocolI32", thrift_test.TestWriteSimpleJSONProtocolI32},
+ {"thrift_test.TestReadSimpleJSONProtocolI32", thrift_test.TestReadSimpleJSONProtocolI32},
+ {"thrift_test.TestWriteSimpleJSONProtocolI64", thrift_test.TestWriteSimpleJSONProtocolI64},
+ {"thrift_test.TestReadSimpleJSONProtocolI64", thrift_test.TestReadSimpleJSONProtocolI64},
+ {"thrift_test.TestWriteSimpleJSONProtocolDouble", thrift_test.TestWriteSimpleJSONProtocolDouble},
+ {"thrift_test.TestReadSimpleJSONProtocolDouble", thrift_test.TestReadSimpleJSONProtocolDouble},
+ {"thrift_test.TestWriteSimpleJSONProtocolString", thrift_test.TestWriteSimpleJSONProtocolString},
+ {"thrift_test.TestReadSimpleJSONProtocolString", thrift_test.TestReadSimpleJSONProtocolString},
+ {"thrift_test.TestWriteSimpleJSONProtocolBinary", thrift_test.TestWriteSimpleJSONProtocolBinary},
+ {"thrift_test.TestReadSimpleJSONProtocolBinary", thrift_test.TestReadSimpleJSONProtocolBinary},
+ {"thrift_test.TestWriteSimpleJSONProtocolList", thrift_test.TestWriteSimpleJSONProtocolList},
+ {"thrift_test.TestWriteSimpleJSONProtocolSet", thrift_test.TestWriteSimpleJSONProtocolSet},
+ {"thrift_test.TestWriteSimpleJSONProtocolMap", thrift_test.TestWriteSimpleJSONProtocolMap},
+ {"thrift_test.TestReadWriteSimpleJSONStruct", thrift_test.TestReadWriteSimpleJSONStruct},
+ {"thrift_test.TestReadWriteSimpleJSONProtocol", thrift_test.TestReadWriteSimpleJSONProtocol},
+}
+var benchmarks = []testing.InternalBenchmark{ //
+}
+
+func main() {
+ testing.Main(__regexp__.MatchString, tests)
+ testing.RunBenchmarks(__regexp__.MatchString, benchmarks)
+}
169 src/thrift/tapplication_exception.go
@@ -0,0 +1,169 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package thrift
+
+import (
+ "os"
+)
+
+const (
+ UNKNOWN_APPLICATION_EXCEPTION = 0
+ UNKNOWN_METHOD = 1
+ INVALID_MESSAGE_TYPE_EXCEPTION = 2
+ WRONG_METHOD_NAME = 3
+ BAD_SEQUENCE_ID = 4
+ MISSING_RESULT = 5
+ INTERNAL_ERROR = 6
+ PROTOCOL_ERROR = 7
+)
+
+
+/**
+ * Application level exception
+ *
+ */
+type TApplicationException interface {
+ TException
+ TypeId() int32
+ Read(iprot TProtocol) (TApplicationException, os.Error)
+ Write(oprot TProtocol) os.Error
+}
+
+type tApplicationException struct {
+ TException
+ type_ int32
+}
+
+func NewTApplicationExceptionDefault() TApplicationException {
+ return NewTApplicationException(UNKNOWN_APPLICATION_EXCEPTION, "UNKNOWN")
+}
+
+func NewTApplicationExceptionType(type_ int32) TApplicationException {
+ return NewTApplicationException(type_, "UNKNOWN")
+}
+
+func NewTApplicationException(type_ int32, message string) TApplicationException {
+ return &tApplicationException{TException: NewTException(message), type_: type_}
+}
+
+func NewTApplicationExceptionMessage(message string) TApplicationException {
+ return NewTApplicationException(UNKNOWN_APPLICATION_EXCEPTION, message)
+}
+
+func (p *tApplicationException) TypeId() int32 {
+ return p.type_
+}
+
+func (p *tApplicationException) Read(iprot TProtocol) (error TApplicationException, err os.Error) {
+ _, err = iprot.ReadStructBegin()
+ if err != nil {
+ return
+ }
+
+ message := ""
+ type_ := int32(UNKNOWN_APPLICATION_EXCEPTION)
+
+ for {
+ _, ttype, id, err := iprot.ReadFieldBegin()
+ if err != nil {
+ return
+ }
+ if ttype == STOP {
+ break
+ }
+ switch id {
+ case 1:
+ if ttype == STRING {
+ message, err = iprot.ReadString()
+ if err != nil {
+ return
+ }
+ } else {
+ err = SkipDefaultDepth(iprot, ttype)
+ if err != nil {
+ return
+ }
+ }
+ break
+ case 2:
+ if ttype == I32 {
+ type_, err = iprot.ReadI32()
+ if err != nil {
+ return
+ }
+ } else {
+ err = SkipDefaultDepth(iprot, ttype)
+ if err != nil {
+ return
+ }
+ }
+ break
+ default:
+ err = SkipDefaultDepth(iprot, ttype)
+ if err != nil {
+ return
+ }
+ break
+ }
+ err = iprot.ReadFieldEnd()
+ if err != nil {
+ return
+ }
+ }
+ err = iprot.ReadStructEnd()
+ error = NewTApplicationException(type_, message)
+ return
+}
+
+func (p *tApplicationException) Write(oprot TProtocol) (err os.Error) {
+ err = oprot.WriteStructBegin("TApplicationException")
+ if len(p.String()) > 0 {
+ err = oprot.WriteFieldBegin("message", STRING, 1)
+ if err != nil {
+ return
+ }
+ err = oprot.WriteString(p.String())
+ if err != nil {
+ return
+ }
+ err = oprot.WriteFieldEnd()
+ if err != nil {
+ return
+ }
+ }
+ err = oprot.WriteFieldBegin("type", I32, 2)
+ if err != nil {
+ return
+ }
+ err = oprot.WriteI32(p.type_)
+ if err != nil {
+ return
+ }
+ err = oprot.WriteFieldEnd()
+ if err != nil {
+ return
+ }
+ err = oprot.WriteFieldStop()
+ if err != nil {
+ return
+ }
+ err = oprot.WriteStructEnd()
+ return
+}
42 src/thrift/tapplication_exception_test.go
@@ -0,0 +1,42 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package thrift_test
+
+import (
+ . "thrift"
+ "testing"
+)
+
+func TestTApplicationException(t *testing.T) {
+ exc := NewTApplicationException(UNKNOWN_APPLICATION_EXCEPTION, "")
+ if exc.String() != "" {
+ t.Fatalf("Expected empty string for exception but found '%s'", exc.String())
+ }
+ if exc.TypeId() != UNKNOWN_APPLICATION_EXCEPTION {
+ t.Fatalf("Expected type UNKNOWN for exception but found '%s'", exc.TypeId())
+ }
+ exc = NewTApplicationException(WRONG_METHOD_NAME, "junk_method")
+ if exc.String() != "junk_method" {
+ t.Fatalf("Expected 'junk_method' for exception but found '%s'", exc.String())
+ }
+ if exc.TypeId() != WRONG_METHOD_NAME {
+ t.Fatalf("Expected type WRONG_METHOD_NAME for exception but found '%s'", exc.TypeId())
+ }
+}
66 src/thrift/tbase.go
@@ -0,0 +1,66 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package thrift
+
+/**
+ * Generic base interface for generated Thrift objects.
+ *
+ */
+type TBase interface {
+
+ /**
+ * Reads the TObject from the given input protocol
+ *
+ * @param iprot Input protocol
+ */
+ Read(iprot TProtocol) (err TException)
+
+ /**
+ * Writes the objects out to the protocol
+ *
+ * @param oprot Output protocol
+ */
+ Write(oprot TProtocol) (err TException)
+
+ /**
+ * Check if a field is currently set or unset.
+ *
+ * @param field
+ */
+ IsSet(field TField) bool
+
+ /**
+ * Get a field's value by field variable. Primitive types will be wrapped in
+ * the appropriate "boxed" types.
+ *
+ * @param field
+ */
+ FieldValue(field TField) interface{}
+
+ /**
+ * Set a field's value by field variable. Primitive types must be "boxed" in
+ * the appropriate object wrapper type.
+ *
+ * @param field
+ */
+ SetFieldValue(field TField, value interface{})
+
+ DeepCopy() TBase
+}
493 src/thrift/tbinary_protocol.go
@@ -0,0 +1,493 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package thrift
+
+import (
+ "encoding/binary"
+ "math"
+ "strings"
+ "io"
+)
+
+type TBinaryProtocol struct {
+ //TProtocolBase;
+ trans TTransport
+ _StrictRead bool
+ _StrictWrite bool
+ _ReadLength int
+ _CheckReadLength bool
+}
+
+type TBinaryProtocolFactory struct {
+ _StrictRead bool
+ _StrictWrite bool
+}
+
+func NewTBinaryProtocolTransport(t TTransport) *TBinaryProtocol {
+ return NewTBinaryProtocol(t, false, true)
+}
+
+func NewTBinaryProtocol(t TTransport, strictRead, strictWrite bool) *TBinaryProtocol {
+ //return &TBinaryProtocol{TProtocolBase:TProtocolBase{trans:t}, _StrictRead:strictRead, _StrictWrite:strictWrite, _ReadLength:0, _CheckReadLength:false};
+ return &TBinaryProtocol{trans: t, _StrictRead: strictRead, _StrictWrite: strictWrite, _ReadLength: 0, _CheckReadLength: false}
+}
+
+func NewTBinaryProtocolFactoryDefault() *TBinaryProtocolFactory {
+ return NewTBinaryProtocolFactory(false, true)
+}
+
+func NewTBinaryProtocolFactory(strictRead, strictWrite bool) *TBinaryProtocolFactory {
+ return &TBinaryProtocolFactory{_StrictRead: strictRead, _StrictWrite: strictWrite}
+}
+
+func (p *TBinaryProtocolFactory) GetProtocol(t TTransport) TProtocol {
+ return NewTBinaryProtocol(t, p._StrictRead, p._StrictWrite)
+}
+
+/**
+ * Writing Methods
+ */
+
+func (p *TBinaryProtocol) WriteMessageBegin(name string, typeId TMessageType, seqId int32) TProtocolException {
+ if p._StrictWrite {
+ version := uint32(VERSION_1) | uint32(typeId)
+ e := p.WriteI32(int32(version))
+ if e != nil {
+ return e
+ }
+ e = p.WriteString(name)
+ if e != nil {
+ return e
+ }
+ e = p.WriteI32(seqId)
+ return e
+ } else {
+ e := p.WriteString(name)
+ if e != nil {
+ return e
+ }
+ e = p.WriteByte(byte(typeId))
+ if e != nil {
+ return e
+ }
+ e = p.WriteI32(seqId)
+ return e
+ }
+ return nil
+}
+
+func (p *TBinaryProtocol) WriteMessageEnd() TProtocolException {
+ return nil
+}
+
+func (p *TBinaryProtocol) WriteStructBegin(name string) TProtocolException {
+ return nil
+}
+
+func (p *TBinaryProtocol) WriteStructEnd() TProtocolException {
+ return nil
+}
+
+func (p *TBinaryProtocol) WriteFieldBegin(name string, typeId TType, id int16) TProtocolException {
+ e := p.WriteByte(byte(typeId))
+ if e != nil {
+ return e
+ }
+ e = p.WriteI16(id)
+ return e
+}
+
+func (p *TBinaryProtocol) WriteFieldEnd() TProtocolException {
+ return nil
+}
+
+func (p *TBinaryProtocol) WriteFieldStop() TProtocolException {
+ e := p.WriteByte(STOP)
+ return e
+}
+
+func (p *TBinaryProtocol) WriteMapBegin(keyType TType, valueType TType, size int) TProtocolException {
+ e := p.WriteByte(byte(keyType))
+ if e != nil {
+ return e
+ }
+ e = p.WriteByte(byte(valueType))
+ if e != nil {
+ return e
+ }
+ e = p.WriteI32(int32(size))
+ return e
+}
+
+func (p *TBinaryProtocol) WriteMapEnd() TProtocolException {
+ return nil
+}
+
+func (p *TBinaryProtocol) WriteListBegin(elemType TType, size int) TProtocolException {
+ e := p.WriteByte(byte(elemType))
+ if e != nil {
+ return e
+ }
+ e = p.WriteI32(int32(size))
+ return e
+}
+
+func (p *TBinaryProtocol) WriteListEnd() TProtocolException {
+ return nil
+}
+
+func (p *TBinaryProtocol) WriteSetBegin(elemType TType, size int) TProtocolException {
+ e := p.WriteByte(byte(elemType))
+ if e != nil {
+ return e
+ }
+ e = p.WriteI32(int32(size))
+ return e
+}
+
+func (p *TBinaryProtocol) WriteSetEnd() TProtocolException {
+ return nil
+}
+
+func (p *TBinaryProtocol) WriteBool(value bool) TProtocolException {
+ if value {
+ return p.WriteByte(1)
+ }
+ return p.WriteByte(0)
+}
+
+func (p *TBinaryProtocol) WriteByte(value byte) TProtocolException {
+ v := []byte{value}
+ _, e := p.trans.Write(v)
+ return NewTProtocolExceptionFromOsError(e)
+}
+
+func (p *TBinaryProtocol) WriteI16(value int16) TProtocolException {
+ h := byte(0xff & (value >> 8))
+ l := byte(0xff & value)
+ v := []byte{h, l}
+ _, e := p.trans.Write(v)
+ return NewTProtocolExceptionFromOsError(e)
+}
+
+func (p *TBinaryProtocol) WriteI32(value int32) TProtocolException {
+ a := byte(0xff & (value >> 24))
+ b := byte(0xff & (value >> 16))
+ c := byte(0xff & (value >> 8))
+ d := byte(0xff & value)
+ v := []byte{a, b, c, d}
+ _, e := p.trans.Write(v)
+ return NewTProtocolExceptionFromOsError(e)
+}
+
+func (p *TBinaryProtocol) WriteI64(value int64) TProtocolException {
+ a := byte(0xff & (value >> 56))
+ b := byte(0xff & (value >> 48))
+ c := byte(0xff & (value >> 40))
+ d := byte(0xff & (value >> 32))
+ e := byte(0xff & (value >> 24))
+ f := byte(0xff & (value >> 16))
+ g := byte(0xff & (value >> 8))
+ h := byte(0xff & value)
+ v := []byte{a, b, c, d, e, f, g, h}
+ _, err := p.trans.Write(v)
+ return NewTProtocolExceptionFromOsError(err)
+}
+
+func (p *TBinaryProtocol) WriteDouble(value float64) TProtocolException {
+ return p.WriteI64(int64(math.Float64bits(value)))
+}
+
+func (p *TBinaryProtocol) WriteString(value string) TProtocolException {
+ return p.WriteBinaryFromReader(strings.NewReader(value), len(value))
+}
+
+func (p *TBinaryProtocol) WriteBinary(value []byte) TProtocolException {
+ e := p.WriteI32(int32(len(value)))
+ if e != nil {
+ return e
+ }
+ _, err := p.trans.Write(value)
+ return NewTProtocolExceptionFromOsError(err)
+}
+
+func (p *TBinaryProtocol) WriteBinaryFromReader(reader io.Reader, size int) TProtocolException {
+ e := p.WriteI32(int32(size))
+ if e != nil {
+ return e
+ }
+ _, err := io.Copyn(p.trans, reader, int64(size))
+ return NewTProtocolExceptionFromOsError(err)
+}
+
+
+/**
+ * Reading methods
+ */
+
+func (p *TBinaryProtocol) ReadMessageBegin() (name string, typeId TMessageType, seqId int32, err TProtocolException) {
+ size, e := p.ReadI32()
+ if e != nil {
+ return "", typeId, 0, NewTProtocolExceptionFromOsError(e)
+ }
+ if size < 0 {
+ typeId = TMessageType(size & 0x0ff)
+ version := int64(int64(size) & VERSION_MASK)
+ if version != VERSION_1 {
+ return name, typeId, seqId, NewTProtocolException(BAD_VERSION, "Bad version in ReadMessageBegin")
+ }
+ name, e = p.ReadString()
+ if e != nil {
+ return name, typeId, seqId, NewTProtocolExceptionFromOsError(e)
+ }
+ seqId, e = p.ReadI32()
+ if e != nil {
+ return name, typeId, seqId, NewTProtocolExceptionFromOsError(e)
+ }
+ return name, typeId, seqId, nil
+ }
+ if p._StrictRead {
+ return name, typeId, seqId, NewTProtocolException(BAD_VERSION, "Missing version in ReadMessageBegin")
+ }
+ name, e2 := p.readStringBody(int(size))
+ if e2 != nil {
+ return name, typeId, seqId, e2
+ }
+ b, e3 := p.ReadByte()
+ if e3 != nil {
+ return name, typeId, seqId, e3
+ }
+ typeId = TMessageType(b)
+ seqId, e4 := p.ReadI32()
+ if e4 != nil {
+ return name, typeId, seqId, e4
+ }
+ return name, typeId, seqId, nil
+}
+
+func (p *TBinaryProtocol) ReadMessageEnd() TProtocolException {
+ return nil
+}
+
+func (p *TBinaryProtocol) ReadStructBegin() (name string, err TProtocolException) {
+ return
+}
+
+func (p *TBinaryProtocol) ReadStructEnd() TProtocolException {
+ return nil
+}
+
+func (p *TBinaryProtocol) ReadFieldBegin() (name string, typeId TType, seqId int16, err TProtocolException) {
+ t, err := p.ReadByte()
+ typeId = TType(t)
+ if err != nil {
+ return name, typeId, seqId, err
+ }
+ if t != STOP {
+ seqId, err = p.ReadI16()
+ }
+ return name, typeId, seqId, err
+}
+
+func (p *TBinaryProtocol) ReadFieldEnd() TProtocolException {
+ return nil
+}
+
+func (p *TBinaryProtocol) ReadMapBegin() (kType, vType TType, size int, err TProtocolException) {
+ k, e := p.ReadByte()
+ if e != nil {
+ err = NewTProtocolExceptionFromOsError(e)
+ return
+ }
+ kType = TType(k)
+ v, e := p.ReadByte()
+ if e != nil {
+ err = NewTProtocolExceptionFromOsError(e)
+ return
+ }
+ vType = TType(v)
+ size32, e := p.ReadI32()
+ size = int(size32)
+ if e != nil {
+ err = NewTProtocolExceptionFromOsError(e)
+ return
+ }
+ return kType, vType, size, nil
+}
+
+func (p *TBinaryProtocol) ReadMapEnd() TProtocolException {
+ return nil
+}
+
+func (p *TBinaryProtocol) ReadListBegin() (elemType TType, size int, err TProtocolException) {
+ b, e := p.ReadByte()
+ if e != nil {
+ err = NewTProtocolExceptionFromOsError(e)
+ return
+ }
+ elemType = TType(b)
+ size32, e := p.ReadI32()
+ size = int(size32)
+ if e != nil {
+ err = NewTProtocolExceptionFromOsError(e)
+ return
+ }
+ return elemType, size, nil
+}
+
+func (p *TBinaryProtocol) ReadListEnd() TProtocolException {
+ return nil
+}
+
+func (p *TBinaryProtocol) ReadSetBegin() (elemType TType, size int, err TProtocolException) {
+ b, e := p.ReadByte()
+ if e != nil {
+ err = NewTProtocolExceptionFromOsError(e)
+ return
+ }
+ elemType = TType(b)
+ size32, e := p.ReadI32()
+ size = int(size32)
+ if e != nil {
+ err = NewTProtocolExceptionFromOsError(e)
+ return
+ }
+ return elemType, size, nil
+}
+
+func (p *TBinaryProtocol) ReadSetEnd() TProtocolException {
+ return nil
+}
+
+func (p *TBinaryProtocol) ReadBool() (bool, TProtocolException) {
+ b, e := p.ReadByte()
+ v := true
+ if b != 1 {
+ v = false
+ }
+ return v, e
+}
+
+func (p *TBinaryProtocol) ReadByte() (value byte, err TProtocolException) {
+ buf := []byte{0}
+ err = p.readAll(buf)
+ return buf[0], err
+}
+
+func (p *TBinaryProtocol) ReadI16() (value int16, err TProtocolException) {
+ buf := []byte{0, 0}
+ err = p.readAll(buf)
+ value = int16(binary.BigEndian.Uint16(buf))
+ return value, err
+}
+
+func (p *TBinaryProtocol) ReadI32() (value int32, err TProtocolException) {
+ buf := []byte{0, 0, 0, 0}
+ err = p.readAll(buf)
+ value = int32(binary.BigEndian.Uint32(buf))
+ return value, err
+}
+
+func (p *TBinaryProtocol) ReadI64() (value int64, err TProtocolException) {
+ buf := []byte{0, 0, 0, 0, 0, 0, 0, 0}
+ err = p.readAll(buf)
+ value = int64(binary.BigEndian.Uint64(buf))
+ return value, err
+}
+
+func (p *TBinaryProtocol) ReadDouble() (value float64, err TProtocolException) {
+ buf := []byte{0, 0, 0, 0, 0, 0, 0, 0}
+ err = p.readAll(buf)
+ value = math.Float64frombits(binary.BigEndian.Uint64(buf))
+ return value, err
+}
+
+func (p *TBinaryProtocol) ReadString() (value string, err TProtocolException) {
+ size, e := p.ReadI32()
+ if e != nil {
+ return "", e
+ }
+ return p.readStringBody(int(size))
+}
+
+func (p *TBinaryProtocol) ReadBinary() ([]byte, TProtocolException) {
+ size, e := p.ReadI32()
+ if e != nil {
+ return nil, e
+ }
+ isize := int(size)
+ e = p.checkReadLength(isize)
+ if e != nil {
+ return nil, e
+ }
+ buf := make([]byte, isize)
+ _, err := p.trans.ReadAll(buf)
+ return buf, NewTProtocolExceptionFromOsError(err)
+}
+
+func (p *TBinaryProtocol) Flush() (err TProtocolException) {
+ return NewTProtocolExceptionFromOsError(p.trans.Flush())
+}
+
+func (p *TBinaryProtocol) Skip(fieldType TType) (err TProtocolException) {
+ return SkipDefaultDepth(p, fieldType)
+}
+
+func (p *TBinaryProtocol) Transport() TTransport {
+ return p.trans
+}
+
+func (p *TBinaryProtocol) readAll(buf []byte) TProtocolException {
+ e := p.checkReadLength(len(buf))
+ if e != nil {
+ return e
+ }
+ _, err := p.trans.ReadAll(buf)
+ return NewTProtocolExceptionFromOsError(err)
+}
+
+func (p *TBinaryProtocol) setReadLength(readLength int) {
+ p._ReadLength = readLength
+ p._CheckReadLength = true
+}
+
+func (p *TBinaryProtocol) checkReadLength(length int) TProtocolException {
+ if p._CheckReadLength {
+ p._ReadLength = p._ReadLength - length
+ if p._ReadLength < 0 {
+ return NewTProtocolException(UNKNOWN_PROTOCOL_EXCEPTION, "Message length exceeded: "+string(length))
+ }
+ }
+ return nil
+}
+
+func (p *TBinaryProtocol) readStringBody(size int) (value string, err TProtocolException) {
+ if size < 0 {
+ return "", nil
+ }
+ err = p.checkReadLength(size)
+ if err != nil {
+ return "", err
+ }
+ isize := int(size)
+ buf := make([]byte, isize)
+ _, e := p.trans.ReadAll(buf)
+ return string(buf), NewTProtocolExceptionFromOsError(e)
+}
31 src/thrift/tbinary_protocol_test.go
@@ -0,0 +1,31 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package thrift_test
+
+import (
+ . "thrift"
+ "testing"
+ //"bytes";
+)
+
+
+func TestReadWriteBinaryProtocol(t *testing.T) {
+ ReadWriteProtocolTest(t, NewTBinaryProtocolFactoryDefault())
+}
856 src/thrift/tcompact_protocol.go
@@ -0,0 +1,856 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package thrift
+
+import (
+ "container/vector"
+ "encoding/binary"
+ "fmt"
+ "math"
+ "os"
+ "strings"
+)
+
+const (
+ COMPACT_PROTOCOL_ID = 0x082
+ COMPACT_VERSION = 1
+ COMPACT_VERSION_MASK = 0x1f
+ COMPACT_TYPE_MASK = 0x0E0
+ COMPACT_TYPE_SHIFT_AMOUNT = 5
+)
+
+type TCompactType byte
+
+const (
+ COMPACT_BOOLEAN_TRUE = 0x01
+ COMPACT_BOOLEAN_FALSE = 0x02
+ COMPACT_BYTE = 0x03
+ COMPACT_I16 = 0x04
+ COMPACT_I32 = 0x05
+ COMPACT_I64 = 0x06
+ COMPACT_DOUBLE = 0x07
+ COMPACT_BINARY = 0x08
+ COMPACT_LIST = 0x09
+ COMPACT_SET = 0x0A
+ COMPACT_MAP = 0x0B
+ COMPACT_STRUCT = 0x0C
+)
+
+var (
+ _TTypeToCompactType []TCompactType
+ _TSTOP TField
+)
+
+func init() {
+ _TSTOP = NewTField("", STOP, 0)
+ _TTypeToCompactType = make([]TCompactType, int(UTF16)+1)
+ _TTypeToCompactType[int(STOP)] = STOP
+ _TTypeToCompactType[int(BOOL)] = COMPACT_BOOLEAN_TRUE
+ _TTypeToCompactType[int(BYTE)] = COMPACT_BYTE
+ _TTypeToCompactType[int(I16)] = COMPACT_I16
+ _TTypeToCompactType[int(I32)] = COMPACT_I32
+ _TTypeToCompactType[int(I64)] = COMPACT_I64
+ _TTypeToCompactType[int(DOUBLE)] = COMPACT_DOUBLE
+ _TTypeToCompactType[int(STRING)] = COMPACT_BINARY
+ _TTypeToCompactType[int(LIST)] = COMPACT_LIST
+ _TTypeToCompactType[int(SET)] = COMPACT_SET
+ _TTypeToCompactType[int(MAP)] = COMPACT_MAP
+ _TTypeToCompactType[int(STRUCT)] = COMPACT_STRUCT
+}
+
+type TCompactProtocolFactory struct{}
+
+func NewTCompactProtocolFactory() *TCompactProtocolFactory {
+ return &TCompactProtocolFactory{}
+}
+
+func (p *TCompactProtocolFactory) GetProtocol(trans TTransport) TProtocol {
+ return NewTCompactProtocol(trans)
+}
+
+type TCompactProtocol struct {
+ trans TTransport
+
+ /**
+ * Used to keep track of the last field for the current and previous structs,
+ * so we can do the delta stuff.
+ */
+ lastField *vector.IntVector
+ lastFieldId int
+
+ /**
+ * If we encounter a boolean field begin, save the TField here so it can
+ * have the value incorporated.
+ */
+ booleanField TField
+
+ /**
+ * If we read a field header, and it's a boolean field, save the boolean
+ * value here so that readBool can use it.
+ */
+ boolValue bool
+ boolValueIsNotNull bool
+}
+
+/**
+ * Create a TCompactProtocol.
+ *
+ * @param transport the TTransport object to read from or write to.
+ */
+func NewTCompactProtocol(trans TTransport) *TCompactProtocol {
+ return &TCompactProtocol{trans: trans, lastField: &vector.IntVector{}}
+}
+
+
+//
+// Public Writing methods.
+//
+
+/**
+ * Write a message header to the wire. Compact Protocol messages contain the
+ * protocol version so we can migrate forwards in the future if need be.
+ */
+func (p *TCompactProtocol) WriteMessageBegin(name string, typeId TMessageType, seqid int32) TProtocolException {
+ _, err := p.writeByteDirect(COMPACT_PROTOCOL_ID)
+ if err != nil {
+ return NewTProtocolExceptionFromOsError(err)
+ }
+ _, err = p.writeByteDirect((COMPACT_VERSION & COMPACT_VERSION_MASK) | ((byte(typeId) << COMPACT_TYPE_SHIFT_AMOUNT) & COMPACT_TYPE_MASK))
+ if err != nil {
+ return NewTProtocolExceptionFromOsError(err)
+ }
+ _, err = p.writeVarint32(seqid)
+ if err != nil {
+ return NewTProtocolExceptionFromOsError(err)
+ }
+ e := p.WriteString(name)
+ return e
+
+}
+
+func (p *TCompactProtocol) WriteMessageEnd() TProtocolException { return nil }
+
+/**
+ * Write a struct begin. This doesn't actually put anything on the wire. We
+ * use it as an opportunity to put special placeholder markers on the field
+ * stack so we can get the field id deltas correct.
+ */
+func (p *TCompactProtocol) WriteStructBegin(name string) TProtocolException {
+ p.lastField.Push(p.lastFieldId)
+ p.lastFieldId = 0
+ return nil
+}
+
+/**
+ * Write a struct end. This doesn't actually put anything on the wire. We use
+ * this as an opportunity to pop the last field from the current struct off
+ * of the field stack.
+ */
+func (p *TCompactProtocol) WriteStructEnd() TProtocolException {
+ p.lastFieldId = p.lastField.Pop()
+ return nil
+}
+
+func (p *TCompactProtocol) WriteFieldBegin(name string, typeId TType, id int16) TProtocolException {
+ if typeId == BOOL {
+ // we want to possibly include the value, so we'll wait.
+ p.booleanField = NewTField(name, typeId, int(id))
+ return nil
+ }
+ _, err := p.writeFieldBeginInternal(name, typeId, id, 0xFF)
+ return NewTProtocolExceptionFromOsError(err)
+}
+
+
+/**
+ * The workhorse of writeFieldBegin. It has the option of doing a
+ * 'type override' of the type header. This is used specifically in the
+ * boolean field case.
+ */
+func (p *TCompactProtocol) writeFieldBeginInternal(name string, typeId TType, id int16, typeOverride byte) (int, os.Error) {
+ // short lastField = lastField_.pop();
+
+ // if there's a type override, use that.
+ var typeToWrite byte
+ if typeOverride == 0xFF {
+ typeToWrite = byte(p.getCompactType(typeId))
+ } else {
+ typeToWrite = typeOverride
+ }
+ // check if we can use delta encoding for the field id
+ fieldId := int(id)
+ written := 0
+ if fieldId > p.lastFieldId && fieldId-p.lastFieldId <= 15 {
+ // write them together
+ written, err := p.writeByteDirect(byte((fieldId-p.lastFieldId)<<4) | typeToWrite)
+ if err != nil {
+ return written, err
+ }
+ } else {
+ // write them separate
+ n, err := p.writeByteDirect(typeToWrite)
+ if err != nil {
+ return n, err
+ }
+ err = p.WriteI16(id)
+ written = n + 2
+ if err != nil {
+ return written, err
+ }
+ }
+
+ p.lastFieldId = fieldId
+ // p.lastField.Push(field.id);
+ return written, nil
+}
+
+
+func (p *TCompactProtocol) WriteFieldEnd() TProtocolException { return nil }
+
+func (p *TCompactProtocol) WriteFieldStop() TProtocolException {
+ _, err := p.writeByteDirect(STOP)
+ return NewTProtocolExceptionFromOsError(err)
+}
+
+func (p *TCompactProtocol) WriteMapBegin(keyType TType, valueType TType, size int) TProtocolException {
+ if size == 0 {
+ _, err := p.writeByteDirect(0)
+ return NewTProtocolExceptionFromOsError(err)
+ }
+ _, err := p.writeVarint32(int32(size))
+ if err != nil {
+ return NewTProtocolExceptionFromOsError(err)
+ }
+ _, err = p.writeByteDirect(byte(p.getCompactType(keyType))<<4 | byte(p.getCompactType(valueType)))
+ return NewTProtocolExceptionFromOsError(err)
+}
+
+func (p *TCompactProtocol) WriteMapEnd() TProtocolException { return nil }
+
+/**
+ * Write a list header.
+ */
+func (p *TCompactProtocol) WriteListBegin(elemType TType, size int) TProtocolException {
+ _, err := p.writeCollectionBegin(elemType, size)
+ return NewTProtocolExceptionFromOsError(err)
+}
+
+func (p *TCompactProtocol) WriteListEnd() TProtocolException { return nil }
+
+/**
+ * Write a set header.
+ */
+func (p *TCompactProtocol) WriteSetBegin(elemType TType, size int) TProtocolException {
+ _, err := p.writeCollectionBegin(elemType, size)
+ return NewTProtocolExceptionFromOsError(err)
+}
+
+func (p *TCompactProtocol) WriteSetEnd() TProtocolException { return nil }
+
+func (p *TCompactProtocol) WriteBool(value bool) TProtocolException {
+ v := byte(COMPACT_BOOLEAN_FALSE)
+ if value {
+ v = byte(COMPACT_BOOLEAN_TRUE)
+ }
+ if p.booleanField != nil {
+ // we haven't written the field header yet
+ _, err := p.writeFieldBeginInternal(p.booleanField.Name(), p.booleanField.TypeId(), int16(p.booleanField.Id()), v)
+ p.booleanField = nil
+ return NewTProtocolExceptionFromOsError(err)
+ }
+ // we're not part of a field, so just write the value.
+ _, err := p.writeByteDirect(v)
+ return NewTProtocolExceptionFromOsError(err)
+}
+
+/**
+ * Write a byte. Nothing to see here!
+ */
+func (p *TCompactProtocol) WriteByte(value byte) TProtocolException {
+ _, err := p.writeByteDirect(value)
+ return NewTProtocolExceptionFromOsError(err)
+}
+
+/**
+ * Write an I16 as a zigzag varint.
+ */
+func (p *TCompactProtocol) WriteI16(value int16) TProtocolException {
+ _, err := p.writeVarint32(p.int32ToZigzag(int32(value)))
+ return NewTProtocolExceptionFromOsError(err)
+}
+
+/**
+ * Write an i32 as a zigzag varint.
+ */
+func (p *TCompactProtocol) WriteI32(value int32) TProtocolException {
+ _, err := p.writeVarint32(p.int32ToZigzag(value))
+ return NewTProtocolExceptionFromOsError(err)
+}
+
+/**
+ * Write an i64 as a zigzag varint.
+ */
+func (p *TCompactProtocol) WriteI64(value int64) TProtocolException {
+ _, err := p.writeVarint64(p.int64ToZigzag(value))
+ return NewTProtocolExceptionFromOsError(err)
+}
+
+/**
+ * Write a double to the wire as 8 bytes.
+ */
+func (p *TCompactProtocol) WriteDouble(value float64) TProtocolException {
+ buf := make([]byte, 8)
+ binary.LittleEndian.PutUint64(buf, math.Float64bits(value))
+ _, err := p.trans.Write(buf)
+ return NewTProtocolExceptionFromOsError(err)
+}
+
+/**
+ * Write a string to the wire with a varint size preceeding.
+ */
+func (p *TCompactProtocol) WriteString(value string) TProtocolException {
+ buf := make([]byte, len(value))
+ strings.NewReader(value).Read(buf)
+ return p.WriteBinary(buf)
+}
+
+/**
+ * Write a byte array, using a varint for the size.
+ */
+func (p *TCompactProtocol) WriteBinary(bin []byte) TProtocolException {
+ _, e := p.writeVarint32(int32(len(bin)))
+ if e != nil {
+ return NewTProtocolExceptionFromOsError(e)
+ }
+ if len(bin) > 0 {
+ _, e = p.trans.Write(bin)
+ return NewTProtocolExceptionFromOsError(e)
+ }
+ return nil
+}
+
+
+//
+// Reading methods.
+//
+
+/**
+ * Read a message header.
+ */
+func (p *TCompactProtocol) ReadMessageBegin() (name string, typeId TMessageType, seqId int32, err TProtocolException) {
+ protocolId, err := p.ReadByte()
+ if protocolId != COMPACT_PROTOCOL_ID {
+ s := fmt.Sprintf("Expected protocol id %02x but got %02x", COMPACT_PROTOCOL_ID, protocolId)
+ return "", typeId, seqId, NewTProtocolException(BAD_VERSION, s)
+ }
+ versionAndType, err := p.ReadByte()
+ version := versionAndType & COMPACT_VERSION_MASK
+ typeId = TMessageType((versionAndType >> COMPACT_TYPE_SHIFT_AMOUNT) & 0x03)
+ if err != nil {
+ return
+ }
+ if version != COMPACT_VERSION {
+ s := fmt.Sprintf("Expected version %02x but got %02x", COMPACT_VERSION, version)
+ err = NewTProtocolException(BAD_VERSION, s)
+ return
+ }
+ seqId, e := p.readVarint32()
+ if e != nil {
+ err = NewTProtocolExceptionFromOsError(e)
+ return
+ }
+ name, err = p.ReadString()
+ return
+}
+
+func (p *TCompactProtocol) ReadMessageEnd() TProtocolException { return nil }
+
+/**
+ * Read a struct begin. There's nothing on the wire for this, but it is our
+ * opportunity to push a new struct begin marker onto the field stack.
+ */
+func (p *TCompactProtocol) ReadStructBegin() (name string, err TProtocolException) {
+ p.lastField.Push(p.lastFieldId)
+ p.lastFieldId = 0
+ return
+}
+
+/**
+ * Doesn't actually consume any wire data, just removes the last field for
+ * this struct from the field stack.
+ */
+func (p *TCompactProtocol) ReadStructEnd() TProtocolException {
+ // consume the last field we read off the wire.
+ p.lastFieldId = p.lastField.Pop()
+ return nil
+}
+
+/**
+ * Read a field header off the wire.
+ */
+func (p *TCompactProtocol) ReadFieldBegin() (name string, typeId TType, id int16, err TProtocolException) {
+ t, err := p.ReadByte()
+ if err != nil {
+ return
+ }
+
+ // if it's a stop, then we can return immediately, as the struct is over.
+ if (t & 0x0f) == STOP {
+ return _TSTOP.Name(), _TSTOP.TypeId(), int16(_TSTOP.Id()), nil
+ }
+
+ // mask off the 4 MSB of the type header. it could contain a field id delta.
+ modifier := int16((t & 0xf0) >> 4)
+ if modifier == 0 {
+ // not a delta. look ahead for the zigzag varint field id.
+ id, err = p.ReadI16()
+ if err != nil {
+ return
+ }
+ } else {
+ // has a delta. add the delta to the last read field id.
+ id = int16(p.lastFieldId) + modifier
+ }
+ typeId, e := p.getTType(TCompactType(t & 0x0f))
+ if e != nil {
+ err = NewTProtocolExceptionFromOsError(e)
+ return
+ }
+
+ // if this happens to be a boolean field, the value is encoded in the type
+ if p.isBoolType(t) {
+ // save the boolean value in a special instance variable.
+ p.boolValue = (byte(t)&0x0f == COMPACT_BOOLEAN_TRUE)
+ p.boolValueIsNotNull = true
+ }
+
+ // push the new field onto the field stack so we can keep the deltas going.
+ p.lastFieldId = int(id)
+ return
+}
+
+func (p *TCompactProtocol) ReadFieldEnd() TProtocolException { return nil }
+
+/**
+ * Read a map header off the wire. If the size is zero, skip reading the key
+ * and value type. This means that 0-length maps will yield TMaps without the
+ * "correct" types.
+ */
+func (p *TCompactProtocol) ReadMapBegin() (keyType TType, valueType TType, size int, err TProtocolException) {
+ size32, e := p.readVarint32()
+ size = int(size32)
+ if e != nil {
+ err = NewTProtocolExceptionFromOsError(e)
+ return
+ }
+ keyAndValueType := byte(STOP)
+ if size != 0 {
+ keyAndValueType, err = p.ReadByte()
+ if err != nil {
+ return
+ }
+ }
+ keyType, _ = p.getTType(TCompactType(keyAndValueType >> 4))
+ valueType, _ = p.getTType(TCompactType(keyAndValueType & 0xf))
+ return
+}
+
+func (p *TCompactProtocol) ReadMapEnd() TProtocolException { return nil }
+
+/**
+ * Read a list header off the wire. If the list size is 0-14, the size will
+ * be packed into the element type header. If it's a longer list, the 4 MSB
+ * of the element type header will be 0xF, and a varint will follow with the
+ * true size.
+ */
+func (p *TCompactProtocol) ReadListBegin() (elemType TType, size int, err TProtocolException) {
+ size_and_type, err := p.ReadByte()
+ if err != nil {
+ return
+ }
+ size = int((size_and_type >> 4) & 0x0f)
+ if size == 15 {
+ size2, e := p.readVarint32()
+ if e != nil {
+ err = NewTProtocolExceptionFromOsError(e)
+ return
+ }
+ size = int(size2)
+ }
+ elemType, e := p.getTType(TCompactType(size_and_type))
+ if e != nil {
+ err = NewTProtocolExceptionFromOsError(e)
+ return
+ }
+ return
+}
+
+func (p *TCompactProtocol) ReadListEnd() TProtocolException { return nil }
+
+/**
+ * Read a set header off the wire. If the set size is 0-14, the size will
+ * be packed into the element type header. If it's a longer set, the 4 MSB
+ * of the element type header will be 0xF, and a varint will follow with the
+ * true size.
+ */
+func (p *TCompactProtocol) ReadSetBegin() (elemType TType, size int, err TProtocolException) {
+ return p.ReadListBegin()
+}
+
+func (p *TCompactProtocol) ReadSetEnd() TProtocolException { return nil }
+
+/**
+ * Read a boolean off the wire. If this is a boolean field, the value should
+ * already have been read during readFieldBegin, so we'll just consume the
+ * pre-stored value. Otherwise, read a byte.
+ */
+func (p *TCompactProtocol) ReadBool() (value bool, err TProtocolException) {
+ if p.boolValueIsNotNull {
+ p.boolValueIsNotNull = false
+ return p.boolValue, nil
+ }
+ v, err := p.ReadByte()
+ return v == COMPACT_BOOLEAN_TRUE, err
+}
+
+/**
+ * Read a single byte off the wire. Nothing interesting here.
+ */
+func (p *TCompactProtocol) ReadByte() (value byte, err TProtocolException) {
+ buf := []byte{0}
+ _, e := p.trans.ReadAll(buf)
+ if e != nil {
+ return 0, NewTProtocolExceptionFromOsError(e)
+ }
+ return buf[0], nil
+}
+
+/**
+ * Read an i16 from the wire as a zigzag varint.
+ */
+func (p *TCompactProtocol) ReadI16() (value int16, err TProtocolException) {
+ v, err := p.ReadI32()
+ return int16(v), err
+}
+
+/**
+ * Read an i32 from the wire as a zigzag varint.
+ */
+func (p *TCompactProtocol) ReadI32() (value int32, err TProtocolException) {
+ v, e := p.readVarint32()
+ if e != nil {
+ return 0, NewTProtocolExceptionFromOsError(e)
+ }
+ value = p.zigzagToInt32(v)
+ return value, nil
+}
+
+/**
+ * Read an i64 from the wire as a zigzag varint.
+ */
+func (p *TCompactProtocol) ReadI64() (value int64, err TProtocolException) {
+ v, e := p.readVarint64()
+ if e != nil {
+ return 0, NewTProtocolExceptionFromOsError(e)
+ }
+ value = p.zigzagToInt64(v)
+ return value, nil
+}
+
+/**
+ * No magic here - just read a double off the wire.
+ */
+func (p *TCompactProtocol) ReadDouble() (value float64, err TProtocolException) {
+ longBits := make([]byte, 8)
+ _, e := p.trans.ReadAll(longBits)
+ if e != nil {
+ return 0.0, NewTProtocolExceptionFromOsError(e)
+ }
+ return math.Float64frombits(p.bytesToUint64(longBits)), nil
+}
+
+/**
+ * Reads a []byte (via readBinary), and then UTF-8 decodes it.
+ */
+func (p *TCompactProtocol) ReadString() (value string, err TProtocolException) {
+ v, e := p.ReadBinary()
+ return string(v), NewTProtocolExceptionFromOsError(e)
+}
+
+/**
+ * Read a []byte from the wire.
+ */
+func (p *TCompactProtocol) ReadBinary() (value []byte, err TProtocolException) {
+ length, e := p.readVarint32()
+ if e != nil {
+ return []byte{}, NewTProtocolExceptionFromOsError(e)
+ }
+ if length == 0 {
+ return []byte{}, nil
+ }
+
+ buf := make([]byte, length)
+ p.trans.ReadAll(buf)
+ return buf, nil
+}
+
+func (p *TCompactProtocol) Flush() (err TProtocolException) {
+ return NewTProtocolExceptionFromOsError(p.trans.Flush())
+}
+
+func (p *TCompactProtocol) Skip(fieldType TType) (err TProtocolException) {
+ return SkipDefaultDepth(p, fieldType)
+}
+
+func (p *TCompactProtocol) Transport() TTransport {
+ return p.trans
+}
+
+//
+// Internal writing methods
+//
+
+/**
+ * Abstract method for writing the start of lists and sets. List and sets on
+ * the wire differ only by the type indicator.
+ */
+func (p *TCompactProtocol) writeCollectionBegin(elemType TType, size int) (int, os.Error) {
+ if size <= 14 {
+ return p.writeByteDirect(byte(int32(size<<4) | int32(p.getCompactType(elemType))))
+ }
+ n, err := p.writeByteDirect(0xf0 | byte(p.getCompactType(elemType)))
+ if err != nil {
+ return n, err
+ }
+ m, err := p.writeVarint32(int32(size))
+ return n + m, err
+}
+
+/**
+ * Write an i32 as a varint. Results in 1-5 bytes on the wire.
+ * TODO(pomack): make a permanent buffer like writeVarint64?
+ */
+func (p *TCompactProtocol) writeVarint32(n int32) (int, os.Error) {
+ i32buf := make([]byte, 5)
+ idx := 0
+ for {
+ if (n & ^0x7F) == 0 {
+ i32buf[idx] = byte(n)
+ idx++
+ // p.writeByteDirect(byte(n));
+ break
+ // return;
+ } else {
+ i32buf[idx] = byte((n & 0x7F) | 0x80)
+ idx++
+ // p.writeByteDirect(byte(((n & 0x7F) | 0x80)));
+ u := uint32(n)
+ n = int32(u >> 7)
+ }
+ }
+ return p.trans.Write(i32buf[0:idx])
+}
+
+/**
+ * Write an i64 as a varint. Results in 1-10 bytes on the wire.
+ */
+func (p *TCompactProtocol) writeVarint64(n int64) (int, os.Error) {
+ varint64out := make([]byte, 10)
+ idx := 0
+ for {
+ if (n & ^0x7F) == 0 {
+ varint64out[idx] = byte(n)
+ idx++
+ break
+ } else {
+ varint64out[idx] = byte((n & 0x7F) | 0x80)
+ idx++
+ u := uint64(n)
+ n = int64(u >> 7)
+ }
+ }
+ return p.trans.Write(varint64out[0:idx])
+}
+
+/**
+ * Convert l into a zigzag long. This allows negative numbers to be
+ * represented compactly as a varint.
+ */
+func (p *TCompactProtocol) int64ToZigzag(l int64) int64 {
+ return (l << 1) ^ (l >> 63)
+}
+
+/**
+ * Convert l into a zigzag long. This allows negative numbers to be
+ * represented compactly as a varint.
+ */
+func (p *TCompactProtocol) int32ToZigzag(n int32) int32 {
+ return (n << 1) ^ (n >> 31)
+}
+
+func (p *TCompactProtocol) fixedUint64ToBytes(n uint64, buf []byte) {
+ binary.LittleEndian.PutUint64(buf, n)
+}
+
+func (p *TCompactProtocol) fixedInt64ToBytes(n int64, buf []byte) {
+ binary.LittleEndian.PutUint64(buf, uint64(n))
+}
+
+/**
+ * Writes a byte without any possiblity of all that field header nonsense.
+ * Used internally by other writing methods that know they need to write a byte.
+ */
+func (p *TCompactProtocol) writeByteDirect(b byte) (int, os.Error) {
+ return p.trans.Write([]byte{b})
+}
+
+/**
+ * Writes a byte without any possiblity of all that field header nonsense.
+ */
+func (p *TCompactProtocol) writeIntAsByteDirect(n int) (int, os.Error) {
+ return p.writeByteDirect(byte(n))
+}
+
+
+//
+// Internal reading methods
+//
+
+/**
+ * Read an i32 from the wire as a varint. The MSB of each byte is set
+ * if there is another byte to follow. This can read up to 5 bytes.
+ */
+func (p *TCompactProtocol) readVarint32() (int32, os.Error) {
+ // if the wire contains the right stuff, this will just truncate the i64 we
+ // read and get us the right sign.
+ v, err := p.readVarint64()
+ return int32(v), err
+}
+
+
+/**
+ * Read an i64 from the wire as a proper varint. The MSB of each byte is set
+ * if there is another byte to follow. This can read up to 10 bytes.
+ */
+func (p *TCompactProtocol) readVarint64() (int64, os.Error) {
+ shift := uint(0)
+ result := int64(0)
+ for {
+ b, err := p.ReadByte()
+ if err != nil {
+ return 0, err
+ }
+ result |= int64(b&0x7f) << shift
+ if (b & 0x80) != 0x80 {
+ break
+ }
+ shift += 7
+ }
+ return result, nil
+}
+
+
+//
+// encoding helpers
+//
+
+/**
+ * Convert from zigzag int to int.
+ */
+func (p *TCompactProtocol) zigzagToInt32(n int32) int32 {
+ u := uint32(n)
+ return int32(u>>1) ^ -(n & 1)
+}
+
+/**
+ * Convert from zigzag long to long.
+ */
+func (p *TCompactProtocol) zigzagToInt64(n int64) int64 {
+ u := uint64(n)
+ return int64(u>>1) ^ -(n & 1)
+}
+
+/**
+ * Note that it's important that the mask bytes are long literals,
+ * otherwise they'll default to ints, and when you shift an int left 56 bits,
+ * you just get a messed up int.
+ */
+func (p *TCompactProtocol) bytesToInt64(b []byte) int64 {
+ return int64(binary.LittleEndian.Uint64(b))
+}
+
+/**
+ * Note that it's important that the mask bytes are long literals,
+ * otherwise they'll default to ints, and when you shift an int left 56 bits,
+ * you just get a messed up int.
+ */
+func (p *TCompactProtocol) bytesToUint64(b []byte) uint64 {
+ return binary.LittleEndian.Uint64(b)
+}
+
+//
+// type testing and converting
+//
+
+func (p *TCompactProtocol) isBoolType(b byte) bool {
+ return (b&0x0f) == COMPACT_BOOLEAN_TRUE || (b&0x0f) == COMPACT_BOOLEAN_FALSE
+}
+
+/**
+ * Given a TCompactType constant, convert it to its corresponding
+ * TType value.
+ */
+func (p *TCompactProtocol) getTType(t TCompactType) (TType, os.Error) {
+ switch byte(t) & 0x0f {
+ case STOP:
+ return STOP, nil
+ case COMPACT_BOOLEAN_FALSE:
+ case COMPACT_BOOLEAN_TRUE:
+ return BOOL, nil
+ case COMPACT_BYTE:
+ return BYTE, nil
+ case COMPACT_I16:
+ return I16, nil
+ case COMPACT_I32:
+ return I32, nil
+ case COMPACT_I64:
+ return I64, nil
+ case COMPACT_DOUBLE:
+ return DOUBLE, nil
+ case COMPACT_BINARY:
+ return STRING, nil
+ case COMPACT_LIST:
+ return LIST, nil
+ case COMPACT_SET:
+ return SET, nil
+ case COMPACT_MAP:
+ return MAP, nil
+ case COMPACT_STRUCT:
+ return STRUCT, nil
+ }
+ return STOP, NewTException("don't know what type: " + string(t&0x0f))
+}
+
+/**
+ * Given a TType value, find the appropriate TCompactProtocol.Types constant.
+ */
+func (p *TCompactProtocol) getCompactType(t TType) TCompactType {
+ return _TTypeToCompactType[int(t)]
+}
56 src/thrift/tcompact_protocol_test.go
@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package thrift_test
+
+import (
+ . "thrift"
+ "testing"
+ //"bytes";
+)
+
+func TestReadWriteCompactProtocol(t *testing.T) {
+ ReadWriteProtocolTest(t, NewTCompactProtocolFactory())
+ /*
+ transports := []TTransport{
+ NewTMemoryBuffer(),
+ NewTIOStreamTransportRW(bytes.NewBuffer(make([]byte, 0, 16384))),
+ NewTFramedTransport(NewTMemoryBuffer()),
+ }
+ for _, trans := range transports {
+ p := NewTCompactProtocol(trans);
+ ReadWriteBool(t, p, trans);
+ p = NewTCompactProtocol(trans);
+ ReadWriteByte(t, p, trans);
+ p = NewTCompactProtocol(trans);
+ ReadWriteI16(t, p, trans);
+ p = NewTCompactProtocol(trans);
+ ReadWriteI32(t, p, trans);
+ p = NewTCompactProtocol(trans);
+ ReadWriteI64(t, p, trans);
+ p = NewTCompactProtocol(trans);
+ ReadWriteDouble(t, p, trans);
+ p = NewTCompactProtocol(trans);
+ ReadWriteString(t, p, trans);
+ p = NewTCompactProtocol(trans);
+ ReadWriteBinary(t, p, trans);
+ trans.Close();
+ }
+ */
+}
127 src/thrift/tcompare.go
@@ -0,0 +1,127 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+
+package thrift
+
+func CompareInt(i, j int) int {
+ if i > j {
+ return 1
+ }
+ if i < j {
+ return -1
+ }
+ return 0
+}
+
+func CompareInt16(i, j int16) int {
+ if i > j {
+ return 1
+ }
+ if i < j {
+ return -1
+ }
+ return 0
+}
+
+func CompareInt32(i, j int32) int {
+ if i > j {
+ return 1
+ }
+ if i < j {
+ return -1
+ }
+ return 0
+}
+
+func CompareInt64(i, j int32) int {
+ if i > j {
+ return 1
+ }
+ if i < j {
+ return -1
+ }
+ return 0
+}
+
+func CompareStringArray(i, j []string) int {
+ if cmp := CompareInt(len(i), len(j)); cmp != 0 {
+ return cmp
+ }
+ size := len(i)
+ for k := 0; k < size; k++ {
+ if cmp := CompareString(i[k], j[k]); cmp != 0 {
+ return cmp
+ }
+ }
+ return 0
+}
+
+func CompareString(i, j string) int {
+ if i > j {
+ return 1
+ }
+ if i < j {
+ return -1
+ }
+ return 0
+}
+
+func CompareFloat(i, j float32) int {
+ if i > j {
+ return 1
+ }
+ if i < j {
+ return -1
+ }
+ return 0
+}
+
+func CompareDouble(i, j float64) int {
+ if i > j {
+ return 1
+ }
+ if i < j {
+ return -1
+ }
+ return 0
+}
+
+func CompareByte(i, j byte) int {
+ if i > j {
+ return 1
+ }
+ if i < j {
+ return -1
+ }
+ return 0
+}
+
+func CompareBool(i, j bool) int {
+ if i {
+ if j {
+ return 0
+ }
+ return 1
+ }
+ if j {
+ return -1
+ }
+ return 0
+}
28 src/thrift/tcontainer.go
@@ -0,0 +1,28 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+
+package thrift
+
+type TContainer interface {
+ Len() int
+ Contains(data interface{}) bool
+ Equals(other interface{}) bool
+ CompareTo(other interface{}) (int, bool)
+}
56 src/thrift/texception.go
@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package thrift
+
+import (
+ "os"
+)
+
+/**
+ * Generic exception class for Thrift.
+ *
+ */
+
+type TException interface {
+ String() string
+}
+
+type tException struct {
+ message string
+}
+
+func (p *tException) String() string {
+ return p.message
+}
+
+func NewTException(m string) TException {
+ return &tException{message: m}
+}
+
+func NewTExceptionFromOsError(e os.Error) TException {
+ if e == nil {
+ return nil
+ }
+ t, ok := e.(TException)
+ if ok {
+ return t
+ }
+ return NewTException(e.String())
+}
38 src/thrift/texception_test.go
@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package thrift_test
+
+import (
+ . "thrift"
+ "os"
+ "testing"
+)
+
+
+func TestTException(t *testing.T) {
+ exc := NewTException("")
+ if exc.String() != "" {
+ t.Fatalf("Expected empty string for exception but found '%s'", exc.String())
+ }
+ exc = NewTExceptionFromOsError(os.EOF)
+ if exc.String() != os.EOF.String() {
+ t.Fatalf("Expected '%s', but found '%s'", os.EOF.String(), exc.String())
+ }
+}
281 src/thrift/tfield.go
@@ -0,0 +1,281 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package thrift
+
+import (
+ "sort"
+)
+
+/**
+ * Helper class that encapsulates field metadata.
+ *
+ */
+type TField interface {
+ Name() string
+ TypeId() TType
+ Id() int
+ String() string
+ CompareTo(other interface{}) (int, bool)
+ Equals(other interface{}) bool
+}
+
+type tField struct {
+ name string
+ typeId TType
+ id int
+}
+
+func NewTFieldDefault() TField {
+ return ANONYMOUS_FIELD
+}
+
+func NewTField(n string, t TType, i int) TField {
+ return &tField{name: n, typeId: t, id: i}
+}
+
+func (p *tField) Name() string {
+ if p == nil {
+ return ""
+ }
+ return p.name
+}
+
+func (p *tField) TypeId() TType {
+ if p == nil {
+ return TType(VOID)
+ }
+ return p.typeId
+}
+
+func (p *tField) Id() int {
+ if p == nil {
+ return -1
+ }
+ return p.id
+}
+
+func (p *tField) String() string {
+ if p == nil {
+ return "<nil>"
+ }
+ return "<TField name:'" + p.name + "' type:" + string(p.typeId) + " field-id:" + string(p.id) + ">"
+}
+
+func (p *tField) CompareTo(other interface{}) (int, bool) {
+ if other == nil {
+ return 1, true
+ }
+ if data, ok := other.(TField); ok {
+ if p.Id() != data.Id() {
+ return CompareInt(p.Id(), data.Id()), true
+ }
+ if p.TypeId() != data.TypeId() {
+ return CompareByte(byte(p.TypeId()), byte(data.TypeId())), true
+ }
+ return CompareString(p.Name(), data.Name()), true
+ }
+ return 0, false
+}
+
+func (p *tField) Equals(other interface{}) bool {
+ if p == nil {
+ return other == nil
+ }
+ if other == nil {
+ return false
+ }
+ if data, ok := other.(TField); ok {
+ return p.TypeId() == data.TypeId() && p.Id() == data.Id()
+ }
+ return false
+}
+
+var ANONYMOUS_FIELD TField
+
+type tFieldArray []TField
+
+func (p tFieldArray) Len() int {
+ return len(p)
+}
+
+func (p tFieldArray) Less(i, j int) bool {
+ return p[i].Id() < p[j].Id()
+}
+
+func (p tFieldArray) Swap(i, j int) {
+ p[i], p[j] = p[j], p[i]
+}
+
+type TFieldContainer interface {
+ TContainer
+ FieldNameFromFieldId(id int) string
+ FieldIdFromFieldName(name string) int
+ FieldFromFieldId(id int) TField
+ FieldFromFieldName(name string) TField
+ At(i int) TField
+ Iter() <-chan TField
+}
+
+type tFieldContainer struct {
+ fields []TField
+ nameToFieldMap map[string]TField
+ idToFieldMap map[int]TField
+}
+
+func NewTFieldContainer(fields []TField) TFieldContainer {
+ sortedFields := make([]TField, len(fields))
+ nameToFieldMap := make(map[string]TField)
+ idToFieldMap := make(map[int]TField)
+ for i, field := range fields {
+ sortedFields[i] = field
+ idToFieldMap[field.Id()] = field
+ if field.Name() != "" {
+ nameToFieldMap[field.Name()] = field
+ }
+ }
+ sort.Sort(tFieldArray(sortedFields))
+ return &tFieldContainer{
+ fields: fields,
+ nameToFieldMap: nameToFieldMap,
+ idToFieldMap: idToFieldMap,
+ }
+}
+
+func (p *tFieldContainer) FieldNameFromFieldId(id int) string {
+ if field, ok := p.idToFieldMap[id]; ok {
+ return field.Name()
+ }
+ return ""
+}
+
+func (p *tFieldContainer) FieldIdFromFieldName(name string) int {
+ if field, ok := p.nameToFieldMap[name]; ok {
+ return field.Id()
+ }
+ return -1
+}
+
+func (p *tFieldContainer) FieldFromFieldId(id int) TField {
+ if field, ok := p.idToFieldMap[id]; ok {
+ return field
+ }
+ return ANONYMOUS_FIELD
+}
+
+func (p *tFieldContainer) FieldFromFieldName(name string) TField {
+ if field, ok := p.nameToFieldMap[name]; ok {
+ return field
+ }
+ return ANONYMOUS_FIELD
+}
+
+func (p *tFieldContainer) Len() int {
+ return len(p.fields)
+}
+
+func (p *tFieldContainer) At(i int) TField {
+ return p.FieldFromFieldId(i)
+}
+
+func (p *tFieldContainer) Contains(data interface{}) bool {
+ if i, ok := data.(int); ok {
+ for _, field := range p.fields {
+ if field.Id() == i {
+ return true
+ }
+ }
+ } else if i, ok := data.(int16); ok {
+ for _, field := range p.fields {
+ if field.Id() == int(i) {
+ return true
+ }
+ }
+ } else if s, ok := data.(string); ok {
+ for _, field := range p.fields {
+ if field.Name() == s {
+ return true
+ }
+ }
+ } else if f, ok := data.(TField); ok {
+ for _, field := range p.fields {
+ if field.Equals(f) {
+ return true
+ }
+ }
+ }
+ return false
+}
+
+func (p *tFieldContainer) Equals(other interface{}) bool {
+ if other == nil {
+ return false
+ }
+ if data, ok := other.(TFieldContainer); ok {
+ if p.Len() != data.Len() {
+ return false
+ }
+ for _, field := range p.fields {
+ if !data.Contains(field) {
+ return false
+ }
+ }
+ return true
+ }
+ return false
+}
+
+func (p *tFieldContainer) CompareTo(other interface{}) (int, bool) {
+ if other == nil {
+ return 1, true
+ }
+ if data, ok := other.(TFieldContainer); ok {
+ cont, ok2 := data.(*tFieldContainer)
+ if ok2 && p == cont {
+ return 0, true
+ }
+ if cmp := CompareInt(p.Len(), data.Len()); cmp != 0 {
+ return cmp, true
+ }
+ for _, field := range p.fields {
+ if cmp, ok3 := field.CompareTo(data.At(field.Id())); !ok3 || cmp != 0 {
+ return cmp, ok3
+ }
+ }
+ return 0, true
+ }
+ return 0, false
+}
+
+func (p *tFieldContainer) Iter() <-chan TField {
+ c := make(chan TField)
+ go p.iterate(c)
+ return c
+}
+
+func (p *tFieldContainer) iterate(c chan<- TField) {
+ for _, v := range p.fields {
+ c <- v
+ }
+ close(c)
+}
+
+func init() {
+ ANONYMOUS_FIELD = NewTField("", STOP, 0)
+}
133 src/thrift/tframed_transport.go
@@ -0,0 +1,133 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package thrift
+
+import (
+ "encoding/binary"
+ "bytes"
+ "os"
+)
+
+
+type TFramedTransport struct {
+ transport TTransport
+ writeBuffer *bytes.Buffer
+ readBuffer *bytes.Buffer
+}
+
+type tFramedTransportFactory struct {
+ factory TTransportFactory
+}
+
+func NewTFramedTransportFactory(factory TTransportFactory) TTransportFactory {
+ return &tFramedTransportFactory{factory: factory}
+}
+
+func (p *tFramedTransportFactory) GetTransport(base TTransport) TTransport {
+ return NewTFramedTransport(p.factory.GetTransport(base))
+}
+
+func NewTFramedTransport(transport TTransport) *TFramedTransport {
+ writeBuf := make([]byte, 0, 1024)
+ readBuf := make([]byte, 0, 1024)
+ return &TFramedTransport{transport: transport, writeBuffer: bytes.NewBuffer(writeBuf), readBuffer: bytes.NewBuffer(readBuf)}
+}
+
+func (p *TFramedTransport) Open() os.Error {
+ return p.transport.Open()
+}
+
+func (p *TFramedTransport) IsOpen() bool {
+ return p.transport.IsOpen()
+}
+
+func (p *TFramedTransport) Peek() bool {
+ return p.transport.Peek()
+}
+
+func (p *TFramedTransport) Close() os.Error {
+ return p.transport.Close()
+}
+
+func (p *TFramedTransport) Read(buf []byte) (int, os.Error) {