code review 3959041: gob: make (en|dec)code(Ui|i)nt methods rather than func...

src/pkg/gob/encoder.go

 // 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.
 
 package gob
 
 import (
         "bytes"
         "io"
         "os"
@@ skipping 30 matching lines @@
 func (enc *Encoder) setError(err os.Error) {
         if enc.err == nil { // remember the first.
                 enc.err = err
         }
         enc.state.b.Reset()
 }
 
 // Send the data item preceded by a unsigned count of its length.
 func (enc *Encoder) send() {
         // Encode the length.
-        encodeUint(enc.countState, uint64(enc.state.b.Len()))
+        enc.countState.encodeUint(uint64(enc.state.b.Len()))
         // Build the buffer.
         countLen := enc.countState.b.Len()
         total := countLen + enc.state.b.Len()
         if total > len(enc.buf) {
                 enc.buf = make([]byte, total+1000) // extra for growth
         }
         // Place the length before the data.
         // TODO(r): avoid the extra copy here.
         enc.countState.b.Read(enc.buf[0:countLen])
         // Now the data.
@@ skipping 43 matching lines @@
         // Need to send it.
         typeLock.Lock()
         info, err := getTypeInfo(rt)
         typeLock.Unlock()
         if err != nil {
                 enc.setError(err)
                 return
         }
         // Send the pair (-id, type)
         // Id:
-        encodeInt(enc.state, -int64(info.id))
+        enc.state.encodeInt(-int64(info.id))
         // Type:
         enc.encode(enc.state.b, reflect.NewValue(info.wire))
         enc.send()
         if enc.err != nil {
                 return
         }
 
         // Remember we've sent this type.
         enc.sent[rt] = info.id
         // Remember we've sent the top-level, possibly indirect type too.
@@ skipping 37 matching lines @@
                         typeLock.Unlock()
                         if err != nil {
                                 enc.setError(err)
                                 return
                         }
                         enc.sent[rt] = info.id
                 }
         }
 
         // Identify the type of this top-level value.
-        encodeInt(enc.state, int64(enc.sent[rt]))
+        enc.state.encodeInt(int64(enc.sent[rt]))
 }
 
 // EncodeValue transmits the data item represented by the reflection value,
 // guaranteeing that all necessary type information has been transmitted first.
 func (enc *Encoder) EncodeValue(value reflect.Value) os.Error {
         // Make sure we're single-threaded through here, so multiple
         // goroutines can share an encoder.
         enc.mutex.Lock()
         defer enc.mutex.Unlock()
 
@@ skipping 14 matching lines @@
         // Encode the object.
         err := enc.encode(enc.state.b, value)
         if err != nil {
                 enc.setError(err)
         } else {
                 enc.send()
         }
 
         return enc.err
 }