Data Streams in Go: Representation and Manipulation

Welcome to the world of data streams! In Go, we utilize slices and maps to handle these continuous datasets efficiently. Whether you're observing a weather station or analyzing game sessions by the second, Go enables seamless data stream management. This lesson will guide you through accessing elements, slicing segments, and converting these streams into strings for better readability.

In Go, we represent data streams using slices and maps. Below is a simple implementation of a DataStream struct, which encapsulates operations on data streams:

package main

import (
    "fmt"
)

type DataStream struct {
    data []map[string]int
}

func NewDataStream(data []map[string]int) *DataStream {
    return &DataStream{data: data}
}

func main() {
    data := []map[string]int{
        {"id": 1, "value": 100},
        {"id": 2, "value": 200},
        {"id": 3, "value": 300},
        {"id": 4, "value": 400},
    }
    stream := NewDataStream(data)
}

Here, we define a slice of maps, each element of which represents a part of our data stream. The sample data point type {"id": 1, "value": 100} contains an id to uniquely identify each element and a value representing the stored data, enabling structured and easily accessible data representation.

To access individual elements of a data stream, we use indexing. Below is a Get method that retrieves the i-th element from the data stream:

func (ds *DataStream) Get(i int) (map[string]int, error) {
    if i < 0 {
        i += len(ds.data)
    }
    if i >= 0 && i < len(ds.data) {
        return ds.data[i], nil
    } else {
        return nil, fmt.Errorf("index out of range")
    }
}

func main() {
    data := []map[string]int{
        {"id": 1, "value": 100},
        {"id": 2, "value": 200},
        {"id": 3, "value": 300},
        {"id": 4, "value": 400},
    }
    stream := NewDataStream(data)

    if elem, err := stream.Get(2); err == nil {
        fmt.Printf("id: %d, value: %d\n", elem["id"], elem["value"])
    } else {
        fmt.Println(err)
    }

    if elem, err := stream.Get(-1); err == nil {
        fmt.Printf("id: %d, value: %d\n", elem["id"], elem["value"])
    } else {
        fmt.Println(err)
    }
}

In this snippet:

• The Get method fetches an element based on its index.
• Negative indexes support backward indexing where -1 fetches the last element.
• An error is returned if the index is out of range, ensuring index boundaries are respected.