You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@thrift.apache.org by cl...@apache.org on 2011/02/20 03:39:21 UTC
svn commit: r1072478 [6/8] - in /thrift/trunk: ./ compiler/cpp/
compiler/cpp/src/generate/ lib/ lib/go/ lib/go/thrift/ test/ tutorial/go/
tutorial/go/src/
Added: thrift/trunk/lib/go/thrift/tprotocol_test.go
URL: http://svn.apache.org/viewvc/thrift/trunk/lib/go/thrift/tprotocol_test.go?rev=1072478&view=auto
==============================================================================
--- thrift/trunk/lib/go/thrift/tprotocol_test.go (added)
+++ thrift/trunk/lib/go/thrift/tprotocol_test.go Sun Feb 20 02:39:19 2011
@@ -0,0 +1,1817 @@
+/*
+ * 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"
+ "http"
+ "math"
+ "net"
+ "io"
+ "os"
+ "bytes"
+ "fmt"
+)
+
+const PROTOCOL_BINARY_DATA_SIZE = 155
+
+var (
+ data string // test data for writing
+ protocol_bdata []byte // test data for writing; same as data
+ BOOL_VALUES []bool
+ BYTE_VALUES []byte
+ INT16_VALUES []int16
+ INT32_VALUES []int32
+ INT64_VALUES []int64
+ DOUBLE_VALUES []float64
+ STRING_VALUES []string
+)
+
+
+func init() {
+ protocol_bdata = make([]byte, PROTOCOL_BINARY_DATA_SIZE)
+ for i := 0; i < PROTOCOL_BINARY_DATA_SIZE; i++ {
+ protocol_bdata[i] = byte((i + 'a') % 255)
+ }
+ data = string(protocol_bdata)
+ BOOL_VALUES = []bool{false, true, false, false, true}
+ BYTE_VALUES = []byte{117, 0, 1, 32, 127, 128, 255}
+ INT16_VALUES = []int16{459, 0, 1, -1, -128, 127, 32767, -32768}
+ INT32_VALUES = []int32{459, 0, 1, -1, -128, 127, 32767, 2147483647, -2147483535}
+ INT64_VALUES = []int64{459, 0, 1, -1, -128, 127, 32767, 2147483647, -2147483535, 34359738481, -35184372088719, -9223372036854775808, 9223372036854775807}
+ DOUBLE_VALUES = []float64{459.3, 0.0, -1.0, 1.0, 0.5, 0.3333, 3.14159, 1.537e-38, 1.673e25, 6.02214179e23, -6.02214179e23, INFINITY.Float64(), NEGATIVE_INFINITY.Float64(), NAN.Float64()}
+ STRING_VALUES = []string{"", "a", "st[uf]f", "st,u:ff with spaces", "stuff\twith\nescape\\characters'...\"lots{of}fun</xml>"}
+}
+
+type HTTPEchoServer struct{}
+
+func (p *HTTPEchoServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+ w.WriteHeader(http.StatusOK)
+ io.Copy(w, req.Body)
+}
+
+func HttpClientSetupForTest(t *testing.T) (net.Listener, net.Addr) {
+ addr, err := FindAvailableTCPServerPort(40000)
+ if err != nil {
+ t.Fatalf("Unable to find available tcp port addr: %s", err)
+ }
+ l, err := net.Listen(addr.Network(), addr.String())
+ if err != nil {
+ t.Fatalf("Unable to setup tcp listener on %s: %s", addr.String(), err)
+ }
+ go http.Serve(l, &HTTPEchoServer{})
+ return l, addr
+}
+
+
+func ReadWriteProtocolTest(t *testing.T, protocolFactory TProtocolFactory) {
+ buf := bytes.NewBuffer(make([]byte, 0, 1024))
+ l, addr := HttpClientSetupForTest(t)
+ transports := []TTransportFactory{
+ NewTMemoryBufferTransportFactory(1024),
+ NewTIOStreamTransportFactory(buf, buf, true),
+ NewTFramedTransportFactory(NewTMemoryBufferTransportFactory(1024)),
+ NewTHttpPostClientTransportFactory("http://" + addr.String()),
+ }
+ for _, tf := range transports {
+ trans := tf.GetTransport(nil)
+ p := protocolFactory.GetProtocol(trans)
+ ReadWriteBool(t, p, trans)
+ trans.Close()
+ }
+ for _, tf := range transports {
+ trans := tf.GetTransport(nil)
+ p := protocolFactory.GetProtocol(trans)
+ ReadWriteByte(t, p, trans)
+ trans.Close()
+ }
+ for _, tf := range transports {
+ trans := tf.GetTransport(nil)
+ p := protocolFactory.GetProtocol(trans)
+ ReadWriteI16(t, p, trans)
+ trans.Close()
+ }
+ for _, tf := range transports {
+ trans := tf.GetTransport(nil)
+ p := protocolFactory.GetProtocol(trans)
+ ReadWriteI32(t, p, trans)
+ trans.Close()
+ }
+ for _, tf := range transports {
+ trans := tf.GetTransport(nil)
+ p := protocolFactory.GetProtocol(trans)
+ ReadWriteI64(t, p, trans)
+ trans.Close()
+ }
+ for _, tf := range transports {
+ trans := tf.GetTransport(nil)
+ p := protocolFactory.GetProtocol(trans)
+ ReadWriteDouble(t, p, trans)
+ trans.Close()
+ }
+ for _, tf := range transports {
+ trans := tf.GetTransport(nil)
+ p := protocolFactory.GetProtocol(trans)
+ ReadWriteString(t, p, trans)
+ trans.Close()
+ }
+ for _, tf := range transports {
+ trans := tf.GetTransport(nil)
+ p := protocolFactory.GetProtocol(trans)
+ ReadWriteBinary(t, p, trans)
+ trans.Close()
+ }
+ for _, tf := range transports {
+ trans := tf.GetTransport(nil)
+ p := protocolFactory.GetProtocol(trans)
+ ReadWriteWork(t, p, trans)
+ trans.Close()
+ }
+ for _, tf := range transports {
+ trans := tf.GetTransport(nil)
+ p := protocolFactory.GetProtocol(trans)
+ ReadWriteCalculate(t, p, trans)
+ trans.Close()
+ }
+
+ // this test doesn't work in all cases due to EOF issues between
+ // buffer read and buffer write when using the same bufio for both
+ //for _, tf := range transports {
+ // trans := tf.GetTransport(nil)
+ // p := GetProtocol(trans);
+ // ReadWriteI64(t, p, trans);
+ // ReadWriteDouble(t, p, trans);
+ // ReadWriteBinary(t, p, trans);
+ // ReadWriteByte(t, p, trans);
+ // trans.Close()
+ //}
+
+ l.Close()
+}
+
+func ReadWriteBool(t *testing.T, p TProtocol, trans TTransport) {
+ thetype := TType(BOOL)
+ thelen := len(BOOL_VALUES)
+ err := p.WriteListBegin(thetype, thelen)
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error writing list begin: %q", "ReadWriteBool", p, trans, err, thetype)
+ }
+ for k, v := range BOOL_VALUES {
+ err = p.WriteBool(v)
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error writing bool in list at index %d: %q", "ReadWriteBool", p, trans, err, k, v)
+ }
+ }
+ p.WriteListEnd()
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error writing list end: %q", "ReadWriteBool", p, trans, err, BOOL_VALUES)
+ }
+ p.Flush()
+ thetype2, thelen2, err := p.ReadListBegin()
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteBool", p, trans, err, BOOL_VALUES)
+ }
+ _, ok := p.(*TSimpleJSONProtocol)
+ if !ok {
+ if thetype != thetype2 {
+ t.Errorf("%s: %T %T type %s != type %s", "ReadWriteBool", p, trans, thetype, thetype2)
+ }
+ if thelen != thelen2 {
+ t.Errorf("%s: %T %T len %s != len %s", "ReadWriteBool", p, trans, thelen, thelen2)
+ }
+ }
+ for k, v := range BOOL_VALUES {
+ value, err := p.ReadBool()
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error reading bool at index %d: %q", "ReadWriteBool", p, trans, err, k, v)
+ }
+ if v != value {
+ t.Errorf("%s: index %d %q %q %q != %q", "ReadWriteBool", k, p, trans, v, value)
+ }
+ }
+ err = p.ReadListEnd()
+ if err != nil {
+ t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteBool", p, trans, err)
+ }
+}
+
+func ReadWriteByte(t *testing.T, p TProtocol, trans TTransport) {
+ thetype := TType(BYTE)
+ thelen := len(BYTE_VALUES)
+ err := p.WriteListBegin(thetype, thelen)
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error writing list begin: %q", "ReadWriteByte", p, trans, err, thetype)
+ }
+ for k, v := range BYTE_VALUES {
+ err = p.WriteByte(v)
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error writing byte in list at index %d: %q", "ReadWriteByte", p, trans, err, k, v)
+ }
+ }
+ err = p.WriteListEnd()
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error writing list end: %q", "ReadWriteByte", p, trans, err, BYTE_VALUES)
+ }
+ err = p.Flush()
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error flushing list of bytes: %q", "ReadWriteByte", p, trans, err, BYTE_VALUES)
+ }
+ thetype2, thelen2, err := p.ReadListBegin()
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteByte", p, trans, err, BYTE_VALUES)
+ }
+ _, ok := p.(*TSimpleJSONProtocol)
+ if !ok {
+ if thetype != thetype2 {
+ t.Errorf("%s: %T %T type %s != type %s", "ReadWriteByte", p, trans, thetype, thetype2)
+ }
+ if thelen != thelen2 {
+ t.Errorf("%s: %T %T len %s != len %s", "ReadWriteByte", p, trans, thelen, thelen2)
+ }
+ }
+ for k, v := range BYTE_VALUES {
+ value, err := p.ReadByte()
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error reading byte at index %d: %q", "ReadWriteByte", p, trans, err, k, v)
+ }
+ if v != value {
+ t.Errorf("%s: %T %T %d != %d", "ReadWriteByte", p, trans, v, value)
+ }
+ }
+ err = p.ReadListEnd()
+ if err != nil {
+ t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteByte", p, trans, err)
+ }
+}
+
+func ReadWriteI16(t *testing.T, p TProtocol, trans TTransport) {
+ thetype := TType(I16)
+ thelen := len(INT16_VALUES)
+ p.WriteListBegin(thetype, thelen)
+ for _, v := range INT16_VALUES {
+ p.WriteI16(v)
+ }
+ p.WriteListEnd()
+ p.Flush()
+ thetype2, thelen2, err := p.ReadListBegin()
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteI16", p, trans, err, INT16_VALUES)
+ }
+ _, ok := p.(*TSimpleJSONProtocol)
+ if !ok {
+ if thetype != thetype2 {
+ t.Errorf("%s: %T %T type %s != type %s", "ReadWriteI16", p, trans, thetype, thetype2)
+ }
+ if thelen != thelen2 {
+ t.Errorf("%s: %T %T len %s != len %s", "ReadWriteI16", p, trans, thelen, thelen2)
+ }
+ }
+ for k, v := range INT16_VALUES {
+ value, err := p.ReadI16()
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error reading int16 at index %d: %q", "ReadWriteI16", p, trans, err, k, v)
+ }
+ if v != value {
+ t.Errorf("%s: %T %T %d != %d", "ReadWriteI16", p, trans, v, value)
+ }
+ }
+ err = p.ReadListEnd()
+ if err != nil {
+ t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteI16", p, trans, err)
+ }
+}
+
+func ReadWriteI32(t *testing.T, p TProtocol, trans TTransport) {
+ thetype := TType(I32)
+ thelen := len(INT32_VALUES)
+ p.WriteListBegin(thetype, thelen)
+ for _, v := range INT32_VALUES {
+ p.WriteI32(v)
+ }
+ p.WriteListEnd()
+ p.Flush()
+ thetype2, thelen2, err := p.ReadListBegin()
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteI32", p, trans, err, INT32_VALUES)
+ }
+ _, ok := p.(*TSimpleJSONProtocol)
+ if !ok {
+ if thetype != thetype2 {
+ t.Errorf("%s: %T %T type %s != type %s", "ReadWriteI32", p, trans, thetype, thetype2)
+ }
+ if thelen != thelen2 {
+ t.Errorf("%s: %T %T len %s != len %s", "ReadWriteI32", p, trans, thelen, thelen2)
+ }
+ }
+ for k, v := range INT32_VALUES {
+ value, err := p.ReadI32()
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error reading int32 at index %d: %q", "ReadWriteI32", p, trans, err, k, v)
+ }
+ if v != value {
+ t.Errorf("%s: %T %T %d != %d", "ReadWriteI32", p, trans, v, value)
+ }
+ }
+ if err != nil {
+ t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteI32", p, trans, err)
+ }
+}
+
+func ReadWriteI64(t *testing.T, p TProtocol, trans TTransport) {
+ thetype := TType(I64)
+ thelen := len(INT64_VALUES)
+ p.WriteListBegin(thetype, thelen)
+ for _, v := range INT64_VALUES {
+ p.WriteI64(v)
+ }
+ p.WriteListEnd()
+ p.Flush()
+ thetype2, thelen2, err := p.ReadListBegin()
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteI64", p, trans, err, INT64_VALUES)
+ }
+ _, ok := p.(*TSimpleJSONProtocol)
+ if !ok {
+ if thetype != thetype2 {
+ t.Errorf("%s: %T %T type %s != type %s", "ReadWriteI64", p, trans, thetype, thetype2)
+ }
+ if thelen != thelen2 {
+ t.Errorf("%s: %T %T len %s != len %s", "ReadWriteI64", p, trans, thelen, thelen2)
+ }
+ }
+ for k, v := range INT64_VALUES {
+ value, err := p.ReadI64()
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error reading int64 at index %d: %q", "ReadWriteI64", p, trans, err, k, v)
+ }
+ if v != value {
+ t.Errorf("%s: %T %T %q != %q", "ReadWriteI64", p, trans, v, value)
+ }
+ }
+ if err != nil {
+ t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteI64", p, trans, err)
+ }
+}
+
+func ReadWriteDouble(t *testing.T, p TProtocol, trans TTransport) {
+ thetype := TType(DOUBLE)
+ thelen := len(DOUBLE_VALUES)
+ p.WriteListBegin(thetype, thelen)
+ for _, v := range DOUBLE_VALUES {
+ p.WriteDouble(v)
+ }
+ p.WriteListEnd()
+ p.Flush()
+ wrotebuffer := ""
+ if memtrans, ok := trans.(*TMemoryBuffer); ok {
+ wrotebuffer = memtrans.String()
+ }
+ thetype2, thelen2, err := p.ReadListBegin()
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error reading list: %q, wrote: %v", "ReadWriteDouble", p, trans, err, DOUBLE_VALUES, wrotebuffer)
+ }
+ if thetype != thetype2 {
+ t.Errorf("%s: %T %T type %s != type %s", "ReadWriteDouble", p, trans, thetype, thetype2)
+ }
+ if thelen != thelen2 {
+ t.Errorf("%s: %T %T len %s != len %s", "ReadWriteDouble", p, trans, thelen, thelen2)
+ }
+ for k, v := range DOUBLE_VALUES {
+ value, err := p.ReadDouble()
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error reading double at index %d: %q", "ReadWriteDouble", p, trans, err, k, v)
+ }
+ if math.IsNaN(v) {
+ if !math.IsNaN(value) {
+ t.Errorf("%s: %T %T math.IsNaN(%q) != math.IsNaN(%q)", "ReadWriteDouble", p, trans, v, value)
+ }
+ } else if v != value {
+ t.Errorf("%s: %T %T %v != %q", "ReadWriteDouble", p, trans, v, value)
+ }
+ }
+ err = p.ReadListEnd()
+ if err != nil {
+ t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteDouble", p, trans, err)
+ }
+}
+
+func ReadWriteString(t *testing.T, p TProtocol, trans TTransport) {
+ thetype := TType(STRING)
+ thelen := len(STRING_VALUES)
+ p.WriteListBegin(thetype, thelen)
+ for _, v := range STRING_VALUES {
+ p.WriteString(v)
+ }
+ p.WriteListEnd()
+ p.Flush()
+ thetype2, thelen2, err := p.ReadListBegin()
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteString", p, trans, err, STRING_VALUES)
+ }
+ _, ok := p.(*TSimpleJSONProtocol)
+ if !ok {
+ if thetype != thetype2 {
+ t.Errorf("%s: %T %T type %s != type %s", "ReadWriteString", p, trans, thetype, thetype2)
+ }
+ if thelen != thelen2 {
+ t.Errorf("%s: %T %T len %s != len %s", "ReadWriteString", p, trans, thelen, thelen2)
+ }
+ }
+ for k, v := range STRING_VALUES {
+ value, err := p.ReadString()
+ if err != nil {
+ t.Errorf("%s: %T %T %q Error reading string at index %d: %q", "ReadWriteString", p, trans, err, k, v)
+ }
+ if v != value {
+ t.Errorf("%s: %T %T %d != %d", "ReadWriteString", p, trans, v, value)
+ }
+ }
+ if err != nil {
+ t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteString", p, trans, err)
+ }
+}
+
+
+func ReadWriteBinary(t *testing.T, p TProtocol, trans TTransport) {
+ v := protocol_bdata
+ p.WriteBinary(v)
+ p.Flush()
+ value, err := p.ReadBinary()
+ if err != nil {
+ t.Errorf("%s: %T %T Unable to read binary: %s", "ReadWriteBinary", p, trans, err.String())
+ }
+ if len(v) != len(value) {
+ t.Errorf("%s: %T %T len(v) != len(value)... %d != %d", "ReadWriteBinary", p, trans, len(v), len(value))
+ } else {
+ for i := 0; i < len(v); i++ {
+ if v[i] != value[i] {
+ t.Errorf("%s: %T %T %s != %s", "ReadWriteBinary", p, trans, v, value)
+ }
+ }
+ }
+}
+
+
+func ReadWriteWork(t *testing.T, p TProtocol, trans TTransport) {
+ thetype := "struct"
+ orig := NewWork()
+ orig.Num1 = 25
+ orig.Num2 = 102
+ orig.Op = ADD
+ orig.Comment = "Add: 25 + 102"
+ return
+ if e := orig.Write(p); e != nil {
+ t.Fatalf("Unable to write %s value %#v due to error: %s", thetype, orig, e.String())
+ }
+ read := NewWork()
+ e := read.Read(p)
+ if e != nil {
+ t.Fatalf("Unable to read %s due to error: %s", thetype, e.String())
+ }
+ if !orig.Equals(read) {
+ t.Fatalf("Original Write != Read: %#v != %#v ", orig, read)
+ }
+}
+
+
+func ReadWriteCalculate(t *testing.T, p TProtocol, trans TTransport) {
+ messageName := "calculate"
+ logid := int32(12)
+ seqId := int32(35)
+ w := NewWork()
+ w.Num1 = 25
+ w.Num2 = 102
+ w.Op = ADD
+ w.Comment = "Add: 25 + 102"
+
+ args31 := NewCalculateArgs()
+ args31.Logid = logid
+ args31.W = w
+ p.WriteMessageBegin(messageName, CALL, seqId)
+ if err := args31.Write(p); err != nil {
+ t.Fatalf("%s: %T %T Unable to write message: %s", messageName, p, trans, err.String())
+ }
+ p.WriteMessageEnd()
+ p.Transport().Flush()
+
+ name, ttype, seqid, err1 := p.ReadMessageBegin()
+ if err1 != nil {
+ t.Fatalf("%s: %T %T Unable to read message begin: %s", messageName, p, trans, err1.String())
+ }
+ if name != messageName {
+ t.Errorf("%s: %T %T Expected message named \"%s\", but was: \"%s\"", messageName, p, trans, messageName, name)
+ }
+ if ttype != CALL {
+ t.Errorf("%s: %T %T Expected message type \"%s\", but was: \"%s\"", messageName, p, trans, CALL, ttype)
+ }
+ if seqid != seqId {
+ t.Errorf("%s: %T %T Expected message type \"%s\", but was: \"%s\"", messageName, p, trans, seqId, seqid)
+ }
+ calcArgs := NewCalculateArgs()
+ err2 := calcArgs.Read(p)
+ if !args31.Equals(calcArgs) {
+ //cmp1, _ := args31.W.CompareTo(calcArgs.W)
+ cmp2, ok := args31.CompareTo(calcArgs)
+ t.Errorf("%s: %T %T Calculate args not as expected, %T vs %T, cmp: %#v, ok: %#v, equals: %#v", messageName, p, trans, args31, calcArgs, cmp2, ok, args31.Equals(calcArgs))
+ }
+ if err2 != nil {
+ t.Fatalf("%s: %T %T Unable to read message end: %s", messageName, p, trans, err2.String())
+ }
+ err3 := p.ReadMessageEnd()
+ if err3 != nil {
+ t.Fatalf("%s: %T %T Unable to read message end: %s", messageName, p, trans, err3.String())
+ }
+}
+
+
+/**
+ *You can define enums, which are just 32 bit integers. Values are optional
+ *and start at 1 if not supplied, C style again.
+ */
+type Operation int
+
+const (
+ ADD Operation = 1
+ SUBTRACT Operation = 2
+ MULTIPLY Operation = 3
+ DIVIDE Operation = 4
+)
+
+func (p Operation) String() string {
+ switch p {
+ case ADD:
+ return "ADD"
+ case SUBTRACT:
+ return "SUBTRACT"
+ case MULTIPLY:
+ return "MULTIPLY"
+ case DIVIDE:
+ return "DIVIDE"
+ }
+ return ""
+}
+
+func FromOperationString(s string) Operation {
+ switch s {
+ case "ADD":
+ return ADD
+ case "SUBTRACT":
+ return SUBTRACT
+ case "MULTIPLY":
+ return MULTIPLY
+ case "DIVIDE":
+ return DIVIDE
+ }
+ return Operation(-10000)
+}
+
+func (p Operation) Value() int {
+ return int(p)
+}
+
+func (p Operation) IsEnum() bool {
+ return true
+}
+
+/**
+ *Thrift lets you do typedefs to get pretty names for your types. Standard
+ *C style here.
+ */
+type MyInteger int32
+
+const INT32CONSTANT = 9853
+
+var MAPCONSTANT TMap
+/**
+ * Structs are the basic complex data structures. They are comprised of fields
+ * which each have an integer identifier, a type, a symbolic name, and an
+ * optional default value.
+ *
+ * Fields can be declared "optional", which ensures they will not be included
+ * in the serialized output if they aren't set. Note that this requires some
+ * manual management in some languages.
+ *
+ * Attributes:
+ * - Num1
+ * - Num2
+ * - Op
+ * - Comment
+ */
+type Work struct {
+ TStruct
+ _ interface{} "num1" // nil # 0
+ Num1 int32 "num1" // 1
+ Num2 int32 "num2" // 2
+ Op Operation "op" // 3
+ Comment string "comment" // 4
+}
+
+func NewWork() *Work {
+ output := &Work{
+ TStruct: NewTStruct("Work", []TField{
+ NewTField("num1", I32, 1),
+ NewTField("num2", I32, 2),
+ NewTField("op", I32, 3),
+ NewTField("comment", STRING, 4),
+ }),
+ }
+ {
+ output.Num1 = 0
+ }
+ return output
+}
+
+func (p *Work) Read(iprot TProtocol) (err TProtocolException) {
+ _, err = iprot.ReadStructBegin()
+ if err != nil {
+ return NewTProtocolExceptionReadStruct(p.ThriftName(), err)
+ }
+ for {
+ fieldName, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
+ if fieldId < 0 {
+ fieldId = int16(p.FieldIdFromFieldName(fieldName))
+ } else if fieldName == "" {
+ fieldName = p.FieldNameFromFieldId(int(fieldId))
+ }
+ if fieldTypeId == GENERIC {
+ fieldTypeId = p.FieldFromFieldId(int(fieldId)).TypeId()
+ }
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ if fieldTypeId == STOP {
+ break
+ }
+ if fieldId == 1 || fieldName == "num1" {
+ if fieldTypeId == I32 {
+ err = p.ReadField1(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else if fieldTypeId == VOID {
+ err = iprot.Skip(fieldTypeId)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else {
+ err = p.ReadField1(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ }
+ } else if fieldId == 2 || fieldName == "num2" {
+ if fieldTypeId == I32 {
+ err = p.ReadField2(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else if fieldTypeId == VOID {
+ err = iprot.Skip(fieldTypeId)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else {
+ err = p.ReadField2(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ }
+ } else if fieldId == 3 || fieldName == "op" {
+ if fieldTypeId == I32 {
+ err = p.ReadField3(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else if fieldTypeId == VOID {
+ err = iprot.Skip(fieldTypeId)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else {
+ err = p.ReadField3(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ }
+ } else if fieldId == 4 || fieldName == "comment" {
+ if fieldTypeId == STRING {
+ err = p.ReadField4(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else if fieldTypeId == VOID {
+ err = iprot.Skip(fieldTypeId)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else {
+ err = p.ReadField4(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ }
+ } else {
+ err = iprot.Skip(fieldTypeId)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ }
+ err = iprot.ReadFieldEnd()
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ }
+ err = iprot.ReadStructEnd()
+ if err != nil {
+ return NewTProtocolExceptionReadStruct(p.ThriftName(), err)
+ }
+ return err
+}
+
+func (p *Work) ReadField1(iprot TProtocol) (err TProtocolException) {
+ v4, err5 := iprot.ReadI32()
+ if err5 != nil {
+ return NewTProtocolExceptionReadField(1, "num1", p.ThriftName(), err5)
+ }
+ p.Num1 = v4
+ return err
+}
+
+func (p *Work) ReadFieldNum1(iprot TProtocol) TProtocolException {
+ return p.ReadField1(iprot)
+}
+
+func (p *Work) ReadField2(iprot TProtocol) (err TProtocolException) {
+ v6, err7 := iprot.ReadI32()
+ if err7 != nil {
+ return NewTProtocolExceptionReadField(2, "num2", p.ThriftName(), err7)
+ }
+ p.Num2 = v6
+ return err
+}
+
+func (p *Work) ReadFieldNum2(iprot TProtocol) TProtocolException {
+ return p.ReadField2(iprot)
+}
+
+func (p *Work) ReadField3(iprot TProtocol) (err TProtocolException) {
+ v8, err9 := iprot.ReadI32()
+ if err9 != nil {
+ return NewTProtocolExceptionReadField(3, "op", p.ThriftName(), err9)
+ }
+ p.Op = Operation(v8)
+ return err
+}
+
+func (p *Work) ReadFieldOp(iprot TProtocol) TProtocolException {
+ return p.ReadField3(iprot)
+}
+
+func (p *Work) ReadField4(iprot TProtocol) (err TProtocolException) {
+ v10, err11 := iprot.ReadString()
+ if err11 != nil {
+ return NewTProtocolExceptionReadField(4, "comment", p.ThriftName(), err11)
+ }
+ p.Comment = v10
+ return err
+}
+
+func (p *Work) ReadFieldComment(iprot TProtocol) TProtocolException {
+ return p.ReadField4(iprot)
+}
+
+func (p *Work) Write(oprot TProtocol) (err TProtocolException) {
+ err = oprot.WriteStructBegin("Work")
+ if err != nil {
+ return NewTProtocolExceptionWriteStruct(p.ThriftName(), err)
+ }
+ err = p.WriteField1(oprot)
+ if err != nil {
+ return err
+ }
+ err = p.WriteField2(oprot)
+ if err != nil {
+ return err
+ }
+ err = p.WriteField3(oprot)
+ if err != nil {
+ return err
+ }
+ err = p.WriteField4(oprot)
+ if err != nil {
+ return err
+ }
+ err = oprot.WriteFieldStop()
+ if err != nil {
+ return NewTProtocolExceptionWriteField(-1, "STOP", p.ThriftName(), err)
+ }
+ err = oprot.WriteStructEnd()
+ if err != nil {
+ return NewTProtocolExceptionWriteStruct(p.ThriftName(), err)
+ }
+ return err
+}
+
+func (p *Work) WriteField1(oprot TProtocol) (err TProtocolException) {
+ err = oprot.WriteFieldBegin("num1", I32, 1)
+ if err != nil {
+ return NewTProtocolExceptionWriteField(1, "num1", p.ThriftName(), err)
+ }
+ err = oprot.WriteI32(int32(p.Num1))
+ if err != nil {
+ return NewTProtocolExceptionWriteField(1, "num1", p.ThriftName(), err)
+ }
+ err = oprot.WriteFieldEnd()
+ if err != nil {
+ return NewTProtocolExceptionWriteField(1, "num1", p.ThriftName(), err)
+ }
+ return err
+}
+
+func (p *Work) WriteFieldNum1(oprot TProtocol) TProtocolException {
+ return p.WriteField1(oprot)
+}
+
+func (p *Work) WriteField2(oprot TProtocol) (err TProtocolException) {
+ err = oprot.WriteFieldBegin("num2", I32, 2)
+ if err != nil {
+ return NewTProtocolExceptionWriteField(2, "num2", p.ThriftName(), err)
+ }
+ err = oprot.WriteI32(int32(p.Num2))
+ if err != nil {
+ return NewTProtocolExceptionWriteField(2, "num2", p.ThriftName(), err)
+ }
+ err = oprot.WriteFieldEnd()
+ if err != nil {
+ return NewTProtocolExceptionWriteField(2, "num2", p.ThriftName(), err)
+ }
+ return err
+}
+
+func (p *Work) WriteFieldNum2(oprot TProtocol) TProtocolException {
+ return p.WriteField2(oprot)
+}
+
+func (p *Work) WriteField3(oprot TProtocol) (err TProtocolException) {
+ err = oprot.WriteFieldBegin("op", I32, 3)
+ if err != nil {
+ return NewTProtocolExceptionWriteField(3, "op", p.ThriftName(), err)
+ }
+ err = oprot.WriteI32(int32(p.Op))
+ if err != nil {
+ return NewTProtocolExceptionWriteField(3, "op", p.ThriftName(), err)
+ }
+ err = oprot.WriteFieldEnd()
+ if err != nil {
+ return NewTProtocolExceptionWriteField(3, "op", p.ThriftName(), err)
+ }
+ return err
+}
+
+func (p *Work) WriteFieldOp(oprot TProtocol) TProtocolException {
+ return p.WriteField3(oprot)
+}
+
+func (p *Work) WriteField4(oprot TProtocol) (err TProtocolException) {
+ err = oprot.WriteFieldBegin("comment", STRING, 4)
+ if err != nil {
+ return NewTProtocolExceptionWriteField(4, "comment", p.ThriftName(), err)
+ }
+ err = oprot.WriteString(string(p.Comment))
+ if err != nil {
+ return NewTProtocolExceptionWriteField(4, "comment", p.ThriftName(), err)
+ }
+ err = oprot.WriteFieldEnd()
+ if err != nil {
+ return NewTProtocolExceptionWriteField(4, "comment", p.ThriftName(), err)
+ }
+ return err
+}
+
+func (p *Work) WriteFieldComment(oprot TProtocol) TProtocolException {
+ return p.WriteField4(oprot)
+}
+
+func (p *Work) TStructName() string {
+ return "Work"
+}
+
+func (p *Work) ThriftName() string {
+ return "Work"
+}
+
+func (p *Work) String() string {
+ if p == nil {
+ return "<nil>"
+ }
+ return fmt.Sprintf("Work(%+v)", *p)
+}
+
+func (p *Work) CompareTo(other interface{}) (int, bool) {
+ if other == nil {
+ return 1, true
+ }
+ data, ok := other.(*Work)
+ if !ok {
+ return 0, false
+ }
+ if p.Num1 != data.Num1 {
+ if p.Num1 < data.Num1 {
+ return -1, true
+ }
+ return 1, true
+ }
+ if p.Num2 != data.Num2 {
+ if p.Num2 < data.Num2 {
+ return -1, true
+ }
+ return 1, true
+ }
+ if p.Op != data.Op {
+ if p.Op < data.Op {
+ return -1, true
+ }
+ return 1, true
+ }
+ if p.Comment != data.Comment {
+ if p.Comment < data.Comment {
+ return -1, true
+ }
+ return 1, true
+ }
+ return 0, true
+}
+
+func (p *Work) AttributeByFieldId(id int) interface{} {
+ switch id {
+ default:
+ return nil
+ case 1:
+ return p.Num1
+ case 2:
+ return p.Num2
+ case 3:
+ return p.Op
+ case 4:
+ return p.Comment
+ }
+ return nil
+}
+
+func (p *Work) TStructFields() TFieldContainer {
+ return NewTFieldContainer([]TField{
+ NewTField("num1", I32, 1),
+ NewTField("num2", I32, 2),
+ NewTField("op", I32, 3),
+ NewTField("comment", STRING, 4),
+ })
+}
+
+
+type ICalculator interface {
+ /**
+ * Parameters:
+ * - Key
+ */
+ Calculate(logid int32, w *Work) (retval30 int32, ouch *InvalidOperation, err os.Error)
+}
+
+type CalculatorClient struct {
+ Transport TTransport
+ ProtocolFactory TProtocolFactory
+ InputProtocol TProtocol
+ OutputProtocol TProtocol
+ SeqId int32
+}
+
+func NewCalculatorClientFactory(t TTransport, f TProtocolFactory) *CalculatorClient {
+ return &CalculatorClient{Transport: t,
+ ProtocolFactory: f,
+ InputProtocol: f.GetProtocol(t),
+ OutputProtocol: f.GetProtocol(t),
+ SeqId: 0,
+ }
+}
+
+func NewCalculatorClientProtocol(t TTransport, iprot TProtocol, oprot TProtocol) *CalculatorClient {
+ return &CalculatorClient{Transport: t,
+ ProtocolFactory: nil,
+ InputProtocol: iprot,
+ OutputProtocol: oprot,
+ SeqId: 0,
+ }
+}
+
+
+/**
+ * Parameters:
+ * - Logid
+ * - W
+ */
+func (p *CalculatorClient) Calculate(logid int32, w *Work) (retval30 int32, ouch *InvalidOperation, err os.Error) {
+ err = p.SendCalculate(logid, w)
+ if err != nil {
+ return
+ }
+ return p.RecvCalculate()
+}
+
+func (p *CalculatorClient) SendCalculate(logid int32, w *Work) (err os.Error) {
+ oprot := p.OutputProtocol
+ if oprot != nil {
+ oprot = p.ProtocolFactory.GetProtocol(p.Transport)
+ p.OutputProtocol = oprot
+ }
+ oprot.WriteMessageBegin("calculate", CALL, p.SeqId)
+ args31 := NewCalculateArgs()
+ args31.Logid = logid
+ args31.W = w
+ err = args31.Write(oprot)
+ oprot.WriteMessageEnd()
+ oprot.Transport().Flush()
+ return
+}
+
+
+func (p *CalculatorClient) RecvCalculate() (value int32, ouch *InvalidOperation, err os.Error) {
+ iprot := p.InputProtocol
+ if iprot == nil {
+ iprot = p.ProtocolFactory.GetProtocol(p.Transport)
+ p.InputProtocol = iprot
+ }
+ _, mTypeId, _, err := iprot.ReadMessageBegin()
+ if err != nil {
+ return
+ }
+ if mTypeId == EXCEPTION {
+ error33 := NewTApplicationExceptionDefault()
+ error34, err := error33.Read(iprot)
+ if err != nil {
+ return
+ }
+ if err = iprot.ReadMessageEnd(); err != nil {
+ return
+ }
+ err = error34
+ return
+ }
+ result32 := NewCalculateResult()
+ err = result32.Read(iprot)
+ iprot.ReadMessageEnd()
+ value = result32.Success
+ if result32.Ouch != nil {
+ ouch = result32.Ouch
+ }
+ return
+}
+
+
+/**
+ * Attributes:
+ * - Logid
+ * - W
+ */
+type CalculateArgs struct {
+ TStruct
+ _ interface{} "logid" // nil # 0
+ Logid int32 "logid" // 1
+ W *Work "w" // 2
+}
+
+func NewCalculateArgs() *CalculateArgs {
+ output := &CalculateArgs{
+ TStruct: NewTStruct("calculate_args", []TField{
+ NewTField("logid", I32, 1),
+ NewTField("w", STRUCT, 2),
+ }),
+ }
+ {
+ }
+ return output
+}
+
+func (p *CalculateArgs) Read(iprot TProtocol) (err TProtocolException) {
+ _, err = iprot.ReadStructBegin()
+ if err != nil {
+ return NewTProtocolExceptionReadStruct(p.ThriftName(), err)
+ }
+ for {
+ fieldName, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
+ if fieldId < 0 {
+ fieldId = int16(p.FieldIdFromFieldName(fieldName))
+ } else if fieldName == "" {
+ fieldName = p.FieldNameFromFieldId(int(fieldId))
+ }
+ if fieldTypeId == GENERIC {
+ fieldTypeId = p.FieldFromFieldId(int(fieldId)).TypeId()
+ }
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ if fieldTypeId == STOP {
+ break
+ }
+ if fieldId == 1 || fieldName == "logid" {
+ if fieldTypeId == I32 {
+ err = p.ReadField1(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else if fieldTypeId == VOID {
+ err = iprot.Skip(fieldTypeId)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else {
+ err = p.ReadField1(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ }
+ } else if fieldId == 2 || fieldName == "w" {
+ if fieldTypeId == STRUCT {
+ err = p.ReadField2(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else if fieldTypeId == VOID {
+ err = iprot.Skip(fieldTypeId)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else {
+ err = p.ReadField2(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ }
+ } else {
+ err = iprot.Skip(fieldTypeId)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ }
+ err = iprot.ReadFieldEnd()
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ }
+ err = iprot.ReadStructEnd()
+ if err != nil {
+ return NewTProtocolExceptionReadStruct(p.ThriftName(), err)
+ }
+ return err
+}
+
+func (p *CalculateArgs) ReadField1(iprot TProtocol) (err TProtocolException) {
+ v47, err48 := iprot.ReadI32()
+ if err48 != nil {
+ return NewTProtocolExceptionReadField(1, "logid", p.ThriftName(), err48)
+ }
+ p.Logid = v47
+ return err
+}
+
+func (p *CalculateArgs) ReadFieldLogid(iprot TProtocol) TProtocolException {
+ return p.ReadField1(iprot)
+}
+
+func (p *CalculateArgs) ReadField2(iprot TProtocol) (err TProtocolException) {
+ p.W = NewWork()
+ err51 := p.W.Read(iprot)
+ if err51 != nil {
+ return NewTProtocolExceptionReadStruct("p.WWork", err51)
+ }
+ return err
+}
+
+func (p *CalculateArgs) ReadFieldW(iprot TProtocol) TProtocolException {
+ return p.ReadField2(iprot)
+}
+
+func (p *CalculateArgs) Write(oprot TProtocol) (err TProtocolException) {
+ err = oprot.WriteStructBegin("calculate_args")
+ if err != nil {
+ return NewTProtocolExceptionWriteStruct(p.ThriftName(), err)
+ }
+ err = p.WriteField1(oprot)
+ if err != nil {
+ return err
+ }
+ err = p.WriteField2(oprot)
+ if err != nil {
+ return err
+ }
+ err = oprot.WriteFieldStop()
+ if err != nil {
+ return NewTProtocolExceptionWriteField(-1, "STOP", p.ThriftName(), err)
+ }
+ err = oprot.WriteStructEnd()
+ if err != nil {
+ return NewTProtocolExceptionWriteStruct(p.ThriftName(), err)
+ }
+ return err
+}
+
+func (p *CalculateArgs) WriteField1(oprot TProtocol) (err TProtocolException) {
+ err = oprot.WriteFieldBegin("logid", I32, 1)
+ if err != nil {
+ return NewTProtocolExceptionWriteField(1, "logid", p.ThriftName(), err)
+ }
+ err = oprot.WriteI32(int32(p.Logid))
+ if err != nil {
+ return NewTProtocolExceptionWriteField(1, "logid", p.ThriftName(), err)
+ }
+ err = oprot.WriteFieldEnd()
+ if err != nil {
+ return NewTProtocolExceptionWriteField(1, "logid", p.ThriftName(), err)
+ }
+ return err
+}
+
+func (p *CalculateArgs) WriteFieldLogid(oprot TProtocol) TProtocolException {
+ return p.WriteField1(oprot)
+}
+
+func (p *CalculateArgs) WriteField2(oprot TProtocol) (err TProtocolException) {
+ if p.W != nil {
+ err = oprot.WriteFieldBegin("w", STRUCT, 2)
+ if err != nil {
+ return NewTProtocolExceptionWriteField(2, "w", p.ThriftName(), err)
+ }
+ err = p.W.Write(oprot)
+ if err != nil {
+ return NewTProtocolExceptionWriteStruct("Work", err)
+ }
+ err = oprot.WriteFieldEnd()
+ if err != nil {
+ return NewTProtocolExceptionWriteField(2, "w", p.ThriftName(), err)
+ }
+ }
+ return err
+}
+
+func (p *CalculateArgs) WriteFieldW(oprot TProtocol) TProtocolException {
+ return p.WriteField2(oprot)
+}
+
+func (p *CalculateArgs) TStructName() string {
+ return "CalculateArgs"
+}
+
+func (p *CalculateArgs) ThriftName() string {
+ return "calculate_args"
+}
+
+func (p *CalculateArgs) String() string {
+ if p == nil {
+ return "<nil>"
+ }
+ return fmt.Sprintf("CalculateArgs(%+v)", *p)
+}
+
+func (p *CalculateArgs) CompareTo(other interface{}) (int, bool) {
+ if other == nil {
+ return 1, true
+ }
+ data, ok := other.(*CalculateArgs)
+ if !ok {
+ return 0, false
+ }
+ if p.Logid != data.Logid {
+ if p.Logid < data.Logid {
+ return -1, true
+ }
+ return 1, true
+ }
+ if cmp, ok := p.W.CompareTo(data.W); !ok || cmp != 0 {
+ return cmp, ok
+ }
+ return 0, true
+}
+
+func (p *CalculateArgs) AttributeByFieldId(id int) interface{} {
+ switch id {
+ default:
+ return nil
+ case 1:
+ return p.Logid
+ case 2:
+ return p.W
+ }
+ return nil
+}
+
+func (p *CalculateArgs) TStructFields() TFieldContainer {
+ return NewTFieldContainer([]TField{
+ NewTField("logid", I32, 1),
+ NewTField("w", STRUCT, 2),
+ })
+}
+
+/**
+ * Attributes:
+ * - Success
+ * - Ouch
+ */
+type CalculateResult struct {
+ TStruct
+ Success int32 "success" // 0
+ Ouch *InvalidOperation "ouch" // 1
+}
+
+func NewCalculateResult() *CalculateResult {
+ output := &CalculateResult{
+ TStruct: NewTStruct("calculate_result", []TField{
+ NewTField("success", I32, 0),
+ NewTField("ouch", STRUCT, 1),
+ }),
+ }
+ {
+ }
+ return output
+}
+
+func (p *CalculateResult) Read(iprot TProtocol) (err TProtocolException) {
+ _, err = iprot.ReadStructBegin()
+ if err != nil {
+ return NewTProtocolExceptionReadStruct(p.ThriftName(), err)
+ }
+ for {
+ fieldName, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
+ if fieldId < 0 {
+ fieldId = int16(p.FieldIdFromFieldName(fieldName))
+ } else if fieldName == "" {
+ fieldName = p.FieldNameFromFieldId(int(fieldId))
+ }
+ if fieldTypeId == GENERIC {
+ fieldTypeId = p.FieldFromFieldId(int(fieldId)).TypeId()
+ }
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ if fieldTypeId == STOP {
+ break
+ }
+ if fieldId == 0 || fieldName == "success" {
+ if fieldTypeId == I32 {
+ err = p.ReadField0(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else if fieldTypeId == VOID {
+ err = iprot.Skip(fieldTypeId)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else {
+ err = p.ReadField0(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ }
+ } else if fieldId == 1 || fieldName == "ouch" {
+ if fieldTypeId == STRUCT {
+ err = p.ReadField1(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else if fieldTypeId == VOID {
+ err = iprot.Skip(fieldTypeId)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else {
+ err = p.ReadField1(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ }
+ } else {
+ err = iprot.Skip(fieldTypeId)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ }
+ err = iprot.ReadFieldEnd()
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ }
+ err = iprot.ReadStructEnd()
+ if err != nil {
+ return NewTProtocolExceptionReadStruct(p.ThriftName(), err)
+ }
+ return err
+}
+
+func (p *CalculateResult) ReadField0(iprot TProtocol) (err TProtocolException) {
+ v52, err53 := iprot.ReadI32()
+ if err53 != nil {
+ return NewTProtocolExceptionReadField(0, "success", p.ThriftName(), err53)
+ }
+ p.Success = v52
+ return err
+}
+
+func (p *CalculateResult) ReadFieldSuccess(iprot TProtocol) TProtocolException {
+ return p.ReadField0(iprot)
+}
+
+func (p *CalculateResult) ReadField1(iprot TProtocol) (err TProtocolException) {
+ p.Ouch = NewInvalidOperation()
+ err56 := p.Ouch.Read(iprot)
+ if err56 != nil {
+ return NewTProtocolExceptionReadStruct("p.OuchInvalidOperation", err56)
+ }
+ return err
+}
+
+func (p *CalculateResult) ReadFieldOuch(iprot TProtocol) TProtocolException {
+ return p.ReadField1(iprot)
+}
+
+func (p *CalculateResult) Write(oprot TProtocol) (err TProtocolException) {
+ err = oprot.WriteStructBegin("calculate_result")
+ if err != nil {
+ return NewTProtocolExceptionWriteStruct(p.ThriftName(), err)
+ }
+ err = p.WriteField0(oprot)
+ if err != nil {
+ return err
+ }
+ err = p.WriteField1(oprot)
+ if err != nil {
+ return err
+ }
+ err = oprot.WriteFieldStop()
+ if err != nil {
+ return NewTProtocolExceptionWriteField(-1, "STOP", p.ThriftName(), err)
+ }
+ err = oprot.WriteStructEnd()
+ if err != nil {
+ return NewTProtocolExceptionWriteStruct(p.ThriftName(), err)
+ }
+ return err
+}
+
+func (p *CalculateResult) WriteField0(oprot TProtocol) (err TProtocolException) {
+ err = oprot.WriteFieldBegin("success", I32, 0)
+ if err != nil {
+ return NewTProtocolExceptionWriteField(0, "success", p.ThriftName(), err)
+ }
+ err = oprot.WriteI32(int32(p.Success))
+ if err != nil {
+ return NewTProtocolExceptionWriteField(0, "success", p.ThriftName(), err)
+ }
+ err = oprot.WriteFieldEnd()
+ if err != nil {
+ return NewTProtocolExceptionWriteField(0, "success", p.ThriftName(), err)
+ }
+ return err
+}
+
+func (p *CalculateResult) WriteFieldSuccess(oprot TProtocol) TProtocolException {
+ return p.WriteField0(oprot)
+}
+
+func (p *CalculateResult) WriteField1(oprot TProtocol) (err TProtocolException) {
+ if p.Ouch != nil {
+ err = oprot.WriteFieldBegin("ouch", STRUCT, 1)
+ if err != nil {
+ return NewTProtocolExceptionWriteField(1, "ouch", p.ThriftName(), err)
+ }
+ err = p.Ouch.Write(oprot)
+ if err != nil {
+ return NewTProtocolExceptionWriteStruct("InvalidOperation", err)
+ }
+ err = oprot.WriteFieldEnd()
+ if err != nil {
+ return NewTProtocolExceptionWriteField(1, "ouch", p.ThriftName(), err)
+ }
+ }
+ return err
+}
+
+func (p *CalculateResult) WriteFieldOuch(oprot TProtocol) TProtocolException {
+ return p.WriteField1(oprot)
+}
+
+func (p *CalculateResult) TStructName() string {
+ return "CalculateResult"
+}
+
+func (p *CalculateResult) ThriftName() string {
+ return "calculate_result"
+}
+
+func (p *CalculateResult) String() string {
+ if p == nil {
+ return "<nil>"
+ }
+ return fmt.Sprintf("CalculateResult(%+v)", *p)
+}
+
+func (p *CalculateResult) CompareTo(other interface{}) (int, bool) {
+ if other == nil {
+ return 1, true
+ }
+ data, ok := other.(*CalculateResult)
+ if !ok {
+ return 0, false
+ }
+ if p.Success != data.Success {
+ if p.Success < data.Success {
+ return -1, true
+ }
+ return 1, true
+ }
+ if cmp, ok := p.Ouch.CompareTo(data.Ouch); !ok || cmp != 0 {
+ return cmp, ok
+ }
+ return 0, true
+}
+
+func (p *CalculateResult) AttributeByFieldId(id int) interface{} {
+ switch id {
+ default:
+ return nil
+ case 0:
+ return p.Success
+ case 1:
+ return p.Ouch
+ }
+ return nil
+}
+
+func (p *CalculateResult) TStructFields() TFieldContainer {
+ return NewTFieldContainer([]TField{
+ NewTField("success", I32, 0),
+ NewTField("ouch", STRUCT, 1),
+ })
+}
+
+
+/**
+ * Structs can also be exceptions, if they are nasty.
+ *
+ * Attributes:
+ * - What
+ * - Why
+ */
+type InvalidOperation struct {
+ TStruct
+ _ interface{} "what" // nil # 0
+ What int32 "what" // 1
+ Why string "why" // 2
+}
+
+func NewInvalidOperation() *InvalidOperation {
+ output := &InvalidOperation{
+ TStruct: NewTStruct("InvalidOperation", []TField{
+ NewTField("what", I32, 1),
+ NewTField("why", STRING, 2),
+ }),
+ }
+ {
+ }
+ return output
+}
+
+func (p *InvalidOperation) Read(iprot TProtocol) (err TProtocolException) {
+ _, err = iprot.ReadStructBegin()
+ if err != nil {
+ return NewTProtocolExceptionReadStruct(p.ThriftName(), err)
+ }
+ for {
+ fieldName, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
+ if fieldId < 0 {
+ fieldId = int16(p.FieldIdFromFieldName(fieldName))
+ } else if fieldName == "" {
+ fieldName = p.FieldNameFromFieldId(int(fieldId))
+ }
+ if fieldTypeId == GENERIC {
+ fieldTypeId = p.FieldFromFieldId(int(fieldId)).TypeId()
+ }
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ if fieldTypeId == STOP {
+ break
+ }
+ if fieldId == 1 || fieldName == "what" {
+ if fieldTypeId == I32 {
+ err = p.ReadField1(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else if fieldTypeId == VOID {
+ err = iprot.Skip(fieldTypeId)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else {
+ err = p.ReadField1(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ }
+ } else if fieldId == 2 || fieldName == "why" {
+ if fieldTypeId == STRING {
+ err = p.ReadField2(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else if fieldTypeId == VOID {
+ err = iprot.Skip(fieldTypeId)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ } else {
+ err = p.ReadField2(iprot)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ }
+ } else {
+ err = iprot.Skip(fieldTypeId)
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ }
+ err = iprot.ReadFieldEnd()
+ if err != nil {
+ return NewTProtocolExceptionReadField(int(fieldId), fieldName, p.ThriftName(), err)
+ }
+ }
+ err = iprot.ReadStructEnd()
+ if err != nil {
+ return NewTProtocolExceptionReadStruct(p.ThriftName(), err)
+ }
+ return err
+}
+
+func (p *InvalidOperation) ReadField1(iprot TProtocol) (err TProtocolException) {
+ v12, err13 := iprot.ReadI32()
+ if err13 != nil {
+ return NewTProtocolExceptionReadField(1, "what", p.ThriftName(), err13)
+ }
+ p.What = v12
+ return err
+}
+
+func (p *InvalidOperation) ReadFieldWhat(iprot TProtocol) TProtocolException {
+ return p.ReadField1(iprot)
+}
+
+func (p *InvalidOperation) ReadField2(iprot TProtocol) (err TProtocolException) {
+ v14, err15 := iprot.ReadString()
+ if err15 != nil {
+ return NewTProtocolExceptionReadField(2, "why", p.ThriftName(), err15)
+ }
+ p.Why = v14
+ return err
+}
+
+func (p *InvalidOperation) ReadFieldWhy(iprot TProtocol) TProtocolException {
+ return p.ReadField2(iprot)
+}
+
+func (p *InvalidOperation) Write(oprot TProtocol) (err TProtocolException) {
+ err = oprot.WriteStructBegin("InvalidOperation")
+ if err != nil {
+ return NewTProtocolExceptionWriteStruct(p.ThriftName(), err)
+ }
+ err = p.WriteField1(oprot)
+ if err != nil {
+ return err
+ }
+ err = p.WriteField2(oprot)
+ if err != nil {
+ return err
+ }
+ err = oprot.WriteFieldStop()
+ if err != nil {
+ return NewTProtocolExceptionWriteField(-1, "STOP", p.ThriftName(), err)
+ }
+ err = oprot.WriteStructEnd()
+ if err != nil {
+ return NewTProtocolExceptionWriteStruct(p.ThriftName(), err)
+ }
+ return err
+}
+
+func (p *InvalidOperation) WriteField1(oprot TProtocol) (err TProtocolException) {
+ err = oprot.WriteFieldBegin("what", I32, 1)
+ if err != nil {
+ return NewTProtocolExceptionWriteField(1, "what", p.ThriftName(), err)
+ }
+ err = oprot.WriteI32(int32(p.What))
+ if err != nil {
+ return NewTProtocolExceptionWriteField(1, "what", p.ThriftName(), err)
+ }
+ err = oprot.WriteFieldEnd()
+ if err != nil {
+ return NewTProtocolExceptionWriteField(1, "what", p.ThriftName(), err)
+ }
+ return err
+}
+
+func (p *InvalidOperation) WriteFieldWhat(oprot TProtocol) TProtocolException {
+ return p.WriteField1(oprot)
+}
+
+func (p *InvalidOperation) WriteField2(oprot TProtocol) (err TProtocolException) {
+ err = oprot.WriteFieldBegin("why", STRING, 2)
+ if err != nil {
+ return NewTProtocolExceptionWriteField(2, "why", p.ThriftName(), err)
+ }
+ err = oprot.WriteString(string(p.Why))
+ if err != nil {
+ return NewTProtocolExceptionWriteField(2, "why", p.ThriftName(), err)
+ }
+ err = oprot.WriteFieldEnd()
+ if err != nil {
+ return NewTProtocolExceptionWriteField(2, "why", p.ThriftName(), err)
+ }
+ return err
+}
+
+func (p *InvalidOperation) WriteFieldWhy(oprot TProtocol) TProtocolException {
+ return p.WriteField2(oprot)
+}
+
+func (p *InvalidOperation) TStructName() string {
+ return "InvalidOperation"
+}
+
+func (p *InvalidOperation) ThriftName() string {
+ return "InvalidOperation"
+}
+
+func (p *InvalidOperation) String() string {
+ if p == nil {
+ return "<nil>"
+ }
+ return fmt.Sprintf("InvalidOperation(%+v)", *p)
+}
+
+func (p *InvalidOperation) CompareTo(other interface{}) (int, bool) {
+ if other == nil {
+ return 1, true
+ }
+ data, ok := other.(*InvalidOperation)
+ if !ok {
+ return 0, false
+ }
+ if p.What != data.What {
+ if p.What < data.What {
+ return -1, true
+ }
+ return 1, true
+ }
+ if p.Why != data.Why {
+ if p.Why < data.Why {
+ return -1, true
+ }
+ return 1, true
+ }
+ return 0, true
+}
+
+func (p *InvalidOperation) AttributeByFieldId(id int) interface{} {
+ switch id {
+ default:
+ return nil
+ case 1:
+ return p.What
+ case 2:
+ return p.Why
+ }
+ return nil
+}
+
+func (p *InvalidOperation) TStructFields() TFieldContainer {
+ return NewTFieldContainer([]TField{
+ NewTField("what", I32, 1),
+ NewTField("why", STRING, 2),
+ })
+}
Added: thrift/trunk/lib/go/thrift/tserver.go
URL: http://svn.apache.org/viewvc/thrift/trunk/lib/go/thrift/tserver.go?rev=1072478&view=auto
==============================================================================
--- thrift/trunk/lib/go/thrift/tserver.go (added)
+++ thrift/trunk/lib/go/thrift/tserver.go Sun Feb 20 02:39:19 2011
@@ -0,0 +1,61 @@
+/*
+ * 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"
+)
+
+type TServer interface {
+ /**
+ * Core processor
+ */
+ ProcessorFactory() TProcessorFactory
+ /**
+ * Server transport
+ */
+ ServerTransport() TServerTransport
+ /**
+ * Input Transport Factory
+ */
+ InputTransportFactory() TTransportFactory
+ /**
+ * Output Transport Factory
+ */
+ OutputTransportFactory() TTransportFactory
+ /**
+ * Input Protocol Factory
+ */
+ InputProtocolFactory() TProtocolFactory
+ /**
+ * Output Protocol Factory
+ */
+ OutputProtocolFactory() TProtocolFactory
+
+ /**
+ * The run method fires up the server and gets things going.
+ */
+ Serve() os.Error
+ /**
+ * Stop the server. This is optional on a per-implementation basis. Not
+ * all servers are required to be cleanly stoppable.
+ */
+ Stop() os.Error
+}
Added: thrift/trunk/lib/go/thrift/tserver_socket.go
URL: http://svn.apache.org/viewvc/thrift/trunk/lib/go/thrift/tserver_socket.go?rev=1072478&view=auto
==============================================================================
--- thrift/trunk/lib/go/thrift/tserver_socket.go (added)
+++ thrift/trunk/lib/go/thrift/tserver_socket.go Sun Feb 20 02:39:19 2011
@@ -0,0 +1,194 @@
+/*
+ * 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 (
+ "net"
+ "os"
+)
+
+
+type TServerSocket struct {
+ /**
+ * Underlying socket conection object
+ */
+ conn net.Conn
+ /**
+ * Underlying socket conection object
+ */
+ listener net.Listener
+
+ /**
+ * Address to listen on
+ */
+ addr net.Addr
+
+ /**
+ * Client timeout in nanoseconds
+ */
+ nsecClientTimeout int64
+}
+
+type TServerSocketTransportFactory struct {
+ addr net.Addr
+ nsecClientTimeout int64
+}
+
+func (p *TServerSocketTransportFactory) GetTransport(trans TTransport) TTransport {
+ if trans != nil {
+ t, ok := trans.(*TServerSocket)
+ if ok && t.addr != nil {
+ s, _ := NewTServerSocketAddrTimeout(t.addr, t.nsecClientTimeout)
+ return s
+ }
+ }
+ s, _ := NewTServerSocketAddrTimeout(p.addr, p.nsecClientTimeout)
+ return s
+}
+
+func NewTServerSocketTransportFactory(addr net.Addr, nsecClientTimeout int64) *TServerSocketTransportFactory {
+ return &TServerSocketTransportFactory{addr: addr, nsecClientTimeout: nsecClientTimeout}
+}
+
+func NewTServerSocketConn(conn net.Conn) *TServerSocket {
+ return NewTServerSocketConnTimeout(conn, 0)
+}
+
+func NewTServerSocketConnTimeout(conn net.Conn, nsecClientTimeout int64) *TServerSocket {
+ v := &TServerSocket{conn: conn, addr: conn.LocalAddr(), nsecClientTimeout: nsecClientTimeout}
+ conn.SetTimeout(nsecClientTimeout)
+ return v
+}
+
+func NewTServerSocketAddr(addr net.Addr) (*TServerSocket, TTransportException) {
+ return NewTServerSocketAddrTimeout(addr, 0)
+}
+
+func NewTServerSocketAddrTimeout(addr net.Addr, nsecClientTimeout int64) (*TServerSocket, TTransportException) {
+ s := &TServerSocket{addr: addr, nsecClientTimeout: nsecClientTimeout}
+ return s, nil
+}
+
+func (p *TServerSocket) Listen() (err os.Error) {
+ if p.listener == nil {
+ if p.listener, err = net.Listen("tcp", p.addr.String()); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func (p *TServerSocket) Accept() (TTransport, os.Error) {
+ if p.listener == nil {
+ if err := p.Listen(); err != nil {
+ return nil, NewTTransportExceptionFromOsError(err)
+ }
+ if p.listener == nil {
+ return nil, NewTTransportException(NOT_OPEN, "No underlying server socket")
+ }
+ }
+ conn, err := p.listener.Accept()
+ if err != nil {
+ return nil, NewTTransportExceptionFromOsError(err)
+ }
+ conn.SetTimeout(p.nsecClientTimeout)
+ return NewTSocketConn(conn)
+}
+
+/**
+ * Checks whether the socket is connected.
+ */
+func (p *TServerSocket) IsOpen() bool {
+ return p.listener != nil
+}
+
+/**
+ * Connects the socket, creating a new socket object if necessary.
+ */
+func (p *TServerSocket) Open() os.Error {
+ if !p.IsOpen() {
+ l, err := net.Listen(p.addr.Network(), p.addr.String())
+ if err != nil {
+ return err
+ }
+ p.listener = l
+ return nil
+ }
+ return NewTTransportException(ALREADY_OPEN, "Server socket already open")
+}
+
+/**
+ * Perform a nonblocking read into buffer.
+ */
+func (p *TServerSocket) Read(buf []byte) (int, os.Error) {
+ return 0, NewTTransportException(UNKNOWN_TRANSPORT_EXCEPTION, "TServerSocket.Read([]byte) is not implemented")
+}
+
+func (p *TServerSocket) ReadAll(buf []byte) (int, os.Error) {
+ return ReadAllTransport(p, buf)
+}
+
+/**
+ * Perform a nonblocking write of the data in buffer;
+ */
+func (p *TServerSocket) Write(buf []byte) (int, os.Error) {
+ return 0, NewTTransportException(UNKNOWN_TRANSPORT_EXCEPTION, "TServerSocket.Write([]byte) is not implemented")
+}
+
+/**
+ * Flushes the underlying output stream if not null.
+ */
+func (p *TServerSocket) Flush() os.Error {
+ return NewTTransportException(UNKNOWN_TRANSPORT_EXCEPTION, "TServerSocket.Flush() is not implemented")
+}
+
+func (p *TServerSocket) Addr() net.Addr {
+ return p.addr
+}
+
+func (p *TServerSocket) Peek() bool {
+ return p.IsOpen()
+}
+
+/**
+ * Closes the socket.
+ */
+func (p *TServerSocket) Close() (err os.Error) {
+ if p.IsOpen() {
+ err := p.listener.Close()
+ if err != nil {
+ return NewTTransportExceptionFromOsError(err)
+ }
+ p.listener = nil
+ }
+ if p.conn != nil {
+ err := p.conn.Close()
+ if err != nil {
+ return NewTTransportExceptionFromOsError(err)
+ }
+ p.conn = nil
+ }
+ return nil
+}
+
+func (p *TServerSocket) Interrupt() os.Error {
+ // TODO(pomack) fix Interrupt as it is probably not right
+ return NewTTransportExceptionFromOsError(p.Close())
+}
Added: thrift/trunk/lib/go/thrift/tserver_test.go
URL: http://svn.apache.org/viewvc/thrift/trunk/lib/go/thrift/tserver_test.go?rev=1072478&view=auto
==============================================================================
--- thrift/trunk/lib/go/thrift/tserver_test.go (added)
+++ thrift/trunk/lib/go/thrift/tserver_test.go Sun Feb 20 02:39:19 2011
@@ -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_test
+
+import (
+ "testing"
+)
+
+func TestNothing(t *testing.T) {
+
+}
Added: thrift/trunk/lib/go/thrift/tserver_transport.go
URL: http://svn.apache.org/viewvc/thrift/trunk/lib/go/thrift/tserver_transport.go?rev=1072478&view=auto
==============================================================================
--- thrift/trunk/lib/go/thrift/tserver_transport.go (added)
+++ thrift/trunk/lib/go/thrift/tserver_transport.go Sun Feb 20 02:39:19 2011
@@ -0,0 +1,41 @@
+/*
+ * 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"
+
+/**
+ * Server transport. Object which provides client transports.
+ *
+ */
+type TServerTransport interface {
+ Listen() os.Error
+ Accept() (TTransport, os.Error)
+ Close() os.Error
+
+ /**
+ * Optional method implementation. This signals to the server transport
+ * that it should break out of any accept() or listen() that it is currently
+ * blocked on. This method, if implemented, MUST be thread safe, as it may
+ * be called from a different thread context than the other TServerTransport
+ * methods.
+ */
+ Interrupt() os.Error
+}
Added: thrift/trunk/lib/go/thrift/tset.go
URL: http://svn.apache.org/viewvc/thrift/trunk/lib/go/thrift/tset.go?rev=1072478&view=auto
==============================================================================
--- thrift/trunk/lib/go/thrift/tset.go (added)
+++ thrift/trunk/lib/go/thrift/tset.go Sun Feb 20 02:39:19 2011
@@ -0,0 +1,207 @@
+/*
+ * 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/list"
+)
+
+/**
+ * Helper class that encapsulates set metadata.
+ *
+ */
+type TSet interface {
+ TContainer
+ ElemType() TType
+ Add(data interface{})
+ Remove(data interface{})
+ Less(other interface{}) bool
+ Front() *list.Element
+ Back() *list.Element
+ Values() []interface{}
+}
+
+type tSet struct {
+ elemType TType
+ size int
+ l *list.List
+}
+
+func NewTSet(t TType, s int) TSet {
+ return &tSet{elemType: t, size: s, l: list.New()}
+}
+
+func NewTSetDefault() TSet {
+ return NewTSet(STOP, 0)
+}
+
+func (p *tSet) ElemType() TType {
+ return p.elemType
+}
+
+func (p *tSet) Front() *list.Element {
+ return p.l.Front()
+}
+
+func (p *tSet) Back() *list.Element {
+ return p.l.Back()
+}
+
+func (p *tSet) Len() int {
+ if p.l.Len() != 0 {
+ return p.l.Len()
+ }
+ return p.size
+}
+
+func (p *tSet) Contains(data interface{}) bool {
+ return p.find(data) != nil
+}
+
+func (p *tSet) Add(other interface{}) {
+ if data, ok := p.elemType.CoerceData(other); ok {
+ for elem := p.l.Front(); elem != nil; elem = elem.Next() {
+ if cmp, ok := p.elemType.Compare(data, elem.Value); ok && cmp >= 0 {
+ if cmp > 0 {
+ p.l.InsertBefore(data, elem)
+ }
+ return
+ }
+ }
+ }
+}
+
+func (p *tSet) Remove(data interface{}) {
+ elem := p.find(data)
+ if elem != nil {
+ p.l.Remove(elem)
+ }
+}
+
+func (p *tSet) Less(other interface{}) bool {
+ cmp, ok := p.CompareTo(other)
+ return ok && cmp > 0
+}
+
+func (p *tSet) Equals(other interface{}) bool {
+ c, cok := p.CompareTo(other)
+ return cok && c == 0
+}
+
+func (p *tSet) CompareTo(other interface{}) (int, bool) {
+ return TType(SET).Compare(p, other)
+}
+
+func (p *tSet) find(data interface{}) *list.Element {
+ if data == nil {
+ for elem := p.l.Front(); elem != nil; elem = elem.Next() {
+ if elem.Value == nil {
+ return elem
+ }
+ }
+ return nil
+ }
+ data, ok := p.elemType.CoerceData(data)
+ if data == nil || !ok {
+ return nil
+ }
+ if p.elemType.IsBaseType() || p.elemType.IsEnum() {
+ for elem := p.l.Front(); elem != nil; elem = elem.Next() {
+ if data == elem.Value {
+ return elem
+ }
+ }
+ return nil
+ }
+ if cmp, ok := data.(EqualsOtherInterface); ok {
+ for elem := p.l.Front(); elem != nil; elem = elem.Next() {
+ if cmp.Equals(elem.Value) {
+ return elem
+ }
+ }
+ return nil
+ }
+ switch p.elemType {
+ case MAP:
+ if cmp, ok := data.(EqualsMap); ok {
+ for elem := p.l.Front(); elem != nil; elem = elem.Next() {
+ v := elem.Value
+ if v == nil {
+ continue
+ }
+ if cmp.Equals(v.(TMap)) {
+ return elem
+ }
+ }
+ return nil
+ }
+ case SET:
+ if cmp, ok := data.(EqualsSet); ok {
+ for elem := p.l.Front(); elem != nil; elem = elem.Next() {
+ v := elem.Value
+ if v == nil {
+ continue
+ }
+ if cmp.Equals(v.(TSet)) {
+ return elem
+ }
+ }
+ return nil
+ }
+ case LIST:
+ if cmp, ok := data.(EqualsList); ok {
+ for elem := p.l.Front(); elem != nil; elem = elem.Next() {
+ v := elem.Value
+ if v == nil {
+ continue
+ }
+ if cmp.Equals(v.(TList)) {
+ return elem
+ }
+ }
+ return nil
+ }
+ case STRUCT:
+ if cmp, ok := data.(EqualsStruct); ok {
+ for elem := p.l.Front(); elem != nil; elem = elem.Next() {
+ v := elem.Value
+ if v == nil {
+ continue
+ }
+ if cmp.Equals(v.(TStruct)) {
+ return elem
+ }
+ }
+ return nil
+ }
+ }
+ return nil
+}
+
+func (p *tSet) Values() []interface{} {
+ size := p.l.Len()
+ values := make([]interface{}, size, size)
+ i := 0
+ for v := p.l.Front(); v != nil; v = v.Next() {
+ values[i] = v.Value
+ i++
+ }
+ return values
+}