io.Reader & io.Writer

Parte da seção Programação Orientada a Objetos do Journey de GO da Coddy — lição 73 de 107.

A biblioteca padrão do Go demonstra o design baseado em interfaces por meio de duas interfaces fundamentais: io.Reader e io.Writer. Essas interfaces simples sustentam tudo, desde operações de arquivo até comunicação de rede.

A interface io.Reader requer apenas um método:

type Reader interface {
    Read(p []byte) (n int, err error)
}

Ele lê até len(p) bytes no slice e retorna quantos bytes foram lidos. Da mesma forma, io.Writer define:

type Writer interface {
    Write(p []byte) (n int, err error)
}

Qualquer tipo que implemente esses métodos funciona com todo o ecossistema de I/O.

Aqui está um tipo personalizado que implementa io.Reader:

type RepeatReader struct {
    Char  byte
    Count int
    pos   int
}

func (r *RepeatReader) Read(p []byte) (int, error) {
    if r.pos >= r.Count {
        return 0, io.EOF
    }
    n := 0
    for n < len(p) && r.pos < r.Count {
        p[n] = r.Char
        n++
        r.pos++
    }
    return n, nil
}

Agora este leitor personalizado funciona com qualquer função que espere um io.Reader:

reader := &RepeatReader{Char: 'A', Count: 5}
data, _ := io.ReadAll(reader)
fmt.Println(string(data))  // AAAAA

Este design permite que você escreva funções que aceitam io.Reader ou io.Writer, fazendo com que funcionem com arquivos, conexões de rede, buffers ou qualquer implementação personalizada.

Desafio

Fácil

Vamos construir um processador de fluxo de texto personalizado que implementa as interfaces io.Reader e io.Writer! Você criará tipos que podem transformar o texto à medida que ele flui através deles, demonstrando como essas interfaces fundamentais permitem uma poderosa composição de E/S.

Você organizará seu código em dois arquivos:

streams.go: Defina seus tipos personalizados de leitor e escritor.
Crie uma struct CountingReader que envolve uma string e rastreia quantos bytes foram lidos. Ela deve ter campos para a string de origem e um rastreador de posição. Implemente o método Read(p []byte) (int, error) que lê bytes da origem para o slice fornecido, atualiza a posição e retorna io.EOF quando a origem estiver esgotada.

Crie uma struct UppercaseWriter que coleta os dados gravados e os converte para maiúsculas. Ela deve armazenar o resultado acumulado internamente. Implemente o método Write(p []byte) (int, error) que converte os bytes recebidos para maiúsculas e os armazena. Adicione um método Result() string para recuperar o texto em maiúsculas acumulado.

Crie funções construtoras NewCountingReader(source string) *CountingReader e NewUppercaseWriter() *UppercaseWriter para inicializar seus tipos adequadamente.
main.go: Demonstre seus tipos de E/S personalizados funcionando com a biblioteca padrão.
Leia uma entrada de string e, em seguida, use seu CountingReader com io.ReadAll para ler todos os dados. Passe esses dados pelo seu UppercaseWriter usando seu método Write.

Imprima os resultados neste formato:
```
Original: [input]
Uppercase: [result from writer]
Bytes read: [total bytes]
```

A seguinte entrada será fornecida:

Uma única linha de texto

Por exemplo, dado:

Hello World

Sua saída deve ser:

Original: Hello World
Uppercase: HELLO WORLD
Bytes read: 11

E dado:

Go interfaces are powerful

Sua saída deve ser:

Original: Go interfaces are powerful
Uppercase: GO INTERFACES ARE POWERFUL
Bytes read: 26

O ponto principal é que seu CountingReader funciona perfeitamente com io.ReadAll porque ele implementa io.Reader. Qualquer função no ecossistema do Go que aceite um io.Reader funcionará com seu tipo personalizado—esse é o poder do design baseado em interfaces.

Folha de consulta

As interfaces io.Reader e io.Writer do Go são fundamentais para operações de E/S:

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

O método Read lê até len(p) bytes para dentro do slice e retorna o número de bytes lidos. O método Write escreve bytes a partir do slice e retorna o número de bytes escritos.

Qualquer tipo que implemente esses métodos funciona com todo o ecossistema de E/S do Go. Exemplo de um leitor personalizado:

type RepeatReader struct {
    Char  byte
    Count int
    pos   int
}

func (r *RepeatReader) Read(p []byte) (int, error) {
    if r.pos >= r.Count {
        return 0, io.EOF
    }
    n := 0
    for n < len(p) && r.pos < r.Count {
        p[n] = r.Char
        n++
        r.pos++
    }
    return n, nil
}

Usando o leitor personalizado com funções da biblioteca padrão:

reader := &RepeatReader{Char: 'A', Count: 5}
data, _ := io.ReadAll(reader)
fmt.Println(string(data))  // AAAAA

Esse design permite que funções que aceitam io.Reader ou io.Writer funcionem com arquivos, conexões de rede, buffers ou qualquer implementação personalizada.

Experimente você mesmo

package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

func main() {
	// Ler entrada
	reader := bufio.NewReader(os.Stdin)
	input, _ := reader.ReadString('\n')
	// Remover a quebra de linha final, se presente
	if len(input) > 0 && input[len(input)-1] == '\n' {
		input = input[:len(input)-1]
	}

	// TODO: Criar um CountingReader com a string de entrada
	// countingReader := NewCountingReader(input)

	// TODO: Usar io.ReadAll para ler todos os dados do seu CountingReader
	// data, err := io.ReadAll(countingReader)

	// TODO: Criar um UppercaseWriter
	// upperWriter := NewUppercaseWriter()

	// TODO: Escrever os dados no seu UppercaseWriter
	// upperWriter.Write(data)

	// TODO: Imprimir os resultados no formato exigido:
	// Original: [input]
	// Uppercase: [result from writer]
	// Bytes read: [total bytes]

	// Espaço reservado para evitar erro de importação não utilizada - remover ao implementar
	_ = io.EOF
	fmt.Println("Original:", input)
	// fmt.Println("Uppercase:", upperWriter.Result())
	// fmt.Println("Bytes read:", countingReader.Position)
}