feat: add concorrencia package with utilities for concurrency topics in Go

Author: fabianoflorentino

internal/concorrencia/help.go

@@ -0,0 +1,28 @@
+// Package concorrencia provides utilities and examples related to concurrency in Go.
+// It includes functions and constants that demonstrate key concepts such as
+// concurrency vs parallelism, goroutines, waitgroups, race conditions, mutexes,
+// and atomic operations. This package is designed to support learning and
+// understanding of concurrency topics covered in Chapter 18.
+package concorrencia
+
+import (
+	base "github.com/fabianoflorentino/aprendago/pkg/base_content"
+	"github.com/fabianoflorentino/aprendago/pkg/format"
+)
+
+// Help provides a summary of concurrency-related topics covered in Chapter 18.
+// It creates a list of help items, each containing a flag and its corresponding description,
+// and then uses the format package to display the help information in a structured format.
+func Help() {
+	h := []format.HelpMe{
+		{Flag: flagConcorrenciaVsParalelismo, Description: descConcorrenciaVsParalelismo},
+		{Flag: flagGoroutinesWaitgroups, Description: descGoroutinesWaitgroups},
+		{Flag: flagDiscussaoCondicaoDeCorrida, Description: descDiscussaoCondicaoDeCorrida},
+		{Flag: flagCondicaoDeCorrida, Description: descCondicaoDeCorrida},
+		{Flag: flagMutex, Description: descMutex},
+		{Flag: flagAtomic, Description: descAtomic},
+	}
+
+	b := base.New()
+	b.HelpMe("Capítulo 18: Concorrência", h)
+}

internal/concorrencia/menu.go

@@ -0,0 +1,43 @@
+// Package concorrencia provides utilities and structures for working with
+// concurrency-related topics in Go. It includes functionality for creating
+// menus that explore various aspects of concurrency, such as the differences
+// between concurrency and parallelism, the use of goroutines and waitgroups,
+// handling race conditions, and synchronization mechanisms like mutexes and
+// atomic operations. This package is designed to facilitate learning and
+// experimentation with concurrency concepts in Go.
+package concorrencia
+
+import (
+	base "github.com/fabianoflorentino/aprendago/pkg/base_content"
+	"github.com/fabianoflorentino/aprendago/pkg/format"
+)
+
+// Menu generates a list of menu options for concurrency-related topics.
+// It takes a slice of strings as input and returns a slice of formatted menu options.
+// The function initializes a base menu object and defines flags and execution functions
+// for various concurrency topics such as concurrency vs parallelism, goroutines and waitgroups,
+// race conditions, mutexes, and atomic operations. These flags and functions are then passed
+// to the base menu object to create the final menu structure.
+func Menu([]string) []format.MenuOptions {
+	m := base.New()
+
+	newFlag := []string{
+		flagConcorrenciaVsParalelismo,
+		flagGoroutinesWaitgroups,
+		flagDiscussaoCondicaoDeCorrida,
+		flagCondicaoDeCorrida,
+		flagMutex,
+		flagAtomic,
+	}
+
+	newExecFunc := []func(){
+		func() { m.SectionFormat(concorrenciaVsParalelismo, m.SectionFactory(rootDir)) },
+		func() { m.SectionFormat(goroutinesWaitgroups, m.SectionFactory(rootDir)) },
+		func() { m.SectionFormat(discussaoCondicaoDeCorrida, m.SectionFactory(rootDir)) },
+		func() { m.SectionFormat(condicaoDeCorrida, m.SectionFactory(rootDir)) },
+		func() { m.SectionFormat(mutex, m.SectionFactory(rootDir)) },
+		func() { m.SectionFormat(atomic, m.SectionFactory(rootDir)) },
+	}
+
+	return m.Menu(newFlag, newExecFunc)
+}

internal/concorrencia/static_content.go

@@ -0,0 +1,66 @@
+// Package concorrencia provides utilities and constants for exploring concurrency-related
+// topics in Go. It includes definitions for topic names, flags, and descriptions
+// that can be used to structure and reference concurrency concepts consistently
+// throughout the project. This package is designed to facilitate learning and
+// experimentation with concurrency mechanisms such as goroutines, waitgroups, mutexes,
+// and atomic operations.
+package concorrencia
+
+// rootDir represents the relative path to the directory where concurrency-related
+// topics are stored within the project. This constant is used to reference the
+// directory in a consistent manner throughout the codebase.
+const (
+	rootDir = "internal/concorrencia"
+)
+
+// The following constants define the names of various concurrency-related topics.
+// These constants are used to identify and reference specific sections of the
+// concurrency content.
+const (
+	concorrenciaVsParalelismo  string = "Concorrência vs Paralelismo"
+	goroutinesWaitgroups       string = "Goroutines & WaitGroups"
+	discussaoCondicaoDeCorrida string = "Discussão: Condição de corrida"
+	condicaoDeCorrida          string = "Condição de corrida"
+	mutex                      string = "Mutex"
+	atomic                     string = "Atomic"
+)
+
+// The following constants define the command-line flags that can be used to
+// execute specific concurrency-related topics. These flags are used to
+// provide a user-friendly interface for selecting and executing different
+// sections of the concurrency content.
+const (
+	flagConcorrenciaVsParalelismo  string = "--concorrencia-vs-paralelismo"
+	flagGoroutinesWaitgroups       string = "--goroutines-waitgroups"
+	flagDiscussaoCondicaoDeCorrida string = "--discussao-condicao-de-corrida"
+	flagCondicaoDeCorrida          string = "--condicao-de-corrida"
+	flagMutex                      string = "--mutex"
+	flagAtomic                     string = "--atomic"
+)
+
+// The following constants define the descriptions for each concurrency-related
+// topic. These descriptions provide additional context and information about
+// the content covered in each section. They are used to enhance the user
+// experience by providing clear explanations of what each topic entails.
+const (
+	descConcorrenciaVsParalelismo  string = "Apresenta a diferença entre concorrência e paralelismo."
+	descGoroutinesWaitgroups       string = "Apresenta o uso de goroutines e waitgroups."
+	descDiscussaoCondicaoDeCorrida string = "Apresenta uma discussão sobre condição de corrida."
+	descCondicaoDeCorrida          string = "Apresenta o conceito de condição de corrida."
+	descMutex                      string = "Apresenta o uso de mutex."
+	descAtomic                     string = "Apresenta o uso de atomic."
+)
+
+// The following slice contains the names of all concurrency-related topics.
+// This slice is used to iterate over the topics and execute the corresponding
+// sections when the user selects a specific topic.
+var (
+	topics = []string{
+		concorrenciaVsParalelismo,
+		goroutinesWaitgroups,
+		discussaoCondicaoDeCorrida,
+		condicaoDeCorrida,
+		mutex,
+		atomic,
+	}
+)