func (e *Error) writeTo(w *bufio.Writer) error {
if _, err := w.WriteString(e.ID.String()); err != nil {
return err
}
if err := w.WriteByte(' '); err != nil {
return err
}
if _, err := w.Write(ProtoResError); err != nil {
return err
}
if err := w.WriteByte(' '); err != nil {
return err
}
if _, err := w.WriteString(e.Message); err != nil {
return err
}
if err := w.WriteByte('\n'); err != nil {
return err
}
return nil
}
func (e Enqued) writeTo(w *bufio.Writer) (err error) {
if _, err = w.WriteString(e.ID.String()); err != nil {
return err
}
if err = w.WriteByte(' '); err != nil {
return err
}
if _, err = w.Write(ProtoResEnQed); err != nil {
return err
}
if err = w.WriteByte(' '); err != nil {
return err
}
if _, err = w.Write([]byte(e.Queue)); err != nil {
return err
}
if err = w.WriteByte(' '); err != nil {
return err
}
if _, err = w.WriteString(e.TaskID.String()); err != nil {
return err
}
if err = w.WriteByte('\n'); err != nil {
return err
}
return nil
}
func (a Acked) writeTo(w *bufio.Writer) (err error) {
if _, err = w.WriteString(a.ID.String()); err != nil {
return err
}
if err = w.WriteByte(' '); err != nil {
return err
}
if _, err = w.Write(ProtoResAcked); err != nil {
return err
}
if err = w.WriteByte(' '); err != nil {
return err
}
if _, err = w.Write([]byte(a.Queue)); err != nil {
return err
}
if err = w.WriteByte(' '); err != nil {
return err
}
if _, err = w.WriteString(a.TaskID.String()); err != nil {
return err
}
if err = w.WriteByte('\n'); err != nil {
return err
}
return nil
}
/*
Writes all incoming contents from [source] to a file at the given [schemaPath],
returning all found errors to [resultError], and returning only once a value is
received on [exit], or if the file was unable to be opened.
*/
func writeSingleFile(schemaPath string, source chan string, resultError chan error, wg *sync.WaitGroup) {
var contents string
var outFile *os.File
var writer *bufio.Writer
var err error
var ok bool
defer wg.Done()
outFile, err = os.Create(schemaPath)
if err != nil {
resultError <- err
return
}
writer = bufio.NewWriter(outFile)
for {
contents, ok = <-source
if !ok {
break
}
_, err = writer.Write([]byte(contents))
if err != nil {
resultError <- err
}
}
writer.Flush()
}
func (self *writePublish) write(wr *bufio.Writer) error {
var err error
var protocol string
protocol = fmt.Sprintf("PUB %s", self.Subject)
if len(self.ReplyTo) > 0 {
protocol += fmt.Sprintf(" %s", self.ReplyTo)
}
protocol += fmt.Sprintf(" %d\r\n", len(self.Message))
_, err = wr.WriteString(protocol)
if err != nil {
return err
}
_, err = wr.Write(self.Message)
if err != nil {
return err
}
_, err = wr.WriteString("\r\n")
if err != nil {
return err
}
return nil
}
func writeReqToBuf(buf *bufio.Writer, req *Request) {
//写入参数个数
argsCnt := len(req.args) + 1
buf.WriteByte(array_byte)
buf.WriteString(strconv.Itoa(argsCnt))
buf.Write(cr_lf)
//写入命令
buf.WriteByte(size_byte)
buf.WriteString(strconv.Itoa(len(req.cmd)))
buf.Write(cr_lf)
buf.WriteString(req.cmd)
buf.Write(cr_lf)
//写入参数
for _, arg := range req.args {
str := fmt.Sprint(arg)
buf.WriteByte(size_byte)
buf.WriteString(strconv.Itoa(len(str)))
buf.Write(cr_lf)
buf.WriteString(str)
buf.Write(cr_lf)
}
}
func writeLines(lines []*lineInfo, out *bufio.Writer) (err error) {
var size int
var line []byte
for _, item := range lines {
// prepare the line
size = item.indent + len(item.body)
line = make([]byte, size+len(crlf))
for i := 0; i < item.indent; i++ {
line[i] = ' ' // proper indent
}
copy(line[item.indent:], item.body)
copy(line[size:], crlf)
// write to buffer
_, err = out.Write(line)
if err != nil {
return err
}
}
err = out.Flush()
return
}
func WriteBytes(b *bufio.Writer, v []byte) error {
err := b.WriteByte('$')
_, err = b.WriteString(strconv.Itoa(len(v)))
err = b.WriteByte(' ')
_, err = b.Write(v)
return err
}
// sendResponse send resp to client, sendResponse must be goroutine safe.
func (server *Server) writeTCPResponse(wr *bufio.Writer, proto *Proto) (err error) {
if Conf.Debug {
log.Debug("write proto: %v", proto)
}
if err = ioutil.WriteBigEndianInt32(wr, int32(rawHeaderLen)+int32(len(proto.Body))); err != nil {
return
}
if err = ioutil.WriteBigEndianInt16(wr, rawHeaderLen); err != nil {
return
}
if err = ioutil.WriteBigEndianInt16(wr, proto.Ver); err != nil {
return
}
if err = ioutil.WriteBigEndianInt32(wr, proto.Operation); err != nil {
return
}
if err = ioutil.WriteBigEndianInt32(wr, proto.SeqId); err != nil {
return
}
if proto.Body != nil {
if _, err = wr.Write(proto.Body); err != nil {
return
}
}
if err = wr.Flush(); err != nil {
log.Error("tcp wr.Flush() error(%v)", err)
}
proto.Reset()
return
}
func SendHandshakeResponse(writer *bufio.Writer, status byte) (err error) {
_, err = writer.Write([]byte{0x05, status})
if err != nil {
return
}
return writer.Flush()
}
// Write Optional param
func (op *pduOptParam) write(w *bufio.Writer) (err os.Error) {
// Create byte array
p := make([]byte, 4+op.length)
copy(p[0:2], packUint(uint64(op.tag), 2))
copy(p[2:4], packUint(uint64(op.length), 2))
// Determine data type of value
v := reflect.NewValue(op.value)
switch t := v.(type) {
case *reflect.StringValue:
copy(p[4:op.length], []byte(op.value.(string)))
case *reflect.Uint8Value:
p[4] = byte(op.value.(uint8))
case *reflect.Uint16Value:
copy(p[4:6], packUint(uint64(op.value.(uint16)), 2))
case *reflect.Uint32Value:
copy(p[4:8], packUint(uint64(op.value.(uint32)), 4))
}
// Write to buffer
_, err = w.Write(p)
if err != nil {
return
}
// Flush write buffer
err = w.Flush()
return
}
func HandshakeSample(c net.Conn, br *bufio.Reader, bw *bufio.Writer, timeout time.Duration) (err error) {
defer func() {
if r := recover(); r != nil {
err = r.(error)
}
}()
// Send C0+C1
err = bw.WriteByte(0x03)
c1 := CreateRandomBlock(RTMP_SIG_SIZE)
for i := 0; i < 8; i++ {
c1[i] = 0
}
bw.Write(c1)
err = bw.Flush()
CheckError(err, "Handshake() Flush C0+C1")
// Read S0+S1+S2
s0, err := br.ReadByte()
CheckError(err, "Handshake() Read S0")
if s0 != 0x03 {
return errors.New(fmt.Sprintf("Handshake() Got S0: %x", s0))
}
s1 := make([]byte, RTMP_SIG_SIZE)
_, err = io.ReadAtLeast(br, s1, RTMP_SIG_SIZE)
CheckError(err, "Handshake() Read S1")
bw.Write(s1)
err = bw.Flush()
CheckError(err, "Handshake() Flush C2")
_, err = io.ReadAtLeast(br, s1, RTMP_SIG_SIZE)
CheckError(err, "Handshake() Read S2")
return
}
// Write writes request to w.
//
// Write doesn't flush request to w for performance reasons.
func (req *Request) Write(w *bufio.Writer) error {
if len(req.Header.Host()) == 0 {
uri := req.URI()
host := uri.Host()
if len(host) == 0 {
return errRequestHostRequired
}
req.Header.SetHostBytes(host)
req.Header.SetRequestURIBytes(uri.RequestURI())
}
body := req.body
var err error
if req.multipartForm != nil && len(req.body) == 0 {
body, err = marshalMultipartForm(req.multipartForm, req.multipartFormBoundary)
if err != nil {
return fmt.Errorf("error when marshaling multipart form: %s", err)
}
req.Header.SetMultipartFormBoundary(req.multipartFormBoundary)
}
hasBody := !req.Header.noBody()
if hasBody {
req.Header.SetContentLength(len(body))
}
if err = req.Header.Write(w); err != nil {
return err
}
if hasBody {
_, err = w.Write(body)
} else if len(body) > 0 {
return fmt.Errorf("Non-zero body for non-POST request. body=%q", body)
}
return err
}
// Write Bind Response PDU
func (pdu *PDUBindResp) write(w *bufio.Writer) (err os.Error) {
// Write Header
err = pdu.Header.write(w)
if err != nil {
err = os.NewError("Bind Response: Error writing Header")
return
}
// Create byte array the size of the PDU
p := make([]byte, pdu.Header.CmdLength-pdu.OptionalLen-16)
pos := 0
// Copy system id
if len(pdu.SystemId) > 0 {
copy(p[pos:len(pdu.SystemId)], []byte(pdu.SystemId))
pos += len(pdu.SystemId)
}
pos++ // Null terminator
// Write to buffer
_, err = w.Write(p)
if err != nil {
err = os.NewError("Bind Response: Error writing to buffer")
return
}
// Flush write buffer
err = w.Flush()
if err != nil {
err = os.NewError("Bind Response: Error flushing write buffer")
}
// Optional params
err = pdu.writeOptional(w)
if err != nil {
err = os.NewError("Bind Response: Error writing optional params")
}
return
}
// Write writes response to w.
//
// Write doesn't flush response to w for performance reasons.
func (resp *Response) Write(w *bufio.Writer) error {
var err error
if resp.bodyStream != nil {
contentLength := resp.Header.ContentLength()
if contentLength >= 0 {
if err = resp.Header.Write(w); err != nil {
return err
}
if err = writeBodyFixedSize(w, resp.bodyStream, contentLength); err != nil {
return err
}
} else {
resp.Header.SetContentLength(-1)
if err = resp.Header.Write(w); err != nil {
return err
}
if err = writeBodyChunked(w, resp.bodyStream); err != nil {
return err
}
}
if bsc, ok := resp.bodyStream.(io.Closer); ok {
err = bsc.Close()
}
return err
}
resp.Header.SetContentLength(len(resp.body))
if err = resp.Header.Write(w); err != nil {
return err
}
_, err = w.Write(resp.body)
return err
}
func (*protocol) WriteEnd(w *bufio.Writer) error {
_, err := w.Write(_CRLF)
if err != nil {
return err
}
return w.Flush()
}
func readFile(path string) {
var w *bufio.Writer = bufio.NewWriter(os.Stdout)
defer w.Flush()
fmt.Fprintf(w, "read file start: %s\n", path)
file, err := os.OpenFile(path, os.O_RDONLY, 0666) // 打开文件
if err != nil {
fmt.Printf("open file err: %v\n", err)
return
}
defer file.Close() // 延时关闭文件
var buff []byte = make([]byte, 1024)
var r *bufio.Reader = bufio.NewReader(file)
for {
n, _ := r.Read(buff)
if n <= 0 {
fmt.Fprintf(w, "read file end: %s %d\n", path, n)
return
}
w.Write(buff[0:n])
}
}
// sendResponse send resp to client, sendResponse must be goroutine safe.
func (server *Server) writeTCPResponse(wr *bufio.Writer, proto *Proto) (err error) {
if Conf.Debug {
log.Debug("write proto: %v", proto)
}
// if no available memory bufio.Writer auth flush response
if err = ioutil.WriteBigEndianInt32(wr, int32(rawHeaderLen)+int32(len(proto.Body))); err != nil {
return
}
if err = ioutil.WriteBigEndianInt16(wr, rawHeaderLen); err != nil {
return
}
if err = ioutil.WriteBigEndianInt16(wr, proto.Ver); err != nil {
return
}
if err = ioutil.WriteBigEndianInt32(wr, proto.Operation); err != nil {
return
}
if err = ioutil.WriteBigEndianInt32(wr, proto.SeqId); err != nil {
return
}
if proto.Body != nil {
if _, err = wr.Write(proto.Body); err != nil {
return
}
}
proto.Reset()
return
}
func filterNWriteTerms(w bufio.Writer, r io.Reader,
counts []int, thresh int) []int {
nnzCount := 0
scanner := bufio.NewScanner(r)
//read lines from the file
var currLine string
var currWords []string
isHeaderRead := false
fmt.Println("start writing")
for scanner.Scan() {
if !isHeaderRead {
isHeaderRead = true
fmt.Println("writing header")
w.WriteString(scanner.Text())
w.WriteString("\n")
continue
}
//read current line
currLine = scanner.Text()
currLine = strings.Trim(currLine, " ")
if len(currLine) == 0 {
w.Write([]byte("\n"))
continue
}
//read words from line
currWords = strings.Split(currLine, " ")
var currWordInd int64
//fmt.Println(currWords)
for i := 0; i < len(currWords); i += 2 {
currWordInd, _ = strconv.ParseInt(currWords[i], 10, 64)
if counts[currWordInd-1] >= thresh {
//fmt.Println(currWordInd, counts[currWordInd-1], currWords[i], currWords[i+1])
w.WriteString(currWords[i])
w.WriteString(" ")
w.WriteString(currWords[i+1])
w.WriteString(" ")
nnzCount++
}
}
w.WriteString("\n")
}
fmt.Println("new nnz count: ", nnzCount)
//get all new nnz ind
nnzs := make([]int, nnzCount)
j := 0
for i, count := range counts {
if count >= thresh {
nnzs[j] = i + 1
j++
}
}
w.Flush()
return nnzs
}
func (f *FML) writeTo(parentKey string, writer *bufio.Writer) {
for key, val := range f.dict {
fullKey := key
if len(parentKey) != 0 {
fullKey = parentKey + "." + key
}
switch v := val.(type) {
case []*FML:
defer func() {
writeNodeName(fullKey, writer)
for i := 0; i < len(v); i++ {
writer.Write([]byte{'-', ' '})
v[i].writeTo(fullKey, writer)
}
}()
case *FML:
defer func() {
writeNodeName(fullKey, writer)
v.writeTo(fullKey, writer)
}()
default:
//log.Println("write",key)
writer.WriteString(key)
writer.WriteByte(':')
writer.WriteString(wrapVal(v))
//writer.WriteString("after key value")
writer.WriteByte('\n')
}
}
}
func readAndWriteTLS(r *bufio.Reader, w *bufio.Writer, con *tls.Conn, verbose bool) <-chan bool {
c := make(chan bool)
go func() {
defer func() {
(*con).Close()
c <- false
}()
for {
buf := make([]byte, 1024)
message, errRead := r.Read(buf)
if errRead != nil {
if errRead != io.EOF {
if verbose {
log.Println("READ ERROR: ", errRead)
}
}
break
}
_, errWrite := w.Write(buf[:message])
w.Flush()
if errWrite != nil {
if verbose {
log.Println("WRITE ERROR: ", errWrite)
}
return
}
}
}()
return c
}
// Write writes response to w.
//
// Write doesn't flush response to w for performance reasons.
//
// See also WriteTo.
func (resp *Response) Write(w *bufio.Writer) error {
if resp.SkipResponse {
return nil
}
sendBody := !resp.mustSkipBody()
if resp.bodyStream != nil {
return resp.writeBodyStream(w, sendBody)
}
body := resp.bodyBytes()
bodyLen := len(body)
if sendBody || bodyLen > 0 {
resp.Header.SetContentLength(bodyLen)
}
if err := resp.Header.Write(w); err != nil {
return err
}
if sendBody {
if _, err := w.Write(body); err != nil {
return err
}
}
return nil
}
/*
Frame physical write.
*/
func (f *Frame) writeFrame(w *bufio.Writer, l string) error {
// Write the frame Command
if _, e := w.WriteString(f.Command + "\n"); e != nil {
return e
}
// Content length - Always add it if client does not suppress it and
// does not supply it.
if _, ok := f.Headers.Contains("suppress-content-length"); !ok {
if _, clok := f.Headers.Contains("content-length"); !clok {
f.Headers = append(f.Headers, "content-length", strconv.Itoa(len(f.Body)))
}
}
// Write the frame Headers
for i := 0; i < len(f.Headers); i += 2 {
if l > SPL_10 && f.Command != CONNECT {
f.Headers[i] = encode(f.Headers[i])
f.Headers[i+1] = encode(f.Headers[i+1])
}
_, e := w.WriteString(f.Headers[i] + ":" + f.Headers[i+1] + "\n")
if e != nil {
return e
}
}
// Write the last Header LF
if e := w.WriteByte('\n'); e != nil {
return e
}
// Write the body
if len(f.Body) != 0 { // Foolish to write 0 length data
if _, e := w.Write(f.Body); e != nil {
return e
}
}
return nil
}
// writeTo serializes the element to the writer w.
func (e *Element) writeTo(w *bufio.Writer) {
w.WriteByte('<')
if e.Space != "" {
w.WriteString(e.Space)
w.WriteByte(':')
}
w.WriteString(e.Tag)
for _, a := range e.Attr {
w.WriteByte(' ')
a.writeTo(w)
}
if len(e.Child) > 0 {
w.WriteString(">")
for _, c := range e.Child {
c.writeTo(w)
}
w.Write([]byte{'<', '/'})
if e.Space != "" {
w.WriteString(e.Space)
w.WriteByte(':')
}
w.WriteString(e.Tag)
w.WriteByte('>')
} else {
w.Write([]byte{'/', '>'})
}
}
// Function IHex.Write writes the representation of the file to the writer `wr`.
func (ix *IHex) Write(wr *bufio.Writer) (err error) {
for start, data := range ix.areas {
i := 0
for i < len(data) {
var chunk []byte
if i+16 <= len(data) {
chunk = data[i : i+16]
} else {
chunk = data[i:]
}
_, err := wr.Write([]byte(makeLine(0x00, start, chunk)))
if err != nil {
return err
}
start += 16
}
}
_, err = wr.Write([]byte(makeLine(0x01, 0, []byte{})))
if err != nil {
return err
}
return nil
}
func (c *DefaultServerCodec) WriteResponse(wr *bufio.Writer, proto *Proto) (err error) {
log.Debug("write proto: %v", proto)
// packlen =header(16) + body
if err = binary.Write(wr, binary.BigEndian, uint32(rawHeaderLen)+uint32(len(proto.Body))); err != nil {
log.Error("packLen: binary.Write() error(%v)", err)
return
}
if err = binary.Write(wr, binary.BigEndian, rawHeaderLen); err != nil {
log.Error("headerLen: binary.Write() error(%v)", err)
return
}
if err = binary.Write(wr, binary.BigEndian, proto.Ver); err != nil {
log.Error("protoVer: binary.Write() error(%v)", err)
return
}
if err = binary.Write(wr, binary.BigEndian, proto.Operation); err != nil {
log.Error("operation: binary.Write() error(%v)", err)
return
}
if err = binary.Write(wr, binary.BigEndian, proto.SeqId); err != nil {
log.Error("seqId: binary.Write() error(%v)", err)
return
}
if proto.Body != nil {
if _, err = wr.Write(proto.Body); err != nil {
log.Error("body: wr.Write() error(%v)", err)
return
}
}
return wr.Flush()
}
func emit_allele_path_item(ofp *bufio.Writer) {
for k := range g_allele_path_item {
for i := 0; i < len(g_allele_path_item[k]); i++ {
s := fmt.Sprintf("%d,%d,%d,%d,%d,%s\n",
g_allele_path_item[k][i].AlleleId,
g_allele_path_item[k][i].PathItemIndex,
g_allele_path_item[k][i].SequenceId,
g_allele_path_item[k][i].Start,
g_allele_path_item[k][i].Length,
g_allele_path_item[k][i].StrandIsForward)
ofp.Write([]byte(s))
}
}
return
for allele_name := range g_allele_sequenceid_path {
allele_id := g_allele_name_id_map[allele_name]
for i := 0; i < len(g_allele_sequenceid_path[allele_name]); i++ {
seqid := g_allele_sequenceid_path[allele_name][i]
s := fmt.Sprintf("%d,%d,%d,%s,%s,%s\n", allele_id, i, seqid, "NULL", "NULL", "'TRUE'")
ofp.Write([]byte(s))
}
}
}
func (p *Packet) Write(w io.Writer) (err error) {
var bw *bufio.Writer
if w1, ok := w.(*bufio.Writer); ok {
bw = w1
} else {
bw = bufio.NewWriter(w)
}
defer bw.Flush()
err = binary.Write(bw, binary.LittleEndian, p.OpCode)
if err != nil {
return err
}
err = binary.Write(bw, binary.LittleEndian, p.Req)
if err != nil {
return err
}
err = binary.Write(bw, binary.LittleEndian, p.TxID)
if err != nil {
return err
}
err = binary.Write(bw, binary.LittleEndian, p.Length)
if err != nil {
return err
}
if p.Length > 0 {
_, err = bw.Write(p.Value)
if err != nil {
return err
}
}
return nil
}
// writeTree writes a .sgf tree from the treeNodes array
// w is a buffered I/O writer
// n is the TreeNodeIdx of the root of this tree
// needs is a bool that is true when a \n is needed
// nMov keeps a count of moves per line.
// writeTree first writes one node, then recursively calls writeTree
// writeTree is only called from writeGame, which has one active call, and one that is never reached (&& false)
func (p *GameTree) writeTree(w *bufio.Writer, n TreeNodeIdx, needs bool, nMov int, nMovPerLine int) (err error) {
defer u(tr("writeTree"))
if needs == true {
if nMov > 0 {
err = w.WriteByte('\n')
nMov = 0
}
err = w.WriteByte('(')
}
if err == nil {
if nMov == nMovPerLine {
err = w.WriteByte('\n')
nMov = 0
}
err = w.WriteByte(';')
// write the node
typ := p.treeNodes[n].TNodType
switch typ {
case GameInfoNode:
// fmt.Println("writing GameInfoNode\n")
err = p.writeProperties(w, n, true)
case InteriorNode:
// fmt.Println("writing InteriorNode\n")
err = p.writeProperties(w, n, false)
case BlackMoveNode:
_, err = w.WriteString("B[")
_, err = w.Write(SGFCoords(ah.NodeLoc(p.treeNodes[n].propListOrNodeLoc), p.IsFF4()))
err = w.WriteByte(']')
nMov += 1
case WhiteMoveNode:
_, err = w.WriteString("W[")
_, err = w.Write(SGFCoords(ah.NodeLoc(p.treeNodes[n].propListOrNodeLoc), p.IsFF4()))
err = w.WriteByte(']')
nMov += 1
default:
fmt.Println("*** unsupported TreeNodeType in writeTree")
err = errors.New("writeTree: unsupported TreeNodeType" + strconv.FormatInt(int64(typ), 10))
return err
}
if err == nil {
// write the children
lastCh := p.treeNodes[n].Children
if lastCh != nilTreeNodeIdx && err == nil {
ch := p.treeNodes[lastCh].NextSib
chNeeds := (lastCh != ch)
err = p.writeTree(w, ch, chNeeds, nMov, nMovPerLine)
for ch != lastCh && err == nil {
ch = p.treeNodes[ch].NextSib
// nMov += 1
err = p.writeTree(w, ch, chNeeds, nMov, nMovPerLine)
}
}
if (err == nil) && (needs == true) {
err = w.WriteByte(')')
}
}
}
return err
}
func (r *Request) WriteTo(w *bufio.Writer) error {
w.Write(rpc.FlagReq)
w.Write(r.Method.Bytes())
if err := rpc.WriteItems(w, r.Args); err != nil {
return logex.Trace(err)
}
return nil
}