Golang Writer.write Examples

Programming Language: Golang

Namespace/Package Name: io

Class/Type: Writer

Method/Function: write

Examples at hotexamples.com: 1

io.Writer is an interface in Go that abstracts the writing of bytes to a stream. It provides a uniform method to write bytes to different output targets such as files, network sockets, and standard output.

Here are some code examples using io.Writer:

Example 1: Writing to a file

file, err := os.Create("output.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

data := []byte("Hello, world!")
n, err := file.Write(data)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Wrote %d bytes to file\n", n)

In the above example, we create a file named "output.txt", write the string "Hello, world!" to it, and close the file. We use the Write method of the file object to write bytes to the file. This method returns the number of bytes written and an error if any.

Package library: "os"

Example 2: Writing to standard output

data := []byte("Hello, world!")
n, err := os.Stdout.Write(data)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Wrote %d bytes to stdout\n", n)

In the above example, we write the string "Hello, world!" to standard output (the console) using the Write method of the os.Stdout object. This method returns the number of bytes written and an error if any.

Package library: "os"

Example 3: Writing to a network socket

conn, err := net.Dial("tcp", "example.com:80")
if err != nil {
    log.Fatal(err)
}
defer conn.Close()

data := []byte("GET / HTTP/1.0\r\n\r\n")
n, err := conn.Write(data)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Wrote %d bytes to network\n", n)

In the above example, we connect to a web server at example.com on port 80, write an HTTP request to it, and close the connection. We use the Write method of the network connection object to write bytes to the socket. This method returns the number of bytes written and an error if any. Package library: "net"

Golang Writer.write - 1 examples found. These are the top rated real world Golang examples of io.Writer.write extracted from open source projects. You can rate examples to help us improve the quality of examples.

Frequently Used Methods

Show Hide

Write(30)

Flush(19)

Init(17)

Fd(5)

Close(2)

Error(2)

ReadFrom(2)

wait_for_stop(1)

stop(1)

saveBlock(1)

restore(1)

queue(1)

WriteRune(1)

Start(1)

URL(1)

Stat(1)

CloseWithError(1)

Reset(1)

Name(1)

Len(1)

Header(1)

write(1)

Example #1

Show file

File: scannedmp3.go Project: akavel/splitsound

func (m *scannedMp3) crop(startSample, endSample int64, ips io.Reader, ops io.Writer) os.Error {
	//defer ips.Close() // FIXME: leave this to caller

	startSample = maxInt64(startSample, int64(-m.encDelay))
	endSample = minInt64(endSample, m.SampleCount()+int64(m.encPadding))

	maskAth := 0xff
	if startSample != 0 {
		maskAth &= MASK_ATH_KILL_NO_GAP_START
	}
	if endSample != m.SampleCount() {
		maskAth &= MASK_ATH_KILL_NO_GAP_END
	}

	firstFrameInclusive := max(0, int((startSample+int64(m.encDelay-minOverlapSamplesStart))/int64(m.samplesPerFrame)))
	lastFrameExclusive := min(m.musicFrameCount, int(
		(endSample+int64(m.encDelay+minOverlapSamplesEnd+m.samplesPerFrame-1))/int64(m.samplesPerFrame)))
	newEncDelay := m.encDelay + int(startSample-int64(firstFrameInclusive)*int64(m.samplesPerFrame))
	newEncPadding := int(int64(lastFrameExclusive-firstFrameInclusive)*
		int64(m.samplesPerFrame) - int64(newEncDelay) - (endSample - startSample))
	accessFrameRecord(firstFrameInclusive)

	needBytesFromReservoir := getBitResPtr()
	gotBytesFromReservoir := 0
	needPreFrames := 0
	for firstFrameInclusive-needPreFrames > 0 &&
		needBytesFromReservoir > gotBytesFromReservoir &&
		newEncDelay+1152 <= 4095 {
		needPreFrames++
		accessFrameRecord(firstFrameInclusive - needPreFrames)
		gotBytesFromReservoir += getMainDataSectionSize()
	}

	var resFrame []byte
	resFrameSize := 0
	firstFrameNum := firstFrameInclusive
	if needPreFrames == 0 {
		// force writing of PCUT tag frame
		needPreFrames = 1
	}
	if needPreFrames > 0 {
		firstFrameNum--
		newEncDelay += m.samplesPerFrame
		resFrame = make([]byte, MAX_MPAFRAME_SIZE)
		var newAbsStartSample int64 = startSample
		if m.startSample != UNKNOWN_START_SAMPLE {
			newAbsStartSample += m.startSample
		}
		resFrameSize = constructReservoirFrame(resFrame, m.firstFrameHeader,
			needBytesFromReservoir, newAbsStartSample)
	}

	seekTable := make([]byte, 100)
	var avgBytesPerFrame, avgBytesPerSecnd, avgkbps float32
	musiLen := 0
	{ // calculate seek table
		accessFrameRecord(firstFrameInclusive)
		ofs00 := getFrameFileOfs() - resFrameSize
		accessFrameRecord(max(0, lastFrameExclusive-1))
		ofsXX := getFrameFileOfs() + getFrameSize()
		musiLen = ofsXX - ofs00
		avgBytesPerFrame = float32(ofsXX-ofs00) /
			float32(lastFrameExclusive-firstFrameInclusive)
		avgBytesPerSecnd = avgBytesPerFrame * float32(m.firstFrameHeader.SampleRate()) /
			float32(m.firstFrameHeader.SamplesPerFrame())
		avgkbps = avgBytesPerSecnd / float32(125)
		for i := 0; i < 100; i++ {
			fidx := round(float32(firstFrameInclusive+i+1) / 101.0 *
				float32(lastFrameExclusive-firstFrameInclusive))
			accessFrameRecord(max(0, fidx))
			seekTable[i] = byte(round(float32(getFrameFileOfs()-ofs00) * float32(255) /
				float32(ofsXX-ofs00)))
		}
	}

	frameBuff := make([]byte, MAX_MPAFRAME_SIZE)
	fl := XingInfoLameTagFrame.createHeaderFrame(firstFrameHeader, isVBR, avgkbps,
		lastFrameExclusive-firstFrameNum, musiLen, 50, seektable, newEncDelay,
		newEncPadding, xiltFrame, frameBuff, 0, maskATH)
	ops.write(frameBuff, 0, fl)
	filepos := 0
	sideInfoSize := firstFrameHeader.getSideInfoSize()
	bitRes := 0

	if needPreFrames > 0 {
		reservoir = make([]byte, 511)
		if needBytesFromReservoir > 0 {
			for fi := firstFrameInclusive - needPreFrames; fi < firstFrameInclusive; fi++ {
				accessFrameRecord(fi)
				tmp := getFrameFileOfs()
				ips.skip(tmp - filepos)
				filepos = tmp
				fl = getFrameSize()
				readFully(ips, frameBuff, 0, fl)
				filepos += fl
				mdss := getMainDataSectionSize()
				if mdss >= 511 {
					copy(reservoir, frameBuff[fl-511:])
					// System.arraycopy(frameBuff, fl - 511, reservoir, 0, 511);
				} else {
					move := 511 - mdss
					copy(reservoir[:move], reservoir[511-move:])
					copy(reservoir[move:], frameBuff[fl-mdss:])
					// System.arraycopy(reservoir, 511 - move, reservoir, 0, move);
					// System.arraycopy(frameBuff, fl - mdss, reservoir, move, mdss);
				}
			}
			copy(resFrame[resFrameSize-needBytesFromReservoir:resFrameSize], reservoir[511-needBytesFromReservoir:])
			// System.arraycopy(reservoir, 511 - needBytesFromReservoir, resFrame,
			//         resFrameSize - needBytesFromReservoir, needBytesFromReservoir);
		}
		ops.write(resFrame, 0, resFrameSize)
		bitRes = needBytesFromReservoir
	}

	for fi := firstFrameInclusive; fi < lastFrameExclusive; fi++ {
		accessFrameRecord(fi)
		tmp := getFrameFileOfs()
		ips.skip(tmp - filepos)
		filepos = tmp
		fl = getFrameSize()
		readFully(ips, frameBuff, 0, fl)
		filepos += fl
		tmp = getBitResPtr()
		if tmp > bitRes {
			silenceFrame(frameBuff, 0, sideInfoSize)
		}
		ops.Write(frameBuff[:fl])
		tmp = getMainDataSectionSize()
		bitRes = min(bitRes+tmp, maxRes)
	}
}