Implemented the initial Go framework

internal/pipeline/registry.go

@@ -0,0 +1,98 @@
+package pipeline
+
+import "fmt"
+
+// Registry stores all built-in modules addressable by canonical name.
+type Registry struct {
+	inputReaders   map[string]InputReader
+	preprocessors  map[string]Preprocessor
+	postprocessors map[string]Postprocessor
+	outputWriters  map[string]OutputWriter
+	merger         Merger
+}
+
+// NewRegistry creates an empty module registry.
+func NewRegistry() *Registry {
+	return &Registry{
+		inputReaders:   make(map[string]InputReader),
+		preprocessors:  make(map[string]Preprocessor),
+		postprocessors: make(map[string]Postprocessor),
+		outputWriters:  make(map[string]OutputWriter),
+	}
+}
+
+// RegisterInputReader registers an input reader by name.
+func (r *Registry) RegisterInputReader(module InputReader) {
+	r.inputReaders[module.Name()] = module
+}
+
+// RegisterPreprocessor registers a preprocessing module by name.
+func (r *Registry) RegisterPreprocessor(module Preprocessor) {
+	r.preprocessors[module.Name()] = module
+}
+
+// RegisterPostprocessor registers a postprocessing module by name.
+func (r *Registry) RegisterPostprocessor(module Postprocessor) {
+	r.postprocessors[module.Name()] = module
+}
+
+// RegisterOutputWriter registers an output writer by name.
+func (r *Registry) RegisterOutputWriter(module OutputWriter) {
+	r.outputWriters[module.Name()] = module
+}
+
+// RegisterMerger registers the merger implementation.
+func (r *Registry) RegisterMerger(module Merger) {
+	r.merger = module
+}
+
+func (r *Registry) resolveInputReader(name string) (InputReader, error) {
+	module, ok := r.inputReaders[name]
+	if !ok {
+		return nil, fmt.Errorf("unknown input reader %q", name)
+	}
+	return module, nil
+}
+
+func (r *Registry) resolvePreprocessors(names []string) ([]Preprocessor, error) {
+	modules := make([]Preprocessor, 0, len(names))
+	for _, name := range names {
+		module, ok := r.preprocessors[name]
+		if !ok {
+			return nil, fmt.Errorf("unknown preprocessing module %q", name)
+		}
+		modules = append(modules, module)
+	}
+	return modules, nil
+}
+
+func (r *Registry) resolvePostprocessors(names []string) ([]Postprocessor, error) {
+	modules := make([]Postprocessor, 0, len(names))
+	for _, name := range names {
+		module, ok := r.postprocessors[name]
+		if !ok {
+			return nil, fmt.Errorf("unknown postprocessing module %q", name)
+		}
+		modules = append(modules, module)
+	}
+	return modules, nil
+}
+
+func (r *Registry) resolveOutputWriters(names []string) ([]OutputWriter, error) {
+	modules := make([]OutputWriter, 0, len(names))
+	for _, name := range names {
+		module, ok := r.outputWriters[name]
+		if !ok {
+			return nil, fmt.Errorf("unknown output module %q", name)
+		}
+		modules = append(modules, module)
+	}
+	return modules, nil
+}
+
+func (r *Registry) resolveMerger() (Merger, error) {
+	if r.merger == nil {
+		return nil, fmt.Errorf("no merger registered")
+	}
+	return r.merger, nil
+}