go-xmpp2: comparison stream.go

equal deleted inserted replaced

-:bd56fb741f69
+:bee6cc131798
 // Callback to handle a stanza with a particular id.
 type stanzaHandler struct {
 	id string
 	// Return true means pass this to the application
-	f func(interface{}) bool
+	f func(Stanza) bool
 }
 // BUG(cjyar) Review all these *Client receiver methods. They should
 // probably either all be receivers, or none.
 			}
 		}
 	}
 }
-func (cl *Client) readStream(srvIn <-chan interface{}, cliOut chan<- interface{}) {
+func (cl *Client) readStream(srvIn <-chan interface{}, cliOut chan<- Stanza) {
 	defer close(cliOut)
-	handlers := make(map[string]func(interface{}) bool)
+	handlers := make(map[string]func(Stanza) bool)
 Loop:
 	for {
 		select {
 		case h := <-cl.handlers:
 			handlers[h.id] = h.f
 		case x, ok := <-srvIn:
 			if !ok {
 				break Loop
 			}
-			var st *Header
 			switch obj := x.(type) {
 			case *stream:
 				handleStream(obj)
 			case *streamError:
 				cl.handleStreamError(obj)
 			case *starttls:
 				cl.handleTls(obj)
 			case *auth:
 				cl.handleSasl(obj)
 			case Stanza:
-				st = obj.GetHeader()
+				send := true
+				id := obj.GetHeader().Id
+				if handlers[id] != nil {
+					f := handlers[id]
+					delete(handlers, id)
+					send = f(obj)
+				}
+				if send {
+					cliOut <- obj
+				}
 			default:
 				Warn.Logf("Unhandled non-stanza: %T %#v", x, x)
-			}
-			if st == nil {
-				continue
-			}
-			send := true
-			if handlers[st.Id] != nil {
-				f := handlers[st.Id]
-				delete(handlers, st.Id)
-				send = f(x)
-			}
-			if send {
-				cliOut <- x
 			}
 		}
 	}
 }
 // This loop is paused until resource binding is complete. Otherwise
 // the app might inject something inappropriate into our negotiations
 // with the server. The control channel controls this loop's
 // activity.
-func writeStream(srvOut chan<- interface{}, cliIn <-chan interface{},
+func writeStream(srvOut chan<- interface{}, cliIn <-chan Stanza,
 control <-chan int) {
 	defer close(srvOut)
-	var input <-chan interface{}
+	var input <-chan Stanza
 Loop:
 	for {
 		select {
 		case status := <-control:
 			switch status {
 	}
 }
 // Stanzas from the remote go up through a stack of filters to the
 // app. This function manages the filters.
-func filterTop(filterOut <-chan <-chan interface{}, filterIn chan<- <-chan interface{},
+func filterTop(filterOut <-chan <-chan Stanza, filterIn chan<- <-chan Stanza,
-topFilter <-chan interface{}, app chan<- interface{}) {
+topFilter <-chan Stanza, app chan<- Stanza) {
 	defer close(app)
 Loop:
 	for {
 		select {
 		case newFilterOut := <-filterOut:
 			app <- data
 		}
 	}
 }
-func filterBottom(from <-chan interface{}, to chan<- interface{}) {
+func filterBottom(from <-chan Stanza, to chan<- Stanza) {
 	defer close(to)
 	for data := range from {
 		to <- data
 	}
 }
 	if res != "" {
 		bindReq.Resource = &res
 	}
 	msg := &Iq{Header: Header{Type: "set", Id: <-Id,
 		Nested: []interface{}{bindReq}}}
-	f := func(st interface{}) bool {
+	f := func(st Stanza) bool {
 		iq, ok := st.(*Iq)
 		if !ok {
 			Warn.Log("non-iq response")
 		}
 		if iq.Type == "error" {
 // presence) with a given id. The provided function will not be called
 // more than once. If it returns false, the stanza will not be made
 // available on the normal Client.In channel. The stanza handler
 // must not read from that channel, as deliveries on it cannot proceed
 // until the handler returns true or false.
-func (cl *Client) HandleStanza(id string, f func(interface{}) bool) {
+func (cl *Client) HandleStanza(id string, f func(Stanza) bool) {
 	h := &stanzaHandler{id: id, f: f}
 	cl.handlers <- h
 }

changeset 113	bee6cc131798
parent 112	bd56fb741f69
child 114	a058e33c1666