Documents the example

examples/withStreaming/streamExport.go

@@ -2,57 +2,51 @@ package main
 
 import (
 	"fmt"
-	"os"
 	"time"
 
 	"github.com/TrueBlocks/trueblocks-core/sdk"
 	"github.com/TrueBlocks/trueblocks-core/src/apps/chifra/pkg/output"
 	"github.com/TrueBlocks/trueblocks-core/src/apps/chifra/pkg/types"
 )
 
+// TestStreamExport demonstrates the SDK streaming feature by creating a Rendering
+// Context with both Model and Error channels. It also demonstrates canceling the
+// context (and therefore the rendering) by using the Cancel feature.
 func TestStreamExport() {
 	opts := sdk.ExportOptions{
 		Addrs:     []string{"0x1f98431c8ad98523631ae4a59f267346ea31f984"}, // Uniswap V3 Factory
-		Unripe:    true,
+		Unripe:    true,                                                   // to the head of the chain
 		RenderCtx: output.WithChannels(),
 	}
-	opts.Globals.Cache = true
+	opts.Globals.Cache = true // Write to the cache
 
 	go func() {
+		// Sleep for 3 seconds and then cancel the rendering context
 		time.Sleep(3 * time.Second)
 		opts.RenderCtx.Cancel()
 	}()
 
-	if len(os.Args) > 1 {
-		opts.RenderCtx = nil
-		txs, _, err := opts.Export()
-		if err != nil {
-			fmt.Println(err)
-			return
-		}
-
-		for _, tx := range txs {
-			fmt.Printf("%d\t%d\n", tx.BlockNumber, tx.TransactionIndex)
-		}
-	} else {
-		go func() {
-			for {
-				select {
-				case model := <-opts.RenderCtx.ModelChan:
-					if tx, ok := model.(*types.Transaction); !ok {
-						fmt.Println("Not a transaction")
-					} else {
-						fmt.Printf("%d\t%d\n", tx.BlockNumber, tx.TransactionIndex)
-					}
-				case err := <-opts.RenderCtx.ErrorChan:
-					fmt.Println("Error returned by fetchData:", err)
+	go func() {
+		for {
+			select {
+			case model := <-opts.RenderCtx.ModelChan:
+				// We got a transaction. Show it. Note that the cast will always succeed
+				if tx, ok := model.(*types.Transaction); ok {
+					fmt.Printf("%d\t%d\n", tx.BlockNumber, tx.TransactionIndex)
+				} else {
+					fmt.Println("Not a transaction")
 				}
+			case err := <-opts.RenderCtx.ErrorChan:
+				fmt.Println("Error returned by fetchData:", err)
+				// os.Exit(1)
 			}
-		}()
-		_, _, err := opts.Export()
-		if err != nil {
-			fmt.Println(err)
-			return
 		}
+	}()
+
+	// Generate the stream...
+	_, _, err := opts.Export()
+	if err != nil {
+		fmt.Println(err)
+		return
 	}
 }

examples/withStreaming/streamNames.go

@@ -6,28 +6,35 @@ import (
 	"github.com/TrueBlocks/trueblocks-core/sdk"
 	"github.com/TrueBlocks/trueblocks-core/src/apps/chifra/pkg/logger"
 	"github.com/TrueBlocks/trueblocks-core/src/apps/chifra/pkg/output"
+	"github.com/TrueBlocks/trueblocks-core/src/apps/chifra/pkg/types"
 )
 
+// TestStreamNames demonstrates the SDK streaming feature for names by
+// creating a Rendering Context with channels.
 func TestStreamNames() {
 	opts := sdk.NamesOptions{
 		RenderCtx: output.WithChannels(),
 	}
 
 	go func() {
+		// start a go routine that listens to the model and error channels
+		// and prints the names as they stream in
 		for {
 			select {
 			case name := <-opts.RenderCtx.ModelChan:
-				if n, ok := name.(*sdk.Name); !ok {
-					logger.Fatal("This should never happen")
-				} else {
+				if n, ok := name.(*types.Name); ok {
 					fmt.Printf("%s\t%s\t%s\n", n.Tags, n.Address, n.Name)
+				} else {
+					logger.Fatal("This should never happen")
 				}
 			case err := <-opts.RenderCtx.ErrorChan:
 				fmt.Println("Error returned by fetchData:", err)
+				// os.Exit(1)
 			}
 		}
 	}()
 
+	// Generate the stream...
 	if _, _, err := opts.Names(); err != nil {
 		fmt.Println(err)
 	}

examples/withStreaming/streamProgress.go

@@ -10,6 +10,8 @@ import (
 	"github.com/schollz/progressbar/v3"
 )
 
+// TestProgressReporting is a simple example just demonstrating how to use
+// the progress bar to report progress of the stream.
 func TestProgressReporting() {
 	nBlocks := 1000
 	bar := newProgressBar(nBlocks)
@@ -34,12 +36,15 @@ func TestProgressReporting() {
 		}
 	}()
 
+	// This will stream the blocks. Note that they are LightBlocks
+	// which is what BlocksHashes returns.
 	if _, _, err := opts.BlocksHashes(); err != nil {
 		panic(err)
 	}
 	bar.Finish()
 }
 
+// newProgressBar creates a new progress bar with the given count
 func newProgressBar(cnt int) *progressbar.ProgressBar {
 	return progressbar.NewOptions(cnt,
 		progressbar.OptionSetWriter(os.Stdout), //you should install "github.com/k0kubun/go-ansi"